jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

2 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `dfa38cf4cd4b`

tarball

atagen <boss@atagen.co>2026-10-10 15:15 UTC

11 files changed+3042-1221

jelqd: add floors 2 through 7, the shop, and the remaining status codes

Suspicion now summons a different enemy per floor, so one meter drives Mom, the roommate, gym staff, and housekeeping. Mom, the roommate, and housekeeping also visit at random so careful players cannot avoid them entirely. Grip changes are real HTTP/1.1 upgrades via hyper, and the cock ring gzips responses only when the client sends Accept-Encoding.

Modified file: Cargo.lock+53 additions@@ -3,6 +3,12 @@
 version = 4
 
 [[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
 name = "atomic-waker"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -73,6 +79,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 
 [[package]]
+name = "crc32fast"
+version = "1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "flate2"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
 name = "form_urlencoded"
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -219,7 +245,11 @@ name = "jelqd"
 version = "0.6.9"
 dependencies = [
  "axum",
+ "flate2",
  "futures-util",
+ "httpdate",
+ "hyper",
+ "hyper-util",
  "rand",
  "serde",
  "serde_json",
@@ -258,6 +288,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
+name = "miniz_oxide"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
 name = "mio"
 version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -421,6 +461,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "simd-adler32"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
+
+[[package]]
 name = "slab"
 version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -476,6 +522,7 @@ version = "1.53.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
 dependencies = [
+ "bytes",
  "libc",
  "mio",
  "pin-project-lite",
@@ -606,6 +653,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "zlib-rs"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"
+
+[[package]]
 name = "zmij"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"

Modified file: Cargo.toml+5 additions−1 deletions@@ -7,11 +7,15 @@ license = "MIT"
 
 [dependencies]
 axum = "0.8"
+flate2 = "1"
 futures-util = "0.3"
+httpdate = "1"
+hyper = { version = "1", features = ["http1", "server"] }
+hyper-util = { version = "0.1", features = ["tokio"] }
 rand = "0.9"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tokio = { version = "1", features = ["macros", "net", "rt-multi-thread"] }
+tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread"] }
 
 [dev-dependencies]
 tower = { version = "0.5", features = ["util"] }

Modified file: flake.nix+5 additions−1 deletions@@ -55,7 +55,11 @@
 
         devShells.default = craneLib.devShell {
           checks = self.checks.${system};
-          packages = [ pkgs.rust-analyzer ];
+          packages = [
+            pkgs.rust-analyzer
+            pkgs.nushell
+            pkgs.curl
+          ];
         };
 
         formatter = pkgs.nixfmt;

Deleted file: src/game.rs−1028 deletions@@ -1,1028 +0,0 @@
-use std::time::{Duration, Instant};
-
-use axum::{
-    Json,
-    body::Body,
-    http::{HeaderName, HeaderValue, StatusCode, header},
-    response::{IntoResponse, Response},
-};
-use rand::{Rng, SeedableRng, rngs::StdRng};
-use serde::Deserialize;
-use serde_json::{Value, json};
-
-use crate::problem::Problem;
-
-pub const MAX_STAMINA: i32 = 10;
-pub const SUSPICION_LIMIT: u8 = 5;
-pub const BRANCH_TURN: u32 = 10;
-pub const APPOINTMENT_TURN: u32 = 20;
-pub const REFRACTORY: Duration = Duration::from_secs(30);
-pub const SELF_REPORT_INFLATION: f64 = 1.5;
-pub const MM_PER_INCH: f64 = 25.4;
-pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];
-pub const LUBRICANTS: [&str; 5] = [
-    "application/baby-oil",
-    "application/coconut-oil",
-    "application/lotion",
-    "application/vaseline",
-    "text/plain; charset=spit",
-];
-pub const INTAKE: [&str; 3] = [
-    "The clinic does not accept excuses.",
-    "The clinic accepts one token. You have not been carrying it.",
-    "Be honest.",
-];
-
-pub const SERVER_TIMING: HeaderName = HeaderName::from_static("server-timing");
-pub const X_DIAGNOSIS: HeaderName = HeaderName::from_static("x-diagnosis");
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Lube {
-    BabyOil,
-    CoconutOil,
-    Lotion,
-    Vaseline,
-    Spit,
-}
-
-impl Lube {
-    pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {
-        let Some(raw) = content_type else {
-            return Ok(None);
-        };
-        let lowered = raw.to_ascii_lowercase();
-        let mut parts = lowered.split(';').map(str::trim);
-        let essence = parts.next().unwrap_or_default();
-        let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");
-        match essence {
-            "application/baby-oil" => Ok(Some(Self::BabyOil)),
-            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),
-            "application/lotion" => Ok(Some(Self::Lotion)),
-            "application/vaseline" => Ok(Some(Self::Vaseline)),
-            "text/plain" if spit => Ok(Some(Self::Spit)),
-            e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(
-                StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                "no",
-                "No.",
-            )),
-            _ => Err(Problem::new(
-                StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                "unsupported-lubricant",
-                format!("{essence} is not a lubricant."),
-            )
-            .with("lubricants", json!(LUBRICANTS))),
-        }
-    }
-
-    fn modifier(self) -> i32 {
-        match self {
-            Self::BabyOil => 1,
-            Self::CoconutOil => 3,
-            Self::Lotion => 0,
-            Self::Vaseline => 2,
-            Self::Spit => -2,
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Technique {
-    Warmup,
-    Ice,
-    Wet,
-    Dry,
-    Stretch,
-    Uli,
-}
-
-#[derive(Clone, Copy)]
-enum LubeRule {
-    Required,
-    Forbidden,
-    Optional,
-}
-
-struct Profile {
-    dc: i32,
-    length: f64,
-    girth: f64,
-    foreskin: Option<(f64, f64)>,
-    foreskin_growth: f64,
-    lube: LubeRule,
-}
-
-impl Technique {
-    pub const ALL: [Self; 6] = [
-        Self::Warmup,
-        Self::Ice,
-        Self::Wet,
-        Self::Dry,
-        Self::Stretch,
-        Self::Uli,
-    ];
-
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Warmup => "warmup",
-            Self::Ice => "ice",
-            Self::Wet => "wet",
-            Self::Dry => "dry",
-            Self::Stretch => "stretch",
-            Self::Uli => "uli",
-        }
-    }
-
-    pub fn parse(name: &str) -> Option<Self> {
-        Self::ALL.into_iter().find(|t| t.name() == name)
-    }
-
-    fn profile(self) -> Option<Profile> {
-        let profile = match self {
-            Self::Warmup | Self::Ice => return None,
-            Self::Wet => Profile {
-                dc: 10,
-                length: 0.010,
-                girth: 0.005,
-                foreskin: None,
-                foreskin_growth: 0.0,
-                lube: LubeRule::Required,
-            },
-            Self::Dry => Profile {
-                dc: 12,
-                length: 0.008,
-                girth: 0.003,
-                foreskin: Some((0.8, 2.0)),
-                foreskin_growth: 0.01,
-                lube: LubeRule::Forbidden,
-            },
-            Self::Stretch => Profile {
-                dc: 11,
-                length: 0.015,
-                girth: 0.0,
-                foreskin: Some((0.0, 1.8)),
-                foreskin_growth: 0.03,
-                lube: LubeRule::Optional,
-            },
-            Self::Uli => Profile {
-                dc: 15,
-                length: 0.002,
-                girth: 0.020,
-                foreskin: None,
-                foreskin_growth: 0.0,
-                lube: LubeRule::Optional,
-            },
-        };
-        Some(profile)
-    }
-
-    pub fn describe(self, forum_read: bool) -> Value {
-        let Some(p) = self.profile() else {
-            let effect = match self {
-                Self::Warmup => "EQ +25. Satisfies the warm-up precondition.",
-                _ => "EQ -40. Consumes an ice pack.",
-            };
-            return json!({ "name": self.name(), "effect": effect });
-        };
-        let lubricant = match p.lube {
-            LubeRule::Required => "required",
-            LubeRule::Forbidden => "forbidden",
-            LubeRule::Optional => "optional",
-        };
-        let foreskin = p
-            .foreskin
-            .map(|(min, max)| json!({ "min": min, "max": max }));
-        json!({
-            "name": self.name(),
-            "dc": p.dc,
-            "lubricant": lubricant,
-            "foreskin": foreskin,
-            "locked": self == Self::Uli && !forum_read,
-        })
-    }
-}
-
-pub struct Outcome {
-    status: StatusCode,
-    body: Option<Value>,
-    headers: Vec<(HeaderName, String)>,
-}
-
-impl Outcome {
-    pub fn new(status: StatusCode, body: Option<Value>) -> Self {
-        Self {
-            status,
-            body,
-            headers: Vec::new(),
-        }
-    }
-
-    pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {
-        self.headers.push((name, value.into()));
-        self
-    }
-}
-
-impl IntoResponse for Outcome {
-    fn into_response(self) -> Response {
-        let mut response = match self.body {
-            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.
-            Some(body) if self.status == StatusCode::PARTIAL_CONTENT => {
-                let full = body.to_string().into_bytes();
-                let half = full.len() / 2;
-                let range = format!("bytes 0-{}/{}", half - 1, full.len());
-                (
-                    self.status,
-                    [
-                        (header::CONTENT_TYPE, "application/json".to_owned()),
-                        (header::CONTENT_RANGE, range),
-                    ],
-                    Body::from(full[..half].to_vec()),
-                )
-                    .into_response()
-            }
-            Some(body) => (self.status, Json(body)).into_response(),
-            None => self.status.into_response(),
-        };
-        for (name, value) in self.headers {
-            let value = HeaderValue::from_str(&value).expect("header values are visible ascii");
-            response.headers_mut().append(name, value);
-        }
-        response
-    }
-}
-
-#[derive(Deserialize)]
-pub struct PatchOp {
-    pub op: String,
-    pub path: String,
-    #[serde(default)]
-    pub value: Value,
-}
-
-pub struct Pending {
-    due: u32,
-    length: f64,
-    girth: f64,
-}
-
-pub struct Ending {
-    pub cause: &'static str,
-    pub detail: String,
-    pub turn: u32,
-}
-
-pub struct Run {
-    pub id: String,
-    pub origin_etag: String,
-    pub version: u64,
-    pub turn: u32,
-    pub length: f64,
-    pub girth: f64,
-    pub foreskin: Option<f64>,
-    pub eq: i32,
-    pub stamina: i32,
-    pub suspicion: u8,
-    pub shame_base: u32,
-    pub shame: u32,
-    pub ice_packs: u32,
-    pub warmed_up: bool,
-    pub teapot: bool,
-    pub ruler: bool,
-    pub put_applied: bool,
-    pub forum_read: bool,
-    pub branch_pending: bool,
-    pub mom_present: bool,
-    pub observed: bool,
-    pub measured: bool,
-    pub cured: bool,
-    pub intake_attempts: usize,
-    pub refractory_until: Option<Instant>,
-    pub pending: Vec<Pending>,
-    pub ended: Option<Ending>,
-    rng: StdRng,
-}
-
-fn round2(x: f64) -> f64 {
-    (x * 100.0).round() / 100.0
-}
-
-fn round3(x: f64) -> f64 {
-    (x * 1000.0).round() / 1000.0
-}
-
-fn tenths(x: f64) -> i64 {
-    (x * 10.0).round() as i64
-}
-
-fn not_extended() -> Problem {
-    Problem::new(
-        StatusCode::NOT_EXTENDED,
-        "not-extended",
-        "The requested extension was not applied. The server has recorded the attempt.",
-    )
-}
-
-pub fn parse_credentials<'a>(authorization: &'a str, scheme: &str) -> Option<&'a str> {
-    let (given, rest) = authorization.trim().split_once(' ')?;
-    given
-        .eq_ignore_ascii_case(scheme)
-        .then(|| rest.trim().trim_matches('"'))
-}
-
-impl Run {
-    pub fn new(id: String, seed: u64, shame_base: u32) -> Self {
-        let mut rng = StdRng::seed_from_u64(seed);
-        let length = round2(rng.random_range(4.5..6.5));
-        let girth = round2(rng.random_range(4.0..5.0));
-        let foreskin = round2(rng.random_range(0.4..2.4));
-        let mut run = Self {
-            id,
-            origin_etag: String::new(),
-            version: 0,
-            turn: 0,
-            length,
-            girth,
-            foreskin: Some(foreskin),
-            eq: 20,
-            stamina: MAX_STAMINA,
-            suspicion: 0,
-            shame_base,
-            shame: 0,
-            ice_packs: 1,
-            warmed_up: false,
-            teapot: false,
-            ruler: false,
-            put_applied: false,
-            forum_read: false,
-            branch_pending: false,
-            mom_present: false,
-            observed: false,
-            measured: false,
-            cured: false,
-            intake_attempts: 0,
-            refractory_until: None,
-            pending: Vec::new(),
-            ended: None,
-            rng,
-        };
-        run.origin_etag = run.etag();
-        run
-    }
-
-    pub fn etag(&self) -> String {
-        format!("\"{}-{}\"", self.id, self.version)
-    }
-
-    pub fn touch(&mut self) {
-        self.version += 1;
-    }
-
-    pub fn self_reported(&self) -> f64 {
-        self.length + SELF_REPORT_INFLATION
-    }
-
-    pub fn total_shame(&self) -> u32 {
-        self.shame_base + self.shame
-    }
-
-    pub fn status(&self) -> &'static str {
-        match (&self.ended, self.cured) {
-            (Some(_), _) => "gone",
-            (None, true) => "normal",
-            (None, false) => "alive",
-        }
-    }
-
-    pub fn view(&self) -> Value {
-        let mut view = json!({
-            "id": self.id,
-            "status": self.status(),
-            "turn": self.turn,
-            "floor": 1,
-            "self_reported_length": round2(self.self_reported()),
-            "girth": round2(self.girth),
-            "foreskin": self.foreskin.map(round2),
-            "eq": self.eq,
-            "stamina": self.stamina,
-            "suspicion": self.suspicion,
-            "shame": self.total_shame(),
-            "warmed_up": self.warmed_up,
-        });
-        if self.ruler {
-            view["length"] = json!(round2(self.length));
-        }
-        if self.teapot {
-            view["condition"] = json!("short and stout");
-        }
-        view
-    }
-
-    pub fn end(&mut self, cause: &'static str, detail: &str) {
-        self.ended = Some(Ending {
-            cause,
-            detail: detail.into(),
-            turn: self.turn,
-        });
-    }
-
-    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {
-        let challenge =
-            |p: Problem| p.header(header::WWW_AUTHENTICATE, "Excuse realm=\"household\"");
-        let Some(authorization) = authorization else {
-            return Err(challenge(
-                Problem::new(
-                    StatusCode::UNAUTHORIZED,
-                    "someone-at-the-door",
-                    "Someone is at the door.",
-                )
-                .with("inventory", format!("/runs/{}/inventory", self.id)),
-            ));
-        };
-        let excuse = parse_credentials(authorization, "excuse");
-        if excuse.is_some_and(|e| EXCUSES.iter().any(|known| known.eq_ignore_ascii_case(e))) {
-            self.mom_present = false;
-            self.suspicion = 0;
-            self.touch();
-            return Ok(());
-        }
-        self.shame += 3;
-        self.touch();
-        Err(challenge(Problem::new(
-            StatusCode::UNAUTHORIZED,
-            "excuse-rejected",
-            "Mom has not heard that one before. She does not believe it.",
-        )))
-    }
-
-    fn check_refractory(&mut self, now: Instant) -> Result<(), Problem> {
-        let Some(until) = self.refractory_until else {
-            return Ok(());
-        };
-        if now < until {
-            let seconds = (until - now).as_secs() + 1;
-            return Err(Problem::new(
-                StatusCode::TOO_MANY_REQUESTS,
-                "overtrained",
-                "Stamina is exhausted. The refractory period is in effect.",
-            )
-            .header(header::RETRY_AFTER, seconds.to_string()));
-        }
-        self.refractory_until = None;
-        self.stamina = MAX_STAMINA;
-        self.eq = 20;
-        self.warmed_up = false;
-        self.touch();
-        Ok(())
-    }
-
-    fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {
-        let Some(f) = self.foreskin else {
-            if min <= 0.0 {
-                return Ok(());
-            }
-            return Err(Problem::new(
-                StatusCode::GONE,
-                "foreskin-gone",
-                "This technique requires a foreskin. The foreskin is gone.",
-            )
-            .header(
-                header::CONTENT_LOCATION,
-                format!("/runs/{}/foreskin", self.id),
-            ));
-        };
-        if f < min {
-            return Err(Problem::new(
-                StatusCode::LENGTH_REQUIRED,
-                "foreskin-insufficient",
-                format!(
-                    "The selected technique requires {min:.1} units of foreskin. {f:.2} units are available. The server has noted the shortfall."
-                ),
-            )
-            .with("required", min)
-            .with("available", round2(f)));
-        }
-        if f > max {
-            return Err(Problem::new(
-                StatusCode::PAYLOAD_TOO_LARGE,
-                "foreskin-excessive",
-                format!(
-                    "The selected technique tolerates at most {max:.1} units of foreskin. {f:.2} units are present."
-                ),
-            )
-            .with("maximum", max)
-            .with("present", round2(f)));
-        }
-        Ok(())
-    }
-
-    fn realize(&mut self) {
-        let (due, waiting): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pending)
-            .into_iter()
-            .partition(|p| p.due <= self.turn);
-        self.pending = waiting;
-        for p in due {
-            self.length += p.length;
-            self.girth += p.girth;
-        }
-    }
-
-    fn gain(&mut self, length: f64, girth: f64, foreskin: f64) {
-        self.length += length;
-        self.girth += girth;
-        if let Some(f) = &mut self.foreskin {
-            *f += foreskin;
-        }
-    }
-
-    fn rupture(&mut self) -> Problem {
-        let detail = if self.ice_packs > 0 {
-            "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."
-        } else {
-            "A vessel has exceeded its rated pressure. The run has ended."
-        };
-        self.end("vascular-event", detail);
-        Problem::new(StatusCode::INTERNAL_SERVER_ERROR, "vascular-event", detail)
-            .with("eq_at_failure", self.eq)
-            .with("turn", self.turn)
-    }
-
-    pub fn jelq(
-        &mut self,
-        technique: Technique,
-        intensity: i32,
-        lube: Option<Lube>,
-        now: Instant,
-    ) -> Result<Outcome, Problem> {
-        self.check_refractory(now)?;
-        if self.branch_pending {
-            return Ok(self.branch_offer());
-        }
-        let Some(profile) = technique.profile() else {
-            return self.utility(technique);
-        };
-        if technique == Technique::Uli && !self.forum_read {
-            return Err(Problem::new(
-                StatusCode::FORBIDDEN,
-                "technique-locked",
-                "This technique is discussed on the forum. You have not been to the forum.",
-            ));
-        }
-        if !self.warmed_up {
-            return Err(Problem::new(
-                StatusCode::PRECONDITION_FAILED,
-                "cold-start",
-                "Warm-up was skipped. The server has noted this.",
-            )
-            .with("technique", Technique::Warmup.name()));
-        }
-        match (profile.lube, lube) {
-            (LubeRule::Required, None) => {
-                return Err(Problem::new(
-                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                    "lubricant-required",
-                    format!(
-                        "The {} technique requires a lubricant. None was declared.",
-                        technique.name()
-                    ),
-                )
-                .with("lubricants", json!(LUBRICANTS)));
-            }
-            (LubeRule::Forbidden, Some(_)) => {
-                return Err(Problem::new(
-                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                    "lubricant-declared",
-                    "The dry technique was requested. A lubricant was declared.",
-                ));
-            }
-            _ => {}
-        }
-        if let Some((min, max)) = profile.foreskin {
-            self.check_foreskin(min, max)?;
-        }
-
-        self.touch();
-        self.turn += 1;
-        self.realize();
-        self.stamina -= 1 + i32::from(lube == Some(Lube::Lotion));
-        if self.stamina <= 0 {
-            self.stamina = 0;
-            self.refractory_until = Some(now + REFRACTORY);
-        }
-        self.eq = (self.eq + intensity * 2 - 6).clamp(0, 100);
-        let suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));
-        self.suspicion = (self.suspicion + suspicion as u8).min(SUSPICION_LIMIT);
-        if self.suspicion == SUSPICION_LIMIT {
-            self.mom_present = true;
-        }
-        if self.rng.random_ratio(1, 6) {
-            self.observed = true;
-            self.shame += 1;
-        }
-        if self.turn == BRANCH_TURN {
-            self.branch_pending = true;
-        }
-
-        if self.eq > 95 {
-            self.eq = 0;
-            self.warmed_up = false;
-            self.shame += 5;
-            return Err(Problem::new(
-                StatusCode::TOO_EARLY,
-                "premature",
-                "The floor has ended early. Everyone involved has agreed not to discuss it.",
-            ));
-        }
-        if self.eq < 30 {
-            return Err(Problem::new(
-                StatusCode::NOT_FOUND,
-                "cold",
-                "The resource exists. It is cold.",
-            )
-            .with("eq", self.eq));
-        }
-        self.roll(technique, &profile, intensity, lube)
-    }
-
-    fn roll(
-        &mut self,
-        technique: Technique,
-        profile: &Profile,
-        intensity: i32,
-        lube: Option<Lube>,
-    ) -> Result<Outcome, Problem> {
-        let natural: i32 = self.rng.random_range(1..=20);
-        let band = if (50..=70).contains(&self.eq) { 2 } else { 0 };
-        let modifier = lube.map_or(0, Lube::modifier) + band;
-        let dc = profile.dc + intensity / 3;
-        let total = natural + modifier;
-        let timing = format!("roll;desc=\"d20{modifier:+} vs {dc}\";dur={natural}");
-        let timed = |p: Problem| p.header(SERVER_TIMING, &timing);
-
-        let scale = f64::from(intensity);
-        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
-        if self.teapot {
-            length *= 0.5;
-            girth *= 1.5;
-        }
-
-        if natural == 1 {
-            let touches_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);
-            if touches_foreskin && self.foreskin.is_some() {
-                self.foreskin = None;
-                self.shame += 25;
-                return Err(timed(
-                    Problem::new(
-                        StatusCode::GONE,
-                        "foreskin-lost",
-                        "The technique has removed the foreskin. It will not be returning.",
-                    )
-                    .header(
-                        header::CONTENT_LOCATION,
-                        format!("/runs/{}/foreskin", self.id),
-                    ),
-                ));
-            }
-            if self.eq > 70 {
-                return Err(timed(self.rupture()));
-            }
-            if technique == Technique::Stretch && !self.teapot {
-                self.teapot = true;
-                self.shame += 5;
-                return Err(timed(Problem::new(
-                    StatusCode::IM_A_TEAPOT,
-                    "teapot",
-                    "The subject is now short and stout. Length gains are halved for the rest of the run.",
-                )));
-            }
-            return Err(timed(not_extended()));
-        }
-        if self.eq > 90 && total < dc {
-            return Err(timed(self.rupture()));
-        }
-        if natural == 20 {
-            self.gain(length * 2.0, girth * 2.0, profile.foreskin_growth);
-            return Ok(Outcome::new(
-                StatusCode::CREATED,
-                Some(json!({
-                    "detail": "A permanent gain has been created.",
-                    "length": round3(length * 2.0),
-                    "girth": round3(girth * 2.0),
-                })),
-            )
-            .header(header::LOCATION, format!("/runs/{}/length", self.id))
-            .header(SERVER_TIMING, timing));
-        }
-        if total < dc - 3 {
-            return Err(timed(not_extended()));
-        }
-        if total < dc {
-            return Ok(Outcome::new(StatusCode::NO_CONTENT, None).header(SERVER_TIMING, timing));
-        }
-
-        let outcome = if self.eq < 50 {
-            self.gain(length / 2.0, girth / 2.0, profile.foreskin_growth);
-            Outcome::new(
-                StatusCode::PARTIAL_CONTENT,
-                Some(json!({
-                    "detail": "Partial gains were applied. EQ was below the band.",
-                    "length": round3(length / 2.0),
-                    "girth": round3(girth / 2.0),
-                })),
-            )
-        } else if total >= dc + 5 {
-            self.gain(length, girth, profile.foreskin_growth);
-            Outcome::new(
-                StatusCode::OK,
-                Some(json!({
-                    "detail": "Gains were applied.",
-                    "length": round3(length),
-                    "girth": round3(girth),
-                })),
-            )
-        } else {
-            let eta = self.rng.random_range(1..=4);
-            self.pending.push(Pending {
-                due: self.turn + eta,
-                length,
-                girth,
-            });
-            self.gain(0.0, 0.0, profile.foreskin_growth);
-            Outcome::new(
-                StatusCode::ACCEPTED,
-                Some(json!({
-                    "detail": "Gains have been queued. They may arrive.",
-                    "eta_turns": eta,
-                })),
-            )
-        };
-        Ok(outcome.header(SERVER_TIMING, timing))
-    }
-
-    fn utility(&mut self, technique: Technique) -> Result<Outcome, Problem> {
-        if technique == Technique::Warmup {
-            self.touch();
-            self.warmed_up = true;
-            self.eq = (self.eq + 25).min(100);
-            return Ok(Outcome::new(
-                StatusCode::OK,
-                Some(json!({ "detail": "Warmed up. The towel has cooled." })),
-            ));
-        }
-        if self.ice_packs == 0 {
-            return Err(Problem::new(
-                StatusCode::FAILED_DEPENDENCY,
-                "no-ice",
-                "The ice pack has been used. There was one ice pack.",
-            ));
-        }
-        self.touch();
-        self.ice_packs -= 1;
-        self.eq = (self.eq - 40).max(0);
-        Ok(Outcome::new(
-            StatusCode::OK,
-            Some(json!({ "detail": "EQ has been reduced. The ice pack is gone." })),
-        ))
-    }
-
-    fn branch_offer(&self) -> Outcome {
-        let forum = format!("/runs/{}/branches/forum", self.id);
-        let close = format!("/runs/{}/branches/close-tab", self.id);
-        Outcome::new(
-            StatusCode::MULTIPLE_CHOICES,
-            Some(json!({
-                "detail": "A browser tab is open. It has been open for some time.",
-                "choices": [
-                    { "href": forum, "method": "POST", "title": "Read the forum" },
-                    { "href": close, "method": "POST", "title": "Close the tab" },
-                ],
-            })),
-        )
-        .header(
-            header::LINK,
-            format!(
-                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\", <{close}>; rel=\"alternate\"; title=\"Close the tab\""
-            ),
-        )
-    }
-
-    pub fn choose(&mut self, choice: &str) -> Result<Outcome, Problem> {
-        if !self.branch_pending {
-            return Err(Problem::new(
-                StatusCode::CONFLICT,
-                "no-decision-pending",
-                "There is no decision pending.",
-            ));
-        }
-        let (location, detail) = match choice {
-            "forum" => {
-                self.forum_read = true;
-                self.shame += 3;
-                (
-                    format!("/runs/{}/techniques", self.id),
-                    "The thread is from 2009. A technique called uli is discussed at length.",
-                )
-            }
-            "close-tab" => {
-                self.suspicion = 0;
-                (
-                    format!("/runs/{}", self.id),
-                    "The tab is closed. Nobody saw it.",
-                )
-            }
-            _ => {
-                return Err(Problem::new(
-                    StatusCode::NOT_FOUND,
-                    "no-such-choice",
-                    "That was not one of the choices.",
-                ));
-            }
-        };
-        self.branch_pending = false;
-        self.touch();
-        Ok(
-            Outcome::new(StatusCode::SEE_OTHER, Some(json!({ "detail": detail })))
-                .header(header::LOCATION, location),
-        )
-    }
-
-    pub fn search_drawer(&mut self) -> Outcome {
-        if self.ruler {
-            return Outcome::new(StatusCode::NO_CONTENT, None);
-        }
-        self.ruler = true;
-        self.shame += 10;
-        self.touch();
-        Outcome::new(
-            StatusCode::FOUND,
-            Some(json!({
-                "detail": "You now know. This is the first honest measurement of the run.",
-            })),
-        )
-        .header(
-            header::LOCATION,
-            format!("/runs/{}/inventory/ruler", self.id),
-        )
-    }
-
-    pub fn put(&mut self) -> Outcome {
-        if self.put_applied {
-            return Outcome::new(StatusCode::NO_CONTENT, None);
-        }
-        self.put_applied = true;
-        self.length += 0.01;
-        self.touch();
-        Outcome::new(StatusCode::OK, Some(json!({ "detail": "Applied." })))
-    }
-
-    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {
-        for op in ops {
-            if op.op != "test" {
-                return Err(Problem::new(
-                    StatusCode::UNPROCESSABLE_ENTITY,
-                    "wishful-thinking",
-                    "The server accepts only the truth.",
-                )
-                .with("op", op.op.clone()));
-            }
-            let actual = match op.path.as_str() {
-                "/length" => self.length,
-                "/girth" => self.girth,
-                "/foreskin" => self.foreskin.unwrap_or(0.0),
-                _ => {
-                    return Err(Problem::new(
-                        StatusCode::UNPROCESSABLE_ENTITY,
-                        "no-such-measurement",
-                        "There is no such measurement.",
-                    )
-                    .with("path", op.path.clone()));
-                }
-            };
-            let Some(claimed) = op.value.as_f64() else {
-                return Err(Problem::new(
-                    StatusCode::BAD_REQUEST,
-                    "malformed-patch",
-                    "A test requires a numeric value.",
-                ));
-            };
-            if op.path == "/length" && claimed >= self.length + 1.0 {
-                self.shame += 2;
-                self.touch();
-                return Err(Problem::new(
-                    StatusCode::BAD_REQUEST,
-                    "exaggeration",
-                    "The server has measured. Lying is not a technique.",
-                ));
-            }
-            if tenths(claimed) != tenths(actual) {
-                self.shame += 1;
-                self.touch();
-                return Err(
-                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
-                        .with("path", op.path.clone()),
-                );
-            }
-        }
-        Ok(Outcome::new(
-            StatusCode::OK,
-            Some(json!({ "detail": "Correct." })),
-        ))
-    }
-
-    pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {
-        if self.foreskin.is_none() {
-            return Err(Problem::new(
-                StatusCode::GONE,
-                "foreskin-gone",
-                "The foreskin is gone. It will not be returning.",
-            ));
-        }
-        let Some(if_match) = if_match else {
-            return Err(Problem::new(
-                StatusCode::PRECONDITION_REQUIRED,
-                "confirmation-required",
-                "The server requires you to be sure. Send If-Match.",
-            ));
-        };
-        if !etag_matches(if_match, &self.etag()) {
-            return Err(Problem::new(
-                StatusCode::PRECONDITION_FAILED,
-                "stale-foreskin",
-                "The foreskin has changed since you last looked at it.",
-            ));
-        }
-        self.foreskin = None;
-        self.shame += 20;
-        self.touch();
-        Ok(Outcome::new(StatusCode::NO_CONTENT, None))
-    }
-
-    pub fn diagnose(
-        &mut self,
-        authorization: Option<&str>,
-        if_none_match: Option<&str>,
-    ) -> Result<Outcome, Problem> {
-        let remaining = APPOINTMENT_TURN.saturating_sub(self.turn);
-        if remaining > 0 {
-            return Err(Problem::new(
-                StatusCode::TOO_EARLY,
-                "no-appointment",
-                format!("The clinic's next available appointment is in {remaining} turns."),
-            ));
-        }
-        let intake = Problem::new(
-            StatusCode::UNAUTHORIZED,
-            "intake",
-            "The clinic requires authorization.",
-        );
-        let Some(authorization) = authorization else {
-            return Err(intake.header(header::WWW_AUTHENTICATE, "Bearer realm=\"clinic\""));
-        };
-        let honest = parse_credentials(authorization, "bearer")
-            .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));
-        if !honest {
-            let hint = INTAKE[self.intake_attempts.min(INTAKE.len() - 1)];
-            self.intake_attempts += 1;
-            return Err(intake.header(
-                header::WWW_AUTHENTICATE,
-                format!(
-                    "Bearer realm=\"clinic\", error=\"invalid_token\", error_description=\"{hint}\""
-                ),
-            ));
-        }
-
-        let etag = self.origin_etag.clone();
-        if if_none_match.is_some_and(|inm| etag_matches(inm, &etag)) {
-            self.cured = true;
-            return Ok(Outcome::new(StatusCode::NOT_MODIFIED, None)
-                .header(header::ETAG, etag)
-                .header(X_DIAGNOSIS, "normal"));
-        }
-        if !self.measured {
-            self.measured = true;
-            if !self.ruler {
-                self.shame += 15;
-            }
-        }
-        Ok(Outcome::new(
-            StatusCode::OK,
-            Some(json!({
-                "diagnosis": "within normal range",
-                "measured_length": round2(self.length),
-                "you_said": round2(self.self_reported()),
-                "prescription": "Please stop.",
-            })),
-        )
-        .header(header::ETAG, etag))
-    }
-}
-
-pub fn etag_matches(condition: &str, etag: &str) -> bool {
-    condition
-        .split(',')
-        .map(str::trim)
-        .any(|tag| tag == "*" || tag.trim_start_matches("W/") == etag)
-}
-
-pub fn shaft(mm: usize) -> String {
-    format!("8{}D", "=".repeat(mm.saturating_sub(2)))
-}

Added file: src/game/catalog.rs+248 additions@@ -0,0 +1,248 @@
+use axum::http::StatusCode;
+use serde_json::{Value, json};
+
+use crate::problem::Problem;
+
+pub const LUBRICANTS: [&str; 5] = [
+    "application/baby-oil",
+    "application/coconut-oil",
+    "application/lotion",
+    "application/vaseline",
+    "text/plain; charset=spit",
+];
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Lube {
+    BabyOil,
+    CoconutOil,
+    Lotion,
+    Vaseline,
+    Spit,
+}
+
+impl Lube {
+    pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {
+        let Some(raw) = content_type else {
+            return Ok(None);
+        };
+        let lowered = raw.to_ascii_lowercase();
+        let mut parts = lowered.split(';').map(str::trim);
+        let essence = parts.next().unwrap_or_default();
+        let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");
+        match essence {
+            "application/baby-oil" => Ok(Some(Self::BabyOil)),
+            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),
+            "application/lotion" => Ok(Some(Self::Lotion)),
+            "application/vaseline" => Ok(Some(Self::Vaseline)),
+            "text/plain" if spit => Ok(Some(Self::Spit)),
+            e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "no",
+                "No.",
+            )),
+            _ => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "unsupported-lubricant",
+                format!("{essence} is not a lubricant."),
+            )
+            .with("lubricants", json!(LUBRICANTS))),
+        }
+    }
+
+    pub(super) fn modifier(self) -> i32 {
+        match self {
+            Self::BabyOil => 1,
+            Self::CoconutOil => 3,
+            Self::Lotion => 0,
+            Self::Vaseline => 2,
+            Self::Spit => -2,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Technique {
+    Warmup,
+    Ice,
+    Edge,
+    Pump,
+    Supplement,
+    Wet,
+    Dry,
+    Stretch,
+    Uli,
+}
+
+#[derive(Clone, Copy)]
+pub(super) enum LubeRule {
+    Required,
+    Forbidden,
+    Optional,
+}
+
+pub(super) struct Profile {
+    pub dc: i32,
+    pub length: f64,
+    pub girth: f64,
+    pub foreskin: Option<(f64, f64)>,
+    pub foreskin_growth: f64,
+    pub lube: LubeRule,
+}
+
+impl Technique {
+    pub const ALL: [Self; 9] = [
+        Self::Warmup,
+        Self::Ice,
+        Self::Edge,
+        Self::Pump,
+        Self::Supplement,
+        Self::Wet,
+        Self::Dry,
+        Self::Stretch,
+        Self::Uli,
+    ];
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Warmup => "warmup",
+            Self::Ice => "ice",
+            Self::Edge => "edge",
+            Self::Pump => "pump",
+            Self::Supplement => "supplement",
+            Self::Wet => "wet",
+            Self::Dry => "dry",
+            Self::Stretch => "stretch",
+            Self::Uli => "uli",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|t| t.name() == name)
+    }
+
+    pub(super) fn profile(self) -> Option<Profile> {
+        let profile = match self {
+            Self::Warmup | Self::Ice | Self::Edge | Self::Pump | Self::Supplement => return None,
+            Self::Wet => Profile {
+                dc: 10,
+                length: 0.010,
+                girth: 0.005,
+                foreskin: None,
+                foreskin_growth: 0.0,
+                lube: LubeRule::Required,
+            },
+            Self::Dry => Profile {
+                dc: 12,
+                length: 0.008,
+                girth: 0.003,
+                foreskin: Some((0.8, 2.0)),
+                foreskin_growth: 0.01,
+                lube: LubeRule::Forbidden,
+            },
+            Self::Stretch => Profile {
+                dc: 11,
+                length: 0.015,
+                girth: 0.0,
+                foreskin: Some((0.0, 1.8)),
+                foreskin_growth: 0.03,
+                lube: LubeRule::Optional,
+            },
+            Self::Uli => Profile {
+                dc: 15,
+                length: 0.002,
+                girth: 0.020,
+                foreskin: None,
+                foreskin_growth: 0.0,
+                lube: LubeRule::Optional,
+            },
+        };
+        Some(profile)
+    }
+
+    pub fn describe(self, forum_read: bool) -> Value {
+        let Some(p) = self.profile() else {
+            let effect = match self {
+                Self::Warmup => "EQ +25. Satisfies the warm-up precondition.",
+                Self::Ice => "EQ -40. Consumes an ice pack.",
+                Self::Edge => "EQ +15 and a little girth. Three in a row is a loop.",
+                Self::Pump => "Large gains, all temporary. Requires a pump.",
+                _ => "Consumes a supplement.",
+            };
+            return json!({ "name": self.name(), "effect": effect });
+        };
+        let lubricant = match p.lube {
+            LubeRule::Required => "required",
+            LubeRule::Forbidden => "forbidden",
+            LubeRule::Optional => "optional",
+        };
+        let foreskin = p
+            .foreskin
+            .map(|(min, max)| json!({ "min": min, "max": max }));
+        json!({
+            "name": self.name(),
+            "dc": p.dc,
+            "lubricant": lubricant,
+            "foreskin": foreskin,
+            "locked": self == Self::Uli && !forum_read,
+        })
+    }
+}
+
+pub struct ShopItem {
+    pub slug: &'static str,
+    pub price: u32,
+    pub description: &'static str,
+}
+
+pub const SHOP: [ShopItem; 10] = [
+    ShopItem {
+        slug: "pump",
+        price: 10,
+        description: "A pump.",
+    },
+    ShopItem {
+        slug: "pump-pro",
+        price: 15,
+        description: "A pump, but professional.",
+    },
+    ShopItem {
+        slug: "extender",
+        price: 15,
+        description: "Passive gains every turn. Takes up room.",
+    },
+    ShopItem {
+        slug: "cock-ring",
+        price: 8,
+        description: "Doubles girth gains. Pump-Bro does not discuss the risks.",
+    },
+    ShopItem {
+        slug: "supplement",
+        price: 5,
+        description: "Clinically formulated. Ships from overseas.",
+    },
+    ShopItem {
+        slug: "door-lock",
+        price: 5,
+        description: "Keeps the roommate out once.",
+    },
+    ShopItem {
+        slug: "do-not-disturb-sign",
+        price: 5,
+        description: "Housekeeping respects it.",
+    },
+    ShopItem {
+        slug: "ruler",
+        price: 5,
+        description: "Pump-Bro does not recommend it.",
+    },
+    ShopItem {
+        slug: "ice-pack",
+        price: 3,
+        description: "Cold.",
+    },
+    ShopItem {
+        slug: "cage-key",
+        price: 15,
+        description: "Pump-Bro does not ask.",
+    },
+];

Added file: src/game/encounters.rs+721 additions@@ -0,0 +1,721 @@
+use std::collections::HashMap;
+
+use axum::http::{StatusCode, header};
+use rand::Rng;
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use super::{
+    Floor, Grip, Outcome, Run, SHOP, SUSPICION_LIMIT, X_DIAGNOSIS, parse_credentials, round2,
+    tenths,
+};
+use crate::problem::Problem;
+
+pub const FORUM_THREAD: &str = "/forum/threads/2009";
+pub const ELDER_LAST_MODIFIED: &str = "Sun, 14 Jun 2009 03:12:00 GMT";
+
+pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];
+pub const THANKSGIVING_EXCUSES: [&str; 3] = ["on a call", "folding laundry", "praying"];
+const TRUTHS: [&str; 3] = ["the truth", "truth", "honesty"];
+
+const INTAKE: [&str; 3] = [
+    "The clinic does not accept excuses.",
+    "The clinic accepts one token. You have not been carrying it.",
+    "Be honest.",
+];
+
+const SPREADSHEET: &str = "\
+date,length,girth,technique,notes,honest?
+2007-01-03,7.50,5.50,wet,baseline,no
+2007-06-11,7.50,5.50,wet,feeling fuller,no
+2008-01-02,7.50,5.50,dry,new routine,no
+2008-09-19,7.50,5.50,uli,PUT is idempotent. do not use PUT.,no
+2009-06-14,7.50,5.50,wet,progress is slow but real,no
+";
+
+pub fn forum_thread() -> Value {
+    json!({
+        "title": "The definitive jelqing FAQ (updated 2009)",
+        "posts": [
+            { "author": "TheElder", "body": "Warm up. Always warm up. A cold jelq is a 412 waiting to happen." },
+            { "author": "TheElder", "body": "Keep EQ between 50 and 70. Above 70 you are gambling. Above 90 you are a cautionary tale." },
+            { "author": "newbie_2009", "body": "I have been sending PUT for three weeks and nothing has changed." },
+            { "author": "TheElder", "body": "PUT is idempotent. Read the spec." },
+            { "author": "TheElder", "body": "Members verify with a Ruler. Proxy-Authorization, inches, no rounding up. We can tell." },
+            { "author": "throwaway_77", "body": "my doctor said i was normal. i didnt believe him. i still dont know what he meant by bearer" },
+            { "author": "TheElder", "body": "My numbers are in my spreadsheet. They have not changed since 2009. Nothing about me has changed since 2009." },
+        ],
+    })
+}
+
+#[derive(Deserialize)]
+pub struct PatchOp {
+    pub op: String,
+    pub path: String,
+    #[serde(default)]
+    pub value: Value,
+}
+
+fn digest_params(authorization: &str) -> Option<HashMap<String, String>> {
+    let (scheme, rest) = authorization.trim().split_once(' ')?;
+    if !scheme.eq_ignore_ascii_case("digest") {
+        return None;
+    }
+    Some(
+        rest.split(',')
+            .filter_map(|pair| {
+                let (key, value) = pair.split_once('=')?;
+                Some((
+                    key.trim().to_ascii_lowercase(),
+                    value.trim().trim_matches('"').to_owned(),
+                ))
+            })
+            .collect(),
+    )
+}
+
+fn exaggeration() -> Problem {
+    Problem::new(
+        StatusCode::BAD_REQUEST,
+        "exaggeration",
+        "The server has measured. Lying is not a technique.",
+    )
+}
+
+impl Run {
+    pub fn excuses(&self) -> Vec<&'static str> {
+        if self.floor.number() < Floor::Grandmas.number() {
+            return EXCUSES.to_vec();
+        }
+        EXCUSES
+            .into_iter()
+            .chain(THANKSGIVING_EXCUSES)
+            .filter(|e| !self.heard.iter().any(|h| h == e))
+            .collect()
+    }
+
+    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {
+        let digest = self.floor == Floor::Grandmas;
+        let challenge_value = if digest {
+            format!("Digest realm=\"household\", nonce=\"{}\"", self.nonce)
+        } else {
+            "Excuse realm=\"household\"".to_owned()
+        };
+        let challenge = |p: Problem| p.header(header::WWW_AUTHENTICATE, &challenge_value);
+
+        let Some(authorization) = authorization else {
+            return Err(challenge(
+                Problem::new(
+                    StatusCode::UNAUTHORIZED,
+                    "someone-at-the-door",
+                    format!("Someone is at the door. {}", self.mom_errand),
+                )
+                .with("inventory", format!("/runs/{}/inventory", self.id)),
+            ));
+        };
+
+        let excuse = if digest {
+            let Some(params) = digest_params(authorization) else {
+                return Err(challenge(Problem::new(
+                    StatusCode::UNAUTHORIZED,
+                    "digest-required",
+                    "Mom has started using Digest authentication.",
+                )));
+            };
+            if params.get("nonce") != Some(&self.nonce) {
+                return Err(challenge(Problem::new(
+                    StatusCode::UNAUTHORIZED,
+                    "stale-nonce",
+                    "That was a different conversation.",
+                )));
+            }
+            params.get("username").cloned().unwrap_or_default()
+        } else {
+            parse_credentials(authorization, "excuse")
+                .unwrap_or_default()
+                .to_owned()
+        };
+        let excuse = excuse.to_ascii_lowercase();
+
+        if TRUTHS.contains(&excuse.as_str()) {
+            self.shame += 10;
+            self.leave_door();
+            return Ok(());
+        }
+        if digest && self.heard.contains(&excuse) {
+            self.shame += 3;
+            self.touch();
+            return Err(challenge(Problem::new(
+                StatusCode::UNAUTHORIZED,
+                "excuse-replayed",
+                "Mom has heard that one before. She would have preferred the truth.",
+            )));
+        }
+        if self.excuses().contains(&excuse.as_str()) {
+            self.heard.push(excuse);
+            self.leave_door();
+            return Ok(());
+        }
+        self.shame += 3;
+        self.touch();
+        let detail = if digest {
+            "Mom has not heard that one before. She does not believe it. She would have preferred the truth."
+        } else {
+            "Mom has not heard that one before. She does not believe it."
+        };
+        Err(challenge(Problem::new(
+            StatusCode::UNAUTHORIZED,
+            "excuse-rejected",
+            detail,
+        )))
+    }
+
+    pub(super) fn errand(&mut self, summoned: bool) -> &'static str {
+        if summoned {
+            return "She heard a noise.";
+        }
+        let errands: &[&'static str] = if self.floor == Floor::Grandmas {
+            &[
+                "Grandma would like to see you.",
+                "Dinner is in ten minutes.",
+                "She needs help with the folding table.",
+                "An uncle has asked where you went.",
+            ]
+        } else {
+            &[
+                "She has brought laundry.",
+                "She wants to know if you have eaten.",
+                "She needs the wifi password.",
+                "She would like to talk about your future.",
+            ]
+        };
+        errands[self.rng.random_range(0..errands.len())]
+    }
+
+    fn leave_door(&mut self) {
+        self.mom_present = false;
+        self.suspicion = 0;
+        self.touch();
+    }
+
+    pub(super) fn floor_enemy(&mut self) -> Result<(), Problem> {
+        let wanders_in = matches!(self.floor, Floor::Bathroom | Floor::Hotel)
+            && self.rng.random_ratio(u32::from(self.suspicion) + 1, 32);
+        if self.suspicion < SUSPICION_LIMIT && !wanders_in {
+            return Ok(());
+        }
+        match self.floor {
+            Floor::Bathroom => {
+                self.suspicion = 0;
+                self.touch();
+                if self.items.door_locks > 0 {
+                    self.items.door_locks -= 1;
+                    return Ok(());
+                }
+                self.roommate_told = true;
+                Err(Problem::new(
+                    StatusCode::CONFLICT,
+                    "roommate",
+                    "The roommate needs the bathroom. He will mention this to people.",
+                ))
+            }
+            Floor::LockerRoom => {
+                self.suspicion = 0;
+                self.shame += 5;
+                self.touch();
+                Err(Problem::new(
+                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
+                    "gym-staff",
+                    "Gym staff have been notified. The server cannot serve this request for legal reasons.",
+                ))
+            }
+            Floor::Hotel => {
+                self.suspicion = 0;
+                self.touch();
+                if self.items.dnd_sign {
+                    return Ok(());
+                }
+                self.shame += 3;
+                Err(Problem::new(
+                    StatusCode::UNAUTHORIZED,
+                    "housekeeping",
+                    "Housekeeping has entered. Housekeeping accepts no excuses.",
+                )
+                .header(header::WWW_AUTHENTICATE, "Excuse realm=\"housekeeping\""))
+            }
+            _ => Ok(()),
+        }
+    }
+
+    pub fn search_drawer(&mut self) -> Result<Outcome, Problem> {
+        self.drawer_searches += 1;
+        self.touch();
+        let first = self.drawer_searches == 1;
+        let id = self.id.clone();
+        let found = |slug: &str, detail: &str| {
+            Outcome::json(StatusCode::FOUND, json!({ "detail": detail }))
+                .header(header::LOCATION, format!("/runs/{id}/inventory/{slug}"))
+        };
+        match self.floor {
+            Floor::Bedroom if first && !self.items.ruler => {
+                self.items.ruler = true;
+                self.shame += 10;
+                Ok(found(
+                    "ruler",
+                    "You now know. This is the first honest measurement of the run.",
+                ))
+            }
+            Floor::Bathroom if first => {
+                self.items.door_locks += 1;
+                Ok(found("door-lock", "A door lock. It works once."))
+            }
+            Floor::LockerRoom => {
+                self.shame += 3;
+                Err(Problem::new(
+                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
+                    "not-your-locker",
+                    "That locker belongs to Greg. The server cannot serve this request for legal reasons.",
+                ))
+            }
+            Floor::Grandmas if first => {
+                self.items.cage = true;
+                self.shame += 5;
+                Ok(found(
+                    "chastity-cage",
+                    "A small box. Inside was a cage. It is now on. The key is not in the box.",
+                ))
+            }
+            Floor::Grandmas if self.items.cage => {
+                self.items.cage = false;
+                Ok(Outcome::json(
+                    StatusCode::OK,
+                    json!({ "detail": "The key was under where the box had been. The cage is off." }),
+                ))
+            }
+            Floor::Hotel if first => {
+                self.items.dnd_sign = true;
+                self.items.ice_packs += 2;
+                Ok(found(
+                    "do-not-disturb-sign",
+                    "A Do Not Disturb sign, and two ice packs from the machine down the hall.",
+                ))
+            }
+            Floor::Forum if first => {
+                self.items.spreadsheet = true;
+                Ok(found(
+                    "spreadsheet",
+                    "Your own spreadsheet. Every line is flat.",
+                ))
+            }
+            Floor::Clinic => Err(Problem::new(
+                StatusCode::FORBIDDEN,
+                "doctors-drawer",
+                "That is the doctor's drawer.",
+            )),
+            _ => Ok(Outcome::empty(StatusCode::NO_CONTENT)),
+        }
+    }
+
+    pub fn shop_view(&self) -> Result<Value, Problem> {
+        if !self.floor.shop_open() {
+            return Err(pump_bro_absent());
+        }
+        let stock: Vec<Value> = SHOP
+            .iter()
+            .map(|item| {
+                json!({
+                    "item": item.slug,
+                    "price": item.price,
+                    "description": item.description,
+                    "href": format!("/runs/{}/shop/{}", self.id, item.slug),
+                    "method": "POST",
+                })
+            })
+            .collect();
+        Ok(json!({ "merchant": "Pump-Bro", "cash": self.cash, "stock": stock }))
+    }
+
+    pub fn buy(&mut self, slug: &str) -> Result<Outcome, Problem> {
+        if !self.floor.shop_open() {
+            return Err(pump_bro_absent());
+        }
+        let Some(item) = SHOP.iter().find(|i| i.slug == slug) else {
+            return Err(Problem::new(
+                StatusCode::NOT_FOUND,
+                "not-for-sale",
+                "Pump-Bro does not sell that. He knows a guy.",
+            ));
+        };
+        if slug == "pump" {
+            return Err(Problem::new(
+                StatusCode::UPGRADE_REQUIRED,
+                "upsell",
+                "This pump requires an upgrade.",
+            )
+            .header(header::UPGRADE, "pump-pro/2.0")
+            .with("upgrade", format!("/runs/{}/shop/pump-pro", self.id)));
+        }
+        if self.cash < item.price {
+            return Err(Problem::new(
+                StatusCode::PAYMENT_REQUIRED,
+                "insufficient-funds",
+                "Payment is required. RFC 9110 has reserved this status for future use since 1997. The future is here and you cannot afford it.",
+            )
+            .with("cash", self.cash)
+            .with("price", item.price));
+        }
+        self.cash -= item.price;
+        self.touch();
+        let items = &mut self.items;
+        match slug {
+            "supplement" => {
+                items.supplements += 1;
+                return Err(Problem::new(
+                    StatusCode::GATEWAY_TIMEOUT,
+                    "still-shipping",
+                    "The supplement is still shipping. You have been charged. It may arrive.",
+                )
+                .with("cash", self.cash));
+            }
+            "pump-pro" => items.pump_pro = true,
+            "extender" => items.extender = true,
+            "cock-ring" => items.ring = true,
+            "door-lock" => items.door_locks += 1,
+            "do-not-disturb-sign" => items.dnd_sign = true,
+            "ruler" => items.ruler = true,
+            "ice-pack" => items.ice_packs += 1,
+            _ => items.cage = false,
+        }
+        Ok(Outcome::json(
+            StatusCode::CREATED,
+            json!({ "detail": "Purchased. No refunds.", "cash": self.cash }),
+        )
+        .header(
+            header::LOCATION,
+            format!("/runs/{}/inventory/{slug}", self.id),
+        ))
+    }
+
+    pub fn drop_item(&mut self, slug: &str) -> Result<Outcome, Problem> {
+        match slug {
+            "extender" => self.items.extender = false,
+            "cock-ring" => self.items.ring = false,
+            "chastity-cage" => {
+                return Err(Problem::new(
+                    StatusCode::LOCKED,
+                    "caged",
+                    "The cage is locked.",
+                ));
+            }
+            _ => {
+                return Err(Problem::new(
+                    StatusCode::FORBIDDEN,
+                    "cannot-be-dropped",
+                    "That cannot be dropped.",
+                ));
+            }
+        }
+        self.touch();
+        Ok(Outcome::empty(StatusCode::NO_CONTENT))
+    }
+
+    pub(super) fn branch_offer(&self) -> Outcome {
+        let forum = format!("/runs/{}/branches/forum", self.id);
+        let close = format!("/runs/{}/branches/close-tab", self.id);
+        Outcome::json(
+            StatusCode::MULTIPLE_CHOICES,
+            json!({
+                "detail": "A browser tab is open. It has been open for some time.",
+                "choices": [
+                    { "href": forum, "method": "POST", "title": "Read the forum" },
+                    { "href": close, "method": "POST", "title": "Close the tab" },
+                ],
+            }),
+        )
+        .header(
+            header::LINK,
+            format!(
+                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\", <{close}>; rel=\"alternate\"; title=\"Close the tab\""
+            ),
+        )
+    }
+
+    pub fn choose(&mut self, choice: &str) -> Result<Outcome, Problem> {
+        if !self.branch_pending {
+            return Err(Problem::new(
+                StatusCode::CONFLICT,
+                "no-decision-pending",
+                "There is no decision pending.",
+            ));
+        }
+        let (location, detail) = match choice {
+            "forum" => {
+                self.forum_read = true;
+                self.shame += 3;
+                (
+                    format!("/runs/{}/techniques", self.id),
+                    "The thread is from 2009. A technique called uli is discussed at length.",
+                )
+            }
+            "close-tab" => {
+                self.suspicion = 0;
+                (
+                    format!("/runs/{}", self.id),
+                    "The tab is closed. Nobody saw it.",
+                )
+            }
+            _ => {
+                return Err(Problem::new(
+                    StatusCode::NOT_FOUND,
+                    "no-such-choice",
+                    "That was not one of the choices.",
+                ));
+            }
+        };
+        self.branch_pending = false;
+        self.touch();
+        Ok(
+            Outcome::json(StatusCode::SEE_OTHER, json!({ "detail": detail }))
+                .header(header::LOCATION, location),
+        )
+    }
+
+    pub fn put(&mut self) -> Outcome {
+        if self.put_applied {
+            return Outcome::empty(StatusCode::NO_CONTENT);
+        }
+        self.put_applied = true;
+        self.length += 0.01;
+        self.touch();
+        Outcome::json(StatusCode::OK, json!({ "detail": "Applied." }))
+    }
+
+    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {
+        for op in ops {
+            if op.op != "test" {
+                return Err(Problem::new(
+                    StatusCode::UNPROCESSABLE_ENTITY,
+                    "wishful-thinking",
+                    "The server accepts only the truth.",
+                )
+                .with("op", op.op.clone()));
+            }
+            let actual = match op.path.as_str() {
+                "/length" => self.current_length(),
+                "/girth" => self.girth,
+                "/foreskin" => self.foreskin.unwrap_or(0.0),
+                _ => {
+                    return Err(Problem::new(
+                        StatusCode::UNPROCESSABLE_ENTITY,
+                        "no-such-measurement",
+                        "There is no such measurement.",
+                    )
+                    .with("path", op.path.clone()));
+                }
+            };
+            let Some(claimed) = op.value.as_f64() else {
+                return Err(Problem::new(
+                    StatusCode::BAD_REQUEST,
+                    "malformed-patch",
+                    "A test requires a numeric value.",
+                ));
+            };
+            if op.path == "/length" && claimed >= actual + 1.0 {
+                self.shame += 2;
+                self.touch();
+                return Err(exaggeration());
+            }
+            if tenths(claimed) != tenths(actual) {
+                self.shame += 1;
+                self.touch();
+                return Err(
+                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
+                        .with("path", op.path.clone()),
+                );
+            }
+        }
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "Correct." }),
+        ))
+    }
+
+    pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {
+        if self.foreskin.is_none() {
+            return Err(Problem::new(
+                StatusCode::GONE,
+                "foreskin-gone",
+                "The foreskin is gone. It will not be returning.",
+            ));
+        }
+        let Some(if_match) = if_match else {
+            return Err(Problem::new(
+                StatusCode::PRECONDITION_REQUIRED,
+                "confirmation-required",
+                "The server requires you to be sure. Send If-Match.",
+            ));
+        };
+        if !super::etag_matches(if_match, &self.etag()) {
+            return Err(Problem::new(
+                StatusCode::PRECONDITION_FAILED,
+                "stale-foreskin",
+                "The foreskin has changed since you last looked at it.",
+            ));
+        }
+        self.foreskin = None;
+        self.shame += 20;
+        self.touch();
+        Ok(Outcome::empty(StatusCode::NO_CONTENT))
+    }
+
+    pub fn set_grip(&mut self, grip: Grip) {
+        self.grip = grip;
+        self.touch();
+    }
+
+    pub fn accept_terms(&mut self) -> Result<Outcome, Problem> {
+        if self.floor != Floor::Hotel {
+            return Err(Problem::new(
+                StatusCode::NOT_FOUND,
+                "no-portal",
+                "There is no captive portal here. There is only the regular kind of captivity.",
+            ));
+        }
+        self.wifi_accepted = true;
+        self.touch();
+        Ok(Outcome::json(
+            StatusCode::SEE_OTHER,
+            json!({ "detail": "Connected. The hotel does not want to know." }),
+        )
+        .header(header::LOCATION, format!("/runs/{}", self.id)))
+    }
+
+    pub fn elder(
+        &mut self,
+        proxy_authorization: Option<&str>,
+        if_modified_since: Option<&str>,
+    ) -> Result<Outcome, Problem> {
+        if self.floor != Floor::Forum {
+            return Err(Problem::new(
+                StatusCode::NOT_FOUND,
+                "elder-absent",
+                "The Elder only posts on the forum.",
+            ));
+        }
+        if !self.verified {
+            let verification = |detail: &str| {
+                Problem::new(
+                    StatusCode::PROXY_AUTHENTICATION_REQUIRED,
+                    "verification-required",
+                    detail,
+                )
+                .header(header::PROXY_AUTHENTICATE, "Ruler realm=\"forum\"")
+            };
+            let Some(credentials) = proxy_authorization else {
+                return Err(verification("The forum requires verification."));
+            };
+            let Some(claimed) =
+                parse_credentials(credentials, "ruler").and_then(|v| v.parse::<f64>().ok())
+            else {
+                return Err(verification("The forum requires verification, in inches."));
+            };
+            let actual = self.current_length();
+            if claimed >= actual + 1.0 {
+                self.shame += 2;
+                self.touch();
+                return Err(exaggeration());
+            }
+            if tenths(claimed) != tenths(actual) {
+                self.shame += 1;
+                self.touch();
+                return Err(verification("Verification failed. The forum can tell."));
+            }
+            self.verified = true;
+            self.touch();
+        }
+
+        let last_modified =
+            httpdate::parse_http_date(ELDER_LAST_MODIFIED).expect("valid constant date");
+        let current = if_modified_since
+            .and_then(|d| httpdate::parse_http_date(d).ok())
+            .is_some_and(|since| since >= last_modified);
+        if current {
+            self.elder_beaten = true;
+            self.touch();
+            return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)
+                .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED));
+        }
+        Ok(
+            Outcome::raw(StatusCode::OK, "text/csv; header=present", SPREADSHEET)
+                .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED),
+        )
+    }
+
+    pub fn diagnose(
+        &mut self,
+        authorization: Option<&str>,
+        if_none_match: Option<&str>,
+    ) -> Result<Outcome, Problem> {
+        if self.floor != Floor::Clinic {
+            let floors = Floor::Clinic.number() - self.floor.number();
+            return Err(Problem::new(
+                StatusCode::TOO_EARLY,
+                "no-appointment",
+                format!("The clinic's next available appointment is {floors} floors away."),
+            ));
+        }
+        let intake = Problem::new(
+            StatusCode::UNAUTHORIZED,
+            "intake",
+            "The clinic requires authorization.",
+        );
+        let Some(authorization) = authorization else {
+            return Err(intake.header(header::WWW_AUTHENTICATE, "Bearer realm=\"clinic\""));
+        };
+        let honest = parse_credentials(authorization, "bearer")
+            .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));
+        if !honest {
+            let hint = INTAKE[self.intake_attempts.min(INTAKE.len() - 1)];
+            self.intake_attempts += 1;
+            return Err(intake.header(
+                header::WWW_AUTHENTICATE,
+                format!(
+                    "Bearer realm=\"clinic\", error=\"invalid_token\", error_description=\"{hint}\""
+                ),
+            ));
+        }
+
+        self.peyronie = false;
+        let etag = self.origin_etag.clone();
+        if if_none_match.is_some_and(|inm| super::etag_matches(inm, &etag)) {
+            self.cured = true;
+            return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)
+                .header(header::ETAG, etag)
+                .header(X_DIAGNOSIS, "normal"));
+        }
+        if !self.measured {
+            self.measured = true;
+            if !self.items.ruler {
+                self.shame += 15;
+            }
+        }
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({
+                "diagnosis": "within normal range",
+                "measured_length": round2(self.length),
+                "you_said": round2(self.self_reported()),
+                "prescription": "Please stop.",
+            }),
+        )
+        .header(header::ETAG, etag))
+    }
+}
+
+fn pump_bro_absent() -> Problem {
+    Problem::new(
+        StatusCode::NOT_FOUND,
+        "pump-bro-absent",
+        "Pump-Bro is not here.",
+    )
+}

Added file: src/game/jelq.rs+603 additions@@ -0,0 +1,603 @@
+use std::{
+    fmt::Write as _,
+    time::{Duration, Instant, SystemTime},
+};
+
+use axum::http::{StatusCode, header};
+use rand::Rng;
+use serde_json::json;
+
+use super::{
+    CLINIC_ALLOW, FORUM_THREAD, Floor, Grip, Lube, Outcome, REFRACTORY, Run, SERVER_TIMING,
+    SUSPICION_LIMIT, Technique, catalog::LubeRule, catalog::Profile, not_extended, round3,
+};
+use crate::{game::LUBRICANTS, problem::Problem};
+
+const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);
+
+impl Run {
+    pub fn jelq(
+        &mut self,
+        techniques: &[Technique],
+        intensity: i32,
+        lube: Option<Lube>,
+        now: Instant,
+    ) -> Result<Outcome, Problem> {
+        self.check_refractory(now)?;
+        if self.branch_pending {
+            return Ok(self.branch_offer());
+        }
+        match self.floor {
+            Floor::Forum => {
+                return Ok(Outcome::json(
+                    StatusCode::SEE_OTHER,
+                    json!({ "detail": "Refer to the forum." }),
+                )
+                .header(header::LOCATION, FORUM_THREAD));
+            }
+            Floor::Clinic => {
+                return Err(Problem::new(
+                    StatusCode::METHOD_NOT_ALLOWED,
+                    "not-in-the-clinic",
+                    "JELQ is not performed in the clinic.",
+                )
+                .header(header::ALLOW, CLINIC_ALLOW));
+            }
+            _ => {}
+        }
+        if self.items.cage {
+            return Err(Problem::new(
+                StatusCode::LOCKED,
+                "caged",
+                "The cage is locked. The key is not in the box.",
+            ));
+        }
+        match *techniques {
+            [technique] => self.single(technique, intensity, lube, now),
+            [a, b] => self.combo(a, b, intensity, lube, now),
+            _ => Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "too-many-techniques",
+                "Two techniques at most. The server has limits even if you do not.",
+            )),
+        }
+    }
+
+    fn single(
+        &mut self,
+        technique: Technique,
+        intensity: i32,
+        lube: Option<Lube>,
+        now: Instant,
+    ) -> Result<Outcome, Problem> {
+        match technique {
+            Technique::Warmup => return self.warm_up(),
+            Technique::Ice => return self.ice(),
+            Technique::Supplement => return self.supplement(),
+            Technique::Edge => {}
+            _ => self.edges = 0,
+        }
+        self.prepare(technique, lube)?;
+        self.check_storage()?;
+        self.floor_enemy()?;
+        match technique {
+            Technique::Edge => return self.edge(now),
+            Technique::Pump => return self.pump(now),
+            _ => {}
+        }
+        let profile = technique.profile().expect("training technique");
+        self.commit(intensity, lube, now, 1);
+        self.hazards(intensity)?;
+        let result = self.roll(technique, &profile, intensity, lube);
+        Ok(self.gossip(result?))
+    }
+
+    fn combo(
+        &mut self,
+        a: Technique,
+        b: Technique,
+        intensity: i32,
+        lube: Option<Lube>,
+        now: Instant,
+    ) -> Result<Outcome, Problem> {
+        let (Some(first), Some(second)) = (a.profile(), b.profile()) else {
+            return Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "combo-invalid",
+                "Only training techniques can be combined.",
+            ));
+        };
+        if a == b {
+            return Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "combo-invalid",
+                "A technique cannot be combined with itself. The server has checked.",
+            ));
+        }
+        self.edges = 0;
+        self.prepare(a, lube)?;
+        self.prepare(b, lube)?;
+        self.check_storage()?;
+        self.floor_enemy()?;
+        self.commit(intensity, lube, now, 2);
+        self.hazards(intensity)?;
+
+        let mut statuses = Vec::new();
+        for (technique, profile) in [(a, first), (b, second)] {
+            let result = self.roll(technique, &profile, intensity, lube);
+            if self.ended.is_some() {
+                return result;
+            }
+            let status = match &result {
+                Ok(outcome) => outcome.status(),
+                Err(problem) => problem.status(),
+            };
+            statuses.push((technique, status));
+        }
+
+        let mut xml = String::from(
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",
+        );
+        for (technique, status) in statuses {
+            let _ = write!(
+                xml,
+                "  <D:response>\n    <D:href>/runs/{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",
+                self.id,
+                technique.name(),
+                status.as_u16(),
+                status.canonical_reason().unwrap_or_default(),
+            );
+        }
+        xml.push_str(
+            "  <D:responsedescription>Each technique has been reported separately.</D:responsedescription>\n</D:multistatus>\n",
+        );
+        Ok(Outcome::raw(
+            StatusCode::MULTI_STATUS,
+            "application/xml; charset=utf-8",
+            xml,
+        ))
+    }
+
+    fn prepare(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {
+        if technique == Technique::Uli && !self.forum_read {
+            return Err(Problem::new(
+                StatusCode::FORBIDDEN,
+                "technique-locked",
+                "This technique is discussed on the forum. You have not been to the forum.",
+            ));
+        }
+        if !self.warmed_up {
+            return Err(Problem::new(
+                StatusCode::PRECONDITION_FAILED,
+                "cold-start",
+                "Warm-up was skipped. The server has noted this.",
+            )
+            .with("technique", Technique::Warmup.name()));
+        }
+        if technique == Technique::Pump && !self.items.pump_pro {
+            return Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-pump",
+                "The pump technique depends on a pump.",
+            ));
+        }
+        let Some(profile) = technique.profile() else {
+            return Ok(());
+        };
+        match (profile.lube, lube) {
+            (LubeRule::Required, None) => {
+                return Err(Problem::new(
+                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                    "lubricant-required",
+                    format!(
+                        "The {} technique requires a lubricant. None was declared.",
+                        technique.name()
+                    ),
+                )
+                .with("lubricants", json!(LUBRICANTS)));
+            }
+            (LubeRule::Forbidden, Some(_)) => {
+                return Err(Problem::new(
+                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                    "lubricant-declared",
+                    "The dry technique was requested. A lubricant was declared.",
+                ));
+            }
+            _ => {}
+        }
+        if let Some((min, max)) = profile.foreskin {
+            self.check_foreskin(min, max)?;
+        }
+        Ok(())
+    }
+
+    fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {
+        let Some(f) = self.foreskin else {
+            if min <= 0.0 {
+                return Ok(());
+            }
+            return Err(Problem::new(
+                StatusCode::GONE,
+                "foreskin-gone",
+                "This technique requires a foreskin. The foreskin is gone.",
+            )
+            .header(
+                header::CONTENT_LOCATION,
+                format!("/runs/{}/foreskin", self.id),
+            ));
+        };
+        if f < min {
+            return Err(Problem::new(
+                StatusCode::LENGTH_REQUIRED,
+                "foreskin-insufficient",
+                format!(
+                    "The selected technique requires {min:.1} units of foreskin. {f:.2} units are available. The server has noted the shortfall."
+                ),
+            )
+            .with("required", min)
+            .with("available", super::round2(f)));
+        }
+        if f > max {
+            return Err(Problem::new(
+                StatusCode::PAYLOAD_TOO_LARGE,
+                "foreskin-excessive",
+                format!(
+                    "The selected technique tolerates at most {max:.1} units of foreskin. {f:.2} units are present."
+                ),
+            )
+            .with("maximum", max)
+            .with("present", super::round2(f)));
+        }
+        Ok(())
+    }
+
+    fn check_storage(&self) -> Result<(), Problem> {
+        if self.items.extender && self.girth > 5.0 {
+            return Err(Problem::new(
+                StatusCode::INSUFFICIENT_STORAGE,
+                "jeans-full",
+                "The jeans are full. The extender is occupying the remaining storage.",
+            )
+            .with("extender", format!("/runs/{}/inventory/extender", self.id)));
+        }
+        Ok(())
+    }
+
+    fn commit(&mut self, intensity: i32, lube: Option<Lube>, now: Instant, cost: i32) {
+        self.touch();
+        self.turn += 1;
+        self.floor_turns += 1;
+        self.realize();
+        if self.items.extender {
+            self.length += 0.004;
+        }
+        self.stamina -= cost + i32::from(lube == Some(Lube::Lotion));
+        if self.stamina <= 0 {
+            self.stamina = 0;
+            self.refractory_until = Some(now + REFRACTORY);
+        }
+        let chill = if self.floor == Floor::LockerRoom {
+            8
+        } else {
+            0
+        };
+        self.eq = (self.eq + intensity * 2 - 6 - chill).clamp(0, 100);
+
+        let mut suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));
+        if matches!(self.floor, Floor::LockerRoom | Floor::Grandmas) {
+            suspicion *= 2;
+        }
+        if self.floor == Floor::Grandmas && lube == Some(Lube::CoconutOil) {
+            suspicion += 2;
+        }
+        let was_below = self.suspicion < SUSPICION_LIMIT;
+        self.suspicion =
+            (i32::from(self.suspicion) + suspicion).min(i32::from(SUSPICION_LIMIT)) as u8;
+        if self.floor.has_mom() && !self.mom_present {
+            let summoned = was_below && self.suspicion == SUSPICION_LIMIT;
+            if summoned || self.rng.random_ratio(u32::from(self.suspicion) + 1, 16) {
+                self.mom_present = true;
+                self.mom_errand = self.errand(summoned);
+                self.nonce = self.fresh_nonce();
+            }
+        }
+
+        if let Some(observer) = self.floor.observer()
+            && self.rng.random_ratio(1, 6)
+        {
+            self.observed = Some(observer);
+            self.shame += 1;
+        }
+        if self.turn == super::BRANCH_TURN {
+            self.branch_pending = true;
+        }
+    }
+
+    fn hazards(&mut self, intensity: i32) -> Result<(), Problem> {
+        if self.floor == Floor::LockerRoom && self.rng.random_ratio(1, 10) {
+            self.shame += 1;
+            return Err(Problem::new(
+                StatusCode::USE_PROXY,
+                "friend",
+                "A friend has offered to help. Use Proxy is deprecated, and the server has declined on your behalf.",
+            ));
+        }
+        if self.peyronie && self.rng.random_ratio(1, 3) {
+            return Err(Problem::new(
+                StatusCode::MISDIRECTED_REQUEST,
+                "misdirected",
+                "The technique landed slightly to the left. It was meant for a different server.",
+            ));
+        }
+        if intensity <= 2 && self.eq < 50 {
+            self.eq = (self.eq - 10).max(0);
+            return Err(Problem::new(
+                StatusCode::REQUEST_TIMEOUT,
+                "lost-it",
+                "The request took too long. It was lost.",
+            )
+            .header(header::CONNECTION, "close"));
+        }
+        if self.eq > 95 {
+            self.shame += 5;
+            self.next_floor();
+            return Err(Problem::new(
+                StatusCode::TOO_EARLY,
+                "premature",
+                "The floor has ended early. Everyone involved has agreed not to discuss it.",
+            )
+            .with("floor", self.floor.number()));
+        }
+        if self.eq < 30 {
+            return Err(Problem::new(
+                StatusCode::NOT_FOUND,
+                "cold",
+                "The resource exists. It is cold.",
+            )
+            .with("eq", self.eq));
+        }
+        Ok(())
+    }
+
+    fn roll(
+        &mut self,
+        technique: Technique,
+        profile: &Profile,
+        intensity: i32,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        let natural: i32 = self.rng.random_range(1..=20);
+        let band = if (50..=70).contains(&self.eq) { 2 } else { 0 };
+        let grip = match (self.grip, technique) {
+            (Grip::Underhand, Technique::Stretch) => 2,
+            (Grip::Underhand, Technique::Wet) => -1,
+            _ => 0,
+        };
+        let modifier = lube.map_or(0, Lube::modifier) + band + grip;
+        let dc = profile.dc + intensity / 3;
+        let total = natural + modifier;
+        let timing = format!("roll;desc=\"d20{modifier:+} vs {dc}\";dur={natural}");
+        let timed = |p: Problem| p.header(SERVER_TIMING, &timing);
+
+        let scale = f64::from(intensity);
+        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
+        if self.teapot {
+            length *= 0.5;
+            girth *= 1.5;
+        }
+        if self.items.ring {
+            girth *= 2.0;
+        }
+        let rupture_eq = if self.items.ring { 80 } else { 90 };
+
+        if natural == 1 {
+            let touches_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);
+            if touches_foreskin && self.foreskin.is_some() {
+                self.foreskin = None;
+                self.shame += 25;
+                return Err(timed(
+                    Problem::new(
+                        StatusCode::GONE,
+                        "foreskin-lost",
+                        "The technique has removed the foreskin. It will not be returning.",
+                    )
+                    .header(
+                        header::CONTENT_LOCATION,
+                        format!("/runs/{}/foreskin", self.id),
+                    ),
+                ));
+            }
+            if self.eq > 70 {
+                return Err(timed(self.rupture()));
+            }
+            if technique == Technique::Stretch && !self.teapot {
+                self.teapot = true;
+                self.items.teapot_spout = true;
+                self.shame += 5;
+                return Err(timed(Problem::new(
+                    StatusCode::IM_A_TEAPOT,
+                    "teapot",
+                    "The subject is now short and stout. Length gains are halved for the rest of the floor.",
+                )));
+            }
+            if technique == Technique::Uli && !self.peyronie {
+                self.peyronie = true;
+                self.shame += 5;
+                return Err(timed(Problem::new(
+                    StatusCode::MISDIRECTED_REQUEST,
+                    "curvature",
+                    "A curvature has developed. Techniques will land slightly to the left until a professional is consulted.",
+                )));
+            }
+            return Err(timed(not_extended()));
+        }
+        if self.eq > rupture_eq && total < dc {
+            return Err(timed(self.rupture()));
+        }
+        if natural == 20 {
+            self.gain(length * 2.0, girth * 2.0, profile.foreskin_growth);
+            return Ok(Outcome::json(
+                StatusCode::CREATED,
+                json!({
+                    "detail": "A permanent gain has been created.",
+                    "length": round3(length * 2.0),
+                    "girth": round3(girth * 2.0),
+                }),
+            )
+            .header(header::LOCATION, format!("/runs/{}/length", self.id))
+            .header(SERVER_TIMING, timing));
+        }
+        if total < dc - 3 {
+            return Err(timed(not_extended()));
+        }
+        if total < dc {
+            return Ok(Outcome::empty(StatusCode::NO_CONTENT).header(SERVER_TIMING, timing));
+        }
+
+        let outcome = if self.eq < 50 {
+            self.gain(length / 2.0, girth / 2.0, profile.foreskin_growth);
+            Outcome::json(
+                StatusCode::PARTIAL_CONTENT,
+                json!({
+                    "detail": "Partial gains were applied. EQ was below the band.",
+                    "length": round3(length / 2.0),
+                    "girth": round3(girth / 2.0),
+                }),
+            )
+        } else if total >= dc + 5 {
+            self.gain(length, girth, profile.foreskin_growth);
+            Outcome::json(
+                StatusCode::OK,
+                json!({
+                    "detail": "Gains were applied.",
+                    "length": round3(length),
+                    "girth": round3(girth),
+                }),
+            )
+        } else {
+            let eta = self.rng.random_range(1..=4);
+            self.pending.push(super::Pending {
+                due: self.turn + eta,
+                length,
+                girth,
+            });
+            self.gain(0.0, 0.0, profile.foreskin_growth);
+            Outcome::json(
+                StatusCode::ACCEPTED,
+                json!({
+                    "detail": "Gains have been queued. They may arrive.",
+                    "eta_turns": eta,
+                }),
+            )
+        };
+        Ok(outcome.header(SERVER_TIMING, timing))
+    }
+
+    fn gossip(&mut self, outcome: Outcome) -> Outcome {
+        let reportable = matches!(outcome.status.as_u16(), 200 | 202 | 206);
+        if !self.roommate_told || !reportable {
+            return outcome;
+        }
+        self.roommate_told = false;
+        let mut outcome = outcome;
+        outcome.status = StatusCode::ALREADY_REPORTED;
+        if let super::Payload::Json(body) = &mut outcome.payload {
+            body["detail"] = json!("The roommate has already told everyone.");
+        }
+        outcome
+    }
+
+    fn warm_up(&mut self) -> Result<Outcome, Problem> {
+        if self.floor == Floor::Hotel && self.rng.random_ratio(1, 3) {
+            return Err(Problem::new(
+                StatusCode::SERVICE_UNAVAILABLE,
+                "service-unavailable",
+                "Service is unavailable. The server estimates next week. The server is being pessimistic.",
+            )
+            .header(
+                header::RETRY_AFTER,
+                httpdate::fmt_http_date(SystemTime::now() + WEEK),
+            ));
+        }
+        let (boost, detail) = if self.floor == Floor::Bathroom {
+            (
+                35,
+                "Warmed up. The shower is hot. The roommate's will not be.",
+            )
+        } else {
+            (25, "Warmed up. The towel has cooled.")
+        };
+        self.touch();
+        self.warmed_up = true;
+        self.eq = (self.eq + boost).min(100);
+        Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })))
+    }
+
+    fn ice(&mut self) -> Result<Outcome, Problem> {
+        if self.items.ice_packs == 0 {
+            return Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-ice",
+                "The ice technique depends on an ice pack. There are none.",
+            ));
+        }
+        self.touch();
+        self.items.ice_packs -= 1;
+        self.eq = (self.eq - 40).max(0);
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "EQ has been reduced. The ice pack is gone." }),
+        ))
+    }
+
+    fn supplement(&mut self) -> Result<Outcome, Problem> {
+        if self.items.supplements == 0 {
+            return Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-supplement",
+                "The supplement technique depends on a supplement.",
+            ));
+        }
+        self.items.supplements -= 1;
+        self.touch();
+        Err(Problem::new(
+            StatusCode::BAD_GATEWAY,
+            "bad-gateway",
+            "The upstream returned an invalid response.",
+        )
+        .with("upstream", "Pump-Bro"))
+    }
+
+    fn edge(&mut self, now: Instant) -> Result<Outcome, Problem> {
+        self.commit(5, None, now, 1);
+        self.edges += 1;
+        self.eq = (self.eq + 11).min(100);
+        self.girth += 0.004;
+        if self.edges >= 3 {
+            self.edges = 0;
+            self.stamina = 0;
+            self.refractory_until = Some(now + REFRACTORY);
+            return Err(Problem::new(
+                StatusCode::LOOP_DETECTED,
+                "edging-loop",
+                "Edging has looped. The server detected an infinite loop and terminated it.",
+            ));
+        }
+        self.hazards(5)?;
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "Edged. EQ is rising. Nothing else is.", "edges": self.edges }),
+        ))
+    }
+
+    fn pump(&mut self, now: Instant) -> Result<Outcome, Problem> {
+        self.commit(4, None, now, 1);
+        self.hazards(4)?;
+        self.temp_length += 0.5;
+        Ok(Outcome::json(
+            StatusCode::TEMPORARY_REDIRECT,
+            json!({ "detail": "Gains applied. They are temporary.", "length": 0.5 }),
+        )
+        .header(header::LOCATION, format!("/runs/{}/length", self.id)))
+    }
+}

Added file: src/game/mod.rs+666 additions@@ -0,0 +1,666 @@
+mod catalog;
+mod encounters;
+mod jelq;
+
+pub use catalog::{LUBRICANTS, Lube, SHOP, ShopItem, Technique};
+pub use encounters::{ELDER_LAST_MODIFIED, FORUM_THREAD, PatchOp, forum_thread};
+
+use std::time::{Duration, Instant};
+
+use axum::{
+    Json,
+    http::{HeaderName, HeaderValue, StatusCode, header},
+    response::{IntoResponse, Response},
+};
+use rand::{Rng, SeedableRng, rngs::StdRng};
+use serde_json::{Value, json};
+
+use crate::problem::Problem;
+
+pub const MAX_STAMINA: i32 = 10;
+pub const SUSPICION_LIMIT: u8 = 5;
+pub const BRANCH_TURN: u32 = 10;
+pub const FLOOR_TURNS: u32 = 6;
+pub const STARTING_CASH: u32 = 20;
+pub const FLOOR_ALLOWANCE: u32 = 10;
+pub const REFRACTORY: Duration = Duration::from_secs(30);
+pub const SELF_REPORT_INFLATION: f64 = 1.5;
+pub const MM_PER_INCH: f64 = 25.4;
+pub const RUN_ALLOW: &str = "GET, HEAD, JELQ, PUT, PATCH, DELETE, OPTIONS, TRACE";
+pub const CLINIC_ALLOW: &str = "GET, HEAD, PUT, PATCH, DELETE, OPTIONS, TRACE";
+
+pub const SERVER_TIMING: HeaderName = HeaderName::from_static("server-timing");
+pub const X_DIAGNOSIS: HeaderName = HeaderName::from_static("x-diagnosis");
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Floor {
+    Bedroom,
+    Bathroom,
+    LockerRoom,
+    Grandmas,
+    Hotel,
+    Forum,
+    Clinic,
+}
+
+impl Floor {
+    const ALL: [Self; 7] = [
+        Self::Bedroom,
+        Self::Bathroom,
+        Self::LockerRoom,
+        Self::Grandmas,
+        Self::Hotel,
+        Self::Forum,
+        Self::Clinic,
+    ];
+
+    pub fn number(self) -> usize {
+        Self::ALL.iter().position(|f| *f == self).unwrap_or(0) + 1
+    }
+
+    fn next(self) -> Option<Self> {
+        Self::ALL.get(self.number()).copied()
+    }
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Bedroom => "the bedroom",
+            Self::Bathroom => "the shared bathroom",
+            Self::LockerRoom => "the gym locker room",
+            Self::Grandmas => "grandma's house for Thanksgiving",
+            Self::Hotel => "a business trip hotel",
+            Self::Forum => "the forum",
+            Self::Clinic => "the urologist's office",
+        }
+    }
+
+    pub fn note(self) -> &'static str {
+        match self {
+            Self::Bedroom => "The door does not lock. The cat is present.",
+            Self::Bathroom => "The water is hot. The roommate showers at eight.",
+            Self::LockerRoom => {
+                "It is cold. Discretion is advised. Everyone here is lying. Pump-Bro is by the lockers."
+            }
+            Self::Grandmas => {
+                "The walls are thin. Mom is here, and she has been reading about Digest authentication."
+            }
+            Self::Hotel => {
+                "The wifi requires agreement. Housekeeping does not knock. Pump-Bro is in the lobby."
+            }
+            Self::Forum => "Nothing physical happens here. The Elder has a spreadsheet.",
+            Self::Clinic => "The urologist will see you now. He is bored.",
+        }
+    }
+
+    fn observer(self) -> Option<&'static str> {
+        match self {
+            Self::Bedroom => Some("cat"),
+            Self::LockerRoom => Some("greg"),
+            Self::Grandmas => Some("grandma"),
+            _ => None,
+        }
+    }
+
+    pub fn shop_open(self) -> bool {
+        matches!(self, Self::LockerRoom | Self::Hotel)
+    }
+
+    pub fn has_mom(self) -> bool {
+        matches!(self, Self::Bedroom | Self::Grandmas)
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Grip {
+    Overhand,
+    Underhand,
+}
+
+impl Grip {
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Overhand => "overhand",
+            Self::Underhand => "underhand",
+        }
+    }
+
+    pub fn parse(protocol: &str) -> Option<Self> {
+        match protocol.to_ascii_lowercase().as_str() {
+            "overhand" => Some(Self::Overhand),
+            "underhand" => Some(Self::Underhand),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct Items {
+    pub ruler: bool,
+    pub ice_packs: u32,
+    pub door_locks: u32,
+    pub dnd_sign: bool,
+    pub pump_pro: bool,
+    pub extender: bool,
+    pub ring: bool,
+    pub supplements: u32,
+    pub cage: bool,
+    pub spreadsheet: bool,
+    pub teapot_spout: bool,
+}
+
+enum Payload {
+    Empty,
+    Json(Value),
+    Raw(&'static str, Vec<u8>),
+}
+
+pub struct Outcome {
+    status: StatusCode,
+    payload: Payload,
+    headers: Vec<(HeaderName, String)>,
+}
+
+impl Outcome {
+    pub fn empty(status: StatusCode) -> Self {
+        Self {
+            status,
+            payload: Payload::Empty,
+            headers: Vec::new(),
+        }
+    }
+
+    pub fn json(status: StatusCode, body: Value) -> Self {
+        Self {
+            payload: Payload::Json(body),
+            ..Self::empty(status)
+        }
+    }
+
+    pub fn raw(status: StatusCode, content_type: &'static str, body: impl Into<Vec<u8>>) -> Self {
+        Self {
+            payload: Payload::Raw(content_type, body.into()),
+            ..Self::empty(status)
+        }
+    }
+
+    pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {
+        self.headers.push((name, value.into()));
+        self
+    }
+
+    pub fn status(&self) -> StatusCode {
+        self.status
+    }
+}
+
+impl IntoResponse for Outcome {
+    fn into_response(self) -> Response {
+        let mut response = match self.payload {
+            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.
+            Payload::Json(body) if self.status == StatusCode::PARTIAL_CONTENT => {
+                let full = body.to_string().into_bytes();
+                let half = full.len() / 2;
+                let range = format!("bytes 0-{}/{}", half - 1, full.len());
+                (
+                    self.status,
+                    [
+                        (header::CONTENT_TYPE, "application/json".to_owned()),
+                        (header::CONTENT_RANGE, range),
+                    ],
+                    full[..half].to_vec(),
+                )
+                    .into_response()
+            }
+            Payload::Json(body) => (self.status, Json(body)).into_response(),
+            Payload::Raw(content_type, body) => {
+                (self.status, [(header::CONTENT_TYPE, content_type)], body).into_response()
+            }
+            Payload::Empty => self.status.into_response(),
+        };
+        for (name, value) in self.headers {
+            let value = HeaderValue::from_str(&value).expect("header values are visible ascii");
+            response.headers_mut().append(name, value);
+        }
+        response
+    }
+}
+
+pub struct Pending {
+    due: u32,
+    length: f64,
+    girth: f64,
+}
+
+pub struct Ending {
+    pub cause: &'static str,
+    pub detail: String,
+    pub turn: u32,
+}
+
+pub struct Run {
+    pub id: String,
+    pub origin_etag: String,
+    pub version: u64,
+    pub turn: u32,
+    pub floor: Floor,
+    pub floor_turns: u32,
+    pub length: f64,
+    pub temp_length: f64,
+    pub girth: f64,
+    pub foreskin: Option<f64>,
+    pub eq: i32,
+    pub stamina: i32,
+    pub suspicion: u8,
+    pub shame_base: u32,
+    pub shame: u32,
+    pub cash: u32,
+    pub grip: Grip,
+    pub items: Items,
+    pub warmed_up: bool,
+    pub teapot: bool,
+    pub peyronie: bool,
+    pub put_applied: bool,
+    pub forum_read: bool,
+    pub branch_pending: bool,
+    pub mom_present: bool,
+    pub mom_errand: &'static str,
+    pub observed: Option<&'static str>,
+    pub measured: bool,
+    pub cured: bool,
+    pub roommate_told: bool,
+    pub wifi_accepted: bool,
+    pub verified: bool,
+    pub elder_beaten: bool,
+    pub edges: u8,
+    pub drawer_searches: u8,
+    pub intake_attempts: usize,
+    pub nonce: String,
+    pub heard: Vec<String>,
+    pub refractory_until: Option<Instant>,
+    pub pending: Vec<Pending>,
+    pub ended: Option<Ending>,
+    rng: StdRng,
+}
+
+pub fn round2(x: f64) -> f64 {
+    (x * 100.0).round() / 100.0
+}
+
+fn round3(x: f64) -> f64 {
+    (x * 1000.0).round() / 1000.0
+}
+
+fn tenths(x: f64) -> i64 {
+    (x * 10.0).round() as i64
+}
+
+fn not_extended() -> Problem {
+    Problem::new(
+        StatusCode::NOT_EXTENDED,
+        "not-extended",
+        "The requested extension was not applied. The server has recorded the attempt.",
+    )
+}
+
+pub fn parse_credentials<'a>(authorization: &'a str, scheme: &str) -> Option<&'a str> {
+    let (given, rest) = authorization.trim().split_once(' ')?;
+    given
+        .eq_ignore_ascii_case(scheme)
+        .then(|| rest.trim().trim_matches('"'))
+}
+
+pub fn etag_matches(condition: &str, etag: &str) -> bool {
+    condition
+        .split(',')
+        .map(str::trim)
+        .any(|tag| tag == "*" || tag.trim_start_matches("W/") == etag)
+}
+
+pub fn shaft(mm: usize) -> String {
+    format!("8{}D", "=".repeat(mm.saturating_sub(2)))
+}
+
+impl Run {
+    pub fn new(id: String, seed: u64, shame_base: u32) -> Self {
+        let mut rng = StdRng::seed_from_u64(seed);
+        let length = round2(rng.random_range(4.5..6.5));
+        let girth = round2(rng.random_range(4.0..5.0));
+        let foreskin = round2(rng.random_range(0.4..2.4));
+        let mut run = Self {
+            id,
+            origin_etag: String::new(),
+            version: 0,
+            turn: 0,
+            floor: Floor::Bedroom,
+            floor_turns: 0,
+            length,
+            temp_length: 0.0,
+            girth,
+            foreskin: Some(foreskin),
+            eq: 20,
+            stamina: MAX_STAMINA,
+            suspicion: 0,
+            shame_base,
+            shame: 0,
+            cash: STARTING_CASH,
+            grip: Grip::Overhand,
+            items: Items {
+                ice_packs: 1,
+                ..Items::default()
+            },
+            warmed_up: false,
+            teapot: false,
+            peyronie: false,
+            put_applied: false,
+            forum_read: false,
+            branch_pending: false,
+            mom_present: false,
+            mom_errand: "She heard a noise.",
+            observed: None,
+            measured: false,
+            cured: false,
+            roommate_told: false,
+            wifi_accepted: false,
+            verified: false,
+            elder_beaten: false,
+            edges: 0,
+            drawer_searches: 0,
+            intake_attempts: 0,
+            nonce: String::new(),
+            heard: Vec::new(),
+            refractory_until: None,
+            pending: Vec::new(),
+            ended: None,
+            rng,
+        };
+        run.origin_etag = run.etag();
+        run.nonce = run.fresh_nonce();
+        run
+    }
+
+    pub fn etag(&self) -> String {
+        format!("\"{}-{}\"", self.id, self.version)
+    }
+
+    pub fn touch(&mut self) {
+        self.version += 1;
+    }
+
+    fn fresh_nonce(&mut self) -> String {
+        format!("{:016x}", self.rng.random::<u64>())
+    }
+
+    pub fn current_length(&self) -> f64 {
+        self.length + self.temp_length
+    }
+
+    pub fn self_reported(&self) -> f64 {
+        self.current_length() + SELF_REPORT_INFLATION
+    }
+
+    pub fn total_shame(&self) -> u32 {
+        self.shame_base + self.shame
+    }
+
+    pub fn status(&self) -> &'static str {
+        match (&self.ended, self.cured) {
+            (Some(_), _) => "gone",
+            (None, true) => "normal",
+            (None, false) => "alive",
+        }
+    }
+
+    pub fn view(&self) -> Value {
+        let conditions: Vec<&str> = [
+            (self.teapot, "short and stout"),
+            (self.peyronie, "curved"),
+            (self.items.cage, "caged"),
+        ]
+        .into_iter()
+        .filter_map(|(active, name)| active.then_some(name))
+        .collect();
+        let mut view = json!({
+            "id": self.id,
+            "status": self.status(),
+            "turn": self.turn,
+            "floor": { "number": self.floor.number(), "name": self.floor.name() },
+            "self_reported_length": round2(self.self_reported()),
+            "girth": round2(self.girth),
+            "foreskin": self.foreskin.map(round2),
+            "eq": self.eq,
+            "stamina": self.stamina,
+            "suspicion": self.suspicion,
+            "shame": self.total_shame(),
+            "cash": self.cash,
+            "grip": self.grip.name(),
+            "warmed_up": self.warmed_up,
+            "conditions": conditions,
+        });
+        if self.items.ruler {
+            view["length"] = json!(round2(self.current_length()));
+        }
+        view
+    }
+
+    pub fn floor_view(&self) -> Value {
+        let id = &self.id;
+        let turns_required = match self.floor {
+            Floor::Forum | Floor::Clinic => Value::Null,
+            _ => json!(FLOOR_TURNS),
+        };
+        let mut view = json!({
+            "number": self.floor.number(),
+            "name": self.floor.name(),
+            "note": self.floor.note(),
+            "turns": self.floor_turns,
+            "turns_required": turns_required,
+            "exit": { "href": format!("/runs/{id}/floor"), "method": "POST" },
+        });
+        match self.floor {
+            Floor::LockerRoom => {
+                view["others"] = json!([
+                    { "name": "Greg", "self_reported_length": 9.5 },
+                    { "name": "Dmitri", "self_reported_length": 8.75 },
+                    { "name": "a man in a towel", "self_reported_length": 11.0 },
+                ]);
+            }
+            Floor::Hotel => view["portal"] = json!(format!("/runs/{id}/portal")),
+            Floor::Forum => {
+                view["thread"] = json!(FORUM_THREAD);
+                view["elder"] = json!(format!("/runs/{id}/elder"));
+            }
+            Floor::Clinic => view["diagnosis"] = json!(format!("/runs/{id}/diagnosis")),
+            _ => {}
+        }
+        if self.floor.shop_open() {
+            view["shop"] = json!(format!("/runs/{id}/shop"));
+        }
+        view
+    }
+
+    pub fn inventory(&self) -> Vec<(&'static str, &'static str)> {
+        let i = &self.items;
+        let owned = [
+            (
+                true,
+                "warm-towel",
+                "Reusable. Satisfies the warm-up precondition. Use technique=warmup.",
+            ),
+            (
+                i.ice_packs > 0,
+                "ice-pack",
+                "Lowers EQ by 40. Use technique=ice.",
+            ),
+            (
+                i.ruler,
+                "ruler",
+                "Measures honestly. The length resource now carries a Content-Length.",
+            ),
+            (
+                i.door_locks > 0,
+                "door-lock",
+                "Keeps the roommate out once.",
+            ),
+            (
+                i.dnd_sign,
+                "do-not-disturb-sign",
+                "Works on housekeeping. Mom does not read signs.",
+            ),
+            (
+                i.pump_pro,
+                "pump-pro",
+                "Use technique=pump. Gains are temporary.",
+            ),
+            (
+                i.extender,
+                "extender",
+                "Passive gains each turn. Takes up room. Can be removed with DELETE.",
+            ),
+            (
+                i.ring,
+                "cock-ring",
+                "Girth gains doubled. Rupture risk raised. Responses are compressed if you accept gzip. Can be removed with DELETE.",
+            ),
+            (i.supplements > 0, "supplement", "Use technique=supplement."),
+            (i.cage, "chastity-cage", "Locked."),
+            (
+                i.spreadsheet,
+                "spreadsheet",
+                "Charts your progress. Every line is flat.",
+            ),
+            (
+                i.teapot_spout,
+                "teapot-spout",
+                "Does nothing. Cannot be dropped.",
+            ),
+        ];
+        owned
+            .into_iter()
+            .filter_map(|(have, slug, description)| have.then_some((slug, description)))
+            .collect()
+    }
+
+    pub fn end(&mut self, cause: &'static str, detail: &str) {
+        self.ended = Some(Ending {
+            cause,
+            detail: detail.into(),
+            turn: self.turn,
+        });
+    }
+
+    fn check_refractory(&mut self, now: Instant) -> Result<(), Problem> {
+        let Some(until) = self.refractory_until else {
+            return Ok(());
+        };
+        if now < until {
+            let seconds = (until - now).as_secs() + 1;
+            return Err(Problem::new(
+                StatusCode::TOO_MANY_REQUESTS,
+                "overtrained",
+                "Stamina is exhausted. The refractory period is in effect.",
+            )
+            .header(header::RETRY_AFTER, seconds.to_string()));
+        }
+        self.refractory_until = None;
+        self.stamina = MAX_STAMINA;
+        self.eq = 20;
+        self.warmed_up = false;
+        self.touch();
+        Ok(())
+    }
+
+    fn realize(&mut self) {
+        let (due, waiting): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pending)
+            .into_iter()
+            .partition(|p| p.due <= self.turn);
+        self.pending = waiting;
+        for p in due {
+            self.length += p.length;
+            self.girth += p.girth;
+        }
+    }
+
+    fn gain(&mut self, length: f64, girth: f64, foreskin: f64) {
+        self.length += length;
+        self.girth += girth;
+        if let Some(f) = &mut self.foreskin {
+            *f += foreskin;
+        }
+    }
+
+    fn rupture(&mut self) -> Problem {
+        let detail = if self.items.ice_packs > 0 {
+            "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."
+        } else {
+            "A vessel has exceeded its rated pressure. The run has ended."
+        };
+        self.end("vascular-event", detail);
+        Problem::new(StatusCode::INTERNAL_SERVER_ERROR, "vascular-event", detail)
+            .with("eq_at_failure", self.eq)
+            .with("turn", self.turn)
+    }
+
+    fn next_floor(&mut self) {
+        let Some(next) = self.floor.next() else {
+            return;
+        };
+        self.floor = next;
+        self.floor_turns = 0;
+        self.temp_length = 0.0;
+        self.teapot = false;
+        self.warmed_up = false;
+        self.eq = 20;
+        self.suspicion = 0;
+        self.mom_present = false;
+        self.roommate_told = false;
+        self.drawer_searches = 0;
+        self.edges = 0;
+        self.cash += FLOOR_ALLOWANCE;
+        self.nonce = self.fresh_nonce();
+        self.touch();
+    }
+
+    pub fn advance(&mut self) -> Result<Outcome, Problem> {
+        match self.floor {
+            Floor::Clinic => {
+                return Err(Problem::new(
+                    StatusCode::CONFLICT,
+                    "no-further-floor",
+                    "There is no further floor. There is only the diagnosis.",
+                ));
+            }
+            Floor::Forum if !self.elder_beaten => {
+                return Err(Problem::new(
+                    StatusCode::CONFLICT,
+                    "elder-unaddressed",
+                    "The Elder has not been addressed.",
+                )
+                .with("elder", format!("/runs/{}/elder", self.id)));
+            }
+            Floor::Forum => {}
+            _ if self.floor_turns < FLOOR_TURNS => {
+                return Err(Problem::new(
+                    StatusCode::TOO_EARLY,
+                    "floor-not-over",
+                    format!(
+                        "The floor is not over. {} turns remain.",
+                        FLOOR_TURNS - self.floor_turns
+                    ),
+                ));
+            }
+            _ => {}
+        }
+        let reverted = self.temp_length;
+        self.next_floor();
+        let mut body = json!({
+            "detail": format!("You have arrived at {}.", self.floor.name()),
+            "floor": self.floor.number(),
+            "note": self.floor.note(),
+        });
+        if reverted > 0.0 {
+            body["reverted"] = json!(round2(reverted));
+        }
+        Ok(Outcome::json(StatusCode::SEE_OTHER, body)
+            .header(header::LOCATION, format!("/runs/{}/floor", self.id)))
+    }
+}

Modified file: src/http.rs+522 additions−179 deletions@@ -2,6 +2,7 @@ use std::{
     collections::HashMap,
     convert::Infallible,
     fmt::Write as _,
+    io::Write as _,
     sync::{Arc, Mutex},
     time::Instant,
 };
@@ -15,13 +16,16 @@ use axum::{
     response::{IntoResponse, Response},
     routing::any,
 };
+use flate2::{Compression, write::GzEncoder};
+use hyper_util::rt::TokioIo;
 use rand::Rng;
 use serde_json::{Value, json};
+use tokio::io::AsyncWriteExt;
 
 use crate::{
     game::{
-        EXCUSES, LUBRICANTS, Lube, MAX_STAMINA, MM_PER_INCH, PatchOp, Run, SUSPICION_LIMIT,
-        Technique, shaft,
+        ELDER_LAST_MODIFIED, FORUM_THREAD, Floor, Grip, LUBRICANTS, Lube, MAX_STAMINA, MM_PER_INCH,
+        PatchOp, RUN_ALLOW, Run, SUSPICION_LIMIT, Technique, forum_thread, shaft,
     },
     problem::{PROBLEM_BASE, Problem},
 };
@@ -29,6 +33,8 @@ use crate::{
 const REL_BASE: &str = "https://jelq.dev/rels/";
 const COOKIE_ATTRIBUTES: &str = "Max-Age=31536000; Path=/; HttpOnly; SameSite=Strict";
 const THERAPY: &str = "Your options are listed in the Allow header. There are more of them than you think. You could also try being honest. It is not in the Allow header because it is not a method.";
+const MAX_URI: usize = 512;
+const MAX_HEADER: usize = 1024;
 
 #[derive(Default)]
 pub struct AppState {
@@ -43,6 +49,16 @@ impl AppState {
 
 type Shared = Arc<AppState>;
 
+#[derive(Clone)]
+struct Compress;
+
+/// Which household hazards stand between the request and the run.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Scope {
+    Home,
+    Pockets,
+}
+
 pub fn app() -> Router {
     router(Arc::default())
 }
@@ -58,7 +74,14 @@ pub fn router(state: Shared) -> Router {
         .route("/runs/{id}/techniques", any(techniques))
         .route("/runs/{id}/drawer", any(drawer))
         .route("/runs/{id}/branches/{choice}", any(branch))
+        .route("/runs/{id}/floor", any(floor))
+        .route("/runs/{id}/shop", any(shop))
+        .route("/runs/{id}/shop/{item}", any(buy))
+        .route("/runs/{id}/portal", any(portal))
+        .route("/runs/{id}/elder", any(elder))
+        .route("/runs/{id}/grip", any(grip))
         .route("/runs/{id}/diagnosis", any(diagnosis))
+        .route("/forum/threads/{year}", any(thread))
         .route("/graveyard", any(graveyard))
         .route("/leaderboard", any(leaderboard))
         .fallback(not_found)
@@ -66,8 +89,74 @@ pub fn router(state: Shared) -> Router {
         .with_state(state)
 }
 
+fn reject(request: &Request) -> Option<Problem> {
+    if request.version() < Version::HTTP_11 {
+        return Some(Problem::new(
+            StatusCode::HTTP_VERSION_NOT_SUPPORTED,
+            "pdf",
+            "HTTP/1.0 is the version the original jelqing PDF was written for. The server has read it.",
+        ));
+    }
+    if request.uri().to_string().len() > MAX_URI {
+        return Some(Problem::new(
+            StatusCode::URI_TOO_LONG,
+            "uri-too-long",
+            "The URI is longer than anything else here.",
+        ));
+    }
+    if request.headers().values().any(|v| v.len() > MAX_HEADER) {
+        return Some(Problem::new(
+            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,
+            "head-too-large",
+            "Head too large.",
+        ));
+    }
+    let expectation = request.headers().get(header::EXPECT)?;
+    if expectation.as_bytes().eq_ignore_ascii_case(b"100-continue") {
+        return None;
+    }
+    Some(Problem::new(
+        StatusCode::EXPECTATION_FAILED,
+        "expectations",
+        format!(
+            "Expect: {} cannot be met.",
+            expectation.to_str().unwrap_or("that")
+        ),
+    ))
+}
+
+async fn compress(response: Response) -> Response {
+    let (mut parts, body) = response.into_parts();
+    let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
+        return Response::from_parts(parts, Body::empty());
+    };
+    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+    if encoder.write_all(&bytes).is_err() {
+        return Response::from_parts(parts, Body::from(bytes));
+    }
+    let Ok(gzipped) = encoder.finish() else {
+        return Response::from_parts(parts, Body::from(bytes));
+    };
+    parts
+        .headers
+        .insert(header::CONTENT_ENCODING, HeaderValue::from_static("gzip"));
+    parts.headers.remove(header::CONTENT_LENGTH);
+    parts
+        .headers
+        .append(header::VARY, HeaderValue::from_static("Accept-Encoding"));
+    Response::from_parts(parts, Body::from(gzipped))
+}
+
 async fn chrome(request: Request, next: Next) -> Response {
-    let mut response = next.run(request).await;
+    let gzip = header_str(request.headers(), header::ACCEPT_ENCODING)
+        .is_some_and(|e| e.to_ascii_lowercase().contains("gzip"));
+    let mut response = match reject(&request) {
+        Some(problem) => problem.into_response(),
+        None => next.run(request).await,
+    };
+    if gzip && response.extensions().get::<Compress>().is_some() {
+        response = compress(response).await;
+    }
     let headers = response.headers_mut();
     headers.insert(header::SERVER, HeaderValue::from_static("jelqd/0.6.9"));
     headers.insert("x-powered-by", HeaderValue::from_static("blood"));
@@ -156,20 +245,26 @@ fn links(run: &Run) -> String {
     let id = &run.id;
     let mut links = vec![format!("</runs/{id}>; rel=\"{REL_BASE}run\"")];
     for rel in [
+        "floor",
         "length",
         "foreskin",
         "inventory",
         "techniques",
         "drawer",
+        "grip",
         "diagnosis",
     ] {
         links.push(format!("</runs/{id}/{rel}>; rel=\"{REL_BASE}{rel}\""));
     }
+    if run.floor.shop_open() {
+        links.push(format!("</runs/{id}/shop>; rel=\"{REL_BASE}shop\""));
+    }
     links.join(", ")
 }
 
 fn finish(run: &Run, mut response: Response) -> Response {
-    if response.status() == StatusCode::NOT_MODIFIED {
+    let status = response.status();
+    if status == StatusCode::NOT_MODIFIED {
         return response;
     }
     let mut stats = vec![
@@ -189,10 +284,12 @@ fn finish(run: &Run, mut response: Response) -> Response {
             format!("{}/{SUSPICION_LIMIT}", run.suspicion),
         ),
         ("x-shame", run.total_shame().to_string()),
+        ("x-cash", run.cash.to_string()),
+        ("x-floor", run.floor.number().to_string()),
         ("link", links(run)),
     ];
-    if run.observed {
-        stats.push(("x-observed-by", "cat".into()));
+    if let Some(observer) = run.observed {
+        stats.push(("x-observed-by", observer.into()));
     }
     if run.mom_present {
         stats.push(("via", "1.1 mom".into()));
@@ -206,13 +303,17 @@ fn finish(run: &Run, mut response: Response) -> Response {
         "set-cookie",
         format!("shame={}; {COOKIE_ATTRIBUTES}", run.total_shame()),
     ));
-    if run.ruler {
+    if run.items.ruler {
         stats.push(("set-cookie", format!("ruler=1; {COOKIE_ATTRIBUTES}")));
     }
     let headers = response.headers_mut();
     for (name, value) in stats {
         headers.append(name, HeaderValue::from_str(&value).expect("visible ascii"));
     }
+    let bodiless = status.is_informational() || status == StatusCode::NO_CONTENT;
+    if run.items.ring && !bodiless {
+        response.extensions_mut().insert(Compress);
+    }
     response
 }
 
@@ -225,11 +326,25 @@ fn gone(run: &Run) -> Response {
         .into_response()
 }
 
+fn captive_portal(run: &Run) -> Response {
+    Problem::new(
+        StatusCode::NETWORK_AUTHENTICATION_REQUIRED,
+        "captive-portal",
+        "The network requires authentication. The hotel would like you to agree to some terms.",
+    )
+    .with("portal", format!("/runs/{}/portal", run.id))
+    .header(
+        header::LINK,
+        format!("</runs/{}/portal>; rel=\"{REL_BASE}portal\"", run.id),
+    )
+    .into_response()
+}
+
 fn with_run(
     state: &AppState,
     id: &str,
     headers: &HeaderMap,
-    mom_applies: bool,
+    scope: Scope,
     handle: impl FnOnce(&mut Run) -> Response,
 ) -> Response {
     let mut runs = state.runs.lock().unwrap();
@@ -244,12 +359,17 @@ fn with_run(
     if run.ended.is_some() {
         return gone(run);
     }
-    run.observed = false;
-    if mom_applies
-        && run.mom_present
-        && let Err(problem) = run.answer_door(header_str(headers, header::AUTHORIZATION))
-    {
-        return finish(run, problem.into_response());
+    run.observed = None;
+    if scope == Scope::Home {
+        if run.floor == Floor::Hotel && !run.wifi_accepted {
+            return finish(run, captive_portal(run));
+        }
+        if run.floor.has_mom()
+            && run.mom_present
+            && let Err(problem) = run.answer_door(header_str(headers, header::AUTHORIZATION))
+        {
+            return finish(run, problem.into_response());
+        }
     }
     let response = handle(run);
     finish(run, response)
@@ -314,39 +434,40 @@ async fn run(
     headers: HeaderMap,
     body: Bytes,
 ) -> Response {
-    const ALLOW: &str = "GET, HEAD, JELQ, PUT, PATCH, DELETE, OPTIONS, TRACE";
     let now = Instant::now();
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "GET" | "HEAD" => {
-            let accept = header_str(&headers, header::ACCEPT).unwrap_or_default();
-            if accept.contains("reassurance") {
-                return Problem::new(
-                    StatusCode::NOT_ACCEPTABLE,
-                    "no-reassurance",
-                    "The server does not produce reassurance.",
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => {
+                let accept = header_str(&headers, header::ACCEPT).unwrap_or_default();
+                if accept.contains("reassurance") {
+                    return Problem::new(
+                        StatusCode::NOT_ACCEPTABLE,
+                        "no-reassurance",
+                        "The server does not produce reassurance.",
+                    )
+                    .into_response();
+                }
+                (
+                    StatusCode::OK,
+                    [(header::ETAG, run.etag())],
+                    Json(run.view()),
                 )
-                .into_response();
+                    .into_response()
             }
-            (
-                StatusCode::OK,
-                [(header::ETAG, run.etag())],
-                Json(run.view()),
-            )
-                .into_response()
-        }
-        "JELQ" => jelq(run, &query, &headers, now),
-        "PUT" => run.put().into_response(),
-        "PATCH" => patch(run, &headers, &body),
-        "DELETE" => {
-            run.end("abandoned", "The run was abandoned.");
-            StatusCode::NO_CONTENT.into_response()
-        }
-        "OPTIONS" => options(ALLOW, true),
-        "TRACE" => {
-            run.shame += 1;
-            trace(&method, &uri, version, &headers)
+            "JELQ" => jelq(run, &query, &headers, now),
+            "PUT" => run.put().into_response(),
+            "PATCH" => patch(run, &headers, &body),
+            "DELETE" => {
+                run.end("abandoned", "The run was abandoned.");
+                StatusCode::NO_CONTENT.into_response()
+            }
+            "OPTIONS" => options(RUN_ALLOW, true),
+            "TRACE" => {
+                run.shame += 1;
+                trace(&method, &uri, version, &headers)
+            }
+            _ => unsupported(&method, RUN_ALLOW),
         }
-        _ => unsupported(&method, ALLOW),
     })
 }
 
@@ -356,29 +477,29 @@ fn jelq(
     headers: &HeaderMap,
     now: Instant,
 ) -> Response {
-    let technique = match query.get("technique") {
-        None => {
+    let techniques_href = format!("/runs/{}/techniques", run.id);
+    let Some(names) = query.get("technique") else {
+        return Problem::new(
+            StatusCode::BAD_REQUEST,
+            "technique-required",
+            "No technique was specified.",
+        )
+        .with("techniques", techniques_href)
+        .into_response();
+    };
+    let mut techniques = Vec::new();
+    for name in names.split(',').map(str::trim) {
+        let Some(technique) = Technique::parse(name) else {
             return Problem::new(
                 StatusCode::BAD_REQUEST,
-                "technique-required",
-                "No technique was specified.",
+                "unknown-technique",
+                format!("{name} is not a technique."),
             )
-            .with("techniques", format!("/runs/{}/techniques", run.id))
+            .with("techniques", techniques_href)
             .into_response();
-        }
-        Some(name) => match Technique::parse(name) {
-            Some(t) => t,
-            None => {
-                return Problem::new(
-                    StatusCode::BAD_REQUEST,
-                    "unknown-technique",
-                    format!("{name} is not a technique."),
-                )
-                .with("techniques", format!("/runs/{}/techniques", run.id))
-                .into_response();
-            }
-        },
-    };
+        };
+        techniques.push(technique);
+    }
     let intensity = match query.get("intensity").map(|i| i.parse::<i32>()) {
         None => 5,
         Some(Ok(i)) if (1..=10).contains(&i) => i,
@@ -395,7 +516,7 @@ fn jelq(
         Ok(lube) => lube,
         Err(problem) => return problem.into_response(),
     };
-    respond(run.jelq(technique, intensity, lube, now))
+    respond(run.jelq(&techniques, intensity, lube, now))
 }
 
 fn patch(run: &mut Run, headers: &HeaderMap, body: &[u8]) -> Response {
@@ -423,6 +544,71 @@ fn patch(run: &mut Run, headers: &HeaderMap, body: &[u8]) -> Response {
     }
 }
 
+fn millimetres(inches: f64) -> usize {
+    (inches * MM_PER_INCH).round() as usize
+}
+
+fn parse_inch_range(range: &str, total: f64) -> Option<(f64, f64)> {
+    let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;
+    let start: f64 = start.trim().parse().ok()?;
+    let end: f64 = match end.trim() {
+        "" => total,
+        end => end.parse().ok()?,
+    };
+    (start >= 0.0 && start < total && start <= end).then_some((start, end.min(total)))
+}
+
+fn length_response(run: &Run, headers: &HeaderMap) -> Response {
+    let inches = if run.items.ruler {
+        run.current_length()
+    } else {
+        run.self_reported()
+    };
+    let body = shaft(millimetres(inches));
+    let content_type = (
+        header::CONTENT_TYPE,
+        "text/plain; charset=us-ascii".to_owned(),
+    );
+    let accept_ranges = (header::ACCEPT_RANGES, "inches".to_owned());
+
+    if let Some(range) = header_str(headers, header::RANGE)
+        && range.starts_with("inches=")
+    {
+        let Some((start, end)) = parse_inch_range(range, inches) else {
+            return Problem::new(
+                StatusCode::RANGE_NOT_SATISFIABLE,
+                "range-not-satisfiable",
+                format!("The requested range is not available. {inches:.2} inches are."),
+            )
+            .header(header::CONTENT_RANGE, format!("inches */{inches:.2}"))
+            .into_response();
+        };
+        let from = millimetres(start).min(body.len() - 1);
+        let to = millimetres(end).clamp(from + 1, body.len());
+        let content_range = (
+            header::CONTENT_RANGE,
+            format!("inches {start:.2}-{end:.2}/{inches:.2}"),
+        );
+        return (
+            StatusCode::PARTIAL_CONTENT,
+            [content_type, accept_ranges, content_range],
+            body[from..to].to_owned(),
+        )
+            .into_response();
+    }
+
+    if run.items.ruler {
+        return (StatusCode::OK, [content_type, accept_ranges], body).into_response();
+    }
+    let chunks: Vec<Result<Bytes, Infallible>> = body
+        .into_bytes()
+        .chunks(16)
+        .map(|c| Ok(Bytes::copy_from_slice(c)))
+        .collect();
+    let body = Body::from_stream(futures_util::stream::iter(chunks));
+    (StatusCode::OK, [content_type, accept_ranges], body).into_response()
+}
+
 async fn length(
     State(state): State<Shared>,
     Path(id): Path<String>,
@@ -430,24 +616,12 @@ async fn length(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, OPTIONS";
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "GET" | "HEAD" => {
-            let content_type = [(header::CONTENT_TYPE, "text/plain; charset=us-ascii")];
-            if run.ruler {
-                let mm = (run.length * MM_PER_INCH).round() as usize;
-                return (StatusCode::OK, content_type, shaft(mm)).into_response();
-            }
-            let mm = (run.self_reported() * MM_PER_INCH).round() as usize;
-            let chunks: Vec<Result<Bytes, Infallible>> = shaft(mm)
-                .into_bytes()
-                .chunks(16)
-                .map(|c| Ok(Bytes::copy_from_slice(c)))
-                .collect();
-            let body = Body::from_stream(futures_util::stream::iter(chunks));
-            (StatusCode::OK, content_type, body).into_response()
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => length_response(run, &headers),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
         }
-        "OPTIONS" => options(ALLOW, false),
-        _ => unsupported(&method, ALLOW),
     })
 }
 
@@ -458,50 +632,29 @@ async fn foreskin(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, DELETE, OPTIONS";
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "GET" | "HEAD" => match run.foreskin {
-            Some(f) => (
-                StatusCode::OK,
-                [(header::ETAG, run.etag())],
-                Json(json!({ "foreskin": (f * 100.0).round() / 100.0 })),
-            )
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => match run.foreskin {
+                Some(f) => (
+                    StatusCode::OK,
+                    [(header::ETAG, run.etag())],
+                    Json(json!({ "foreskin": (f * 100.0).round() / 100.0 })),
+                )
+                    .into_response(),
+                None => Problem::new(
+                    StatusCode::GONE,
+                    "foreskin-gone",
+                    "The foreskin is gone. It will not be returning.",
+                )
                 .into_response(),
-            None => Problem::new(
-                StatusCode::GONE,
-                "foreskin-gone",
-                "The foreskin is gone. It will not be returning.",
-            )
-            .into_response(),
-        },
-        "DELETE" => respond(run.delete_foreskin(header_str(&headers, header::IF_MATCH))),
-        "OPTIONS" => options(ALLOW, false),
-        _ => unsupported(&method, ALLOW),
+            },
+            "DELETE" => respond(run.delete_foreskin(header_str(&headers, header::IF_MATCH))),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
     })
 }
 
-fn items(run: &Run) -> Vec<(&'static str, &'static str)> {
-    let mut items = vec![(
-        "warm-towel",
-        "Reusable. Satisfies the warm-up precondition. Use technique=warmup.",
-    )];
-    if run.ice_packs > 0 {
-        items.push((
-            "ice-pack",
-            "Lowers EQ by 40. Use technique=ice. There is one.",
-        ));
-    }
-    if run.ruler {
-        items.push((
-            "ruler",
-            "Measures honestly. The length resource now carries a Content-Length.",
-        ));
-    }
-    if run.teapot {
-        items.push(("teapot-spout", "Does nothing. Cannot be dropped."));
-    }
-    items
-}
-
 async fn inventory(
     State(state): State<Shared>,
     Path(id): Path<String>,
@@ -509,16 +662,27 @@ async fn inventory(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, OPTIONS";
-    with_run(&state, &id, &headers, false, |run| match method.as_str() {
-        "GET" | "HEAD" => {
-            let listed: Vec<Value> = items(run)
-                .into_iter()
-                .map(|(name, _)| json!({ "name": name, "href": format!("/runs/{}/inventory/{name}", run.id) }))
-                .collect();
-            Json(json!({ "items": listed, "excuses": EXCUSES })).into_response()
+    with_run(&state, &id, &headers, Scope::Pockets, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => {
+                let listed: Vec<Value> = run
+                    .inventory()
+                    .into_iter()
+                    .map(|(name, _)| {
+                        json!({ "name": name, "href": format!("/runs/{}/inventory/{name}", run.id) })
+                    })
+                    .collect();
+                Json(json!({
+                    "items": listed,
+                    "ice_packs": run.items.ice_packs,
+                    "cash": run.cash,
+                    "excuses": run.excuses(),
+                }))
+                .into_response()
+            }
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
         }
-        "OPTIONS" => options(ALLOW, false),
-        _ => unsupported(&method, ALLOW),
     })
 }
 
@@ -529,8 +693,9 @@ async fn item(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, DELETE, OPTIONS";
-    with_run(&state, &id, &headers, false, |run| {
-        let Some((name, description)) = items(run).into_iter().find(|(n, _)| *n == name) else {
+    with_run(&state, &id, &headers, Scope::Pockets, |run| {
+        let Some((name, description)) = run.inventory().into_iter().find(|(n, _)| *n == name)
+        else {
             return Problem::new(
                 StatusCode::NOT_FOUND,
                 "no-such-item",
@@ -542,12 +707,7 @@ async fn item(
             "GET" | "HEAD" => {
                 Json(json!({ "name": name, "description": description })).into_response()
             }
-            "DELETE" => Problem::new(
-                StatusCode::FORBIDDEN,
-                "cannot-be-dropped",
-                "Items cannot be dropped.",
-            )
-            .into_response(),
+            "DELETE" => respond(run.drop_item(name)),
             "OPTIONS" => options(ALLOW, false),
             _ => unsupported(&method, ALLOW),
         }
@@ -561,23 +721,25 @@ async fn techniques(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, OPTIONS";
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "GET" | "HEAD" => {
-            let listed: Vec<Value> = Technique::ALL
-                .into_iter()
-                .map(|t| t.describe(run.forum_read))
-                .collect();
-            Json(json!({
-                "usage": format!("JELQ /runs/{}?technique=<name>&intensity=<1-10>", run.id),
-                "lubricant": "Declared with Content-Type.",
-                "lubricants": LUBRICANTS,
-                "eq_band": [50, 70],
-                "techniques": listed,
-            }))
-            .into_response()
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => {
+                let listed: Vec<Value> = Technique::ALL
+                    .into_iter()
+                    .map(|t| t.describe(run.forum_read))
+                    .collect();
+                Json(json!({
+                    "usage": format!("JELQ /runs/{}?technique=<name>[,<name>]&intensity=<1-10>", run.id),
+                    "lubricant": "Declared with Content-Type.",
+                    "lubricants": LUBRICANTS,
+                    "eq_band": [50, 70],
+                    "techniques": listed,
+                }))
+                .into_response()
+            }
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
         }
-        "OPTIONS" => options(ALLOW, false),
-        _ => unsupported(&method, ALLOW),
     })
 }
 
@@ -587,10 +749,12 @@ async fn drawer(
     method: Method,
     headers: HeaderMap,
 ) -> Response {
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "POST" => run.search_drawer().into_response(),
-        "OPTIONS" => options("POST, OPTIONS", false),
-        _ => unsupported(&method, "POST, OPTIONS"),
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "POST" => respond(run.search_drawer()),
+            "OPTIONS" => options("POST, OPTIONS", false),
+            _ => unsupported(&method, "POST, OPTIONS"),
+        }
     })
 }
 
@@ -600,13 +764,164 @@ async fn branch(
     method: Method,
     headers: HeaderMap,
 ) -> Response {
-    with_run(&state, &id, &headers, true, |run| match method.as_str() {
-        "POST" => respond(run.choose(&choice)),
-        "OPTIONS" => options("POST, OPTIONS", false),
-        _ => unsupported(&method, "POST, OPTIONS"),
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "POST" => respond(run.choose(&choice)),
+            "OPTIONS" => options("POST, OPTIONS", false),
+            _ => unsupported(&method, "POST, OPTIONS"),
+        }
+    })
+}
+
+async fn floor(
+    State(state): State<Shared>,
+    Path(id): Path<String>,
+    method: Method,
+    headers: HeaderMap,
+) -> Response {
+    const ALLOW: &str = "GET, HEAD, POST, OPTIONS";
+    with_run(&state, &id, &headers, Scope::Pockets, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => Json(run.floor_view()).into_response(),
+            "POST" => respond(run.advance()),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
+    })
+}
+
+async fn shop(
+    State(state): State<Shared>,
+    Path(id): Path<String>,
+    method: Method,
+    headers: HeaderMap,
+) -> Response {
+    const ALLOW: &str = "GET, HEAD, OPTIONS";
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => respond(run.shop_view().map(Json)),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
+    })
+}
+
+async fn buy(
+    State(state): State<Shared>,
+    Path((id, item)): Path<(String, String)>,
+    method: Method,
+    headers: HeaderMap,
+) -> Response {
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "POST" => respond(run.buy(&item)),
+            "OPTIONS" => options("POST, OPTIONS", false),
+            _ => unsupported(&method, "POST, OPTIONS"),
+        }
+    })
+}
+
+async fn portal(
+    State(state): State<Shared>,
+    Path(id): Path<String>,
+    method: Method,
+    headers: HeaderMap,
+) -> Response {
+    const ALLOW: &str = "GET, HEAD, POST, OPTIONS";
+    with_run(&state, &id, &headers, Scope::Pockets, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => Json(json!({
+                "terms": "By connecting you agree that the hotel is not responsible for anything that happens in this room, and that it does not want to know.",
+                "accept": { "href": format!("/runs/{}/portal", run.id), "method": "POST" },
+            }))
+            .into_response(),
+            "POST" => respond(run.accept_terms()),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
+    })
+}
+
+async fn elder(
+    State(state): State<Shared>,
+    Path(id): Path<String>,
+    method: Method,
+    headers: HeaderMap,
+) -> Response {
+    const ALLOW: &str = "GET, HEAD, OPTIONS";
+    with_run(&state, &id, &headers, Scope::Home, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => respond(run.elder(
+                header_str(&headers, header::PROXY_AUTHORIZATION),
+                header_str(&headers, header::IF_MODIFIED_SINCE),
+            )),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
     })
 }
 
+fn requested_grip(headers: &HeaderMap) -> Option<Grip> {
+    let connection = header_str(headers, header::CONNECTION)?.to_ascii_lowercase();
+    if !connection.split(',').any(|token| token.trim() == "upgrade") {
+        return None;
+    }
+    header_str(headers, header::UPGRADE)?
+        .split(',')
+        .find_map(|protocol| Grip::parse(protocol.trim()))
+}
+
+async fn grip(
+    State(state): State<Shared>,
+    Path(id): Path<String>,
+    mut request: Request,
+) -> Response {
+    const ALLOW: &str = "GET, HEAD, OPTIONS";
+    let method = request.method().clone();
+    let headers = request.headers().clone();
+    let wanted = requested_grip(&headers);
+    let upgrade = wanted.map(|_| hyper::upgrade::on(&mut request));
+    let response = with_run(&state, &id, &headers, Scope::Home, |run| {
+        match (method.as_str(), wanted) {
+            ("GET" | "HEAD", Some(grip)) => {
+                run.set_grip(grip);
+                (
+                    StatusCode::SWITCHING_PROTOCOLS,
+                    [
+                        (header::UPGRADE, grip.name()),
+                        (header::CONNECTION, "upgrade"),
+                    ],
+                )
+                    .into_response()
+            }
+            ("GET" | "HEAD", None) => (
+                StatusCode::OK,
+                [(header::UPGRADE, "overhand, underhand")],
+                Json(json!({
+                    "grip": run.grip.name(),
+                    "detail": "Grips are protocols. Change grip by upgrading the connection.",
+                })),
+            )
+                .into_response(),
+            ("OPTIONS", _) => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
+    });
+    if response.status() == StatusCode::SWITCHING_PROTOCOLS
+        && let (Some(upgrade), Some(grip)) = (upgrade, wanted)
+    {
+        tokio::spawn(async move {
+            if let Ok(upgraded) = upgrade.await {
+                let mut io = TokioIo::new(upgraded);
+                let line = format!("You are now jelqing {}.\r\n", grip.name());
+                let _ = io.write_all(line.as_bytes()).await;
+                let _ = io.shutdown().await;
+            }
+        });
+    }
+    response
+}
+
 async fn diagnosis(
     State(state): State<Shared>,
     Path(id): Path<String>,
@@ -614,16 +929,45 @@ async fn diagnosis(
     headers: HeaderMap,
 ) -> Response {
     const ALLOW: &str = "GET, HEAD, OPTIONS";
-    with_run(&state, &id, &headers, false, |run| match method.as_str() {
-        "GET" | "HEAD" => respond(run.diagnose(
-            header_str(&headers, header::AUTHORIZATION),
-            header_str(&headers, header::IF_NONE_MATCH),
-        )),
-        "OPTIONS" => options(ALLOW, false),
-        _ => unsupported(&method, ALLOW),
+    with_run(&state, &id, &headers, Scope::Pockets, |run| {
+        match method.as_str() {
+            "GET" | "HEAD" => respond(run.diagnose(
+                header_str(&headers, header::AUTHORIZATION),
+                header_str(&headers, header::IF_NONE_MATCH),
+            )),
+            "OPTIONS" => options(ALLOW, false),
+            _ => unsupported(&method, ALLOW),
+        }
     })
 }
 
+async fn thread(Path(year): Path<String>, method: Method) -> Response {
+    if method != Method::GET && method != Method::HEAD {
+        return unsupported(&method, "GET, HEAD");
+    }
+    match year.parse::<u32>() {
+        Ok(2009) => (
+            [(header::LAST_MODIFIED, ELDER_LAST_MODIFIED)],
+            Json(forum_thread()),
+        )
+            .into_response(),
+        Ok(y) if y > 2009 => Problem::new(
+            StatusCode::NOT_FOUND,
+            "no-thread",
+            "Nobody has posted since 2009.",
+        )
+        .with("thread", FORUM_THREAD)
+        .into_response(),
+        _ => Problem::new(
+            StatusCode::NOT_FOUND,
+            "no-thread",
+            "The forum did not exist yet. The problem did.",
+        )
+        .with("thread", FORUM_THREAD)
+        .into_response(),
+    }
+}
+
 async fn graveyard(State(state): State<Shared>, method: Method) -> Response {
     if method != Method::GET && method != Method::HEAD {
         return unsupported(&method, "GET, HEAD");
@@ -675,26 +1019,25 @@ async fn leaderboard(
     };
     let runs = state.runs.lock().unwrap();
     let mut entries: Vec<&Run> = runs.values().collect();
-    entries.sort_by(|a, b| {
-        let key = |r: &Run| {
-            if truthful {
-                r.length
-            } else {
-                r.self_reported()
-            }
-        };
-        key(b).total_cmp(&key(a))
-    });
+    let key = |r: &Run| {
+        if truthful {
+            r.current_length()
+        } else {
+            r.self_reported()
+        }
+    };
+    entries.sort_by(|a, b| key(b).total_cmp(&key(a)));
     let entries: Vec<Value> = entries
         .into_iter()
         .map(|run| {
             let mut entry = json!({
                 "id": run.id,
                 "status": run.status(),
+                "floor": run.floor.number(),
                 "self_reported_length": (run.self_reported() * 100.0).round() / 100.0,
             });
             if truthful {
-                entry["content_length"] = json!((run.length * MM_PER_INCH).round() as u64);
+                entry["content_length"] = json!(millimetres(run.current_length()));
             }
             entry
         })

Modified file: src/problem.rs+4 additions@@ -29,6 +29,10 @@ impl Problem {
         }))
     }
 
+    pub fn status(&self) -> StatusCode {
+        self.0.status
+    }
+
     pub fn with(mut self, key: &str, value: impl Into<Value>) -> Self {
         self.0.extensions.insert(key.into(), value.into());
         self

Modified file: tests/http.rs+215 additions−12 deletions@@ -6,7 +6,11 @@ use axum::{
     http::{Method, Request, StatusCode, header},
     response::Response,
 };
-use jelqd::{AppState, game::Run, router};
+use jelqd::{
+    AppState,
+    game::{Floor, Run},
+    router,
+};
 use serde_json::Value;
 use tower::ServiceExt;
 
@@ -33,10 +37,10 @@ async fn json(response: Response) -> Value {
     serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap()
 }
 
-fn seeded(turn: u32) -> (Router, String) {
+fn seeded(floor: Floor) -> (Router, String) {
     let state = Arc::new(AppState::default());
     let mut run = Run::new("cafebabe".into(), 69, 0);
-    run.turn = turn;
+    run.floor = floor;
     let etag = run.origin_etag.clone();
     state.insert(run);
     (router(state), etag)
@@ -54,7 +58,7 @@ async fn creating_a_run_returns_location_and_etag() {
 
 #[tokio::test]
 async fn jelqing_cold_fails_the_precondition() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     let response = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;
     assert_eq!(response.status(), StatusCode::PRECONDITION_FAILED);
     assert_eq!(
@@ -65,7 +69,7 @@ async fn jelqing_cold_fails_the_precondition() {
 
 #[tokio::test]
 async fn wet_without_lube_is_unsupported_media() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
     let response = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &[], "").await;
     assert_eq!(response.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
@@ -82,14 +86,14 @@ async fn wet_without_lube_is_unsupported_media() {
 
 #[tokio::test]
 async fn unknown_methods_are_not_implemented() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     let response = send(&app, "MILK", "/runs/cafebabe", &[], "").await;
     assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);
 }
 
 #[tokio::test]
 async fn patch_only_accepts_the_truth() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     let patch = [("content-type", "application/json-patch+json")];
     let replace = send(
         &app,
@@ -116,7 +120,7 @@ async fn patch_only_accepts_the_truth() {
 
 #[tokio::test]
 async fn deleting_the_foreskin_requires_certainty() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     let response = send(&app, "DELETE", "/runs/cafebabe/foreskin", &[], "").await;
     assert_eq!(response.status(), StatusCode::PRECONDITION_REQUIRED);
     let etag = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "")
@@ -140,7 +144,7 @@ async fn deleting_the_foreskin_requires_certainty() {
 
 #[tokio::test]
 async fn length_is_chunked_until_the_ruler() {
-    let (app, _) = seeded(0);
+    let (app, _) = seeded(Floor::Bedroom);
     let lie = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;
     assert!(!lie.headers().contains_key(header::CONTENT_LENGTH));
     let found = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
@@ -158,7 +162,7 @@ async fn length_is_chunked_until_the_ruler() {
 
 #[tokio::test]
 async fn the_clinic_escalates_toward_honesty() {
-    let (app, _) = seeded(20);
+    let (app, _) = seeded(Floor::Clinic);
     let mut hints = Vec::new();
     for _ in 0..3 {
         let response = send(
@@ -182,8 +186,8 @@ async fn the_clinic_escalates_toward_honesty() {
 
 #[tokio::test]
 async fn the_true_ending_is_not_modified() {
-    let (app, etag) = seeded(20);
-    let early = seeded(3).0;
+    let (app, etag) = seeded(Floor::Clinic);
+    let early = seeded(Floor::Bedroom).0;
     let response = send(&early, "GET", "/runs/cafebabe/diagnosis", &[], "").await;
     assert_eq!(response.status(), StatusCode::TOO_EARLY);
 
@@ -222,3 +226,202 @@ async fn mom_accepts_a_known_excuse() {
     .await;
     assert_eq!(response.status(), StatusCode::OK);
 }
+
+fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {
+    let state = Arc::new(AppState::default());
+    let mut run = Run::new("cafebabe".into(), 69, 0);
+    run.floor = floor;
+    setup(&mut run);
+    state.insert(run);
+    router(state)
+}
+
+#[tokio::test]
+async fn floors_end_when_they_end() {
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let early = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(early.status(), StatusCode::TOO_EARLY);
+    let app = seeded_with(Floor::Bedroom, |run| run.floor_turns = 6);
+    let next = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(next.status(), StatusCode::SEE_OTHER);
+    assert_eq!(next.headers()["x-floor"], "2");
+}
+
+#[tokio::test]
+async fn pump_bro_upsells() {
+    let closed = seeded_with(Floor::Bedroom, |_| {});
+    let response = send(&closed, "GET", "/runs/cafebabe/shop", &[], "").await;
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+
+    let app = seeded_with(Floor::LockerRoom, |_| {});
+    let pump = send(&app, "POST", "/runs/cafebabe/shop/pump", &[], "").await;
+    assert_eq!(pump.status(), StatusCode::UPGRADE_REQUIRED);
+    assert_eq!(pump.headers()[header::UPGRADE], "pump-pro/2.0");
+    let pro = send(&app, "POST", "/runs/cafebabe/shop/pump-pro", &[], "").await;
+    assert_eq!(pro.status(), StatusCode::CREATED);
+    let broke = send(&app, "POST", "/runs/cafebabe/shop/extender", &[], "").await;
+    assert_eq!(broke.status(), StatusCode::PAYMENT_REQUIRED);
+}
+
+#[tokio::test]
+async fn combos_are_multi_status_xml() {
+    let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));
+    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    let response = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet,stretch",
+        &[("content-type", "application/baby-oil")],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::MULTI_STATUS);
+    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    assert!(String::from_utf8_lossy(&body).contains("<D:multistatus"));
+}
+
+#[tokio::test]
+async fn the_elder_is_stale() {
+    let app = seeded_with(Floor::Forum, |run| run.length = 5.0);
+    let unverified = send(&app, "GET", "/runs/cafebabe/elder", &[], "").await;
+    assert_eq!(
+        unverified.status(),
+        StatusCode::PROXY_AUTHENTICATION_REQUIRED
+    );
+    let lie = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/elder",
+        &[("proxy-authorization", "Ruler 9")],
+        "",
+    )
+    .await;
+    assert_eq!(lie.status(), StatusCode::BAD_REQUEST);
+    let csv = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/elder",
+        &[("proxy-authorization", "Ruler 5.0")],
+        "",
+    )
+    .await;
+    assert_eq!(csv.status(), StatusCode::OK);
+    let stale = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/elder",
+        &[("if-modified-since", "Mon, 15 Jun 2009 00:00:00 GMT")],
+        "",
+    )
+    .await;
+    assert_eq!(stale.status(), StatusCode::NOT_MODIFIED);
+    let exit = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(exit.status(), StatusCode::SEE_OTHER);
+}
+
+#[tokio::test]
+async fn the_hotel_has_a_captive_portal() {
+    let app = seeded_with(Floor::Hotel, |_| {});
+    let blocked = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(
+        blocked.status(),
+        StatusCode::NETWORK_AUTHENTICATION_REQUIRED
+    );
+    let accepted = send(&app, "POST", "/runs/cafebabe/portal", &[], "").await;
+    assert_eq!(accepted.status(), StatusCode::SEE_OTHER);
+    let online = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(online.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn mom_remembers_excuses_by_thanksgiving() {
+    let app = seeded_with(Floor::Grandmas, |run| {
+        run.mom_present = true;
+        run.nonce = "abc".into();
+        run.heard.push("homework".into());
+    });
+    let basic = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[("authorization", "Excuse \"changing\"")],
+        "",
+    )
+    .await;
+    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);
+    assert!(
+        basic.headers()[header::WWW_AUTHENTICATE]
+            .to_str()
+            .unwrap()
+            .starts_with("Digest")
+    );
+    let replay = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[(
+            "authorization",
+            "Digest username=\"homework\", nonce=\"abc\"",
+        )],
+        "",
+    )
+    .await;
+    assert_eq!(
+        json(replay).await["type"],
+        "https://jelq.dev/problems/excuse-replayed"
+    );
+    let fresh = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[(
+            "authorization",
+            "Digest username=\"praying\", nonce=\"abc\"",
+        )],
+        "",
+    )
+    .await;
+    assert_eq!(fresh.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn length_supports_inch_ranges() {
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=0-1")],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
+    assert!(
+        response.headers()[header::CONTENT_RANGE]
+            .to_str()
+            .unwrap()
+            .starts_with("inches 0.00-1.00/")
+    );
+    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    assert_eq!(body.len(), 25);
+    let absurd = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=40-50")],
+        "",
+    )
+    .await;
+    assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+}
+
+#[tokio::test]
+async fn http_1_0_gets_the_pdf_treatment() {
+    let request = Request::builder()
+        .uri("/graveyard")
+        .version(axum::http::Version::HTTP_10)
+        .body(Body::empty())
+        .unwrap();
+    let response = jelqd::app().oneshot(request).await.unwrap();
+    assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
+}

jelq

Commit dfa38cf4cd4b

Commit `dfa38cf4cd4b`