jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

45 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `8b8e83329a1d`

tarball

atagen <boss@atagen.co>2026-10-12 13:18 UTC

74 files changed+6356-5352

game, http: regroup the run, type the strings, and stop blocking the runtime

Run carried forty loose fields that every module and the HTTP layer
reached into, so it is now body, standing, household, online and
identity, with the HTTP side reading gauges and reach instead of
internals. state.rs, turn.rs and http/runs.rs each did several jobs and
are split by job, statuses, causes, notices, excuses, branches and patch
ops are enums, and the turn tick lives in begin_turn. The dice no longer
pay for the model's state prose on every roll.

SQLite and the model both block, so every request runs on the blocking
pool, idle runs are swept on a timer instead of scanned on every POST
/runs, the listings page by fifty, records keep their first timestamp
under a user_version schema, and a run whose lock a panic poisoned is
buried as lost instead of resumed half-applied. The tests are split by
area, the ones that could not fail are gone, and the endings, Mum's
refusals, the Elder's ban and the records now have coverage.

Modified file: Cargo.toml+1−1

@@ -18,7 +18,7 @@ rusqlite = { version = "0.40.2", features = ["bundled"] }

1818 serde = { version = "1", features = ["derive"] }

1919 serde_json = "1"

2020 sha2 = "0.10"

21-tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread"] }

21+tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }

2222 tower = { version = "0.5", features = ["util"] }

2323 tower-http = { version = "0.6", features = ["catch-panic"] }

2424 ureq = { version = "2", default-features = false, features = ["json"] }

Modified file: src/config.rs+12 additions−5 deletions@@ -26,17 +26,24 @@ impl Default for Config {
     }
 }
 
+/// The XDG state directory, so `nix run` from anywhere finds the same graveyard.
+fn default_db() -> PathBuf {
+    let state = std::env::var_os("XDG_STATE_HOME")
+        .map(PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/state")));
+    match state {
+        Some(dir) => dir.join("jelqd").join("jelqd.sqlite"),
+        None => PathBuf::from("jelqd.sqlite"),
+    }
+}
+
 impl Config {
     pub fn from_env() -> Self {
         let var = |name| std::env::var(name).ok();
         let defaults = Self::default();
         Self {
             addr: var("JELQD_ADDR").unwrap_or(defaults.addr),
-            db: Some(
-                var("JELQD_DB")
-                    .unwrap_or_else(|| "jelqd.sqlite".into())
-                    .into(),
-            ),
+            db: Some(var("JELQD_DB").map_or_else(default_db, PathBuf::from)),
             secret: var("JELQD_SECRET").map_or(defaults.secret, |s| Secret::new(s.into_bytes())),
             oracle: match var("JELQD_ORACLE").as_deref() {
                 Some("clm") => OracleTemplate::Clm {

Deleted file: src/game/balance.rs−113 deletions@@ -1,113 +0,0 @@
-//! Every tunable number in the game. Odds are written as "1 in N".
-
-use std::ops::RangeInclusive;
-
-pub const MAX_STAMINA: i32 = 10;
-pub const PULLED_STAMINA: i32 = 7;
-pub const STARTING_EQ: i32 = 20;
-pub const STARTING_CASH: u32 = 20;
-pub const STARTING_ICE_PACKS: u32 = 1;
-pub const SUSPICION_LIMIT: u8 = 5;
-pub const PATIENCE: u8 = 3;
-
-pub const FLOOR_TURNS: u32 = 6;
-pub const FLOOR_ALLOWANCE: u32 = 10;
-pub const BRANCH_TURN: u32 = 10;
-
-pub const EQ_BAND: RangeInclusive<i32> = 50..=70;
-pub const BAND_BONUS: i32 = 2;
-pub const COLD_EQ: i32 = 30;
-pub const DANGER_EQ: i32 = 70;
-pub const HOT_EQ: i32 = 85;
-pub const RUPTURE_LINE: i32 = 90;
-pub const RING_RUPTURE_LINE: i32 = 80;
-pub const PREMATURE_EQ: i32 = 95;
-pub const EQ_WOBBLE: i32 = 3;
-pub const CHANGING_ROOM_CHILL: i32 = 8;
-
-pub const WARMUP_EQ: i32 = 25;
-pub const SHOWER_EQ: i32 = 35;
-pub const TOWELLESS_EQ: i32 = 10;
-pub const ICE_EQ: i32 = 40;
-pub const EDGE_EQ: i32 = 11;
-pub const EDGE_LOOP: u8 = 3;
-pub const PRIAPISM_EQ: i32 = 75;
-pub const PRIAPISM_TURNS: u8 = 5;
-
-pub const SELF_REPORT_INFLATION: f64 = 1.5;
-pub const MM_PER_INCH: f64 = 25.4;
-pub const HONEST_TOLERANCE: f64 = 0.06;
-pub const EXAGGERATION: f64 = 1.0;
-/// Girth plus a quarter of the length is what the jeans have to hold alongside the extender.
-pub const STORAGE_BULK: f64 = 6.5;
-pub const GIRTH_RESPECTED: f64 = 5.0;
-pub const GIRTH_THICK: f64 = 5.5;
-pub const FORESKIN_GLIDE: f64 = 1.0;
-pub const LOCKER_ROOM_BAR: f64 = 8.0;
-pub const LOCKER_ROOM_SHAME: u32 = 3;
-pub const PUT_GAIN: f64 = 0.01;
-pub const PUMP_GAIN: f64 = 0.5;
-pub const EXTENDER_GAIN: f64 = 0.004;
-pub const EDGE_GIRTH: f64 = 0.004;
-
-pub const RUPTURE_IN_BAND: u32 = 250;
-pub const RUPTURE_WARM: u32 = 25;
-pub const RUPTURE_HOT: u32 = 10;
-pub const RUPTURE_PREMATURE: u32 = 3;
-pub const ZIP: u32 = 200;
-pub const RULER_IN_DRAWER: u32 = 2;
-pub const KEY_IN_DRAWER: u32 = 3;
-pub const GREGS_LOCKER: u32 = 20;
-pub const DEGLOVING: u32 = 60;
-pub const DEGLOVING_INTENSITY: i32 = 8;
-pub const WINDOW: u32 = 60;
-pub const PULLED_MUSCLE: u32 = 12;
-pub const PULLED_MUSCLE_INTENSITY: i32 = 9;
-pub const RING_PRIAPISM: u32 = 10;
-pub const RING_TIGHT_PRIAPISM: u32 = 4;
-pub const THIN_MARKUP: u32 = 3;
-pub const SUPPLEMENT_WORKS: u32 = 5;
-pub const RUPTURE_HOLD: u32 = 250;
-pub const ULI_ODDS: u32 = 4;
-pub const MEDITATION_EQ: i32 = 10;
-pub const HOLD_EQ: i32 = 15;
-pub const REFLECTION: u32 = 12;
-pub const ARRIVAL_BONUS: i32 = 1;
-pub const GREED_WARM: f64 = 1.5;
-pub const GREED_HOT: f64 = 2.0;
-pub const COCONUT_ODDS: u32 = 3;
-pub const ENERGY_ODDS: u32 = 5;
-pub const KITCHEN_ICE_ODDS: u32 = 8;
-pub const KETTLE_ODDS: u32 = 6;
-pub const ULI_READS: u8 = 2;
-pub const DRAWER_JAMS: u32 = 4;
-/// A telling is suspicion + 1 in this many, so a quiet house tolerates a raid and a noisy one does not.
-pub const KITCHEN_TOLD: u32 = 8;
-pub const RAID_NOISE: i32 = 1;
-pub const PATCH_EQ: i32 = 3;
-pub const KITCHEN_TELLINGS: u8 = 2;
-pub const WATERMELON: (u32, u32) = (2, 5);
-/// Caught with the melon is suspicion + 2 in this many.
-pub const CAUGHT_MELONED: u32 = 9;
-pub const MELON_SHAME: u32 = 5;
-pub const ENERGY_STAMINA: i32 = 3;
-pub const FRICTION_MAX: i32 = 10;
-pub const FRICTION_DRY: i32 = 2;
-pub const FRICTION_SPIT: i32 = 1;
-pub const FRICTION_GRIP: i32 = 1;
-pub const FRICTION_HOLD: i32 = 2;
-pub const FRICTION_MEDITATE: i32 = 2;
-pub const FRICTION_FLOOR: i32 = 1;
-pub const FRICTION_BURN_AT: i32 = 6;
-pub const FRICTION_BURN: u32 = 10;
-pub const BURN_RUPTURE: i32 = 15;
-pub const OBSERVED: u32 = 6;
-pub const CAT_TAKES_TOWEL: u32 = 5;
-pub const FRIEND: u32 = 10;
-pub const CURVE_MISSES: u32 = 3;
-pub const HOTEL_STRESS: u32 = 3;
-pub const VIRAL_ERRAND: u32 = 2;
-
-/// Visits are (suspicion + 1) in N per turn.
-pub const MUM_VISIT: u32 = 16;
-pub const WANDERER_VISIT: u32 = 32;

Added file: src/game/balance/body.rs+18 additions@@ -0,0 +1,18 @@
+pub const SELF_REPORT_INFLATION: f64 = 1.5;
+pub const MM_PER_INCH: f64 = 25.4;
+pub const HONEST_TOLERANCE: f64 = 0.06;
+pub const EXAGGERATION: f64 = 1.0;
+/// Girth plus a quarter of the length is what the jeans have to hold alongside the extender.
+pub const STORAGE_BULK: f64 = 6.5;
+pub const GIRTH_RESPECTED: f64 = 5.0;
+pub const GIRTH_THICK: f64 = 5.5;
+pub const FORESKIN_GLIDE: f64 = 1.0;
+pub const LOCKER_ROOM_BAR: f64 = 8.0;
+pub const LOCKER_ROOM_SHAME: u32 = 3;
+pub const PUT_GAIN: f64 = 0.01;
+pub const PUMP_GAIN: f64 = 0.5;
+pub const EXTENDER_GAIN: f64 = 0.004;
+pub const EDGE_GIRTH: f64 = 0.004;
+pub const QUEUED_ETA: std::ops::RangeInclusive<i32> = 1..=4;
+pub const LOCKER_ROOM_OTHERS: [(&str, f64); 3] =
+    [("Greg", 9.5), ("Dmitri", 8.75), ("a man in a towel", 11.0)];

Added file: src/game/balance/economy.rs+6

@@ -0,0 +1,6 @@

1+pub const STARTING_CASH: u32 = 20;

2+pub const STARTING_ICE_PACKS: u32 = 1;

3+pub const FLOOR_ALLOWANCE: u32 = 10;

4+pub const THIN_MARKUP: u32 = 3;

5+/// The footage gains this many views a second, starting from one.

6+pub const VIEWS_PER_SECOND: u64 = 37;

Added file: src/game/balance/eq.rs+36 additions@@ -0,0 +1,36 @@
+use std::ops::RangeInclusive;
+
+pub const STARTING_EQ: i32 = 20;
+pub const EQ_BAND: RangeInclusive<i32> = 50..=70;
+pub const BAND_BONUS: i32 = 2;
+pub const COLD_EQ: i32 = 30;
+pub const DANGER_EQ: i32 = 70;
+pub const HOT_EQ: i32 = 85;
+pub const RUPTURE_LINE: i32 = 90;
+pub const RING_RUPTURE_LINE: i32 = 80;
+pub const PREMATURE_EQ: i32 = 95;
+pub const EQ_WOBBLE: i32 = 3;
+pub const CHANGING_ROOM_CHILL: i32 = 8;
+pub const WARMUP_EQ: i32 = 25;
+pub const SHOWER_EQ: i32 = 35;
+pub const TOWELLESS_EQ: i32 = 10;
+pub const ICE_EQ: i32 = 40;
+pub const EDGE_EQ: i32 = 11;
+pub const PRIAPISM_EQ: i32 = 75;
+pub const PRIAPISM_TURNS: u8 = 5;
+pub const MEDITATION_EQ: i32 = 10;
+pub const HOLD_EQ: i32 = 15;
+pub const ARRIVAL_BONUS: i32 = 1;
+pub const GREED_WARM: f64 = 1.5;
+pub const GREED_HOT: f64 = 2.0;
+pub const PATCH_EQ: i32 = 3;
+pub const STROKE_EQ: i32 = 2;
+pub const STROKE_EQ_COST: i32 = 6;
+pub const SOFT_INTENSITY: i32 = 2;
+pub const LOST_IT_EQ: i32 = 10;
+/// A roll this far under the DC is a 510 rather than a 204.
+pub const NEAR_MISS: i32 = 3;
+/// A roll this far over the DC lands its gains at once rather than queueing them.
+pub const CLEAN_HIT: i32 = 5;
+pub const UNDERHAND_STRETCH: i32 = 2;
+pub const UNDERHAND_WET: i32 = -1;

Added file: src/game/balance/floors.rs+13 additions@@ -0,0 +1,13 @@
+pub const FLOOR_TURNS: u32 = 6;
+pub const BRANCH_TURN: u32 = 10;
+pub const ZIP: u32 = 200;
+pub const RULER_IN_DRAWER: u32 = 2;
+pub const KEY_IN_DRAWER: u32 = 3;
+pub const GREGS_LOCKER: u32 = 20;
+pub const ULI_ODDS: u32 = 4;
+pub const ULI_READS: u8 = 2;
+pub const DRAWER_JAMS: u32 = 4;
+pub const OBSERVED: u32 = 6;
+pub const CAT_TAKES_TOWEL: u32 = 5;
+pub const HOTEL_STRESS: u32 = 3;
+pub const BATHROOM_VASELINE: u32 = 2;

Added file: src/game/balance/friction.rs+11 additions@@ -0,0 +1,11 @@
+pub const FRICTION_MAX: i32 = 10;
+pub const FRICTION_DRY: i32 = 2;
+pub const FRICTION_SPIT: i32 = 1;
+pub const FRICTION_GRIP: i32 = 1;
+pub const FRICTION_HOLD: i32 = 2;
+pub const FRICTION_MEDITATE: i32 = 2;
+pub const FRICTION_FLOOR: i32 = 1;
+pub const FRICTION_BURN_AT: i32 = 6;
+pub const FRICTION_BURN: u32 = 10;
+/// Extra friction by intensity, from 1 to 10.
+pub const VIGOUR: [i32; 10] = [0, 0, 0, 0, 0, 1, 1, 1, 2, 2];

Added file: src/game/balance/household.rs+6

@@ -0,0 +1,6 @@

1+pub const SUSPICION_LIMIT: u8 = 5;

2+pub const PATIENCE: u8 = 3;

3+pub const VIRAL_ERRAND: u32 = 2;

4+/// Visits are (suspicion + 1) in N per turn.

5+pub const MUM_VISIT: u32 = 16;

6+pub const WANDERER_VISIT: u32 = 32;

Added file: src/game/balance/kitchen.rs+12 additions@@ -0,0 +1,12 @@
+pub const COCONUT_ODDS: u32 = 3;
+pub const ENERGY_ODDS: u32 = 5;
+pub const KITCHEN_ICE_ODDS: u32 = 8;
+pub const KETTLE_ODDS: u32 = 6;
+/// A telling is suspicion + 1 in this many, so a quiet house tolerates a raid and a noisy one does not.
+pub const KITCHEN_TOLD: u32 = 8;
+pub const RAID_NOISE: i32 = 1;
+pub const KITCHEN_TELLINGS: u8 = 2;
+pub const WATERMELON: (u32, u32) = (2, 5);
+/// Caught with the melon is suspicion + 2 in this many.
+pub const CAUGHT_MELONED: u32 = 9;
+pub const MELON_SHAME: u32 = 5;

Added file: src/game/balance/mishaps.rs+17 additions@@ -0,0 +1,17 @@
+pub const RUPTURE_IN_BAND: u32 = 250;
+pub const RUPTURE_WARM: u32 = 25;
+pub const RUPTURE_HOT: u32 = 10;
+pub const RUPTURE_PREMATURE: u32 = 3;
+pub const DEGLOVING: u32 = 60;
+pub const DEGLOVING_INTENSITY: i32 = 8;
+pub const WINDOW: u32 = 60;
+pub const PULLED_MUSCLE: u32 = 12;
+pub const PULLED_MUSCLE_INTENSITY: i32 = 9;
+pub const RING_PRIAPISM: u32 = 10;
+pub const RING_TIGHT_PRIAPISM: u32 = 4;
+pub const SUPPLEMENT_WORKS: u32 = 5;
+pub const RUPTURE_HOLD: u32 = 250;
+pub const REFLECTION: u32 = 12;
+pub const BURN_RUPTURE: i32 = 15;
+pub const FRIEND: u32 = 10;
+pub const CURVE_MISSES: u32 = 3;

Added file: src/game/balance/mod.rs+21 additions@@ -0,0 +1,21 @@
+//! Every tunable number in the game. Odds are written as "1 in N".
+
+mod body;
+mod economy;
+mod eq;
+mod floors;
+mod friction;
+mod household;
+mod kitchen;
+mod mishaps;
+mod stamina;
+
+pub use body::*;
+pub use economy::*;
+pub use eq::*;
+pub use floors::*;
+pub use friction::*;
+pub use household::*;
+pub use kitchen::*;
+pub use mishaps::*;
+pub use stamina::*;

Added file: src/game/balance/stamina.rs+4

@@ -0,0 +1,4 @@

1+pub const MAX_STAMINA: i32 = 10;

2+pub const PULLED_STAMINA: i32 = 7;

3+pub const EDGE_LOOP: u8 = 3;

4+pub const ENERGY_STAMINA: i32 = 3;

Modified file: src/game/body.rs+81 additions−87 deletions@@ -1,96 +1,95 @@
 use axum::http::StatusCode;
-use serde::Deserialize;
-use serde_json::{Value, json};
 
 use super::{
-    Grip, Outcome, Run,
-    balance::{EXAGGERATION, GIRTH_RESPECTED, GIRTH_THICK, LOCKER_ROOM_BAR, PATCH_EQ, PUT_GAIN},
-    etag_matches, honest,
+    Outcome, Run,
+    balance::{GIRTH_RESPECTED, GIRTH_THICK, LOCKER_ROOM_BAR, MAX_STAMINA, STARTING_EQ},
+    credentials::etag_matches,
 };
 use crate::problem::Problem;
 
-#[derive(Deserialize)]
-pub struct PatchOp {
-    pub op: String,
-    pub path: String,
-    #[serde(default)]
-    pub value: Value,
+pub struct Body {
+    pub(crate) length: f64,
+    pub(crate) girth: f64,
+    pub(crate) foreskin: Option<f64>,
+    pub(crate) eq: i32,
+    pub(crate) stamina: i32,
+    pub(crate) friction: i32,
+    pub(crate) grip: Grip,
+    /// The grip of the last stroke, which decides whether this one gets the switching discount.
+    pub(crate) jelq_grip: Option<Grip>,
+    pub(crate) warmed_up: bool,
+    pub(crate) exhausted: bool,
+    pub(crate) put_applied: bool,
+    pub(crate) conditions: Conditions,
+    pub(crate) pending: Vec<Pending>,
 }
 
-pub(super) fn exaggeration() -> Problem {
-    Problem::new(
-        StatusCode::BAD_REQUEST,
-        "exaggeration",
-        "The server has measured. Lying is not a technique.",
-    )
+impl Body {
+    pub fn new(length: f64, girth: f64, foreskin: f64) -> Self {
+        Self {
+            length,
+            girth,
+            foreskin: Some(foreskin),
+            eq: STARTING_EQ,
+            stamina: MAX_STAMINA,
+            friction: 0,
+            grip: Grip::Overhand,
+            jelq_grip: None,
+            warmed_up: false,
+            exhausted: false,
+            put_applied: false,
+            conditions: Conditions::default(),
+            pending: Vec::new(),
+        }
+    }
 }
 
-impl Run {
-    pub fn put(&mut self) -> Outcome {
-        if self.put_applied {
-            return Outcome::empty(StatusCode::NO_CONTENT);
+#[derive(Default)]
+pub struct Conditions {
+    pub(crate) peyronie: bool,
+    pub(crate) pulled_muscle: bool,
+    pub(crate) priapism_turns: u8,
+    pub(crate) friction_burn: bool,
+}
+
+/// Gains a `202` promised, due on a later turn.
+pub struct Pending {
+    pub(crate) due: u32,
+    pub(crate) length: f64,
+    pub(crate) girth: f64,
+    pub(crate) foreskin: f64,
+}
+
+#[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",
         }
-        self.put_applied = true;
-        self.length += PUT_GAIN;
-        self.touch();
-        Outcome::json(StatusCode::OK, json!({ "detail": "Applied." }))
     }
+}
 
-    /// Being measured is not arousing, so every PATCH costs a little EQ whatever it finds.
-    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {
-        self.reset_eq(self.eq - PATCH_EQ);
-        self.touch();
-        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 + EXAGGERATION {
-                self.shame += 2;
-                self.touch();
-                return Err(exaggeration());
-            }
-            if !honest(claimed, actual) {
-                self.shame += 1;
-                self.touch();
-                return Err(
-                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
-                        .with("path", op.path.clone()),
-                );
-            }
+impl std::str::FromStr for Grip {
+    type Err = ();
+
+    fn from_str(protocol: &str) -> Result<Self, ()> {
+        match protocol.to_ascii_lowercase().as_str() {
+            "overhand" => Ok(Self::Overhand),
+            "underhand" => Ok(Self::Underhand),
+            _ => Err(()),
         }
-        Ok(Outcome::json(
-            StatusCode::OK,
-            json!({ "detail": "Correct." }),
-        ))
     }
+}
 
+impl Run {
     pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {
-        if self.foreskin.is_none() {
+        if self.body.foreskin.is_none() {
             return Err(Problem::new(
                 StatusCode::GONE,
                 "foreskin-gone",
@@ -111,27 +110,27 @@ impl Run {
                 "The foreskin has changed since you last looked at it.",
             ));
         }
-        self.foreskin = None;
-        self.shame += 20;
+        self.body.foreskin = None;
+        self.standing.shame += 20;
         self.touch();
         Ok(Outcome::empty(StatusCode::NO_CONTENT))
     }
 
     pub fn set_grip(&mut self, grip: Grip) -> Result<(), Problem> {
         self.grip_closes(grip)?;
-        self.grip = grip;
+        self.body.grip = grip;
         self.touch();
         Ok(())
     }
 
     pub(super) fn grip_closes(&self, grip: Grip) -> Result<(), Problem> {
-        if grip == Grip::Underhand && self.girth > GIRTH_THICK {
+        if grip == Grip::Underhand && self.body.girth > GIRTH_THICK {
             return Err(Problem::new(
                 StatusCode::PAYLOAD_TOO_LARGE,
                 "grip-too-small",
                 format!(
                     "The underhand grip no longer closes around {:.2} inches of girth.",
-                    self.girth
+                    self.body.girth
                 ),
             )
             .with("maximum", GIRTH_THICK));
@@ -145,11 +144,6 @@ impl Run {
     }
 
     pub fn girth_respected(&self) -> bool {
-        self.girth >= GIRTH_RESPECTED
+        self.body.girth >= GIRTH_RESPECTED
     }
 }
-
-/// A cylinder whose circumference is the girth.
-pub fn volume(length: f64, girth: f64) -> f64 {
-    girth * girth * length / (4.0 * std::f64::consts::PI)
-}

Added file: src/game/cause.rs+134 additions@@ -0,0 +1,134 @@
+use axum::http::StatusCode;
+
+use crate::problem::Problem;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Cause {
+    Ruptured { ice_unused: bool },
+    Caught,
+    Opened,
+    Banned,
+    Degloved,
+    Zip,
+    Meloned,
+    Abandoned,
+    Lost,
+}
+
+impl Cause {
+    pub const ALL: [Self; 10] = [
+        Self::Ruptured { ice_unused: true },
+        Self::Ruptured { ice_unused: false },
+        Self::Caught,
+        Self::Opened,
+        Self::Banned,
+        Self::Degloved,
+        Self::Zip,
+        Self::Meloned,
+        Self::Abandoned,
+        Self::Lost,
+    ];
+
+    pub fn slug(self) -> &'static str {
+        match self {
+            Self::Ruptured { .. } => "vascular-event",
+            Self::Caught => "caught",
+            Self::Opened => "opened",
+            Self::Banned => "banned",
+            Self::Degloved => "degloved",
+            Self::Zip => "zip",
+            Self::Meloned => "watermelon",
+            Self::Abandoned => "abandoned",
+            Self::Lost => "lost",
+        }
+    }
+
+    pub fn detail(self) -> &'static str {
+        match self {
+            Self::Ruptured { ice_unused: true } => {
+                "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."
+            }
+            Self::Ruptured { ice_unused: false } => {
+                "A vessel has exceeded its rated pressure. The run has ended."
+            }
+            Self::Caught => {
+                "Mum has seen enough. The run has ended. Nobody will mention it at dinner."
+            }
+            Self::Opened => {
+                "Mum has stopped knocking and opened the door. The run has ended. Nobody will mention it at dinner."
+            }
+            Self::Banned => "Your account has been banned. The forum can tell. The run has ended.",
+            Self::Degloved => {
+                "The outer layer has been removed in one piece. It will not be returning. The run has ended."
+            }
+            Self::Zip => {
+                "The request conflicts with the current state of the zip. The run has ended."
+            }
+            Self::Meloned => {
+                "You have been caught with the watermelon. Nobody will mention it at dinner. The run has ended."
+            }
+            Self::Abandoned => "The run was abandoned.",
+            Self::Lost => {
+                "The server fell over mid-stroke and the run went with it. Nobody will mention it at dinner."
+            }
+        }
+    }
+
+    /// The records keep the slug and the ice, which is all a cause needs to be told again.
+    pub fn parse(slug: &str, ice_unused: bool) -> Option<Self> {
+        Self::ALL.into_iter().find(|cause| {
+            cause.slug() == slug
+                && !matches!(cause, Self::Ruptured { ice_unused: unused } if *unused != ice_unused)
+        })
+    }
+
+    fn status(self) -> StatusCode {
+        match self {
+            Self::Ruptured { .. } | Self::Lost => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::Caught | Self::Opened | Self::Degloved | Self::Abandoned | Self::Meloned => {
+                StatusCode::GONE
+            }
+            Self::Banned => StatusCode::FORBIDDEN,
+            Self::Zip => StatusCode::CONFLICT,
+        }
+    }
+
+    pub fn problem(self) -> Problem {
+        Problem::new(self.status(), self.slug(), self.detail())
+    }
+}
+
+pub struct Ending {
+    pub(crate) cause: Cause,
+    pub(crate) turn: u32,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum RunStatus {
+    Alive,
+    Prescribed,
+    /// The true ending, the clinic's `304`.
+    Normal,
+    Gone,
+}
+
+impl RunStatus {
+    pub const ALL: [Self; 4] = [Self::Alive, Self::Prescribed, Self::Normal, Self::Gone];
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Alive => "alive",
+            Self::Prescribed => "prescribed",
+            Self::Normal => "normal",
+            Self::Gone => "gone",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|status| status.name() == name)
+    }
+
+    pub fn finished(self) -> bool {
+        self != Self::Alive
+    }
+}

Added file: src/game/checks.rs+162 additions@@ -0,0 +1,162 @@
+use super::{
+    LUBRICANTS, Lube, Run, Technique,
+    balance::STORAGE_BULK,
+    lube::LubeRule,
+    techniques::{Training, Utility},
+};
+use crate::problem::Problem;
+use axum::http::{StatusCode, header};
+use serde_json::json;
+
+impl Run {
+    pub(super) fn ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {
+        self.access(technique)?;
+        match technique {
+            Technique::Training(training) => Self::check_lube(training, lube),
+            Technique::Utility(_) => Ok(()),
+        }
+    }
+
+    pub(super) fn access(&self, technique: Technique) -> Result<(), Problem> {
+        if technique == Technique::Training(Training::Uli) && !self.online.uli_taught {
+            return Err(Problem::new(
+                StatusCode::FORBIDDEN,
+                "technique-locked",
+                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not found the reply.",
+            ));
+        }
+        if !self.body.warmed_up {
+            return Err(Problem::new(
+                StatusCode::PRECONDITION_FAILED,
+                "cold-start",
+                "Warm-up was skipped. The server has noted this.",
+            )
+            .with("technique", Utility::Warmup.name()));
+        }
+        if matches!(technique, Technique::Training(_)) {
+            self.grip_closes(self.body.grip)?;
+        }
+        match technique {
+            Technique::Utility(Utility::Pump) if !self.items.kit.pump_pro => Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-pump",
+                "The pump technique depends on a pump.",
+            )),
+            Technique::Utility(_) => Ok(()),
+            Technique::Training(training) => match training.profile().foreskin {
+                Some((min, max)) => self.check_foreskin(min, max),
+                None => Ok(()),
+            },
+        }
+    }
+
+    pub(super) fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {
+        match (training.profile().lube, lube) {
+            (LubeRule::Required, None) => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "lubricant-required",
+                format!(
+                    "The {} technique requires a lubricant. None was declared.",
+                    training.name()
+                ),
+            )
+            .with("lubricants", json!(LUBRICANTS))),
+            (LubeRule::Forbidden, Some(_)) => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "lubricant-declared",
+                format!(
+                    "The {} technique was requested. A lubricant was declared.",
+                    training.name()
+                ),
+            )),
+            _ => Ok(()),
+        }
+    }
+
+    /// One unit of whatever was declared. Spit is free and the tap is always on.
+    pub(super) fn lube_available(&self, lube: Option<Lube>) -> Result<(), Problem> {
+        let Some(bottle) = lube.and_then(Lube::item) else {
+            return Ok(());
+        };
+        if !self.items.has(bottle) {
+            return Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "lubricant-exhausted",
+                format!("{} was declared, but the bottle is empty.", bottle.slug()),
+            ));
+        }
+        Ok(())
+    }
+
+    pub(super) fn take_lube(&mut self, lube: Option<Lube>) -> Result<(), Problem> {
+        self.lube_available(lube)?;
+        if let Some(lube) = lube {
+            self.items.lubes.take(lube);
+        }
+        Ok(())
+    }
+
+    pub fn techniques_now(&self) -> impl Iterator<Item = Technique> + '_ {
+        let blocked = !self.floor.timed() || self.items.kit.cage || self.body.exhausted;
+        Technique::ALL
+            .into_iter()
+            .filter(move |_| !blocked)
+            .filter(|&technique| match technique {
+                Technique::Utility(Utility::Warmup) => {
+                    !self.body.warmed_up || self.here.kitchen.kettle_boiled
+                }
+                Technique::Utility(Utility::Ice) => self.items.stores.ice_packs > 0,
+                Technique::Utility(Utility::Supplement) => self.items.stores.supplements > 0,
+                Technique::Utility(Utility::Meditate) => !self.here.meditated,
+                Technique::Utility(Utility::Energy) => self.items.stores.energy_drinks > 0,
+                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),
+            })
+    }
+
+    pub(super) fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {
+        let Some(f) = self.body.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, self.path("/foreskin")));
+        };
+        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));
+        }
+        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));
+        }
+        Ok(())
+    }
+
+    pub(super) fn check_storage(&self) -> Result<(), Problem> {
+        if self.items.kit.extender && self.body.girth + self.current_length() / 4.0 > STORAGE_BULK {
+            return Err(Problem::new(
+                StatusCode::INSUFFICIENT_STORAGE,
+                "jeans-full",
+                "The jeans are full. The extender is occupying the remaining storage.",
+            )
+            .with("extender", self.path("/inventory/extender")));
+        }
+        Ok(())
+    }
+}

Modified file: src/game/clinic.rs+23 additions−11 deletions@@ -1,12 +1,24 @@
 use axum::http::{StatusCode, header};
 use serde_json::json;
 
-use super::{Floor, Outcome, Run, body::volume, etag_matches, parse_credentials, round2};
+use super::{
+    Floor, Outcome, Run,
+    credentials::{Scheme, etag_matches, parse_credentials},
+    measure::{round2, volume},
+};
 use crate::{
     headers::{SERVER_TIMING, X_DIAGNOSIS},
     problem::Problem,
 };
 
+#[derive(Default)]
+pub struct Clinic {
+    pub(crate) intake_attempts: usize,
+    pub(crate) measured: bool,
+    pub(crate) prescribed: bool,
+    pub(crate) cured: bool,
+}
+
 const INTAKE: [&str; 3] = [
     "The clinic does not accept excuses.",
     "The clinic accepts one token. You have not been carrying it.",
@@ -35,7 +47,7 @@ impl Run {
         let Some(authorization) = authorization else {
             return Err(intake.header(header::WWW_AUTHENTICATE, "Bearer realm=\"clinic\""));
         };
-        let truthful = parse_credentials(authorization, "bearer")
+        let truthful = parse_credentials(authorization, Scheme::Bearer)
             .is_some_and(|token| token.eq_ignore_ascii_case("honesty"));
         if !truthful {
             let hint = INTAKE[self.clinic.intake_attempts.min(INTAKE.len() - 1)];
@@ -48,8 +60,8 @@ impl Run {
             ));
         }
 
-        self.conditions.peyronie = false;
-        self.conditions.priapism_turns = 0;
+        self.body.conditions.peyronie = false;
+        self.body.conditions.priapism_turns = 0;
         let etag = self.origin_etag();
         if if_none_match.is_some_and(|inm| etag_matches(inm, &etag)) {
             self.clinic.cured = true;
@@ -59,15 +71,15 @@ impl Run {
         }
         if !self.clinic.measured {
             self.clinic.measured = true;
-            if !self.items.ruler {
-                self.shame += 15;
+            if !self.items.kit.ruler {
+                self.standing.shame += 15;
             }
         }
-        let volume = volume(self.length, self.girth);
-        let foreskin = self.foreskin.unwrap_or(0.0);
+        let volume = volume(self.body.length, self.body.girth);
+        let foreskin = self.body.foreskin.unwrap_or(0.0);
         let timing = format!(
             "length;dur={:.2}, girth;dur={:.2}, foreskin;dur={foreskin:.2}, volume;desc=\"cubic inches\";dur={volume:.2}",
-            self.length, self.girth
+            self.body.length, self.body.girth
         );
         self.clinic.prescribed = true;
         self.touch();
@@ -76,8 +88,8 @@ impl Run {
             json!({
                 "diagnosis": "within normal range",
                 "detail": "Congratulations. You have been cured of a condition you never had. The run is over.",
-                "measured_length": round2(self.length),
-                "measured_girth": round2(self.girth),
+                "measured_length": round2(self.body.length),
+                "measured_girth": round2(self.body.girth),
                 "volume": round2(volume),
                 "prescription": "Please stop.",
             }),

Added file: src/game/credentials.rs+32 additions@@ -0,0 +1,32 @@
+#[derive(Clone, Copy)]
+pub enum Scheme {
+    Basic,
+    Bearer,
+    Excuse,
+    Ruler,
+}
+
+impl Scheme {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Basic => "basic",
+            Self::Bearer => "bearer",
+            Self::Excuse => "excuse",
+            Self::Ruler => "ruler",
+        }
+    }
+}
+
+pub fn parse_credentials(authorization: &str, scheme: Scheme) -> Option<&str> {
+    let (given, rest) = authorization.trim().split_once(' ')?;
+    given
+        .eq_ignore_ascii_case(scheme.name())
+        .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)
+}

Added file: src/game/dispatch.rs+164 additions@@ -0,0 +1,164 @@
+use super::{
+    Floor, Lube, Outcome, Run, Story, Technique,
+    techniques::{Training, Utility},
+};
+use crate::problem::Problem;
+use axum::http::{StatusCode, header};
+use serde_json::json;
+use std::{fmt::Write as _, ops::ControlFlow};
+
+impl Run {
+    pub fn jelq(
+        &mut self,
+        techniques: &[Technique],
+        intensity: i32,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        self.check_exhausted()?;
+        if self.online.story == Story::Pending {
+            return Ok(self.branch_offer());
+        }
+        if self.floor == Floor::Forum {
+            return Ok(Outcome::json(
+                StatusCode::SEE_OTHER,
+                json!({ "detail": "Refer to the forum." }),
+            )
+            .header(header::LOCATION, super::FORUM_THREAD));
+        }
+        if self.items.kit.cage {
+            return Err(Problem::new(
+                StatusCode::LOCKED,
+                "caged",
+                "The cage is locked. The key is not in the box.",
+            ));
+        }
+        match *techniques {
+            [Technique::Utility(utility)] => self.utility(utility, lube),
+            [Technique::Training(training)] => self.single(training, intensity, lube),
+            [Technique::Training(a), Technique::Training(b)] => self.combo(a, b, intensity, lube),
+            [_, _] => Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "combo-invalid",
+                "Only training techniques can be combined.",
+            )),
+            _ => Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "too-many-techniques",
+                "Two techniques at most. The server has limits even if you do not.",
+            )),
+        }
+    }
+
+    pub(super) fn utility(
+        &mut self,
+        utility: Utility,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        match utility {
+            Utility::Warmup => return self.warm_up(),
+            Utility::Ice => return self.ice(),
+            Utility::Supplement => return self.supplement(),
+            Utility::Meditate => return self.meditate(),
+            Utility::Energy => return self.energy(),
+            Utility::Edge | Utility::Pump => {}
+        }
+        self.ready(Technique::Utility(utility), lube)?;
+        self.check_storage()?;
+        self.floor_enemy()?;
+        match utility {
+            Utility::Edge => self.edge(),
+            _ => self.pump(),
+        }
+    }
+
+    pub(super) fn single(
+        &mut self,
+        training: Training,
+        intensity: i32,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        self.ready(Technique::Training(training), lube)?;
+        self.check_storage()?;
+        self.lube_available(lube)?;
+        self.floor_enemy()?;
+        self.take_lube(lube)?;
+        self.chafe(lube, intensity);
+        self.commit(intensity, lube, 1);
+        if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
+            return Ok(interrupted);
+        }
+        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {
+            return Ok(interrupted);
+        }
+        let outcome = self.roll(training, intensity, lube)?;
+        Ok(self.gossip(outcome))
+    }
+
+    pub(super) fn combo(
+        &mut self,
+        a: Training,
+        b: Training,
+        intensity: i32,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        if a == b {
+            return Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "combo-invalid",
+                "A technique cannot be combined with itself. The server has checked.",
+            ));
+        }
+        self.ready(Technique::Training(a), lube)?;
+        self.ready(Technique::Training(b), lube)?;
+        self.check_storage()?;
+        self.lube_available(lube)?;
+        self.floor_enemy()?;
+        self.take_lube(lube)?;
+        self.chafe(lube, intensity);
+        self.chafe(lube, intensity);
+        self.commit(intensity, lube, 2);
+        for training in [a, b] {
+            if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
+                return Ok(interrupted);
+            }
+        }
+        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {
+            return Ok(interrupted);
+        }
+
+        let mut statuses = Vec::new();
+        for training in [a, b] {
+            let result = self.roll(training, intensity, lube);
+            if self.ended.is_some() {
+                return result;
+            }
+            let status = match result {
+                Ok(outcome) => self.gossip(outcome).status(),
+                Err(problem) => problem.status(),
+            };
+            statuses.push((training, status));
+        }
+
+        let mut xml = String::from(
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",
+        );
+        for (training, status) in statuses {
+            let _ = write!(
+                xml,
+                "  <D:response>\n    <D:href>{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",
+                self.path(""),
+                training.name(),
+                status.as_u16(),
+                crate::problem::reason(status),
+            );
+        }
+        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,
+        ))
+    }
+}

Added file: src/game/drawer.rs+161 additions@@ -0,0 +1,161 @@
+use super::{
+    Floor, Item, Notice, Outcome, Run,
+    balance::{BATHROOM_VASELINE, DRAWER_JAMS, GREGS_LOCKER, KEY_IN_DRAWER, RULER_IN_DRAWER},
+};
+use crate::problem::Problem;
+use axum::http::{StatusCode, header};
+use serde_json::json;
+
+fn nothing() -> Result<Outcome, Problem> {
+    Ok(Outcome::empty(StatusCode::NO_CONTENT))
+}
+
+impl Run {
+    pub(super) fn found(&self, item: Item, detail: &str) -> Outcome {
+        Outcome::json(StatusCode::FOUND, json!({ "detail": detail })).header(
+            header::LOCATION,
+            self.path(&format!("/inventory/{}", item.slug())),
+        )
+    }
+
+    pub fn search_drawer(&mut self) -> Result<Outcome, Problem> {
+        self.touch();
+        self.end_kitchen_visit();
+        if self.items.kit.cage {
+            return Ok(self.rummage_for_key());
+        }
+        let first = !self.here.drawer.searched;
+        self.here.drawer.searched = true;
+        match self.floor {
+            Floor::Bedroom => self.search_bedroom(first),
+            Floor::Bathroom if first => Ok(self.search_bathroom()),
+            Floor::ChangingRoom => self.search_locker(first),
+            Floor::Nans if first => {
+                self.items.grant(Item::Cage);
+                self.standing.shame += 5;
+                Ok(self.found(
+                    Item::Cage,
+                    "A small box. Inside was a cage. It is now on. The key is not in the box.",
+                ))
+            }
+            Floor::Hotel if first => {
+                for item in [Item::DndSign, Item::IcePack, Item::IcePack, Item::Lotion] {
+                    self.items.grant(item);
+                }
+                Ok(self.found(
+                    Item::DndSign,
+                    "A Do Not Disturb sign, two ice packs from the machine down the hall, and a complimentary lotion.",
+                ))
+            }
+            Floor::Forum if first => {
+                self.items.grant(Item::Spreadsheet);
+                Ok(self.found(
+                    Item::Spreadsheet,
+                    "Your own spreadsheet. Every line is flat.",
+                ))
+            }
+            Floor::Clinic => Err(Problem::new(
+                StatusCode::FORBIDDEN,
+                "doctors-drawer",
+                "That is the doctor's drawer.",
+            )),
+            _ => nothing(),
+        }
+    }
+
+    fn search_bedroom(&mut self, first: bool) -> Result<Outcome, Problem> {
+        let ruler_here = self.chance(
+            self.decision("ruler", "Is there a ruler hiding in the drawer?"),
+            RULER_IN_DRAWER,
+        );
+        if !first || self.items.kit.ruler || !ruler_here {
+            return nothing();
+        }
+        self.items.grant(Item::Ruler);
+        self.standing.shame += 10;
+        Ok(self.found(
+            Item::Ruler,
+            "You now know. This is the first honest measurement of the run.",
+        ))
+    }
+
+    fn search_bathroom(&mut self) -> Outcome {
+        self.items.grant(Item::DoorLock);
+        let vaseline = self.chance(
+            self.decision(
+                "bathroom-vaseline",
+                "Is it the vaseline behind the door lock, rather than the lotion?",
+            ),
+            BATHROOM_VASELINE,
+        );
+        let (lube, detail) = if vaseline {
+            (
+                Item::Vaseline,
+                "A door lock, which works once, and a tub of vaseline behind it.",
+            )
+        } else {
+            (
+                Item::Lotion,
+                "A door lock, which works once, and a bottle of lotion behind it.",
+            )
+        };
+        self.items.grant(lube);
+        self.found(Item::DoorLock, detail)
+    }
+
+    fn search_locker(&mut self, first: bool) -> Result<Outcome, Problem> {
+        let open = first
+            && self.chance(
+                self.decision("gregs-locker", "Has Greg left his locker open?"),
+                GREGS_LOCKER,
+            );
+        if open {
+            self.items.grant(Item::BabyOil);
+            return Ok(self.found(
+                Item::BabyOil,
+                "Greg has left his locker open. The baby oil is yours now, legally speaking.",
+            ));
+        }
+        self.standing.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.",
+        ))
+    }
+
+    /// Searching while caged is noisy, costs the floor turn, and the key only turns up some of
+    /// the time. A jammed drawer takes a whole turn to work loose.
+    pub(super) fn rummage_for_key(&mut self) -> Outcome {
+        self.begin_turn();
+        self.add_suspicion(1);
+        self.maybe_summon_mum();
+        if self.here.drawer.jammed {
+            self.here.drawer.jammed = false;
+            self.notices.push(Notice::DrawerComesLoose);
+            return Outcome::empty(StatusCode::NO_CONTENT);
+        }
+        if !self.chance(
+            self.decision("key", "Does the drawer finally give up the cage key?"),
+            KEY_IN_DRAWER,
+        ) {
+            if self.chance(
+                self.decision("drawer-jams", "Has the drawer jammed on its runners?"),
+                DRAWER_JAMS,
+            ) {
+                self.here.drawer.jammed = true;
+                self.notices.push(Notice::DrawerJammed);
+            }
+            return Outcome::empty(StatusCode::NO_CONTENT);
+        }
+        self.items.grant(Item::CageKey);
+        Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "The key was in the drawer. The cage is off." }),
+        )
+    }
+
+    pub fn drawer_worth_searching(&self) -> bool {
+        !self.here.drawer.searched || self.items.kit.cage
+    }
+}

Added file: src/game/floor.rs+147 additions@@ -0,0 +1,147 @@
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+#[repr(u8)]
+pub enum Floor {
+    Bedroom = 1,
+    Bathroom = 2,
+    ChangingRoom = 3,
+    Nans = 4,
+    Hotel = 5,
+    Forum = 6,
+    Clinic = 7,
+}
+
+impl Floor {
+    pub fn number(self) -> u8 {
+        self as u8
+    }
+
+    pub fn next(self) -> Option<Self> {
+        match self {
+            Self::Bedroom => Some(Self::Bathroom),
+            Self::Bathroom => Some(Self::ChangingRoom),
+            Self::ChangingRoom => Some(Self::Nans),
+            Self::Nans => Some(Self::Hotel),
+            Self::Hotel => Some(Self::Forum),
+            Self::Forum => Some(Self::Clinic),
+            Self::Clinic => None,
+        }
+    }
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Bedroom => "the bedroom",
+            Self::Bathroom => "the shared bathroom",
+            Self::ChangingRoom => "the gym changing room",
+            Self::Nans => "Nan's house at Christmas",
+            Self::Hotel => "a business trip hotel",
+            Self::Forum => "the forum",
+            Self::Clinic => "the urologist's office",
+        }
+    }
+
+    pub fn place(self) -> &'static str {
+        match self {
+            Self::Bedroom => "the bedroom",
+            Self::Bathroom => "the bathroom",
+            Self::ChangingRoom => "the changing room",
+            Self::Nans => "Nan's house",
+            Self::Hotel => "the hotel room",
+            Self::Forum => "the forum floor",
+            Self::Clinic => "the clinic",
+        }
+    }
+
+    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. Your brother showers at eight.",
+            Self::ChangingRoom => {
+                "It is cold. Discretion is advised. Everyone here is lying. Pump-Bro is by the lockers."
+            }
+            Self::Nans => {
+                "The walls are thin. Mum 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.",
+        }
+    }
+
+    pub fn observer(self) -> Option<Observer> {
+        match self {
+            Self::Bedroom => Some(Observer::Cat),
+            Self::ChangingRoom => Some(Observer::Greg),
+            Self::Nans => Some(Observer::Nan),
+            _ => None,
+        }
+    }
+
+    pub fn has_mum(self) -> bool {
+        matches!(self, Self::Bedroom | Self::Nans)
+    }
+
+    pub fn has_window(self) -> bool {
+        matches!(self, Self::Bedroom | Self::Nans | Self::Hotel)
+    }
+
+    pub fn shop_open(self) -> bool {
+        matches!(self, Self::ChangingRoom | Self::Hotel)
+    }
+
+    pub fn has_kitchen(self) -> bool {
+        matches!(self, Self::Bedroom | Self::Nans)
+    }
+
+    pub fn timed(self) -> bool {
+        !matches!(self, Self::Forum | Self::Clinic)
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Observer {
+    Cat,
+    Greg,
+    Nan,
+}
+
+impl Observer {
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Cat => "cat",
+            Self::Greg => "greg",
+            Self::Nan => "nan",
+        }
+    }
+}
+
+/// State that belongs to the current floor and resets when you leave it.
+#[derive(Default)]
+pub struct FloorState {
+    pub(crate) turns: u32,
+    pub(crate) warm_arrival: bool,
+    pub(crate) drawer: Drawer,
+    pub(crate) kitchen: KitchenVisit,
+    pub(crate) thread_rolls: u8,
+    pub(crate) edges: u8,
+    pub(crate) temp_length: f64,
+    pub(crate) teapot: bool,
+    pub(crate) towel_stolen: bool,
+    pub(crate) meditated: bool,
+    pub(crate) brother_told: bool,
+    pub(crate) shopping: bool,
+    pub(crate) wifi_accepted: bool,
+}
+
+#[derive(Default)]
+pub struct Drawer {
+    pub(crate) searched: bool,
+    pub(crate) jammed: bool,
+}
+
+#[derive(Default)]
+pub struct KitchenVisit {
+    pub(crate) kettle_boiled: bool,
+    pub(crate) melon_offered: bool,
+}

Deleted file: src/game/floors.rs−292 deletions@@ -1,292 +0,0 @@
-use axum::http::{StatusCode, header};
-use serde_json::{Value, json};
-
-use super::{
-    Cause, Elder, Floor, FloorState, Item, Outcome, Run,
-    balance::{
-        DRAWER_JAMS, EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, GREGS_LOCKER,
-        KEY_IN_DRAWER, LOCKER_ROOM_BAR, LOCKER_ROOM_SHAME, RULER_IN_DRAWER, STARTING_EQ,
-        SUSPICION_LIMIT, ZIP,
-    },
-    round2,
-};
-use crate::problem::Problem;
-
-impl Run {
-    pub(super) fn next_floor(&mut self, paid: bool) {
-        let Some(next) = self.floor.next() else {
-            return;
-        };
-        let warm = EQ_BAND.contains(&self.eq);
-        self.floor = next;
-        self.here = FloorState {
-            warm_arrival: warm,
-            ..FloorState::default()
-        };
-        self.warmed_up = false;
-        self.reset_eq(STARTING_EQ);
-        self.suspicion = 0;
-        self.shed(FRICTION_FLOOR);
-        self.mum = None;
-        if self.floor == Floor::ChangingRoom && !self.holds_own_in_the_locker_room() {
-            self.shame += LOCKER_ROOM_SHAME;
-            self.notices
-                .push("Kev is 8 inches, he says. Nobody asked you, which is worse.");
-        }
-        if paid {
-            self.cash += FLOOR_ALLOWANCE;
-        }
-        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 != Elder::Beaten => {
-                return Err(Problem::new(
-                    StatusCode::CONFLICT,
-                    "elder-unaddressed",
-                    "The Elder has not been addressed.",
-                )
-                .with("elder", self.path("/elder")));
-            }
-            floor if floor.timed() && self.here.turns < FLOOR_TURNS => {
-                return Err(Problem::new(
-                    StatusCode::TOO_EARLY,
-                    "floor-not-over",
-                    format!(
-                        "The floor is not over. {} turns remain.",
-                        FLOOR_TURNS - self.here.turns
-                    ),
-                ));
-            }
-            _ => {}
-        }
-        if self.chance(
-            self.decision(
-                "zip",
-                "As the floor ends and you put yourself away, does the zip catch?",
-            ),
-            ZIP,
-        ) {
-            return Err(self.end(Cause::Zip));
-        }
-        let left = self.floor.name();
-        let reverted = self.here.temp_length;
-        self.next_floor(true);
-        let warm = if self.here.warm_arrival {
-            ", and the warmth came with you"
-        } else {
-            ""
-        };
-        let mut body = json!({
-            "detail": format!("You leave {left}. You have arrived at {}{warm}.", self.floor.name()),
-            "note": self.floor.note(),
-        });
-        if reverted > 0.0 {
-            body["reverted"] = json!(round2(reverted));
-        }
-        Ok(
-            Outcome::json(StatusCode::SEE_OTHER, body)
-                .header(header::LOCATION, self.path("/floor")),
-        )
-    }
-
-    pub fn floor_view(&self) -> Value {
-        let mut view = json!({
-            "name": self.floor.name(),
-            "note": self.floor.note(),
-            "turns": self.here.turns,
-            "turns_required": self.floor.timed().then_some(FLOOR_TURNS),
-            "exit": { "href": self.path("/floor"), "method": "POST" },
-        });
-        match self.floor {
-            Floor::ChangingRoom => {
-                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 },
-                    { "name": "Kev", "self_reported_length": LOCKER_ROOM_BAR },
-                ]);
-            }
-            Floor::Hotel => view["portal"] = json!(self.path("/portal")),
-            Floor::Forum => {
-                view["thread"] = json!(super::FORUM_THREAD);
-                view["elder"] = json!(self.path("/elder"));
-            }
-            Floor::Clinic => view["diagnosis"] = json!(self.path("/diagnosis")),
-            _ => {}
-        }
-        if self.floor.shop_open() {
-            view["shop"] = json!(self.path("/shop"));
-        }
-        view
-    }
-
-    fn found(&self, item: Item, detail: &str) -> Outcome {
-        Outcome::json(StatusCode::FOUND, json!({ "detail": detail })).header(
-            header::LOCATION,
-            self.path(&format!("/inventory/{}", item.slug())),
-        )
-    }
-
-    pub fn search_drawer(&mut self) -> Result<Outcome, Problem> {
-        self.touch();
-        self.end_kitchen_visit();
-        if self.items.cage {
-            return Ok(self.rummage_for_key());
-        }
-        let first = !self.here.drawer_searched;
-        self.here.drawer_searched = true;
-        let ruler_here = self.floor == Floor::Bedroom
-            && self.chance(
-                self.decision("ruler", "Is there a ruler hiding in the drawer?"),
-                RULER_IN_DRAWER,
-            );
-        let vaseline_here = self.floor == Floor::Bathroom
-            && first
-            && self.chance(
-                self.decision(
-                    "bathroom-vaseline",
-                    "Is it the vaseline behind the door lock, rather than the lotion?",
-                ),
-                2,
-            );
-        let locker_open = self.floor == Floor::ChangingRoom
-            && first
-            && self.chance(
-                self.decision("gregs-locker", "Has Greg left his locker open?"),
-                GREGS_LOCKER,
-            );
-        match self.floor {
-            Floor::Bedroom if first && !self.items.ruler && ruler_here => {
-                self.items.grant(Item::Ruler);
-                self.shame += 10;
-                Ok(self.found(
-                    Item::Ruler,
-                    "You now know. This is the first honest measurement of the run.",
-                ))
-            }
-            Floor::Bathroom if first => {
-                self.items.grant(Item::DoorLock);
-                let detail = if vaseline_here {
-                    self.items.grant(Item::Vaseline);
-                    "A door lock, which works once, and a tub of vaseline behind it."
-                } else {
-                    self.items.grant(Item::Lotion);
-                    "A door lock, which works once, and a bottle of lotion behind it."
-                };
-                Ok(self.found(Item::DoorLock, detail))
-            }
-            Floor::ChangingRoom if locker_open => {
-                self.items.grant(Item::BabyOil);
-                Ok(self.found(
-                    Item::BabyOil,
-                    "Greg has left his locker open. The baby oil is yours now, legally speaking.",
-                ))
-            }
-            Floor::ChangingRoom => {
-                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::Nans if first => {
-                self.items.grant(Item::Cage);
-                self.shame += 5;
-                Ok(self.found(
-                    Item::Cage,
-                    "A small box. Inside was a cage. It is now on. The key is not in the box.",
-                ))
-            }
-            Floor::Hotel if first => {
-                self.items.grant(Item::DndSign);
-                self.items.grant(Item::IcePack);
-                self.items.grant(Item::IcePack);
-                self.items.grant(Item::Lotion);
-                Ok(self.found(
-                    Item::DndSign,
-                    "A Do Not Disturb sign, two ice packs from the machine down the hall, and a complimentary lotion.",
-                ))
-            }
-            Floor::Forum if first => {
-                self.items.grant(Item::Spreadsheet);
-                Ok(self.found(
-                    Item::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 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.here.wifi_accepted = true;
-        self.touch();
-        Ok(Outcome::json(
-            StatusCode::SEE_OTHER,
-            json!({ "detail": "Connected. The hotel does not want to know." }),
-        )
-        .header(header::LOCATION, self.path("")))
-    }
-
-    /// Searching while caged is noisy, costs the floor turn, and the key only turns up some of
-    /// the time. A jammed drawer takes a whole turn to work loose.
-    fn rummage_for_key(&mut self) -> Outcome {
-        self.turn += 1;
-        self.here.turns += 1;
-        self.realise();
-        let was_below = self.suspicion < SUSPICION_LIMIT;
-        self.suspicion = (self.suspicion + 1).min(SUSPICION_LIMIT);
-        self.maybe_summon_mum(was_below);
-        if self.here.drawer_jammed {
-            self.here.drawer_jammed = false;
-            self.notices
-                .push("The drawer comes loose. That took a while.");
-            return Outcome::empty(StatusCode::NO_CONTENT);
-        }
-        if !self.chance(
-            self.decision("key", "Does the drawer finally give up the cage key?"),
-            KEY_IN_DRAWER,
-        ) {
-            if self.chance(
-                self.decision("drawer-jams", "Has the drawer jammed on its runners?"),
-                DRAWER_JAMS,
-            ) {
-                self.here.drawer_jammed = true;
-                self.notices.push("The drawer has jammed.");
-            }
-            return Outcome::empty(StatusCode::NO_CONTENT);
-        }
-        self.items.grant(Item::CageKey);
-        Outcome::json(
-            StatusCode::OK,
-            json!({ "detail": "The key was in the drawer. The cage is off." }),
-        )
-    }
-
-    /// Whether searching the drawer on this floor would turn anything up.
-    pub fn drawer_worth_searching(&self) -> bool {
-        !self.here.drawer_searched || self.items.cage
-    }
-}

Modified file: src/game/forum.rs+92 additions−38 deletions@@ -1,18 +1,21 @@
-use std::time::SystemTime;
+use std::{sync::LazyLock, time::SystemTime};
 
 use axum::http::{StatusCode, header};
 use serde_json::{Value, json};
 
 use super::{
-    Cause, Elder, Floor, Outcome, Run, Story,
+    Cause, Floor, Outcome, Run,
     balance::{EXAGGERATION, PATIENCE, ULI_ODDS, ULI_READS},
-    body::exaggeration,
-    honest, parse_credentials,
+    credentials::{Scheme, parse_credentials},
+    measure::{exaggeration, honest},
 };
 use crate::{headers::X_FORUM_NOTE, problem::Problem};
 
 pub const FORUM_THREAD: &str = "/forum/threads/2009";
 pub const ELDER_LAST_MODIFIED: &str = "Sun, 14 Jun 2009 03:12:00 GMT";
+static ELDER_POSTED: LazyLock<SystemTime> = LazyLock::new(|| {
+    httpdate::parse_http_date(ELDER_LAST_MODIFIED).expect("the Elder's date is a valid HTTP-date")
+});
 
 const SPREADSHEET: &str = "\
 date,length,girth,technique,notes,honest?
@@ -57,10 +60,71 @@ fn verification(detail: &str) -> Problem {
     .header(header::PROXY_AUTHENTICATE, "Ruler realm=\"forum\"")
 }
 
+/// The browser tab that opens on turn 10.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Story {
+    Unopened,
+    Pending,
+    ReadForum,
+    ClosedTab,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Branch {
+    Forum,
+    CloseTab,
+}
+
+impl Branch {
+    pub fn slug(self) -> &'static str {
+        match self {
+            Self::Forum => "forum",
+            Self::CloseTab => "close-tab",
+        }
+    }
+}
+
+impl std::str::FromStr for Branch {
+    type Err = ();
+
+    fn from_str(slug: &str) -> Result<Self, ()> {
+        [Self::Forum, Self::CloseTab]
+            .into_iter()
+            .find(|branch| branch.slug() == slug)
+            .ok_or(())
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Elder {
+    Unverified { strikes: u8 },
+    Verified,
+    Beaten,
+}
+
+/// The run's life online, from the tab on turn 10 to the footage the neighbour took.
+pub struct Online {
+    pub(crate) story: Story,
+    pub(crate) uli_taught: bool,
+    pub(crate) elder: Elder,
+    pub(crate) filmed_at: Option<SystemTime>,
+}
+
+impl Default for Online {
+    fn default() -> Self {
+        Self {
+            story: Story::Unopened,
+            uli_taught: false,
+            elder: Elder::Unverified { strikes: 0 },
+            filmed_at: None,
+        }
+    }
+}
+
 impl Run {
     pub(super) fn branch_offer(&self) -> Outcome {
-        let forum = self.path("/branches/forum");
-        let close = self.path("/branches/close-tab");
+        let forum = self.path(&format!("/branches/{}", Branch::Forum.slug()));
+        let close = self.path(&format!("/branches/{}", Branch::CloseTab.slug()));
         Outcome::json(
             StatusCode::MULTIPLE_CHOICES,
             json!({
@@ -79,8 +143,8 @@ impl Run {
         )
     }
 
-    pub fn choose(&mut self, choice: &str) -> Result<Outcome, Problem> {
-        if self.story != Story::Pending {
+    pub fn choose(&mut self, choice: Branch) -> Result<Outcome, Problem> {
+        if self.online.story != Story::Pending {
             return Err(Problem::new(
                 StatusCode::CONFLICT,
                 "no-decision-pending",
@@ -88,29 +152,22 @@ impl Run {
             ));
         }
         let (story, location, detail) = match choice {
-            "forum" => {
-                self.shame += 3;
+            Branch::Forum => {
+                self.standing.shame += 3;
                 let detail =
                     "The thread is from 2009. A technique called uli is discussed at length.";
                 (Story::ReadForum, self.path("/techniques"), detail)
             }
-            "close-tab" => {
-                self.suspicion = 0;
+            Branch::CloseTab => {
+                self.standing.suspicion = 0;
                 (
                     Story::ClosedTab,
                     self.path(""),
                     "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.story = story;
+        self.online.story = story;
         self.touch();
         Ok(
             Outcome::json(StatusCode::SEE_OTHER, json!({ "detail": detail }))
@@ -121,7 +178,7 @@ impl Run {
     /// Re-reading is free. Each floor gets a couple of live reads that may surface the reply,
     /// after which the forum is down and the browser serves what it kept.
     pub fn read_thread(&mut self) -> Result<Outcome, Problem> {
-        if self.story == Story::Pending {
+        if self.online.story == Story::Pending {
             return Ok(self.branch_offer());
         }
         if !self.thread_reachable() {
@@ -132,13 +189,12 @@ impl Run {
             ));
         }
         self.end_kitchen_visit();
-        if self.uli_taught {
+        if self.online.uli_taught {
             return Ok(Outcome::json(StatusCode::OK, forum_thread()));
         }
         if self.here.thread_rolls >= ULI_READS {
-            let age = httpdate::parse_http_date(ELDER_LAST_MODIFIED)
-                .ok()
-                .and_then(|posted| SystemTime::now().duration_since(posted).ok())
+            let age = SystemTime::now()
+                .duration_since(*ELDER_POSTED)
                 .map_or(0, |age| age.as_secs());
             return Ok(Outcome::json(StatusCode::OK, forum_thread())
                 .header(header::AGE, age.to_string())
@@ -153,7 +209,7 @@ impl Run {
             ),
             ULI_ODDS,
         ) {
-            self.uli_taught = true;
+            self.online.uli_taught = true;
             return Ok(Outcome::json(
                 StatusCode::OK,
                 json!({ "detail": "Past the necroposting, a reply from TheElder lays out the technique. Uli. The full routine. You write it down before the tab can lose it." }),
@@ -165,7 +221,7 @@ impl Run {
 
     fn elder_strike(&mut self, problem: Problem) -> Problem {
         self.touch();
-        let Elder::Unverified { strikes } = &mut self.elder else {
+        let Elder::Unverified { strikes } = &mut self.online.elder else {
             return problem;
         };
         *strikes += 1;
@@ -177,24 +233,24 @@ impl Run {
 
     /// Failed verification counts toward a ban even on GET, the way repeated bad credentials lock an account.
     fn verify_member(&mut self, proxy_authorization: Option<&str>) -> Result<(), Problem> {
-        if !matches!(self.elder, Elder::Unverified { .. }) {
+        if !matches!(self.online.elder, Elder::Unverified { .. }) {
             return Ok(());
         }
         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())
+            parse_credentials(credentials, Scheme::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 + EXAGGERATION {
-            self.shame += 2;
+            self.standing.shame += 2;
             return Err(self.elder_strike(exaggeration()));
         }
         if !honest(claimed, actual) {
-            self.shame += 1;
+            self.standing.shame += 1;
             let failed = verification("Verification failed. The forum can tell.");
             if self.girth_respected() {
                 return Err(failed.header(
@@ -204,7 +260,7 @@ impl Run {
             }
             return Err(self.elder_strike(failed));
         }
-        self.elder = Elder::Verified;
+        self.online.elder = Elder::Verified;
         self.touch();
         Ok(())
     }
@@ -223,14 +279,12 @@ impl Run {
         }
         self.verify_member(proxy_authorization)?;
 
-        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);
+            .is_some_and(|since| since >= *ELDER_POSTED);
         if current {
-            if self.elder != Elder::Beaten {
-                self.elder = Elder::Beaten;
+            if self.online.elder != Elder::Beaten {
+                self.online.elder = Elder::Beaten;
                 self.touch();
             }
             return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)
@@ -238,7 +292,7 @@ impl Run {
         }
         let spreadsheet = Outcome::raw(StatusCode::OK, "text/csv; header=present", SPREADSHEET)
             .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED);
-        if self.filmed_at.is_some() {
+        if self.online.filmed_at.is_some() {
             return Ok(spreadsheet.header(X_FORUM_NOTE, "We have seen the footage."));
         }
         Ok(spreadsheet)

Added file: src/game/gauges.rs+173 additions@@ -0,0 +1,173 @@
+use std::time::Instant;
+
+use serde_json::{Value, json};
+
+use super::{
+    Elder, Excuse, Floor, Grip, Item, Observer, Run, Story,
+    balance::{DANGER_EQ, KITCHEN_TELLINGS},
+};
+
+pub enum Shown {
+    Measured(f64),
+    SelfReported(f64),
+}
+
+pub struct Gauges {
+    pub(crate) length: Shown,
+    pub(crate) girth: f64,
+    pub(crate) foreskin: Option<f64>,
+    pub(crate) friction: i32,
+    pub(crate) eq: i32,
+    pub(crate) stamina: i32,
+    pub(crate) max_stamina: i32,
+    pub(crate) suspicion: u8,
+    pub(crate) cash: u32,
+    pub(crate) floor: u8,
+    pub(crate) observed: Option<Observer>,
+    pub(crate) mum_at_door: bool,
+    pub(crate) warnings: Vec<&'static str>,
+    pub(crate) ruler: bool,
+    pub(crate) ring: bool,
+}
+
+pub struct Reach {
+    pub(crate) foreskin: bool,
+    pub(crate) drawer: bool,
+    pub(crate) kitchen: bool,
+    pub(crate) thread: bool,
+    pub(crate) shop: bool,
+    pub(crate) portal: bool,
+    pub(crate) elder: bool,
+    pub(crate) footage: bool,
+    pub(crate) diagnosis: bool,
+    pub(crate) branch_pending: bool,
+    pub(crate) shopping: bool,
+}
+
+impl Run {
+    /// Drains the notices, so call it once per response.
+    pub fn gauges(&mut self) -> Gauges {
+        let conditions = &self.body.conditions;
+        let mut warnings = Vec::new();
+        if conditions.pulled_muscle {
+            warnings.push("a muscle has been pulled");
+        }
+        if conditions.friction_burn {
+            warnings.push("friction burn");
+        }
+        warnings.extend(self.notices.drain(..).map(|notice| notice.text()));
+        if self.body.eq > DANGER_EQ && self.ended.is_none() {
+            warnings.push("it is turning purple");
+        }
+        Gauges {
+            length: if self.items.kit.ruler {
+                Shown::Measured(self.current_length())
+            } else {
+                Shown::SelfReported(self.self_reported())
+            },
+            girth: self.body.girth,
+            foreskin: self.body.foreskin,
+            friction: self.body.friction,
+            eq: self.body.eq,
+            stamina: self.body.stamina,
+            max_stamina: self.max_stamina(),
+            suspicion: self.standing.suspicion,
+            cash: self.standing.cash,
+            floor: self.floor.number(),
+            observed: self.observed,
+            mum_at_door: self.household.mum.is_some(),
+            warnings,
+            ruler: self.items.kit.ruler,
+            ring: self.items.kit.ring,
+        }
+    }
+
+    pub fn reach(&self) -> Reach {
+        Reach {
+            foreskin: self.body.foreskin.is_some(),
+            drawer: self.drawer_worth_searching(),
+            kitchen: self.floor.has_kitchen() && self.household.kitchen_tellings < KITCHEN_TELLINGS,
+            thread: self.thread_reachable(),
+            shop: self.floor.shop_open(),
+            portal: self.needs_portal(),
+            elder: self.floor == Floor::Forum && self.online.elder != Elder::Beaten,
+            footage: self.online.filmed_at.is_some(),
+            diagnosis: self.floor == Floor::Clinic,
+            branch_pending: self.online.story == Story::Pending,
+            shopping: self.here.shopping,
+        }
+    }
+
+    pub fn needs_portal(&self) -> bool {
+        self.floor == Floor::Hotel && !self.here.wifi_accepted
+    }
+
+    /// Shame follows the player across runs in a signed cookie. Each response adds this run's new
+    /// shame to whatever total the client presents, so two runs at once both count.
+    pub fn settle_shame(&mut self, presented: Option<u32>) -> u32 {
+        let standing = &mut self.standing;
+        let total =
+            presented.unwrap_or(standing.shame_total) + (standing.shame - standing.shame_reported);
+        standing.shame_reported = standing.shame;
+        standing.shame_total = total;
+        total
+    }
+
+    pub fn trace(&mut self) {
+        self.standing.shame += 1;
+    }
+
+    pub fn measured(&self) -> bool {
+        self.items.kit.ruler
+    }
+
+    pub fn id(&self) -> &str {
+        &self.ident.id
+    }
+
+    pub fn last_seen(&self) -> Instant {
+        self.ident.last_seen
+    }
+
+    /// A request has arrived. Whoever was watching last time has looked away.
+    pub fn seen(&mut self, now: Instant) {
+        self.ident.last_seen = now;
+        self.observed = None;
+    }
+
+    pub fn foreskin(&self) -> Option<f64> {
+        self.body.foreskin
+    }
+
+    pub fn grip(&self) -> Grip {
+        self.body.grip
+    }
+
+    pub fn knows_uli(&self) -> bool {
+        self.online.uli_taught
+    }
+
+    pub fn holds(&self, item: Item) -> bool {
+        self.items.has(item)
+    }
+
+    pub fn inventory_view(&self) -> Value {
+        let items: Vec<Value> = self
+            .items
+            .owned()
+            .into_iter()
+            .map(|item| {
+                json!({
+                    "name": item.slug(),
+                    "href": self.path(&format!("/inventory/{}", item.slug())),
+                })
+            })
+            .collect();
+        json!({
+            "items": items,
+            "ice_packs": self.items.stores.ice_packs,
+            "supplements": self.items.stores.supplements,
+            "excuses": self.excuses().into_iter().map(Excuse::phrase).collect::<Vec<_>>(),
+        })
+    }
+}

Modified file: src/game/hazards.rs+37 additions−39 deletions@@ -4,40 +4,41 @@ use axum::http::{StatusCode, header};
 use serde_json::json;
 
 use super::{
-    Cause, Floor, Outcome, Run,
+    Cause, Floor, Notice, Outcome, Run,
     balance::{
-        BURN_RUPTURE, COLD_EQ, CURVE_MISSES, DANGER_EQ, DEGLOVING, DEGLOVING_INTENSITY, FRIEND,
-        HOT_EQ, PREMATURE_EQ, RUPTURE_HOT, RUPTURE_IN_BAND, RUPTURE_PREMATURE, RUPTURE_WARM,
-        SUSPICION_LIMIT, WANDERER_VISIT, WINDOW,
+        BURN_RUPTURE, COLD_EQ, CURVE_MISSES, DANGER_EQ, DEGLOVING, DEGLOVING_INTENSITY, EQ_BAND,
+        FRIEND, HOT_EQ, LOST_IT_EQ, PREMATURE_EQ, RUPTURE_HOT, RUPTURE_IN_BAND, RUPTURE_PREMATURE,
+        RUPTURE_WARM, SOFT_INTENSITY, SUSPICION_LIMIT, WANDERER_VISIT, WINDOW,
     },
     techniques::Training,
+    travel::Exit,
 };
 use crate::problem::Problem;
 
 type Interruption = Result<ControlFlow<Outcome>, Problem>;
 
 impl Run {
-    /// How far the friction burn drags the rupture tiers down.
-    pub(super) fn burn(&self) -> i32 {
-        if self.conditions.friction_burn {
+    /// Whether EQ is past `line`, with a friction burn dragging every line down.
+    pub(super) fn hotter_than(&self, line: i32) -> bool {
+        let burn = if self.body.conditions.friction_burn {
             BURN_RUPTURE
         } else {
             0
-        }
+        };
+        self.body.eq > line - burn
     }
 
     /// The rupture tier for any turn that is not a jelq, so never the premature band's 1 in 3.
     pub(super) fn rupture_odds(&self) -> u32 {
-        if self.eq <= DANGER_EQ - self.burn() {
+        if !self.hotter_than(DANGER_EQ) {
             RUPTURE_IN_BAND
-        } else if self.eq <= HOT_EQ - self.burn() {
+        } else if !self.hotter_than(HOT_EQ) {
             RUPTURE_WARM
         } else {
             RUPTURE_HOT
         }
     }
 
-    /// Accidents tied to a specific technique.
     pub(super) fn mishaps(&mut self, training: Training, intensity: i32) -> Interruption {
         if training == Training::Dry
             && intensity >= DEGLOVING_INTENSITY
@@ -51,10 +52,8 @@ impl Run {
         Ok(ControlFlow::Continue(()))
     }
 
-    /// Everything that can go wrong on a committed turn before the roll.
     pub(super) fn hazards(&mut self, intensity: i32) -> Interruption {
-        let burn = self.burn();
-        if self.eq <= PREMATURE_EQ - burn
+        if !self.hotter_than(PREMATURE_EQ)
             && self.chance(
                 self.decision("rupture", "Does this jelq rupture something?"),
                 self.rupture_odds(),
@@ -63,14 +62,14 @@ impl Run {
             return Err(self.rupture());
         }
         if self.floor.has_window()
-            && !self.items.blinds
+            && !self.items.kit.blinds
             && self.oracle.chance_not(
                 self.decision("window", "Are the curtains still closed?"),
                 WINDOW,
             )
         {
-            self.shame += 30;
-            self.filmed_at.get_or_insert_with(SystemTime::now);
+            self.standing.shame += 30;
+            self.online.filmed_at.get_or_insert_with(SystemTime::now);
             return Ok(ControlFlow::Break(
                 Outcome::json(
                     StatusCode::CREATED,
@@ -85,14 +84,14 @@ impl Run {
                 FRIEND,
             )
         {
-            self.shame += 1;
+            self.standing.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.conditions.peyronie
+        if self.body.conditions.peyronie
             && self.chance(
                 self.decision(
                     "misdirected",
@@ -107,8 +106,8 @@ impl Run {
                 "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);
+        if intensity <= SOFT_INTENSITY && self.body.eq < *EQ_BAND.start() {
+            self.body.eq = (self.body.eq - LOST_IT_EQ).max(0);
             return Err(Problem::new(
                 StatusCode::REQUEST_TIMEOUT,
                 "lost-it",
@@ -116,7 +115,7 @@ impl Run {
             )
             .header(header::CONNECTION, "close"));
         }
-        if self.eq > PREMATURE_EQ - burn {
+        if self.hotter_than(PREMATURE_EQ) {
             if self.chance(
                 self.decision(
                     "rupture",
@@ -126,15 +125,15 @@ impl Run {
             ) {
                 return Err(self.rupture());
             }
-            self.shame += 5;
-            self.next_floor(false);
+            self.standing.shame += 5;
+            self.next_floor(Exit::Premature);
             return Err(Problem::new(
                 StatusCode::TOO_EARLY,
                 "premature",
                 "The floor has ended early. Everyone involved has agreed not to discuss it.",
             ));
         }
-        if self.eq < COLD_EQ {
+        if self.body.eq < COLD_EQ {
             return Err(Problem::new(
                 StatusCode::NOT_FOUND,
                 "cold",
@@ -146,7 +145,7 @@ impl Run {
 
     /// The enemies suspicion summons on floors without Mum.
     pub(super) fn floor_enemy(&mut self) -> Result<(), Problem> {
-        let visits = u32::from(self.suspicion) + 1;
+        let visits = u32::from(self.standing.suspicion) + 1;
         let wanders_in = matches!(self.floor, Floor::Bathroom | Floor::Hotel)
             && self.oracle.ratio_choice(
                 self.decision("wanderer", "Does anyone else come through the door?"),
@@ -155,16 +154,16 @@ impl Run {
                 "No",
                 "Yes",
             );
-        if self.suspicion < SUSPICION_LIMIT && !wanders_in {
+        if self.standing.suspicion < SUSPICION_LIMIT && !wanders_in {
             return Ok(());
         }
         match self.floor {
             Floor::Bathroom => {
-                self.suspicion = 0;
+                self.standing.suspicion = 0;
                 self.touch();
-                if self.items.door_locks > 0 {
-                    self.items.door_locks -= 1;
-                    self.notices.push("your brother tried the door");
+                if self.items.stores.door_locks > 0 {
+                    self.items.stores.door_locks -= 1;
+                    self.notices.push(Notice::BrotherTriedTheDoor);
                     return Ok(());
                 }
                 self.here.brother_told = true;
@@ -175,14 +174,13 @@ impl Run {
                 ))
             }
             Floor::ChangingRoom => {
-                self.suspicion = 0;
+                self.standing.suspicion = 0;
                 self.touch();
                 if self.girth_respected() {
-                    self.notices
-                        .push("the gym staff have seen worse, and they leave it there");
+                    self.notices.push(Notice::GymStaffLeaveIt);
                     return Ok(());
                 }
-                self.shame += 5;
+                self.standing.shame += 5;
                 Err(Problem::new(
                     StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
                     "gym-staff",
@@ -190,13 +188,13 @@ impl Run {
                 ))
             }
             Floor::Hotel => {
-                self.suspicion = 0;
+                self.standing.suspicion = 0;
                 self.touch();
-                if self.items.dnd_sign {
-                    self.notices.push("housekeeping read the sign");
+                if self.items.kit.dnd_sign {
+                    self.notices.push(Notice::HousekeepingReadTheSign);
                     return Ok(());
                 }
-                self.shame += 3;
+                self.standing.shame += 3;
                 Err(Problem::new(
                     StatusCode::UNAUTHORIZED,
                     "housekeeping",

Modified file: src/game/household.rs+190 additions−119 deletions@@ -3,36 +3,85 @@ use std::collections::HashMap;
 use axum::http::{StatusCode, header};
 
 use super::{
-    Cause, Floor, Run,
+    Cause, Floor, Notice, Run,
     balance::{PATIENCE, VIRAL_ERRAND},
-    parse_credentials,
+    credentials::{Scheme, parse_credentials},
 };
 use crate::problem::Problem;
 
-const EXCUSES: [&str; 7] = [
-    "changing",
-    "homework",
-    "pulled a muscle",
-    "tidying",
-    "the washing up",
-    "fed the cat",
-    "revising",
-];
-const CHRISTMAS_EXCUSES: [&str; 6] = [
-    "on a call",
-    "wrapping presents",
-    "folding the washing",
-    "hanging the lights",
-    "helping Nan",
-    "peeling sprouts",
-];
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Excuse {
+    Changing,
+    Homework,
+    PulledAMuscle,
+    Tidying,
+    TheWashingUp,
+    FedTheCat,
+    Revising,
+    OnACall,
+    WrappingPresents,
+    FoldingTheWashing,
+    HangingTheLights,
+    HelpingNan,
+    PeelingSprouts,
+}
+
+impl Excuse {
+    const EVERYDAY: [Self; 7] = [
+        Self::Changing,
+        Self::Homework,
+        Self::PulledAMuscle,
+        Self::Tidying,
+        Self::TheWashingUp,
+        Self::FedTheCat,
+        Self::Revising,
+    ];
+    const CHRISTMAS: [Self; 6] = [
+        Self::OnACall,
+        Self::WrappingPresents,
+        Self::FoldingTheWashing,
+        Self::HangingTheLights,
+        Self::HelpingNan,
+        Self::PeelingSprouts,
+    ];
+
+    pub fn phrase(self) -> &'static str {
+        match self {
+            Self::Changing => "changing",
+            Self::Homework => "homework",
+            Self::PulledAMuscle => "pulled a muscle",
+            Self::Tidying => "tidying",
+            Self::TheWashingUp => "the washing up",
+            Self::FedTheCat => "fed the cat",
+            Self::Revising => "revising",
+            Self::OnACall => "on a call",
+            Self::WrappingPresents => "wrapping presents",
+            Self::FoldingTheWashing => "folding the washing",
+            Self::HangingTheLights => "hanging the lights",
+            Self::HelpingNan => "helping Nan",
+            Self::PeelingSprouts => "peeling sprouts",
+        }
+    }
+
+    fn all() -> impl Iterator<Item = Self> {
+        Self::EVERYDAY.into_iter().chain(Self::CHRISTMAS)
+    }
+
+    fn parse(spoken: &str) -> Option<Self> {
+        Self::all().find(|excuse| excuse.phrase().eq_ignore_ascii_case(spoken))
+    }
+}
+
 /// Every excuse Mum might hear, so a localised one can be traced back to the phrase she checks.
 pub fn vocabulary() -> impl Iterator<Item = &'static str> {
-    EXCUSES.into_iter().chain(CHRISTMAS_EXCUSES)
+    Excuse::all().map(Excuse::phrase)
 }
 
-const TRUTHS: [&str; 3] = ["the truth", "truth", "honesty"];
-const TRUE_WHEN_PULLED: &str = "pulled a muscle";
+fn is_truth(spoken: &str) -> bool {
+    ["the truth", "truth", "honesty"]
+        .iter()
+        .any(|truth| truth.eq_ignore_ascii_case(spoken))
+}
 
 const BEDROOM_ERRANDS: [&str; 4] = [
     "She has brought your washing.",
@@ -47,6 +96,21 @@ const CHRISTMAS_ERRANDS: [&str; 4] = [
     "An uncle has asked where you went.",
 ];
 
+#[derive(Default)]
+pub struct Household {
+    pub(crate) mum: Option<MumVisit>,
+    /// Every excuse Mum has accepted this run. Digest Mum remembers them all.
+    pub(crate) heard: Vec<Excuse>,
+    pub(crate) kitchen_tellings: u8,
+}
+
+pub struct MumVisit {
+    pub(crate) errand: &'static str,
+    pub(crate) nonce: String,
+    pub(crate) strikes: u8,
+    pub(crate) knocked: bool,
+}
+
 fn digest_params(authorization: &str) -> Option<HashMap<String, String>> {
     let (scheme, rest) = authorization.trim().split_once(' ')?;
     if !scheme.eq_ignore_ascii_case("digest") {
@@ -65,22 +129,23 @@ fn digest_params(authorization: &str) -> Option<HashMap<String, String>> {
     )
 }
 
-fn spoken(authorization: &str) -> String {
+fn spoken(authorization: &str) -> &str {
     authorization
         .split_once(' ')
-        .map(|(_, rest)| rest.trim().trim_matches('"').to_ascii_lowercase())
-        .unwrap_or_default()
+        .map_or("", |(_, rest)| rest.trim().trim_matches('"'))
+}
+
+fn turned_away(code: &'static str, detail: &'static str) -> Problem {
+    Problem::new(StatusCode::UNAUTHORIZED, code, detail)
 }
 
 impl Run {
-    pub fn excuses(&self) -> Vec<&'static str> {
+    pub fn excuses(&self) -> Vec<Excuse> {
         if self.floor.number() < Floor::Nans.number() {
-            return EXCUSES.to_vec();
+            return Excuse::EVERYDAY.to_vec();
         }
-        EXCUSES
-            .into_iter()
-            .chain(CHRISTMAS_EXCUSES)
-            .filter(|e| !self.heard.iter().any(|h| h.eq_ignore_ascii_case(e)))
+        Excuse::all()
+            .filter(|excuse| !self.household.heard.contains(excuse))
             .collect()
     }
 
@@ -88,7 +153,7 @@ impl Run {
         if summoned {
             return "She heard a noise.";
         }
-        if self.filmed_at.is_some()
+        if self.online.filmed_at.is_some()
             && self.chance(
                 self.decision("viral", "Has a neighbour already sent Mum the footage?"),
                 VIRAL_ERRAND,
@@ -112,114 +177,121 @@ impl Run {
 
     /// Mum answers every request on the run until she has been given something she believes.
     pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {
-        let Some((errand, nonce)) = self.mum.as_ref().map(|v| (v.errand, v.nonce.clone())) else {
+        let Some(visit) = &self.household.mum else {
             return Ok(());
         };
         let digest = self.floor == Floor::Nans;
-        let challenge_value = if digest {
-            format!("Digest realm=\"household\", nonce=\"{nonce}\"")
+        let challenge = if digest {
+            format!("Digest realm=\"household\", nonce=\"{}\"", visit.nonce)
         } else {
             "Excuse realm=\"household\"".to_owned()
         };
-        let challenge = |p: Problem| p.header(header::WWW_AUTHENTICATE, &challenge_value);
-
-        let Some(authorization) = authorization else {
-            let knocked_before = self.mum.as_ref().is_some_and(|visit| visit.knocked);
-            if let Some(visit) = &mut self.mum {
-                visit.knocked = true;
-            }
-            if !knocked_before {
-                self.touch();
-                return Err(challenge(
-                    Problem::new(
-                        StatusCode::UNAUTHORIZED,
-                        "someone-at-the-door",
-                        format!("Someone is at the door. {errand}"),
-                    )
-                    .with("inventory", self.path("/inventory")),
-                ));
-            }
-            return Err(self.strike(
-                challenge(Problem::new(
-                    StatusCode::UNAUTHORIZED,
-                    "knocking-again",
-                    format!("Mum is knocking again. {errand}"),
-                )),
-                Cause::Opened,
-            ));
+        let result = match authorization {
+            None => Err(self.knock()),
+            Some(authorization) => self.hear(authorization, digest),
+        };
+        if self.ended.is_some() {
+            return result;
+        }
+        result.map_err(|problem| problem.header(header::WWW_AUTHENTICATE, &challenge))
+    }
+
+    /// The first knock is free. Every one after it is a strike.
+    fn knock(&mut self) -> Problem {
+        let Some(visit) = &mut self.household.mum else {
+            unreachable!("knock is only called while Mum is at the door");
         };
+        let errand = visit.errand;
+        if !std::mem::replace(&mut visit.knocked, true) {
+            self.touch();
+            return Problem::new(
+                StatusCode::UNAUTHORIZED,
+                "someone-at-the-door",
+                format!("Someone is at the door. {errand}"),
+            )
+            .with("inventory", self.path("/inventory"));
+        }
+        self.strike(
+            Problem::new(
+                StatusCode::UNAUTHORIZED,
+                "knocking-again",
+                format!("Mum is knocking again. {errand}"),
+            ),
+            Cause::Opened,
+        )
+    }
 
-        if TRUTHS.contains(&spoken(authorization).as_str()) {
-            self.shame += 10;
-            self.leave_door();
+    fn hear(&mut self, authorization: &str, digest: bool) -> Result<(), Problem> {
+        if is_truth(spoken(authorization)) {
+            self.confess();
             return Ok(());
         }
-        if parse_credentials(authorization, "basic").is_some() {
-            return Err(self.mum_strike(challenge(Problem::new(
-                StatusCode::UNAUTHORIZED,
+        if parse_credentials(authorization, Scheme::Basic).is_some() {
+            return Err(self.mum_strike(turned_away(
                 "basic",
                 "Mum does not accept Basic authentication. Nobody should.",
-            ))));
+            )));
         }
-
-        let excuse = if digest {
-            let Some(params) = digest_params(authorization) else {
-                return Err(self.mum_strike(challenge(Problem::new(
-                    StatusCode::UNAUTHORIZED,
-                    "digest-required",
-                    "Mum has started using Digest authentication.",
-                ))));
-            };
-            if params.get("nonce") != Some(&nonce) {
-                return Err(self.mum_strike(challenge(Problem::new(
-                    StatusCode::UNAUTHORIZED,
-                    "stale-nonce",
-                    "That was a different conversation.",
-                ))));
-            }
-            params.get("username").cloned().unwrap_or_default()
+        let said = if digest {
+            self.digest_username(authorization)?
         } else {
-            parse_credentials(authorization, "excuse")
+            parse_credentials(authorization, Scheme::Excuse)
                 .unwrap_or_default()
                 .to_owned()
         };
-        let excuse = excuse.to_ascii_lowercase();
-
-        if TRUTHS.contains(&excuse.as_str()) {
-            self.shame += 10;
-            self.leave_door();
+        if is_truth(&said) {
+            self.confess();
             return Ok(());
         }
-        let true_now = self.conditions.pulled_muscle && excuse == TRUE_WHEN_PULLED;
-        if digest && self.heard.contains(&excuse) && !true_now {
-            self.shame += 3;
-            return Err(self.mum_strike(challenge(Problem::new(
-                StatusCode::UNAUTHORIZED,
+        let excuse = Excuse::parse(&said);
+        let true_now = self.body.conditions.pulled_muscle && excuse == Some(Excuse::PulledAMuscle);
+        if digest && !true_now && excuse.is_some_and(|e| self.household.heard.contains(&e)) {
+            self.standing.shame += 3;
+            return Err(self.mum_strike(turned_away(
                 "excuse-replayed",
                 "Mum has heard that one before. She would have preferred the truth.",
-            ))));
+            )));
         }
-        if true_now
-            || self
-                .excuses()
-                .iter()
-                .any(|e| e.eq_ignore_ascii_case(&excuse))
-        {
-            self.heard.push(excuse);
+        if let Some(excuse) = excuse.filter(|e| true_now || self.excuses().contains(e)) {
+            self.household.heard.push(excuse);
             self.leave_door();
             return Ok(());
         }
-        self.shame += 3;
-        let detail = if digest {
-            "Mum has not heard that one before. She does not believe it. She would have preferred the truth."
-        } else {
-            "Mum has not heard that one before. She does not believe it."
-        };
-        Err(self.mum_strike(challenge(Problem::new(
-            StatusCode::UNAUTHORIZED,
+        self.standing.shame += 3;
+        Err(self.mum_strike(turned_away(
             "excuse-rejected",
-            detail,
-        ))))
+            if digest {
+                "Mum has not heard that one before. She does not believe it. She would have preferred the truth."
+            } else {
+                "Mum has not heard that one before. She does not believe it."
+            },
+        )))
+    }
+
+    fn digest_username(&mut self, authorization: &str) -> Result<String, Problem> {
+        let Some(mut params) = digest_params(authorization) else {
+            return Err(self.mum_strike(turned_away(
+                "digest-required",
+                "Mum has started using Digest authentication.",
+            )));
+        };
+        let current = self
+            .household
+            .mum
+            .as_ref()
+            .is_some_and(|visit| params.get("nonce") == Some(&visit.nonce));
+        if !current {
+            return Err(self.mum_strike(turned_away(
+                "stale-nonce",
+                "That was a different conversation.",
+            )));
+        }
+        Ok(params.remove("username").unwrap_or_default())
+    }
+
+    fn confess(&mut self) {
+        self.standing.shame += 10;
+        self.leave_door();
     }
 
     fn mum_strike(&mut self, problem: Problem) -> Problem {
@@ -228,7 +300,7 @@ impl Run {
 
     fn strike(&mut self, problem: Problem, cause: Cause) -> Problem {
         self.touch();
-        let Some(visit) = &mut self.mum else {
+        let Some(visit) = &mut self.household.mum else {
             return problem;
         };
         visit.strikes += 1;
@@ -239,10 +311,9 @@ impl Run {
     }
 
     fn leave_door(&mut self) {
-        self.mum = None;
-        self.suspicion = 0;
-        self.notices
-            .push("Mum seems satisfied. She takes the washing with her.");
+        self.household.mum = None;
+        self.standing.suspicion = 0;
+        self.notices.push(Notice::MumSatisfied);
         self.touch();
     }
 }

Added file: src/game/inventory.rs+149 additions@@ -0,0 +1,149 @@
+use super::{Item, Lube, balance::STARTING_ICE_PACKS};
+
+#[derive(Default)]
+pub struct Items {
+    pub(crate) kit: Kit,
+    pub(crate) stores: Stores,
+    pub(crate) lubes: LubeStock,
+}
+
+#[derive(Default)]
+pub struct Kit {
+    pub(crate) ruler: bool,
+    pub(crate) dnd_sign: bool,
+    pub(crate) blinds: bool,
+    pub(crate) pump_pro: bool,
+    pub(crate) extender: bool,
+    pub(crate) ring: bool,
+    pub(crate) cage: bool,
+    pub(crate) spreadsheet: bool,
+    pub(crate) teapot_spout: bool,
+}
+
+pub struct Stores {
+    pub(crate) ice_packs: u32,
+    pub(crate) door_locks: u32,
+    pub(crate) supplements: u32,
+    pub(crate) energy_drinks: u32,
+}
+
+impl Default for Stores {
+    fn default() -> Self {
+        Self {
+            ice_packs: STARTING_ICE_PACKS,
+            door_locks: 0,
+            supplements: 0,
+            energy_drinks: 0,
+        }
+    }
+}
+
+pub struct LubeStock {
+    pub(crate) baby_oil: u32,
+    pub(crate) coconut_oil: u32,
+    pub(crate) lotion: u32,
+    pub(crate) vaseline: u32,
+}
+
+impl Default for LubeStock {
+    fn default() -> Self {
+        Self {
+            baby_oil: 1,
+            coconut_oil: 0,
+            lotion: 1,
+            vaseline: 0,
+        }
+    }
+}
+
+impl LubeStock {
+    /// Spit is the only lubricant that never runs out, so it has no count.
+    fn bottle(&mut self, lube: Lube) -> Option<&mut u32> {
+        match lube {
+            Lube::Spit => None,
+            Lube::BabyOil => Some(&mut self.baby_oil),
+            Lube::CoconutOil => Some(&mut self.coconut_oil),
+            Lube::Lotion => Some(&mut self.lotion),
+            Lube::Vaseline => Some(&mut self.vaseline),
+        }
+    }
+
+    pub fn has(&self, lube: Lube) -> bool {
+        match lube {
+            Lube::Spit => true,
+            Lube::BabyOil => self.baby_oil > 0,
+            Lube::CoconutOil => self.coconut_oil > 0,
+            Lube::Lotion => self.lotion > 0,
+            Lube::Vaseline => self.vaseline > 0,
+        }
+    }
+
+    pub fn take(&mut self, lube: Lube) {
+        if let Some(bottle) = self.bottle(lube) {
+            *bottle = bottle.saturating_sub(1);
+        }
+    }
+
+    fn add(&mut self, lube: Lube) {
+        if let Some(bottle) = self.bottle(lube) {
+            *bottle += 1;
+        }
+    }
+}
+
+impl Items {
+    pub fn has(&self, item: Item) -> bool {
+        match item {
+            Item::WarmTowel => true,
+            Item::IcePack => self.stores.ice_packs > 0,
+            Item::Ruler => self.kit.ruler,
+            Item::DoorLock => self.stores.door_locks > 0,
+            Item::DndSign => self.kit.dnd_sign,
+            Item::Blinds => self.kit.blinds,
+            Item::PumpPro => self.kit.pump_pro,
+            Item::Extender => self.kit.extender,
+            Item::Ring => self.kit.ring,
+            Item::Supplement => self.stores.supplements > 0,
+            Item::Cage => self.kit.cage,
+            Item::Spreadsheet => self.kit.spreadsheet,
+            Item::TeapotSpout => self.kit.teapot_spout,
+            Item::EnergyDrink => self.stores.energy_drinks > 0,
+            Item::BabyOil => self.lubes.has(Lube::BabyOil),
+            Item::CoconutOil => self.lubes.has(Lube::CoconutOil),
+            Item::Lotion => self.lubes.has(Lube::Lotion),
+            Item::Vaseline => self.lubes.has(Lube::Vaseline),
+            Item::Pump | Item::CageKey => false,
+        }
+    }
+
+    pub fn owned(&self) -> Vec<Item> {
+        Item::ALL
+            .into_iter()
+            .filter(|&item| self.has(item))
+            .collect()
+    }
+
+    pub fn grant(&mut self, item: Item) {
+        match item {
+            Item::IcePack => self.stores.ice_packs += 1,
+            Item::Ruler => self.kit.ruler = true,
+            Item::DoorLock => self.stores.door_locks += 1,
+            Item::DndSign => self.kit.dnd_sign = true,
+            Item::Blinds => self.kit.blinds = true,
+            Item::PumpPro => self.kit.pump_pro = true,
+            Item::Extender => self.kit.extender = true,
+            Item::Ring => self.kit.ring = true,
+            Item::Supplement => self.stores.supplements += 1,
+            Item::Cage => self.kit.cage = true,
+            Item::CageKey => self.kit.cage = false,
+            Item::Spreadsheet => self.kit.spreadsheet = true,
+            Item::TeapotSpout => self.kit.teapot_spout = true,
+            Item::EnergyDrink => self.stores.energy_drinks += 1,
+            Item::BabyOil => self.lubes.add(Lube::BabyOil),
+            Item::CoconutOil => self.lubes.add(Lube::CoconutOil),
+            Item::Lotion => self.lubes.add(Lube::Lotion),
+            Item::Vaseline => self.lubes.add(Lube::Vaseline),
+            Item::WarmTowel | Item::Pump => {}
+        }
+    }
+}

Modified file: src/game/items.rs+1 additions−104 deletions@@ -1,5 +1,3 @@
-use super::balance::STARTING_ICE_PACKS;
-
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Item {
     WarmTowel,
@@ -43,7 +41,7 @@ pub const SHOP: [Item; 15] = [
 ];
 
 impl Item {
-    const ALL: [Self; 20] = [
+    pub(super) const ALL: [Self; 20] = [
         Self::WarmTowel,
         Self::IcePack,
         Self::Ruler,
@@ -156,104 +154,3 @@ impl Item {
         }
     }
 }
-
-pub struct Items {
-    pub ruler: bool,
-    pub ice_packs: u32,
-    pub door_locks: u32,
-    pub dnd_sign: bool,
-    pub blinds: bool,
-    pub pump_pro: bool,
-    pub extender: bool,
-    pub ring: bool,
-    pub supplements: u32,
-    pub cage: bool,
-    pub spreadsheet: bool,
-    pub teapot_spout: bool,
-    pub baby_oil: u32,
-    pub coconut_oil: u32,
-    pub lotion: u32,
-    pub vaseline: u32,
-    pub energy_drinks: u32,
-}
-
-impl Default for Items {
-    fn default() -> Self {
-        Self {
-            ruler: false,
-            ice_packs: STARTING_ICE_PACKS,
-            door_locks: 0,
-            dnd_sign: false,
-            blinds: false,
-            pump_pro: false,
-            extender: false,
-            ring: false,
-            supplements: 0,
-            cage: false,
-            spreadsheet: false,
-            teapot_spout: false,
-            baby_oil: 1,
-            coconut_oil: 0,
-            lotion: 1,
-            vaseline: 0,
-            energy_drinks: 0,
-        }
-    }
-}
-
-impl Items {
-    pub fn has(&self, item: Item) -> bool {
-        match item {
-            Item::WarmTowel => true,
-            Item::IcePack => self.ice_packs > 0,
-            Item::Ruler => self.ruler,
-            Item::DoorLock => self.door_locks > 0,
-            Item::DndSign => self.dnd_sign,
-            Item::Blinds => self.blinds,
-            Item::PumpPro => self.pump_pro,
-            Item::Extender => self.extender,
-            Item::Ring => self.ring,
-            Item::Supplement => self.supplements > 0,
-            Item::Cage => self.cage,
-            Item::Spreadsheet => self.spreadsheet,
-            Item::TeapotSpout => self.teapot_spout,
-            Item::BabyOil => self.baby_oil > 0,
-            Item::CoconutOil => self.coconut_oil > 0,
-            Item::Lotion => self.lotion > 0,
-            Item::Vaseline => self.vaseline > 0,
-            Item::EnergyDrink => self.energy_drinks > 0,
-            Item::Pump | Item::CageKey => false,
-        }
-    }
-
-    pub fn owned(&self) -> Vec<Item> {
-        Item::ALL
-            .into_iter()
-            .filter(|&item| self.has(item))
-            .collect()
-    }
-
-    pub fn grant(&mut self, item: Item) {
-        match item {
-            Item::IcePack => self.ice_packs += 1,
-            Item::Ruler => self.ruler = true,
-            Item::DoorLock => self.door_locks += 1,
-            Item::DndSign => self.dnd_sign = true,
-            Item::Blinds => self.blinds = true,
-            Item::PumpPro => self.pump_pro = true,
-            Item::Extender => self.extender = true,
-            Item::Ring => self.ring = true,
-            Item::Supplement => self.supplements += 1,
-            Item::Cage => self.cage = true,
-            Item::CageKey => self.cage = false,
-            Item::Spreadsheet => self.spreadsheet = true,
-            Item::TeapotSpout => self.teapot_spout = true,
-            Item::BabyOil => self.baby_oil += 1,
-            Item::CoconutOil => self.coconut_oil += 1,
-            Item::Lotion => self.lotion += 1,
-            Item::Vaseline => self.vaseline += 1,
-            Item::EnergyDrink => self.energy_drinks += 1,
-            Item::WarmTowel | Item::Pump => {}
-        }
-    }
-}

Modified file: src/game/kitchen.rs+18 additions−22 deletions@@ -2,10 +2,10 @@ use axum::http::{StatusCode, header};
 use serde_json::json;
 
 use super::{
-    Cause, Floor, Item, Outcome, Run, Story,
+    Cause, Floor, Item, Notice, Outcome, Run, Story,
     balance::{
         CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KETTLE_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TELLINGS,
-        KITCHEN_TOLD, MELON_SHAME, RAID_NOISE, RUPTURE_LINE, SUSPICION_LIMIT, WATERMELON,
+        KITCHEN_TOLD, MELON_SHAME, RAID_NOISE, RUPTURE_LINE, WATERMELON,
     },
 };
 use crate::problem::Problem;
@@ -20,27 +20,23 @@ impl Run {
                 "There is no kitchen on this floor.",
             ));
         }
-        if self.kitchen_tellings >= KITCHEN_TELLINGS {
+        if self.household.kitchen_tellings >= KITCHEN_TELLINGS {
             return Err(Problem::new(
                 StatusCode::GONE,
                 "kitchen-off-limits",
                 "The kitchen is off limits. You have been told twice.",
             ));
         }
-        if self.story == Story::Pending {
+        if self.online.story == Story::Pending {
             return Ok(self.branch_offer());
         }
-        self.touch();
-        self.turn += 1;
-        self.here.turns += 1;
-        self.realise();
+        self.begin_turn();
         if self.chance(
             self.decision("rupture", "Does this raid of the fridge rupture something?"),
             self.rupture_odds(),
         ) {
             return Err(self.rupture());
         }
-        let was_below = self.suspicion < SUSPICION_LIMIT;
         self.make_noise(RAID_NOISE);
         // One draw of 120 keeps the marginals at the documented 1 in 3, 1 in 5, 1 in 8 and 1 in 6.
         let loot = self.oracle.pick(
@@ -63,7 +59,7 @@ impl Run {
                 "Nothing. The fridge is ordinary.",
             ],
         );
-        let melon = self.eq > RUPTURE_LINE
+        let melon = self.body.eq > RUPTURE_LINE
             && self.oracle.ratio(
                 self.decision(
                     "watermelon",
@@ -72,17 +68,17 @@ impl Run {
                 WATERMELON.0,
                 WATERMELON.1,
             );
-        self.settle(was_below);
+        self.settle();
         if self.oracle.ratio(
             self.decision(
                 "kitchen-told",
                 "Has the household had enough of the raiding?",
             ),
-            u32::from(self.suspicion) + 1,
+            u32::from(self.standing.suspicion) + 1,
             KITCHEN_TOLD,
         ) {
-            self.kitchen_tellings += 1;
-            if self.kitchen_tellings >= KITCHEN_TELLINGS {
+            self.household.kitchen_tellings += 1;
+            if self.household.kitchen_tellings >= KITCHEN_TELLINGS {
                 self.end_kitchen_visit();
                 return Err(Problem::new(
                     StatusCode::GONE,
@@ -91,13 +87,13 @@ impl Run {
                 ));
             }
             self.notices.push(if self.floor == Floor::Nans {
-                "Stop raiding the fridge."
+                Notice::StopRaidingTheFridge
             } else {
-                "Stop raiding the kitchen."
+                Notice::StopRaidingTheKitchen
             });
         }
         if melon {
-            self.here.melon_offered = true;
+            self.here.kitchen.melon_offered = true;
             return Ok(self.melon_offer());
         }
         Ok(self.unpack(loot))
@@ -115,7 +111,7 @@ impl Run {
             ),
             2 => (Item::IcePack, "An ice pack, buried under the peas."),
             3 => {
-                self.here.kettle_boiled = true;
+                self.here.kitchen.kettle_boiled = true;
                 return Outcome::json(
                     StatusCode::OK,
                     json!({ "detail": "The kettle has just boiled. The towel can be warmed once more." }),
@@ -149,23 +145,23 @@ impl Run {
 
     /// A bail-out that costs no turn. The more the household has already heard, the likelier Mum is in the doorway.
     pub fn commit_melon(&mut self) -> Result<Outcome, Problem> {
-        if !self.here.melon_offered {
+        if !self.here.kitchen.melon_offered {
             return Err(Problem::new(
                 StatusCode::CONFLICT,
                 "no-melon-on-offer",
                 "There is no watermelon on offer.",
             ));
         }
-        self.here.melon_offered = false;
+        self.here.kitchen.melon_offered = false;
         self.reset_eq(0);
-        self.shame += MELON_SHAME;
+        self.standing.shame += MELON_SHAME;
         self.touch();
         if self.oracle.ratio(
             self.decision(
                 "caught-meloned",
                 "Is Mum standing in the doorway as you look up?",
             ),
-            u32::from(self.suspicion) + 2,
+            u32::from(self.standing.suspicion) + 2,
             CAUGHT_MELONED,
         ) {
             return Err(self.end(Cause::Meloned));

Added file: src/game/lube.rs+90 additions@@ -0,0 +1,90 @@
+use axum::http::StatusCode;
+use serde_json::json;
+
+use super::Item;
+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 fn modifier(self) -> i32 {
+        match self {
+            Self::BabyOil => 1,
+            Self::CoconutOil => 3,
+            Self::Lotion => 0,
+            Self::Vaseline => 2,
+            Self::Spit => -2,
+        }
+    }
+
+    /// The bottle this lube comes in. Spit has none and never runs out.
+    pub fn item(self) -> Option<Item> {
+        match self {
+            Self::Spit => None,
+            Self::BabyOil => Some(Item::BabyOil),
+            Self::CoconutOil => Some(Item::CoconutOil),
+            Self::Lotion => Some(Item::Lotion),
+            Self::Vaseline => Some(Item::Vaseline),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum LubeRule {
+    Required,
+    Forbidden,
+    Optional,
+}
+
+impl LubeRule {
+    pub(super) fn name(self) -> &'static str {
+        match self {
+            Self::Required => "required",
+            Self::Forbidden => "forbidden",
+            Self::Optional => "optional",
+        }
+    }
+}

Added file: src/game/measure.rs+134 additions@@ -0,0 +1,134 @@
+use axum::http::StatusCode;
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use super::{
+    Outcome, Run,
+    balance::{EXAGGERATION, HONEST_TOLERANCE, PATCH_EQ, PUT_GAIN},
+};
+use crate::problem::Problem;
+
+pub fn round2(x: f64) -> f64 {
+    (x * 100.0).round() / 100.0
+}
+
+pub(super) fn round3(x: f64) -> f64 {
+    (x * 1000.0).round() / 1000.0
+}
+
+pub(super) fn honest(claimed: f64, actual: f64) -> bool {
+    (claimed - actual).abs() < HONEST_TOLERANCE
+}
+
+/// A cylinder whose circumference is the girth.
+pub fn volume(length: f64, girth: f64) -> f64 {
+    girth * girth * length / (4.0 * std::f64::consts::PI)
+}
+
+pub fn shaft(mm: usize) -> String {
+    format!("8{}D", "=".repeat(mm.saturating_sub(2)))
+}
+
+pub(super) fn exaggeration() -> Problem {
+    Problem::new(
+        StatusCode::BAD_REQUEST,
+        "exaggeration",
+        "The server has measured. Lying is not a technique.",
+    )
+}
+
+/// One JSON Patch operation as sent, before the server decides what it will honour.
+#[derive(Deserialize)]
+pub struct PatchOp {
+    op: String,
+    path: String,
+    #[serde(default)]
+    value: Value,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Measurement {
+    Length,
+    Girth,
+    Foreskin,
+}
+
+struct Claim {
+    measurement: Measurement,
+    value: f64,
+}
+
+impl PatchOp {
+    fn claim(&self) -> Result<Claim, Problem> {
+        if self.op != "test" {
+            return Err(Problem::new(
+                StatusCode::UNPROCESSABLE_ENTITY,
+                "wishful-thinking",
+                "The server accepts only the truth.",
+            )
+            .with("op", self.op.clone()));
+        }
+        let measurement = match self.path.as_str() {
+            "/length" => Measurement::Length,
+            "/girth" => Measurement::Girth,
+            "/foreskin" => Measurement::Foreskin,
+            _ => {
+                return Err(Problem::new(
+                    StatusCode::UNPROCESSABLE_ENTITY,
+                    "no-such-measurement",
+                    "There is no such measurement.",
+                )
+                .with("path", self.path.clone()));
+            }
+        };
+        let value = self.value.as_f64().ok_or_else(|| {
+            Problem::new(
+                StatusCode::BAD_REQUEST,
+                "malformed-patch",
+                "A test requires a numeric value.",
+            )
+        })?;
+        Ok(Claim { measurement, value })
+    }
+}
+
+impl Run {
+    pub fn put(&mut self) -> Outcome {
+        if self.body.put_applied {
+            return Outcome::empty(StatusCode::NO_CONTENT);
+        }
+        self.body.put_applied = true;
+        self.body.length += PUT_GAIN;
+        self.touch();
+        Outcome::json(StatusCode::OK, json!({ "detail": "Applied." }))
+    }
+
+    /// Being measured is not arousing, so every PATCH costs a little EQ whatever it finds.
+    pub fn patch(&mut self, ops: &[PatchOp]) -> Result<Outcome, Problem> {
+        self.reset_eq(self.body.eq - PATCH_EQ);
+        self.touch();
+        for op in ops {
+            let claim = op.claim()?;
+            let actual = match claim.measurement {
+                Measurement::Length => self.current_length(),
+                Measurement::Girth => self.body.girth,
+                Measurement::Foreskin => self.body.foreskin.unwrap_or(0.0),
+            };
+            if claim.measurement == Measurement::Length && claim.value >= actual + EXAGGERATION {
+                self.standing.shame += 2;
+                return Err(exaggeration());
+            }
+            if !honest(claim.value, actual) {
+                self.standing.shame += 1;
+                return Err(
+                    Problem::new(StatusCode::CONFLICT, "test-failed", "The test failed.")
+                        .with("path", op.path.clone()),
+                );
+            }
+        }
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "Correct." }),
+        ))
+    }
+}

Modified file: src/game/mod.rs+34 additions−435 deletions@@ -1,450 +1,49 @@
 pub mod balance;
 mod body;
+mod cause;
+mod checks;
 mod clinic;
-mod floors;
+mod credentials;
+mod dispatch;
+mod drawer;
+mod floor;
 mod forum;
+mod gauges;
 mod hazards;
 mod household;
+mod inventory;
 mod items;
 mod kitchen;
+mod lube;
+mod measure;
+mod notice;
 pub(crate) mod oracle;
 mod outcome;
+mod progress;
+mod rest;
+mod roll;
+mod run;
 mod shop;
-mod state;
+mod standing;
 mod techniques;
-mod turn;
+mod travel;
 mod utility;
 
-pub use body::{PatchOp, volume};
-pub use forum::{ELDER_LAST_MODIFIED, FORUM_THREAD, forum_thread};
-pub use household::vocabulary as excuse_vocabulary;
-pub use items::{Item, Items, SHOP};
+#[cfg(test)]
+pub use body::Pending;
+pub use body::{Body, Grip};
+pub use cause::{Cause, Ending, RunStatus};
+pub use clinic::Clinic;
+pub use floor::{Floor, FloorState, Observer};
+pub use forum::{Branch, ELDER_LAST_MODIFIED, Elder, FORUM_THREAD, Online, Story, forum_thread};
+pub use gauges::{Gauges, Shown};
+pub use household::{Excuse, Household, MumVisit, vocabulary as excuse_vocabulary};
+pub use inventory::Items;
+pub use items::{Item, SHOP};
+pub use lube::{LUBRICANTS, Lube};
+pub use measure::{PatchOp, shaft, volume};
+pub use notice::Notice;
 pub use outcome::{Outcome, Payload};
-pub use state::{
-    Cause, Clinic, Conditions, Elder, Ending, Floor, FloorState, Grip, MumVisit, Observer,
-    RunStatus, Story,
-};
-pub use techniques::{LUBRICANTS, Lube, Technique};
-
-use std::{
-    hash::{DefaultHasher, Hash, Hasher},
-    time::{Instant, SystemTime},
-};
-
-use axum::http::StatusCode;
-use serde_json::{Value, json};
-
-use crate::problem::Problem;
-use balance::{
-    BRANCH_TURN, HONEST_TOLERANCE, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, SELF_REPORT_INFLATION,
-    STARTING_CASH, STARTING_EQ,
-};
-use oracle::{Oracle, OracleTemplate};
-use state::Pending;
-
-pub struct Run {
-    /// The private id in the run's URL. Knowing it is the only authorisation a run has.
-    pub id: String,
-    pub public_id: String,
-    etag_salt: u64,
-    pub version: u64,
-    pub turn: u32,
-    pub floor: Floor,
-    pub here: FloorState,
-    pub length: f64,
-    pub girth: f64,
-    pub foreskin: Option<f64>,
-    pub eq: i32,
-    pub stamina: i32,
-    pub suspicion: u8,
-    pub shame: u32,
-    pub shame_reported: u32,
-    pub shame_total: u32,
-    pub cash: u32,
-    pub grip: Grip,
-    pub friction: i32,
-    pub jelq_grip: Option<Grip>,
-    pub items: Items,
-    pub conditions: Conditions,
-    pub warmed_up: bool,
-    pub put_applied: bool,
-    pub story: Story,
-    pub uli_taught: bool,
-    pub kitchen_tellings: u8,
-    pub mum: Option<MumVisit>,
-    pub heard: Vec<String>,
-    pub elder: Elder,
-    pub clinic: Clinic,
-    pub seeded: bool,
-    pub filmed_at: Option<SystemTime>,
-    pub observed: Option<Observer>,
-    pub exhausted: bool,
-    pub pending: Vec<Pending>,
-    pub notices: Vec<&'static str>,
-    pub ended: Option<Ending>,
-    pub last_seen: Instant,
-    oracle: Oracle,
-}
-
-pub fn round2(x: f64) -> f64 {
-    (x * 100.0).round() / 100.0
-}
-
-fn round3(x: f64) -> f64 {
-    (x * 1000.0).round() / 1000.0
-}
-
-fn honest(claimed: f64, actual: f64) -> bool {
-    (claimed - actual).abs() < HONEST_TOLERANCE
-}
-
-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 {
-    #[cfg(test)]
-    pub fn new(id: String, public_id: String, seed: u64) -> Self {
-        Self::with_oracle(id, public_id, seed, &OracleTemplate::Rng)
-    }
-
-    pub fn with_oracle(
-        id: String,
-        public_id: String,
-        seed: u64,
-        template: &OracleTemplate,
-    ) -> Self {
-        let mut oracle = Oracle::build(template, seed);
-        let length = round2(oracle.span(
-            Run::unborn("length", "How long is it, in inches?"),
-            4.5,
-            6.5,
-        ));
-        let girth = round2(oracle.span(
-            Run::unborn("girth", "How thick is it, in inches?"),
-            4.0,
-            5.0,
-        ));
-        let foreskin = round2(oracle.span(
-            Run::unborn("foreskin", "How much foreskin is there, in inches?"),
-            0.4,
-            2.4,
-        ));
-        let etag_salt = oracle.u64();
-        Self {
-            id,
-            public_id,
-            etag_salt,
-            version: 0,
-            turn: 0,
-            floor: Floor::Bedroom,
-            here: FloorState::default(),
-            length,
-            girth,
-            foreskin: Some(foreskin),
-            eq: STARTING_EQ,
-            stamina: MAX_STAMINA,
-            suspicion: 0,
-            shame: 0,
-            shame_reported: 0,
-            shame_total: 0,
-            cash: STARTING_CASH,
-            grip: Grip::Overhand,
-            friction: 0,
-            jelq_grip: None,
-            items: Items::default(),
-            conditions: Conditions::default(),
-            warmed_up: false,
-            put_applied: false,
-            story: Story::Unopened,
-            uli_taught: false,
-            kitchen_tellings: 0,
-            mum: None,
-            heard: Vec::new(),
-            notices: Vec::new(),
-            elder: Elder::Unverified { strikes: 0 },
-            clinic: Clinic::default(),
-            seeded: false,
-            filmed_at: None,
-            observed: None,
-            exhausted: false,
-            pending: Vec::new(),
-            ended: None,
-            last_seen: Instant::now(),
-            oracle,
-        }
-    }
-
-    /// A roll for a run that does not exist yet, so there is no state to describe.
-    fn unborn(site: &'static str, ask: &str) -> oracle::Roll {
-        oracle::Roll {
-            state: "A new run is being created. No game has been played yet.".into(),
-            site,
-            ask: ask.into(),
-        }
-    }
-
-    fn etag_at(&self, version: u64) -> String {
-        let mut hasher = DefaultHasher::new();
-        (self.etag_salt, version).hash(&mut hasher);
-        format!("\"{:016x}\"", hasher.finish())
-    }
-
-    pub fn etag(&self) -> String {
-        self.etag_at(self.version)
-    }
-
-    /// The ETag the run had when it was created, which the true ending asks for.
-    pub fn origin_etag(&self) -> String {
-        self.etag_at(0)
-    }
-
-    pub fn touch(&mut self) {
-        self.version += 1;
-    }
-
-    pub(super) fn shed(&mut self, friction: i32) {
-        self.friction = (self.friction - friction).max(0);
-    }
-
-    /// Priapism holds EQ up no matter what else moves it.
-    pub(super) fn reset_eq(&mut self, eq: i32) {
-        let floor = if self.conditions.priapism_turns > 0 {
-            PRIAPISM_EQ
-        } else {
-            0
-        };
-        self.eq = eq.max(floor);
-    }
-
-    /// A melon offer stands only while the raiding streak continues. Any other action ends it.
-    pub(super) fn end_kitchen_visit(&mut self) {
-        self.here.melon_offered = false;
-    }
-
-    /// Going back to the jelq walks away from both the fridge and Pump-Bro.
-    pub(super) fn step_away(&mut self) {
-        self.end_kitchen_visit();
-        self.here.shopping = false;
-    }
-
-    fn fresh_nonce(&mut self) -> String {
-        format!("{:016x}", self.oracle.u64())
-    }
-
-    /// One game decision for the oracle, phrased for the model and stamped
-    /// with the state as the player sees it.
-    fn decision(&self, site: &'static str, ask: impl std::fmt::Display) -> oracle::Roll {
-        oracle::Roll {
-            state: self.oracle_state(),
-            site,
-            ask: ask.to_string(),
-        }
-    }
-
-    fn oracle_state(&self) -> String {
-        let mut s = String::new();
-        let place = match self.floor {
-            Floor::Bedroom => "the bedroom",
-            Floor::Bathroom => "the bathroom",
-            Floor::ChangingRoom => "the changing room",
-            Floor::Nans => "Nan's house",
-            Floor::Hotel => "the hotel room",
-            Floor::Forum => "the forum floor",
-            Floor::Clinic => "the clinic",
-        };
-        s.push_str(&format!(
-            "Floor {}, {place}. Turn {}.\n\n",
-            self.floor.number(),
-            self.turn
-        ));
-        s.push_str(&format!(
-            "eq: {}\nstamina: {}\nfriction: {}\n",
-            self.eq, self.stamina, self.friction
-        ));
-        if self.conditions.friction_burn {
-            s.push_str("friction burn: yes, untreated\n");
-        }
-        if self.conditions.priapism_turns > 0 {
-            s.push_str("priapism: yes\n");
-        }
-        if self.conditions.peyronie {
-            s.push_str("peyronie's disease: yes\n");
-        }
-        if self.conditions.pulled_muscle {
-            s.push_str("pulled muscle: yes\n");
-        }
-        s.push_str(&format!(
-            "suspicion: {}\nshame: {}\nwarmed up: {}\ngrip: {}\n",
-            self.suspicion,
-            self.shame,
-            if self.warmed_up { "yes" } else { "no" },
-            self.grip.name(),
-        ));
-        let held: Vec<&str> = self.items.owned().iter().map(|item| item.slug()).collect();
-        if !held.is_empty() {
-            s.push_str(&format!("items: {}\n", held.join(", ")));
-        }
-        if self.mum.is_some() {
-            s.push_str("Mum is at the door\n");
-        }
-        s
-    }
-
-    fn chance(&mut self, roll: oracle::Roll, odds: u32) -> bool {
-        self.oracle.chance(roll, odds)
-    }
-
-    pub fn path(&self, sub: &str) -> String {
-        format!("/runs/{}{sub}", self.id)
-    }
-
-    pub fn current_length(&self) -> f64 {
-        self.length + self.here.temp_length
-    }
-
-    pub fn self_reported(&self) -> f64 {
-        self.current_length() + SELF_REPORT_INFLATION
-    }
-
-    pub fn max_stamina(&self) -> i32 {
-        if self.conditions.pulled_muscle {
-            PULLED_STAMINA
-        } else {
-            MAX_STAMINA
-        }
-    }
-
-    pub fn forum_read(&self) -> bool {
-        self.story == Story::ReadForum
-    }
-
-    pub fn thread_reachable(&self) -> bool {
-        self.turn >= BRANCH_TURN
-            || self.forum_read()
-            || self.floor.number() >= Floor::Forum.number()
-    }
-
-    pub fn footage(&self) -> Option<(SystemTime, u64)> {
-        let filmed = self.filmed_at?;
-        let age = filmed.elapsed().map_or(0, |d| d.as_secs());
-        Some((filmed, age))
-    }
-
-    pub fn status(&self) -> RunStatus {
-        if self.ended.is_some() {
-            RunStatus::Gone
-        } else if self.clinic.cured {
-            RunStatus::Normal
-        } else if self.clinic.prescribed {
-            RunStatus::Prescribed
-        } else {
-            RunStatus::Alive
-        }
-    }
-
-    /// The parts of the run that its response headers do not already carry.
-    pub fn view(&self) -> Value {
-        let conditions: Vec<&str> = [
-            (self.here.teapot, "short and stout"),
-            (self.conditions.peyronie, "curved"),
-            (self.items.cage, "caged"),
-            (self.conditions.priapism_turns > 0, "priapism"),
-            (self.conditions.pulled_muscle, "pulled muscle"),
-            (self.filmed_at.is_some(), "viral"),
-        ]
-        .into_iter()
-        .filter_map(|(active, name)| active.then_some(name))
-        .collect();
-        json!({
-            "public_id": self.public_id,
-            "status": self.status().name(),
-            "turn": self.turn,
-            "run_shame": self.shame,
-            "grip": self.grip.name(),
-            "warmed_up": self.warmed_up,
-            "ranked": !self.seeded,
-            "conditions": conditions,
-        })
-    }
-
-    pub fn end(&mut self, cause: Cause) -> Problem {
-        self.ended = Some(Ending {
-            cause,
-            turn: self.turn,
-        });
-        cause.problem().with("turn", self.turn)
-    }
-
-    /// The refractory period is the next HOLD. It comes back with full stamina and nothing else.
-    fn recover(&mut self) {
-        self.exhausted = false;
-        self.stamina = self.max_stamina();
-        self.reset_eq(STARTING_EQ);
-        self.warmed_up = false;
-    }
-
-    fn check_exhausted(&self) -> Result<(), Problem> {
-        if !self.exhausted {
-            return Ok(());
-        }
-        Err(Problem::new(
-            StatusCode::TOO_MANY_REQUESTS,
-            "overtrained",
-            "Stamina is exhausted. HOLD for the refractory period.",
-        ))
-    }
-
-    fn exhaust(&mut self) {
-        self.stamina = 0;
-        self.exhausted = true;
-    }
-
-    fn realise(&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 cause = Cause::Ruptured {
-            ice_unused: self.items.ice_packs > 0,
-        };
-        self.end(cause)
-    }
-}
+pub use run::Run;
+pub use standing::Standing;
+pub use techniques::Technique;

Added file: src/game/notice.rs+33 additions@@ -0,0 +1,33 @@
+/// Something that happened alongside the turn, which rides on the response as a `Warning`.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Notice {
+    BrotherTriedTheDoor,
+    GymStaffLeaveIt,
+    HousekeepingReadTheSign,
+    StopRaidingTheKitchen,
+    StopRaidingTheFridge,
+    KevIsTheBar,
+    DrawerJammed,
+    DrawerComesLoose,
+    ThreadHasReplies,
+    Reflection,
+    MumSatisfied,
+}
+
+impl Notice {
+    pub fn text(self) -> &'static str {
+        match self {
+            Self::BrotherTriedTheDoor => "your brother tried the door",
+            Self::GymStaffLeaveIt => "the gym staff have seen worse, and they leave it there",
+            Self::HousekeepingReadTheSign => "housekeeping read the sign",
+            Self::StopRaidingTheKitchen => "Stop raiding the kitchen.",
+            Self::StopRaidingTheFridge => "Stop raiding the fridge.",
+            Self::KevIsTheBar => "Kev is 8 inches, he says. Nobody asked you, which is worse.",
+            Self::DrawerJammed => "The drawer has jammed.",
+            Self::DrawerComesLoose => "The drawer comes loose. That took a while.",
+            Self::ThreadHasReplies => "Somewhere, a forum thread from 2009 still has replies.",
+            Self::Reflection => "the count reached ten, and then the reflection started",
+            Self::MumSatisfied => "Mum seems satisfied. She takes the washing with her.",
+        }
+    }
+}

Modified file: src/game/oracle.rs+11 additions−28 deletions@@ -8,12 +8,10 @@
 use rand::{Rng, SeedableRng, rngs::StdRng};
 use serde_json::{Value, json};
 
-/// One named decision. The state prose is what the model reads as context, the
-/// ask is the question, and the site is a stable name for logs and caching.
 pub(crate) struct Roll {
     pub(crate) state: String,
     pub(crate) site: &'static str,
-    pub(crate) ask: String,
+    pub(crate) ask: &'static str,
 }
 
 pub(crate) enum Oracle {
@@ -26,12 +24,6 @@ pub(crate) enum OracleTemplate {
     Clm { url: String },
 }
 
-impl OracleTemplate {
-    pub(crate) fn blocks(&self) -> bool {
-        matches!(self, Self::Clm { .. })
-    }
-}
-
 pub(crate) struct Clm {
     url: String,
     agent: ureq::Agent,
@@ -55,12 +47,15 @@ impl Oracle {
         }
     }
 
+    pub(crate) fn listens(&self) -> bool {
+        matches!(self, Self::Clm { .. })
+    }
+
     /// Identity randomness, never a game decision.
     pub(crate) fn u64(&mut self) -> u64 {
         self.technical().random()
     }
 
-    /// A yes/no game roll with stated odds of 1 in `odds`.
     pub(crate) fn chance(&mut self, roll: Roll, odds: u32) -> bool {
         match self {
             Self::Rng(rng) => rng.random_ratio(1, odds),
@@ -71,10 +66,7 @@ impl Oracle {
         }
     }
 
-    /// A yes/no game roll where the ask describes the calm outcome, not the
-    /// event. The model believes dull statements more readily than rare
-    /// warnings, so the interrupts that read as drama get phrased as calm.
-    /// The rng arm still draws the event, never the calm.
+    /// The model believes dull statements more readily than rare warnings, so the ask states the calm outcome.
     pub(crate) fn chance_not(&mut self, roll: Roll, odds: u32) -> bool {
         match self {
             Self::Rng(rng) => rng.random_ratio(1, odds),
@@ -85,10 +77,7 @@ impl Oracle {
         }
     }
 
-    /// A yes/no game roll with general odds of `num` in `den`, put to the
-    /// model as a choice between the calm answer and the event. The noul head
-    /// answers interrupt questions with yes; the choice head, offered the two
-    /// answers side by side, does not.
+    /// The noul head answers interrupt questions with yes, and the choice head, offered both answers, does not.
     pub(crate) fn ratio_choice(
         &mut self,
         roll: Roll,
@@ -100,13 +89,12 @@ impl Oracle {
         match self {
             Self::Rng(rng) => rng.random_ratio(num, den),
             Self::Clm { clm, .. } => {
-                let i = clm.choose(&roll.state, roll.site, &roll.ask, &[calm, event]);
+                let i = clm.choose(&roll.state, roll.site, roll.ask, &[calm, event]);
                 i == 1
             }
         }
     }
 
-    /// A yes/no game roll with general odds of `num` in `den`.
     pub(crate) fn ratio(&mut self, roll: Roll, num: u32, den: u32) -> bool {
         match self {
             Self::Rng(rng) => rng.random_ratio(num, den),
@@ -117,9 +105,7 @@ impl Oracle {
         }
     }
 
-    /// One bucket chosen by weighted draw. The rng arm draws by `weights` and
-    /// ignores the descriptions; the clm arm reads them all and picks the one
-    /// the model believes, weights unused.
+    /// The model picks among the descriptions and never sees the weights.
     pub(crate) fn pick(&mut self, roll: Roll, weights: &[u32], options: &[&str]) -> usize {
         match self {
             Self::Rng(rng) => {
@@ -133,12 +119,11 @@ impl Oracle {
                 }
                 weights.len() - 1
             }
-            Self::Clm { clm, .. } => clm.choose(&roll.state, roll.site, &roll.ask, options),
+            Self::Clm { clm, .. } => clm.choose(&roll.state, roll.site, roll.ask, options),
         }
     }
 
-    /// A value in `lo..hi`. The rng arm draws uniformly; the clm arm picks from
-    /// a 0.1-step grid so the model is choosing among described options.
+    /// The model picks from a 0.1-step grid, since it can only choose among described options.
     pub(crate) fn span(&mut self, roll: Roll, lo: f64, hi: f64) -> f64 {
         match self {
             Self::Rng(rng) => rng.random_range(lo..hi),
@@ -159,8 +144,6 @@ impl Oracle {
         }
     }
 
-    /// An integer in `lo..=hi`. The rng arm draws uniformly; the clm arm picks
-    /// from the integers as described options.
     pub(crate) fn span_int(&mut self, roll: Roll, lo: i32, hi: i32) -> i32 {
         match self {
             Self::Rng(rng) => rng.random_range(lo..=hi),

Modified file: src/game/outcome.rs+19 additions−3 deletions@@ -9,9 +9,9 @@ pub enum Payload {
 
 /// A successful result of a game action, before it becomes an HTTP response.
 pub struct Outcome {
-    pub status: StatusCode,
-    pub payload: Payload,
-    pub headers: Vec<(HeaderName, String)>,
+    status: StatusCode,
+    payload: Payload,
+    headers: Vec<(HeaderName, String)>,
 }
 
 impl Outcome {
@@ -41,4 +41,20 @@ impl Outcome {
         self.headers.push((name, value.into()));
         self
     }
+
+    pub fn status(&self) -> StatusCode {
+        self.status
+    }
+
+    pub(super) fn retold(mut self, status: StatusCode, detail: &str) -> Self {
+        self.status = status;
+        if let Payload::Json(body) = &mut self.payload {
+            body["detail"] = Value::from(detail);
+        }
+        self
+    }
+
+    pub fn into_parts(self) -> (StatusCode, Payload, Vec<(HeaderName, String)>) {
+        (self.status, self.payload, self.headers)
+    }
 }

Added file: src/game/progress.rs+185 additions@@ -0,0 +1,185 @@
+use super::{
+    Floor, Lube, MumVisit, Notice, Observer, Run, Story,
+    balance::{
+        BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, EQ_WOBBLE, EXTENDER_GAIN,
+        FORESKIN_GLIDE, FRICTION_BURN, FRICTION_BURN_AT, FRICTION_DRY, FRICTION_GRIP, FRICTION_MAX,
+        FRICTION_SPIT, GIRTH_THICK, HOT_EQ, OBSERVED, PRIAPISM_EQ, PRIAPISM_TURNS, PULLED_MUSCLE,
+        PULLED_MUSCLE_INTENSITY, RING_PRIAPISM, RING_TIGHT_PRIAPISM, STROKE_EQ, STROKE_EQ_COST,
+        SUSPICION_LIMIT, VIGOUR,
+    },
+};
+
+impl Run {
+    pub(super) fn chafe(&mut self, lube: Option<Lube>, intensity: i32) {
+        let (base, slip) = match lube {
+            None => (FRICTION_DRY, 0),
+            Some(Lube::Spit) => (FRICTION_SPIT, 0),
+            Some(Lube::Lotion) => (0, 0),
+            Some(Lube::BabyOil | Lube::CoconutOil) => (0, 1),
+            Some(Lube::Vaseline) => (0, 2),
+        };
+        let vigour = usize::try_from(intensity - 1).map_or(0, |i| VIGOUR[i.min(VIGOUR.len() - 1)]);
+        let unlubed = matches!(lube, None | Some(Lube::Spit));
+        let thick = i32::from(unlubed && self.body.girth > GIRTH_THICK);
+        let glide = i32::from(unlubed && self.body.foreskin.is_some_and(|f| f >= FORESKIN_GLIDE));
+        let mut friction = (base + vigour + thick - slip - glide).max(0);
+        if friction > 0
+            && self
+                .body
+                .jelq_grip
+                .is_some_and(|grip| grip != self.body.grip)
+        {
+            friction -= FRICTION_GRIP;
+        }
+        self.body.jelq_grip = Some(self.body.grip);
+        self.body.friction = (self.body.friction + friction).min(FRICTION_MAX);
+        if self.body.friction >= FRICTION_BURN_AT
+            && !self.body.conditions.friction_burn
+            && self.chance(
+                self.decision(
+                    "friction-burn",
+                    "With the skin this raw, has it finally burned?",
+                ),
+                FRICTION_BURN,
+            )
+        {
+            self.body.conditions.friction_burn = true;
+        }
+    }
+
+    pub(super) fn commit(&mut self, intensity: i32, lube: Option<Lube>, cost: i32) {
+        self.begin_turn();
+        self.step_away();
+        if self.items.kit.extender {
+            self.body.length += EXTENDER_GAIN;
+        }
+        self.body.stamina -= cost + i32::from(lube == Some(Lube::Lotion));
+        if self.body.stamina <= 0 {
+            self.exhaust();
+        }
+        let chill = if self.floor == Floor::ChangingRoom {
+            CHANGING_ROOM_CHILL
+        } else {
+            0
+        };
+        let wobble = self.oracle.span_int(
+            self.decision(
+                "wobble",
+                "How does the count drift on this stroke, up or down?",
+            ),
+            -EQ_WOBBLE,
+            EQ_WOBBLE,
+        );
+        self.body.eq =
+            (self.body.eq + intensity * STROKE_EQ - STROKE_EQ_COST - chill + wobble).clamp(0, 100);
+
+        self.make_noise(intensity / 5 + i32::from(lube == Some(Lube::Vaseline)));
+        if self.floor == Floor::Nans && lube == Some(Lube::CoconutOil) {
+            self.add_suspicion(2);
+        }
+
+        if intensity >= PULLED_MUSCLE_INTENSITY
+            && !self.body.conditions.pulled_muscle
+            && self.oracle.chance_not(
+                self.decision("pulled-muscle", "Do the muscles hold?"),
+                PULLED_MUSCLE,
+            )
+        {
+            self.body.conditions.pulled_muscle = true;
+            self.body.stamina = self.body.stamina.min(self.max_stamina());
+        }
+        self.settle();
+    }
+
+    pub(super) fn make_noise(&mut self, noise: i32) {
+        let doubled = match self.floor {
+            Floor::Nans => true,
+            Floor::ChangingRoom => !self.holds_own_in_the_locker_room(),
+            _ => false,
+        };
+        self.add_suspicion(if doubled { noise * 2 } else { noise });
+    }
+
+    pub(super) fn add_suspicion(&mut self, amount: i32) {
+        self.standing.suspicion = u8::try_from(
+            (i32::from(self.standing.suspicion) + amount).clamp(0, i32::from(SUSPICION_LIMIT)),
+        )
+        .unwrap_or(SUSPICION_LIMIT);
+    }
+
+    pub(super) fn settle(&mut self) {
+        self.maybe_summon_mum();
+        if let Some(observer) = self.floor.observer()
+            && self.chance(
+                self.decision("observed", "Has someone quietly noticed what is going on?"),
+                OBSERVED,
+            )
+        {
+            self.observed = Some(observer);
+            self.standing.shame += 1;
+            if observer == Observer::Cat
+                && self.chance(
+                    self.decision("cat-takes-towel", "Has the cat taken the towel?"),
+                    CAT_TAKES_TOWEL,
+                )
+            {
+                self.here.towel_stolen = true;
+            }
+        }
+        if self.items.kit.ring
+            && self.body.eq > HOT_EQ
+            && self.chance(
+                self.decision(
+                    "ring-priapism",
+                    "With the ring still on and everything this warm, will it not go down?",
+                ),
+                if self.body.girth > GIRTH_THICK {
+                    RING_TIGHT_PRIAPISM
+                } else {
+                    RING_PRIAPISM
+                },
+            )
+        {
+            self.body.conditions.priapism_turns = PRIAPISM_TURNS;
+        }
+        if self.body.conditions.priapism_turns > 0 {
+            self.body.conditions.priapism_turns -= 1;
+            self.body.eq = self.body.eq.max(PRIAPISM_EQ);
+        }
+        if self.turn == BRANCH_TURN && self.online.story == Story::Unopened {
+            self.online.story = Story::Pending;
+            self.notices.push(Notice::ThreadHasReplies);
+        }
+    }
+
+    pub(super) fn maybe_summon_mum(&mut self) {
+        let was_below = self.standing.at_turn_start < SUSPICION_LIMIT;
+        if !self.floor.has_mum() || self.household.mum.is_some() {
+            return;
+        }
+        let summoned = was_below && self.standing.suspicion == SUSPICION_LIMIT;
+        let mut visits = u32::from(self.standing.suspicion) + 1;
+        if self.here.brother_told {
+            visits *= 2;
+        }
+        if summoned
+            || self.oracle.ratio(
+                self.decision(
+                    "mum-summon",
+                    "With this much noise in the house, is Mum on her way up?",
+                ),
+                visits,
+                super::balance::MUM_VISIT,
+            )
+        {
+            let errand = self.errand(summoned);
+            let nonce = self.fresh_nonce();
+            self.household.mum = Some(MumVisit {
+                errand,
+                nonce,
+                strikes: 0,
+                knocked: false,
+            });
+        }
+    }
+}

Added file: src/game/rest.rs+87 additions@@ -0,0 +1,87 @@
+use super::{
+    Notice, Outcome, Run, Story,
+    balance::{
+        DANGER_EQ, FRICTION_HOLD, FRICTION_MEDITATE, HOLD_EQ, MEDITATION_EQ, REFLECTION,
+        RUPTURE_HOLD,
+    },
+};
+use crate::problem::Problem;
+use axum::http::StatusCode;
+use serde_json::json;
+
+impl Run {
+    pub fn can_hold(&self) -> bool {
+        self.body.eq > DANGER_EQ || self.body.stamina <= 2
+    }
+
+    pub fn hold(&mut self) -> Result<Outcome, Problem> {
+        if self.online.story == Story::Pending {
+            return Ok(self.branch_offer());
+        }
+        if self.items.kit.cage {
+            return Err(Problem::new(
+                StatusCode::LOCKED,
+                "caged",
+                "The cage is locked. The key is not in the box.",
+            ));
+        }
+        self.begin_turn();
+        if self.oracle.chance_not(
+            self.decision("rupture", "The pause is uneventful"),
+            RUPTURE_HOLD,
+        ) {
+            return Err(self.rupture());
+        }
+        if self.body.exhausted {
+            self.recover();
+            self.shed(FRICTION_HOLD);
+            self.settle();
+            let detail = if self.body.conditions.priapism_turns > 0 {
+                "The count went well past ten. Stamina is back. It went down a little. Maybe. You hope."
+            } else {
+                "The count went well past ten. Stamina is back. Everything else has gone quiet, and you are cold again."
+            };
+            return Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })));
+        }
+        if self.chance(
+            self.decision(
+                "reflection",
+                "In the quiet afterwards, have you caught your own eye in the mirror?",
+            ),
+            REFLECTION,
+        ) {
+            self.body.eq = 0;
+            self.standing.shame += 1;
+            self.notices.push(Notice::Reflection);
+        } else {
+            self.body.eq = (self.body.eq - HOLD_EQ).clamp(0, 100);
+        }
+        self.body.stamina = (self.body.stamina + 1).min(self.max_stamina());
+        self.shed(FRICTION_HOLD);
+        self.settle();
+        Ok(Outcome::empty(StatusCode::NO_CONTENT))
+    }
+
+    /// The breathing technique from the forum's replies. It spends no stamina and the turn is
+    /// not the floor's, but each floor allows it once.
+    pub(super) fn meditate(&mut self) -> Result<Outcome, Problem> {
+        if self.here.meditated {
+            return Err(Problem::new(
+                StatusCode::CONFLICT,
+                "already-meditated",
+                "This floor has had its meditation.",
+            ));
+        }
+        self.here.meditated = true;
+        self.step_away();
+        self.reset_eq(self.body.eq - MEDITATION_EQ);
+        self.shed(FRICTION_MEDITATE);
+        self.touch();
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({
+                "detail": "In through the nose, out through the mouth. EQ falls by ten.",
+            }),
+        ))
+    }
+}

Added file: src/game/roll.rs+222 additions@@ -0,0 +1,222 @@
+use super::{
+    Grip, Lube, Outcome, Run,
+    balance::{
+        ARRIVAL_BONUS, BAND_BONUS, CLEAN_HIT, DANGER_EQ, EQ_BAND, GREED_HOT, GREED_WARM, HOT_EQ,
+        NEAR_MISS, QUEUED_ETA, RING_RUPTURE_LINE, RUPTURE_LINE, UNDERHAND_STRETCH, UNDERHAND_WET,
+    },
+    body::Pending,
+    measure::round3,
+    techniques::{Profile, Training},
+};
+use crate::{headers::SERVER_TIMING, problem::Problem};
+use axum::http::{StatusCode, header};
+use serde_json::json;
+
+impl Run {
+    pub(super) fn roll(
+        &mut self,
+        training: Training,
+        intensity: i32,
+        lube: Option<Lube>,
+    ) -> Result<Outcome, Problem> {
+        let profile = training.profile();
+        let natural: i32 = self.oracle.span_int(
+            self.decision(
+                "natural",
+                "What does the twenty-sided die show for this technique?",
+            ),
+            1,
+            20,
+        );
+        let modifier = self.modifier(training, lube);
+        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 (length, girth) = self.scaled_gains(&profile, intensity);
+        let rupture_line = if self.items.kit.ring {
+            RING_RUPTURE_LINE
+        } else {
+            RUPTURE_LINE
+        };
+
+        if natural == 1 {
+            return Err(timed(self.critical_failure(training, &profile)));
+        }
+        self.here.warm_arrival = false;
+        if natural == 2 && self.hotter_than(DANGER_EQ) {
+            return Err(timed(self.rupture()));
+        }
+        if self.hotter_than(rupture_line) && 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::PERMANENT_REDIRECT,
+                json!({
+                    "detail": "Your length has moved permanently.",
+                    "length": round3(length * 2.0),
+                    "girth": round3(girth * 2.0),
+                }),
+            )
+            .header(header::LOCATION, self.path("/length"))
+            .header(SERVER_TIMING, timing));
+        }
+        if total < dc - NEAR_MISS {
+            return Err(timed(not_extended()));
+        }
+        if total < dc {
+            return Ok(Outcome::empty(StatusCode::NO_CONTENT).header(SERVER_TIMING, timing));
+        }
+        Ok(self
+            .land(&profile, length, girth, total >= dc + CLEAN_HIT)
+            .header(SERVER_TIMING, timing))
+    }
+
+    fn modifier(&self, training: Training, lube: Option<Lube>) -> i32 {
+        let band = if EQ_BAND.contains(&self.body.eq) {
+            BAND_BONUS
+        } else {
+            0
+        };
+        let grip = match (self.body.grip, training) {
+            (Grip::Underhand, Training::Stretch) => UNDERHAND_STRETCH,
+            (Grip::Underhand, Training::Wet) => UNDERHAND_WET,
+            _ => 0,
+        };
+        let arrival = if self.here.warm_arrival {
+            ARRIVAL_BONUS
+        } else {
+            0
+        };
+        lube.map_or(0, Lube::modifier) + band + grip + arrival
+    }
+
+    fn land(&mut self, profile: &Profile, length: f64, girth: f64, clean: bool) -> Outcome {
+        if self.body.eq < *EQ_BAND.start() {
+            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 clean {
+            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.oracle.span_int(
+                self.decision("eta", "In how many turns will the queued gains arrive?"),
+                *QUEUED_ETA.start(),
+                *QUEUED_ETA.end(),
+            );
+            self.body.pending.push(Pending {
+                due: self.turn + eta.unsigned_abs(),
+                length,
+                girth,
+                foreskin: profile.foreskin_growth,
+            });
+            Outcome::json(
+                StatusCode::ACCEPTED,
+                json!({
+                    "detail": "Gains have been queued. They may arrive.",
+                    "eta_turns": eta,
+                }),
+            )
+        }
+    }
+
+    pub(super) fn scaled_gains(&self, profile: &Profile, intensity: i32) -> (f64, f64) {
+        let scale = f64::from(intensity);
+        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
+        let greed = if self.body.eq > HOT_EQ {
+            GREED_HOT
+        } else if self.body.eq > DANGER_EQ {
+            GREED_WARM
+        } else {
+            1.0
+        };
+        length *= greed;
+        girth *= greed;
+        if self.here.teapot {
+            length *= 0.5;
+            girth *= 1.5;
+        }
+        if self.items.kit.ring {
+            girth *= 2.0;
+        }
+        if self.body.conditions.friction_burn {
+            length *= 0.5;
+            girth *= 0.5;
+        }
+        (length, girth)
+    }
+
+    pub(super) fn critical_failure(&mut self, training: Training, profile: &Profile) -> Problem {
+        let uses_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);
+        if uses_foreskin && self.body.foreskin.is_some() {
+            self.body.foreskin = None;
+            self.standing.shame += 25;
+            return Problem::new(
+                StatusCode::GONE,
+                "foreskin-lost",
+                "The technique has removed the foreskin. It will not be returning.",
+            )
+            .header(header::CONTENT_LOCATION, self.path("/foreskin"));
+        }
+        if self.hotter_than(DANGER_EQ) {
+            return self.rupture();
+        }
+        if training == Training::Stretch && !self.here.teapot {
+            self.here.teapot = true;
+            self.items.kit.teapot_spout = true;
+            self.standing.shame += 5;
+            return 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 training == Training::Uli && !self.body.conditions.peyronie {
+            self.body.conditions.peyronie = true;
+            self.standing.shame += 5;
+            return Problem::new(
+                StatusCode::MISDIRECTED_REQUEST,
+                "curvature",
+                "A curvature has developed. Techniques will land slightly to the left until a professional is consulted.",
+            );
+        }
+        not_extended()
+    }
+
+    pub(super) fn gossip(&mut self, outcome: Outcome) -> Outcome {
+        let reportable = matches!(outcome.status().as_u16(), 200 | 202 | 206 | 308);
+        if !self.here.brother_told || !reportable {
+            return outcome;
+        }
+        self.here.brother_told = false;
+        outcome.retold(
+            StatusCode::ALREADY_REPORTED,
+            "Your brother has already told Mum.",
+        )
+    }
+}
+
+pub(super) fn not_extended() -> Problem {
+    Problem::new(
+        StatusCode::NOT_EXTENDED,
+        "not-extended",
+        "The requested extension was not applied. The server has recorded the attempt.",
+    )
+}

Added file: src/game/run.rs+364 additions@@ -0,0 +1,364 @@
+use std::{
+    hash::{DefaultHasher, Hash, Hasher},
+    time::{Instant, SystemTime},
+};
+
+use axum::http::StatusCode;
+use serde_json::{Value, json};
+
+use super::{
+    Body, Cause, Clinic, Ending, Floor, FloorState, Household, Items, Notice, Observer, Online,
+    RunStatus, Standing, Story,
+    balance::{
+        BRANCH_TURN, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, SELF_REPORT_INFLATION, STARTING_EQ,
+    },
+    measure::round2,
+    oracle::{Oracle, OracleTemplate, Roll},
+};
+use crate::problem::Problem;
+
+pub struct Identity {
+    /// The private id in the run's URL. Knowing it is the only authorisation a run has.
+    pub(crate) id: String,
+    pub(crate) public_id: String,
+    pub(crate) seeded: bool,
+    etag_salt: u64,
+    pub(crate) version: u64,
+    pub(crate) last_seen: Instant,
+}
+
+pub struct Run {
+    pub(crate) ident: Identity,
+    pub(crate) body: Body,
+    pub(crate) standing: Standing,
+    pub(crate) household: Household,
+    pub(crate) online: Online,
+    pub(crate) items: Items,
+    pub(crate) clinic: Clinic,
+    pub(crate) turn: u32,
+    pub(crate) floor: Floor,
+    pub(crate) here: FloorState,
+    pub(crate) observed: Option<Observer>,
+    pub(crate) notices: Vec<Notice>,
+    pub(crate) ended: Option<Ending>,
+    pub(super) oracle: Oracle,
+}
+
+impl Run {
+    #[cfg(test)]
+    pub fn new(id: String, public_id: String, seed: u64) -> Self {
+        Self::with_oracle(id, public_id, seed, false, &OracleTemplate::Rng)
+    }
+
+    pub fn with_oracle(
+        id: String,
+        public_id: String,
+        seed: u64,
+        seeded: bool,
+        template: &OracleTemplate,
+    ) -> Self {
+        let mut oracle = Oracle::build(template, seed);
+        let length = round2(oracle.span(
+            Run::unborn("length", "How long is it, in inches?"),
+            4.5,
+            6.5,
+        ));
+        let girth = round2(oracle.span(
+            Run::unborn("girth", "How thick is it, in inches?"),
+            4.0,
+            5.0,
+        ));
+        let foreskin = round2(oracle.span(
+            Run::unborn("foreskin", "How much foreskin is there, in inches?"),
+            0.4,
+            2.4,
+        ));
+        let etag_salt = oracle.u64();
+        Self {
+            ident: Identity {
+                id,
+                public_id,
+                seeded,
+                etag_salt,
+                version: 0,
+                last_seen: Instant::now(),
+            },
+            body: Body::new(length, girth, foreskin),
+            standing: Standing::default(),
+            household: Household::default(),
+            online: Online::default(),
+            items: Items::default(),
+            clinic: Clinic::default(),
+            turn: 0,
+            floor: Floor::Bedroom,
+            here: FloorState::default(),
+            observed: None,
+            notices: Vec::new(),
+            ended: None,
+            oracle,
+        }
+    }
+
+    fn unborn(site: &'static str, ask: &'static str) -> Roll {
+        Roll {
+            state: "A new run is being created. No game has been played yet.".into(),
+            site,
+            ask,
+        }
+    }
+
+    fn etag_at(&self, version: u64) -> String {
+        let mut hasher = DefaultHasher::new();
+        (self.ident.etag_salt, version).hash(&mut hasher);
+        format!("\"{:016x}\"", hasher.finish())
+    }
+
+    pub fn etag(&self) -> String {
+        self.etag_at(self.ident.version)
+    }
+
+    /// The ETag the run had when it was created, which the true ending asks for.
+    pub fn origin_etag(&self) -> String {
+        self.etag_at(0)
+    }
+
+    pub fn touch(&mut self) {
+        self.ident.version += 1;
+    }
+
+    pub(super) fn begin_turn(&mut self) {
+        self.touch();
+        self.turn += 1;
+        self.here.turns += 1;
+        self.standing.at_turn_start = self.standing.suspicion;
+        self.realise();
+    }
+
+    pub(super) fn shed(&mut self, friction: i32) {
+        self.body.friction = (self.body.friction - friction).max(0);
+    }
+
+    /// Priapism holds EQ up no matter what else moves it.
+    pub(super) fn reset_eq(&mut self, eq: i32) {
+        let floor = if self.body.conditions.priapism_turns > 0 {
+            PRIAPISM_EQ
+        } else {
+            0
+        };
+        self.body.eq = eq.max(floor);
+    }
+
+    pub(super) fn end_kitchen_visit(&mut self) {
+        self.here.kitchen.melon_offered = false;
+    }
+
+    /// Going back to the jelq walks away from both the fridge and Pump-Bro.
+    pub(super) fn step_away(&mut self) {
+        self.end_kitchen_visit();
+        self.here.shopping = false;
+    }
+
+    pub(super) fn fresh_nonce(&mut self) -> String {
+        format!("{:016x}", self.oracle.u64())
+    }
+
+    /// One game decision. The dice ignore the state prose, so it is only written for the model.
+    pub(super) fn decision(&self, site: &'static str, ask: &'static str) -> Roll {
+        Roll {
+            state: if self.oracle.listens() {
+                self.oracle_state()
+            } else {
+                String::new()
+            },
+            site,
+            ask,
+        }
+    }
+
+    fn oracle_state(&self) -> String {
+        let mut s = format!(
+            "Floor {}, {}. Turn {}.\n\neq: {}\nstamina: {}\nfriction: {}\n",
+            self.floor.number(),
+            self.floor.place(),
+            self.turn,
+            self.body.eq,
+            self.body.stamina,
+            self.body.friction
+        );
+        let conditions = &self.body.conditions;
+        for (active, line) in [
+            (conditions.friction_burn, "friction burn: yes, untreated\n"),
+            (conditions.priapism_turns > 0, "priapism: yes\n"),
+            (conditions.peyronie, "peyronie's disease: yes\n"),
+            (conditions.pulled_muscle, "pulled muscle: yes\n"),
+        ] {
+            if active {
+                s.push_str(line);
+            }
+        }
+        s.push_str(&format!(
+            "suspicion: {}\nshame: {}\nwarmed up: {}\ngrip: {}\n",
+            self.standing.suspicion,
+            self.standing.shame,
+            if self.body.warmed_up { "yes" } else { "no" },
+            self.body.grip.name(),
+        ));
+        let held: Vec<&str> = self.items.owned().iter().map(|item| item.slug()).collect();
+        if !held.is_empty() {
+            s.push_str(&format!("items: {}\n", held.join(", ")));
+        }
+        if self.household.mum.is_some() {
+            s.push_str("Mum is at the door\n");
+        }
+        s
+    }
+
+    pub(super) fn chance(&mut self, roll: Roll, odds: u32) -> bool {
+        self.oracle.chance(roll, odds)
+    }
+
+    pub fn path(&self, sub: &str) -> String {
+        format!("/runs/{}{sub}", self.ident.id)
+    }
+
+    pub fn current_length(&self) -> f64 {
+        self.body.length + self.here.temp_length
+    }
+
+    pub fn self_reported(&self) -> f64 {
+        self.current_length() + SELF_REPORT_INFLATION
+    }
+
+    pub fn shown_length(&self) -> f64 {
+        if self.items.kit.ruler {
+            self.current_length()
+        } else {
+            self.self_reported()
+        }
+    }
+
+    pub fn max_stamina(&self) -> i32 {
+        if self.body.conditions.pulled_muscle {
+            PULLED_STAMINA
+        } else {
+            MAX_STAMINA
+        }
+    }
+
+    pub fn forum_read(&self) -> bool {
+        self.online.story == Story::ReadForum
+    }
+
+    pub fn thread_reachable(&self) -> bool {
+        self.turn >= BRANCH_TURN
+            || self.forum_read()
+            || self.floor.number() >= Floor::Forum.number()
+    }
+
+    pub fn footage(&self) -> Option<(SystemTime, u64)> {
+        let filmed = self.online.filmed_at?;
+        let age = filmed.elapsed().map_or(0, |d| d.as_secs());
+        Some((filmed, age))
+    }
+
+    pub fn status(&self) -> RunStatus {
+        if self.ended.is_some() {
+            RunStatus::Gone
+        } else if self.clinic.cured {
+            RunStatus::Normal
+        } else if self.clinic.prescribed {
+            RunStatus::Prescribed
+        } else {
+            RunStatus::Alive
+        }
+    }
+
+    /// The parts of the run that its response headers do not already carry.
+    pub fn view(&self) -> Value {
+        let conditions: Vec<&str> = [
+            (self.here.teapot, "short and stout"),
+            (self.body.conditions.peyronie, "curved"),
+            (self.items.kit.cage, "caged"),
+            (self.body.conditions.priapism_turns > 0, "priapism"),
+            (self.body.conditions.pulled_muscle, "pulled muscle"),
+            (self.online.filmed_at.is_some(), "viral"),
+        ]
+        .into_iter()
+        .filter_map(|(active, name)| active.then_some(name))
+        .collect();
+        json!({
+            "public_id": self.ident.public_id,
+            "status": self.status().name(),
+            "turn": self.turn,
+            "run_shame": self.standing.shame,
+            "grip": self.body.grip.name(),
+            "warmed_up": self.body.warmed_up,
+            "ranked": !self.ident.seeded,
+            "conditions": conditions,
+        })
+    }
+
+    pub fn end(&mut self, cause: Cause) -> Problem {
+        self.ended = Some(Ending {
+            cause,
+            turn: self.turn,
+        });
+        cause.problem().with("turn", self.turn)
+    }
+
+    /// The refractory period is the next HOLD. It comes back with full stamina and nothing else.
+    pub(super) fn recover(&mut self) {
+        self.body.exhausted = false;
+        self.body.stamina = self.max_stamina();
+        self.reset_eq(STARTING_EQ);
+        self.body.warmed_up = false;
+    }
+
+    pub(super) fn check_exhausted(&self) -> Result<(), Problem> {
+        if !self.body.exhausted {
+            return Ok(());
+        }
+        Err(Problem::new(
+            StatusCode::TOO_MANY_REQUESTS,
+            "overtrained",
+            "Stamina is exhausted. HOLD for the refractory period.",
+        ))
+    }
+
+    pub(super) fn exhaust(&mut self) {
+        self.body.stamina = 0;
+        self.body.exhausted = true;
+    }
+
+    pub(super) fn realise(&mut self) {
+        let (due, waiting): (Vec<_>, Vec<_>) = std::mem::take(&mut self.body.pending)
+            .into_iter()
+            .partition(|p| p.due <= self.turn);
+        self.body.pending = waiting;
+        for p in due {
+            self.gain(p.length, p.girth, p.foreskin);
+        }
+    }
+
+    pub(super) fn gain(&mut self, length: f64, girth: f64, foreskin: f64) {
+        self.body.length += length;
+        self.body.girth += girth;
+        if let Some(f) = &mut self.body.foreskin {
+            *f += foreskin;
+        }
+    }
+
+    pub(super) fn rupture(&mut self) -> Problem {
+        let cause = Cause::Ruptured {
+            ice_unused: self.items.stores.ice_packs > 0,
+        };
+        self.end(cause)
+    }
+
+    /// A run whose lock was poisoned by a panic mid-turn cannot be trusted to carry on.
+    pub fn lose(&mut self) {
+        if self.ended.is_none() {
+            self.end(Cause::Lost);
+        }
+    }
+}

Modified file: src/game/shop.rs+9 additions−7 deletions@@ -27,10 +27,12 @@ impl Run {
         Some(item.price()? + markup)
     }
 
-    pub fn shop_view(&self) -> Result<Value, Problem> {
+    /// Looking at the stock opens a shopping session, which lasts until the next jelq.
+    pub fn browse_shop(&mut self) -> Result<Value, Problem> {
         if !self.floor.shop_open() {
             return Err(pump_bro_absent());
         }
+        self.here.shopping = true;
         let stock: Vec<Value> = SHOP
             .iter()
             .filter_map(|item| {
@@ -52,7 +54,7 @@ impl Run {
         Ok(view)
     }
 
-    pub fn buy(&mut self, slug: &str) -> Result<Outcome, Problem> {
+    pub fn buy(&mut self, item: Option<Item>) -> Result<Outcome, Problem> {
         if !self.floor.shop_open() {
             return Err(pump_bro_absent());
         }
@@ -63,7 +65,7 @@ impl Run {
                 "Pump-Bro does not sell that. He knows a guy.",
             )
         };
-        let item = Item::parse(slug)
+        let item = item
             .filter(|item| SHOP.contains(item))
             .ok_or_else(not_for_sale)?;
         let price = self.price(item).ok_or_else(not_for_sale)?;
@@ -76,7 +78,7 @@ impl Run {
             .header(header::UPGRADE, "pump-pro/2.0")
             .with("upgrade", self.path("/shop/pump-pro")));
         }
-        if self.cash < price {
+        if self.standing.cash < price {
             return Err(Problem::new(
                 StatusCode::PAYMENT_REQUIRED,
                 "insufficient-funds",
@@ -84,7 +86,7 @@ impl Run {
             )
             .with("price", price));
         }
-        self.cash -= price;
+        self.standing.cash -= price;
         self.items.grant(item);
         self.touch();
         if item == Item::Supplement {
@@ -106,8 +108,8 @@ impl Run {
 
     pub fn drop_item(&mut self, item: Item) -> Result<Outcome, Problem> {
         match item {
-            Item::Extender => self.items.extender = false,
-            Item::Ring => self.items.ring = false,
+            Item::Extender => self.items.kit.extender = false,
+            Item::Ring => self.items.kit.ring = false,
             Item::Cage => {
                 return Err(Problem::new(
                     StatusCode::LOCKED,

Added file: src/game/standing.rs+25 additions@@ -0,0 +1,25 @@
+use super::balance::STARTING_CASH;
+
+pub struct Standing {
+    pub(crate) suspicion: u8,
+    /// Suspicion before this turn's noise, so Mum can tell the turn that crossed the limit.
+    pub(crate) at_turn_start: u8,
+    /// This run's shame. The cross-run total lives in the signed cookie.
+    pub(crate) shame: u32,
+    pub(crate) shame_reported: u32,
+    pub(crate) shame_total: u32,
+    pub(crate) cash: u32,
+}
+
+impl Default for Standing {
+    fn default() -> Self {
+        Self {
+            suspicion: 0,
+            at_turn_start: 0,
+            shame: 0,
+            shame_reported: 0,
+            shame_total: 0,
+            cash: STARTING_CASH,
+        }
+    }
+}

Deleted file: src/game/state.rs−294 deletions@@ -1,294 +0,0 @@
-use axum::http::StatusCode;
-
-use crate::problem::Problem;
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-#[repr(u8)]
-pub enum Floor {
-    Bedroom = 1,
-    Bathroom = 2,
-    ChangingRoom = 3,
-    Nans = 4,
-    Hotel = 5,
-    Forum = 6,
-    Clinic = 7,
-}
-
-impl Floor {
-    pub fn number(self) -> u8 {
-        self as u8
-    }
-
-    pub fn next(self) -> Option<Self> {
-        match self {
-            Self::Bedroom => Some(Self::Bathroom),
-            Self::Bathroom => Some(Self::ChangingRoom),
-            Self::ChangingRoom => Some(Self::Nans),
-            Self::Nans => Some(Self::Hotel),
-            Self::Hotel => Some(Self::Forum),
-            Self::Forum => Some(Self::Clinic),
-            Self::Clinic => None,
-        }
-    }
-
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Bedroom => "the bedroom",
-            Self::Bathroom => "the shared bathroom",
-            Self::ChangingRoom => "the gym changing room",
-            Self::Nans => "Nan's house at Christmas",
-            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. Your brother showers at eight.",
-            Self::ChangingRoom => {
-                "It is cold. Discretion is advised. Everyone here is lying. Pump-Bro is by the lockers."
-            }
-            Self::Nans => {
-                "The walls are thin. Mum 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.",
-        }
-    }
-
-    pub fn observer(self) -> Option<Observer> {
-        match self {
-            Self::Bedroom => Some(Observer::Cat),
-            Self::ChangingRoom => Some(Observer::Greg),
-            Self::Nans => Some(Observer::Nan),
-            _ => None,
-        }
-    }
-
-    pub fn has_mum(self) -> bool {
-        matches!(self, Self::Bedroom | Self::Nans)
-    }
-
-    pub fn has_window(self) -> bool {
-        matches!(self, Self::Bedroom | Self::Nans | Self::Hotel)
-    }
-
-    pub fn shop_open(self) -> bool {
-        matches!(self, Self::ChangingRoom | Self::Hotel)
-    }
-
-    pub fn has_kitchen(self) -> bool {
-        matches!(self, Self::Bedroom | Self::Nans)
-    }
-
-    pub fn timed(self) -> bool {
-        !matches!(self, Self::Forum | Self::Clinic)
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Observer {
-    Cat,
-    Greg,
-    Nan,
-}
-
-impl Observer {
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Cat => "cat",
-            Self::Greg => "greg",
-            Self::Nan => "nan",
-        }
-    }
-}
-
-#[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,
-        }
-    }
-}
-
-/// State that belongs to the current floor and resets when you leave it.
-#[derive(Default)]
-pub struct FloorState {
-    pub turns: u32,
-    pub drawer_searched: bool,
-    pub drawer_jammed: bool,
-    pub kettle_boiled: bool,
-    pub thread_rolls: u8,
-    pub edges: u8,
-    pub temp_length: f64,
-    pub teapot: bool,
-    pub towel_stolen: bool,
-    pub brother_told: bool,
-    pub shopping: bool,
-    pub meditated: bool,
-    pub melon_offered: bool,
-    pub warm_arrival: bool,
-    pub wifi_accepted: bool,
-}
-
-#[derive(Default)]
-pub struct Conditions {
-    pub peyronie: bool,
-    pub pulled_muscle: bool,
-    pub priapism_turns: u8,
-    pub friction_burn: bool,
-}
-
-pub struct MumVisit {
-    pub errand: &'static str,
-    pub nonce: String,
-    pub strikes: u8,
-    pub knocked: bool,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Elder {
-    Unverified { strikes: u8 },
-    Verified,
-    Beaten,
-}
-
-#[derive(Default)]
-pub struct Clinic {
-    pub intake_attempts: usize,
-    pub measured: bool,
-    pub prescribed: bool,
-    pub cured: bool,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Story {
-    Unopened,
-    Pending,
-    ReadForum,
-    ClosedTab,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Cause {
-    Ruptured { ice_unused: bool },
-    Caught,
-    Opened,
-    Banned,
-    Degloved,
-    Zip,
-    Meloned,
-    Abandoned,
-}
-
-impl Cause {
-    pub fn slug(self) -> &'static str {
-        match self {
-            Self::Ruptured { .. } => "vascular-event",
-            Self::Caught => "caught",
-            Self::Opened => "opened",
-            Self::Banned => "banned",
-            Self::Degloved => "degloved",
-            Self::Zip => "zip",
-            Self::Meloned => "watermelon",
-            Self::Abandoned => "abandoned",
-        }
-    }
-
-    pub fn detail(self) -> &'static str {
-        match self {
-            Self::Ruptured { ice_unused: true } => {
-                "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."
-            }
-            Self::Ruptured { ice_unused: false } => {
-                "A vessel has exceeded its rated pressure. The run has ended."
-            }
-            Self::Caught => {
-                "Mum has seen enough. The run has ended. Nobody will mention it at dinner."
-            }
-            Self::Opened => {
-                "Mum has stopped knocking and opened the door. The run has ended. Nobody will mention it at dinner."
-            }
-            Self::Banned => "Your account has been banned. The forum can tell. The run has ended.",
-            Self::Degloved => {
-                "The outer layer has been removed in one piece. It will not be returning. The run has ended."
-            }
-            Self::Zip => {
-                "The request conflicts with the current state of the zip. The run has ended."
-            }
-            Self::Meloned => {
-                "You have been caught with the watermelon. Nobody will mention it at dinner. The run has ended."
-            }
-            Self::Abandoned => "The run was abandoned.",
-        }
-    }
-
-    fn status(self) -> StatusCode {
-        match self {
-            Self::Ruptured { .. } => StatusCode::INTERNAL_SERVER_ERROR,
-            Self::Caught | Self::Opened | Self::Degloved | Self::Abandoned => StatusCode::GONE,
-            Self::Meloned => StatusCode::GONE,
-            Self::Banned => StatusCode::FORBIDDEN,
-            Self::Zip => StatusCode::CONFLICT,
-        }
-    }
-
-    pub fn problem(self) -> Problem {
-        Problem::new(self.status(), self.slug(), self.detail())
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum RunStatus {
-    Alive,
-    Prescribed,
-    /// The true ending, the clinic's `304`.
-    Normal,
-    Gone,
-}
-
-impl RunStatus {
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Alive => "alive",
-            Self::Prescribed => "prescribed",
-            Self::Normal => "normal",
-            Self::Gone => "gone",
-        }
-    }
-
-    pub fn finished(self) -> bool {
-        self != Self::Alive
-    }
-}
-
-pub struct Ending {
-    pub cause: Cause,
-    pub turn: u32,
-}
-
-pub struct Pending {
-    pub due: u32,
-    pub length: f64,
-    pub girth: f64,
-}

Modified file: src/game/techniques.rs+7 additions−82 deletions@@ -1,64 +1,6 @@
-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 fn modifier(self) -> i32 {
-        match self {
-            Self::BabyOil => 1,
-            Self::CoconutOil => 3,
-            Self::Lotion => 0,
-            Self::Vaseline => 2,
-            Self::Spit => -2,
-        }
-    }
-}
+use super::lube::LubeRule;
 
 /// Techniques that roll for gains.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -87,31 +29,14 @@ pub enum Technique {
     Utility(Utility),
 }
 
-#[derive(Clone, Copy)]
-pub enum LubeRule {
-    Required,
-    Forbidden,
-    Optional,
-}
-
-impl LubeRule {
-    fn name(self) -> &'static str {
-        match self {
-            Self::Required => "required",
-            Self::Forbidden => "forbidden",
-            Self::Optional => "optional",
-        }
-    }
-}
-
 pub struct Profile {
-    pub dc: i32,
-    pub length: f64,
-    pub girth: f64,
+    pub(crate) dc: i32,
+    pub(crate) length: f64,
+    pub(crate) girth: f64,
     /// Minimum and maximum foreskin the technique tolerates. A minimum above zero means it is used.
-    pub foreskin: Option<(f64, f64)>,
-    pub foreskin_growth: f64,
-    pub lube: LubeRule,
+    pub(crate) foreskin: Option<(f64, f64)>,
+    pub(crate) foreskin_growth: f64,
+    pub(crate) lube: LubeRule,
 }
 
 impl Training {

Added file: src/game/travel.rs+152 additions@@ -0,0 +1,152 @@
+use super::{
+    Cause, Elder, Floor, FloorState, Notice, Outcome, Run,
+    balance::{
+        EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, LOCKER_ROOM_BAR, LOCKER_ROOM_OTHERS,
+        LOCKER_ROOM_SHAME, STARTING_EQ, ZIP,
+    },
+    measure::round2,
+};
+use crate::problem::Problem;
+use axum::http::{StatusCode, header};
+use serde_json::{Value, json};
+
+/// How a floor was left. Only a proper exit is paid.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum Exit {
+    Proper,
+    Premature,
+}
+
+impl Run {
+    pub(super) fn next_floor(&mut self, exit: Exit) {
+        let Some(next) = self.floor.next() else {
+            return;
+        };
+        let warm = EQ_BAND.contains(&self.body.eq);
+        self.floor = next;
+        self.here = FloorState {
+            warm_arrival: warm,
+            ..FloorState::default()
+        };
+        self.body.warmed_up = false;
+        self.reset_eq(STARTING_EQ);
+        self.standing.suspicion = 0;
+        self.shed(FRICTION_FLOOR);
+        self.household.mum = None;
+        if self.floor == Floor::ChangingRoom && !self.holds_own_in_the_locker_room() {
+            self.standing.shame += LOCKER_ROOM_SHAME;
+            self.notices.push(Notice::KevIsTheBar);
+        }
+        if exit == Exit::Proper {
+            self.standing.cash += FLOOR_ALLOWANCE;
+        }
+        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.online.elder != Elder::Beaten => {
+                return Err(Problem::new(
+                    StatusCode::CONFLICT,
+                    "elder-unaddressed",
+                    "The Elder has not been addressed.",
+                )
+                .with("elder", self.path("/elder")));
+            }
+            floor if floor.timed() && self.here.turns < FLOOR_TURNS => {
+                return Err(Problem::new(
+                    StatusCode::TOO_EARLY,
+                    "floor-not-over",
+                    format!(
+                        "The floor is not over. {} turns remain.",
+                        FLOOR_TURNS - self.here.turns
+                    ),
+                ));
+            }
+            _ => {}
+        }
+        if self.chance(
+            self.decision(
+                "zip",
+                "As the floor ends and you put yourself away, does the zip catch?",
+            ),
+            ZIP,
+        ) {
+            return Err(self.end(Cause::Zip));
+        }
+        let left = self.floor.name();
+        let reverted = self.here.temp_length;
+        self.next_floor(Exit::Proper);
+        let warm = if self.here.warm_arrival {
+            ", and the warmth came with you"
+        } else {
+            ""
+        };
+        let mut body = json!({
+            "detail": format!("You leave {left}. You have arrived at {}{warm}.", self.floor.name()),
+            "note": self.floor.note(),
+        });
+        if reverted > 0.0 {
+            body["reverted"] = json!(round2(reverted));
+        }
+        Ok(
+            Outcome::json(StatusCode::SEE_OTHER, body)
+                .header(header::LOCATION, self.path("/floor")),
+        )
+    }
+
+    pub fn floor_view(&self) -> Value {
+        let mut view = json!({
+            "name": self.floor.name(),
+            "note": self.floor.note(),
+            "turns": self.here.turns,
+            "turns_required": self.floor.timed().then_some(FLOOR_TURNS),
+            "exit": { "href": self.path("/floor"), "method": "POST" },
+        });
+        match self.floor {
+            Floor::ChangingRoom => {
+                let others: Vec<Value> = LOCKER_ROOM_OTHERS
+                    .into_iter()
+                    .chain([("Kev", LOCKER_ROOM_BAR)])
+                    .map(|(name, length)| json!({ "name": name, "self_reported_length": length }))
+                    .collect();
+                view["others"] = json!(others);
+            }
+            Floor::Hotel => view["portal"] = json!(self.path("/portal")),
+            Floor::Forum => {
+                view["thread"] = json!(super::FORUM_THREAD);
+                view["elder"] = json!(self.path("/elder"));
+            }
+            Floor::Clinic => view["diagnosis"] = json!(self.path("/diagnosis")),
+            _ => {}
+        }
+        if self.floor.shop_open() {
+            view["shop"] = json!(self.path("/shop"));
+        }
+        view
+    }
+
+    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.here.wifi_accepted = true;
+        self.touch();
+        Ok(Outcome::json(
+            StatusCode::SEE_OTHER,
+            json!({ "detail": "Connected. The hotel does not want to know." }),
+        )
+        .header(header::LOCATION, self.path("")))
+    }
+}

Deleted file: src/game/turn.rs−785 deletions@@ -1,785 +0,0 @@
-use std::{fmt::Write as _, ops::ControlFlow};
-
-use axum::http::{StatusCode, header};
-use serde_json::json;
-
-use super::{
-    Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,
-    balance::{
-        ARRIVAL_BONUS, BAND_BONUS, BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, DANGER_EQ,
-        EQ_BAND, EQ_WOBBLE, EXTENDER_GAIN, FORESKIN_GLIDE, FRICTION_BURN, FRICTION_BURN_AT,
-        FRICTION_DRY, FRICTION_GRIP, FRICTION_HOLD, FRICTION_MAX, FRICTION_MEDITATE, FRICTION_SPIT,
-        GIRTH_THICK, GREED_HOT, GREED_WARM, HOLD_EQ, HOT_EQ, MEDITATION_EQ, OBSERVED, PRIAPISM_EQ,
-        PRIAPISM_TURNS, PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, REFLECTION, RING_PRIAPISM,
-        RING_RUPTURE_LINE, RING_TIGHT_PRIAPISM, RUPTURE_HOLD, RUPTURE_LINE, STORAGE_BULK,
-        SUSPICION_LIMIT,
-    },
-    not_extended, round3,
-    state::{MumVisit, Observer, Pending},
-    techniques::{LubeRule, Profile, Training, Utility},
-};
-use crate::{headers::SERVER_TIMING, problem::Problem};
-
-impl Run {
-    pub fn jelq(
-        &mut self,
-        techniques: &[Technique],
-        intensity: i32,
-        lube: Option<Lube>,
-    ) -> Result<Outcome, Problem> {
-        self.check_exhausted()?;
-        if self.story == Story::Pending {
-            return Ok(self.branch_offer());
-        }
-        if self.floor == Floor::Forum {
-            return Ok(Outcome::json(
-                StatusCode::SEE_OTHER,
-                json!({ "detail": "Refer to the forum." }),
-            )
-            .header(header::LOCATION, super::FORUM_THREAD));
-        }
-        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::Utility(utility)] => self.utility(utility, lube),
-            [Technique::Training(training)] => self.single(training, intensity, lube),
-            [Technique::Training(a), Technique::Training(b)] => self.combo(a, b, intensity, lube),
-            [_, _] => Err(Problem::new(
-                StatusCode::BAD_REQUEST,
-                "combo-invalid",
-                "Only training techniques can be combined.",
-            )),
-            _ => Err(Problem::new(
-                StatusCode::BAD_REQUEST,
-                "too-many-techniques",
-                "Two techniques at most. The server has limits even if you do not.",
-            )),
-        }
-    }
-
-    fn utility(&mut self, utility: Utility, lube: Option<Lube>) -> Result<Outcome, Problem> {
-        match utility {
-            Utility::Warmup => return self.warm_up(),
-            Utility::Ice => return self.ice(),
-            Utility::Supplement => return self.supplement(),
-            Utility::Meditate => return self.meditate(),
-            Utility::Energy => return self.energy(),
-            Utility::Edge | Utility::Pump => {}
-        }
-        self.ready(Technique::Utility(utility), lube)?;
-        self.check_storage()?;
-        self.floor_enemy()?;
-        match utility {
-            Utility::Edge => self.edge(),
-            _ => self.pump(),
-        }
-    }
-
-    fn single(
-        &mut self,
-        training: Training,
-        intensity: i32,
-        lube: Option<Lube>,
-    ) -> Result<Outcome, Problem> {
-        self.ready(Technique::Training(training), lube)?;
-        self.check_storage()?;
-        self.lube_available(lube)?;
-        self.floor_enemy()?;
-        self.take_lube(lube)?;
-        self.chafe(lube, intensity);
-        self.commit(intensity, lube, 1);
-        if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
-            return Ok(interrupted);
-        }
-        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {
-            return Ok(interrupted);
-        }
-        let outcome = self.roll(training, intensity, lube)?;
-        Ok(self.gossip(outcome))
-    }
-
-    fn combo(
-        &mut self,
-        a: Training,
-        b: Training,
-        intensity: i32,
-        lube: Option<Lube>,
-    ) -> Result<Outcome, Problem> {
-        if a == b {
-            return Err(Problem::new(
-                StatusCode::BAD_REQUEST,
-                "combo-invalid",
-                "A technique cannot be combined with itself. The server has checked.",
-            ));
-        }
-        self.ready(Technique::Training(a), lube)?;
-        self.ready(Technique::Training(b), lube)?;
-        self.check_storage()?;
-        self.lube_available(lube)?;
-        self.floor_enemy()?;
-        self.take_lube(lube)?;
-        self.chafe(lube, intensity);
-        self.chafe(lube, intensity);
-        self.commit(intensity, lube, 2);
-        for training in [a, b] {
-            if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {
-                return Ok(interrupted);
-            }
-        }
-        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {
-            return Ok(interrupted);
-        }
-
-        let mut statuses = Vec::new();
-        for training in [a, b] {
-            let result = self.roll(training, intensity, lube);
-            if self.ended.is_some() {
-                return result;
-            }
-            let status = match result {
-                Ok(outcome) => self.gossip(outcome).status,
-                Err(problem) => problem.status(),
-            };
-            statuses.push((training, status));
-        }
-
-        let mut xml = String::from(
-            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",
-        );
-        for (training, status) in statuses {
-            let _ = write!(
-                xml,
-                "  <D:response>\n    <D:href>{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",
-                self.path(""),
-                training.name(),
-                status.as_u16(),
-                crate::problem::reason(status),
-            );
-        }
-        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 ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {
-        self.access(technique)?;
-        match technique {
-            Technique::Training(training) => Self::check_lube(training, lube),
-            Technique::Utility(_) => Ok(()),
-        }
-    }
-
-    /// Whether the run could attempt the technique now, ignoring the lubricant.
-    fn access(&self, technique: Technique) -> Result<(), Problem> {
-        if technique == Technique::Training(Training::Uli) && !self.uli_taught {
-            return Err(Problem::new(
-                StatusCode::FORBIDDEN,
-                "technique-locked",
-                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not found the reply.",
-            ));
-        }
-        if !self.warmed_up {
-            return Err(Problem::new(
-                StatusCode::PRECONDITION_FAILED,
-                "cold-start",
-                "Warm-up was skipped. The server has noted this.",
-            )
-            .with("technique", Utility::Warmup.name()));
-        }
-        if matches!(technique, Technique::Training(_)) {
-            self.grip_closes(self.grip)?;
-        }
-        match technique {
-            Technique::Utility(Utility::Pump) if !self.items.pump_pro => Err(Problem::new(
-                StatusCode::FAILED_DEPENDENCY,
-                "no-pump",
-                "The pump technique depends on a pump.",
-            )),
-            Technique::Utility(_) => Ok(()),
-            Technique::Training(training) => match training.profile().foreskin {
-                Some((min, max)) => self.check_foreskin(min, max),
-                None => Ok(()),
-            },
-        }
-    }
-
-    fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {
-        match (training.profile().lube, lube) {
-            (LubeRule::Required, None) => Err(Problem::new(
-                StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                "lubricant-required",
-                format!(
-                    "The {} technique requires a lubricant. None was declared.",
-                    training.name()
-                ),
-            )
-            .with("lubricants", json!(LUBRICANTS))),
-            (LubeRule::Forbidden, Some(_)) => Err(Problem::new(
-                StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                "lubricant-declared",
-                format!(
-                    "The {} technique was requested. A lubricant was declared.",
-                    training.name()
-                ),
-            )),
-            _ => Ok(()),
-        }
-    }
-
-    /// One unit of whatever was declared. Spit is free and the tap is always on.
-    fn lube_available(&self, lube: Option<Lube>) -> Result<(), Problem> {
-        let (held, name) = match lube {
-            None | Some(Lube::Spit) => return Ok(()),
-            Some(Lube::BabyOil) => (&self.items.baby_oil, "baby-oil"),
-            Some(Lube::CoconutOil) => (&self.items.coconut_oil, "coconut-oil"),
-            Some(Lube::Lotion) => (&self.items.lotion, "lotion"),
-            Some(Lube::Vaseline) => (&self.items.vaseline, "vaseline"),
-        };
-        if *held == 0 {
-            return Err(Problem::new(
-                StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                "lubricant-exhausted",
-                format!("{name} was declared, but the bottle is empty."),
-            ));
-        }
-        Ok(())
-    }
-
-    fn take_lube(&mut self, lube: Option<Lube>) -> Result<(), Problem> {
-        self.lube_available(lube)?;
-        let held = match lube {
-            None | Some(Lube::Spit) => return Ok(()),
-            Some(Lube::BabyOil) => &mut self.items.baby_oil,
-            Some(Lube::CoconutOil) => &mut self.items.coconut_oil,
-            Some(Lube::Lotion) => &mut self.items.lotion,
-            Some(Lube::Vaseline) => &mut self.items.vaseline,
-        };
-        *held -= 1;
-        Ok(())
-    }
-
-    /// The techniques a JELQ could use right now without being refused before the roll.
-    pub fn techniques_now(&self) -> Vec<Technique> {
-        let blocked = !self.floor.timed() || self.items.cage || self.exhausted;
-        if blocked {
-            return Vec::new();
-        }
-        Technique::ALL
-            .into_iter()
-            .filter(|&technique| match technique {
-                Technique::Utility(Utility::Warmup) => true,
-                Technique::Utility(Utility::Ice) => self.items.ice_packs > 0,
-                Technique::Utility(Utility::Supplement) => self.items.supplements > 0,
-                Technique::Utility(Utility::Meditate) => !self.here.meditated,
-                Technique::Utility(Utility::Energy) => self.items.energy_drinks > 0,
-                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),
-            })
-            .collect()
-    }
-
-    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, self.path("/foreskin")));
-        };
-        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));
-        }
-        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));
-        }
-        Ok(())
-    }
-
-    fn check_storage(&self) -> Result<(), Problem> {
-        if self.items.extender && self.girth + self.current_length() / 4.0 > STORAGE_BULK {
-            return Err(Problem::new(
-                StatusCode::INSUFFICIENT_STORAGE,
-                "jeans-full",
-                "The jeans are full. The extender is occupying the remaining storage.",
-            )
-            .with("extender", self.path("/inventory/extender")));
-        }
-        Ok(())
-    }
-
-    pub(super) fn chafe(&mut self, lube: Option<Lube>, intensity: i32) {
-        let (base, slip) = match lube {
-            None => (FRICTION_DRY, 0),
-            Some(Lube::Spit) => (FRICTION_SPIT, 0),
-            Some(Lube::Lotion) => (0, 0),
-            Some(Lube::BabyOil | Lube::CoconutOil) => (0, 1),
-            Some(Lube::Vaseline) => (0, 2),
-        };
-        let vigour = match intensity {
-            ..=5 => 0,
-            6..=8 => 1,
-            _ => 2,
-        };
-        let unlubed = matches!(lube, None | Some(Lube::Spit));
-        let thick = i32::from(unlubed && self.girth > GIRTH_THICK);
-        let glide = i32::from(unlubed && self.foreskin.is_some_and(|f| f >= FORESKIN_GLIDE));
-        let mut friction = (base + vigour + thick - slip - glide).max(0);
-        if friction > 0 && self.jelq_grip.is_some_and(|grip| grip != self.grip) {
-            friction -= FRICTION_GRIP;
-        }
-        self.jelq_grip = Some(self.grip);
-        self.friction = (self.friction + friction).min(FRICTION_MAX);
-        if self.friction >= FRICTION_BURN_AT
-            && !self.conditions.friction_burn
-            && self.chance(
-                self.decision(
-                    "friction-burn",
-                    "With the skin this raw, has it finally burned?",
-                ),
-                FRICTION_BURN,
-            )
-        {
-            self.conditions.friction_burn = true;
-        }
-    }
-
-    pub(super) fn commit(&mut self, intensity: i32, lube: Option<Lube>, cost: i32) {
-        self.touch();
-        self.turn += 1;
-        self.here.turns += 1;
-        self.step_away();
-        self.realise();
-        if self.items.extender {
-            self.length += EXTENDER_GAIN;
-        }
-        self.stamina -= cost + i32::from(lube == Some(Lube::Lotion));
-        if self.stamina <= 0 {
-            self.exhaust();
-        }
-        let chill = if self.floor == Floor::ChangingRoom {
-            CHANGING_ROOM_CHILL
-        } else {
-            0
-        };
-        let wobble = self.oracle.span_int(
-            self.decision(
-                "wobble",
-                "How does the count drift on this stroke, up or down?",
-            ),
-            -EQ_WOBBLE,
-            EQ_WOBBLE,
-        );
-        self.eq = (self.eq + intensity * 2 - 6 - chill + wobble).clamp(0, 100);
-
-        let was_below = self.suspicion < SUSPICION_LIMIT;
-        self.make_noise(intensity / 5 + i32::from(lube == Some(Lube::Vaseline)));
-        if self.floor == Floor::Nans && lube == Some(Lube::CoconutOil) {
-            self.add_suspicion(2);
-        }
-
-        if intensity >= PULLED_MUSCLE_INTENSITY
-            && !self.conditions.pulled_muscle
-            && self.oracle.chance_not(
-                self.decision("pulled-muscle", "Do the muscles hold?"),
-                PULLED_MUSCLE,
-            )
-        {
-            self.conditions.pulled_muscle = true;
-            self.stamina = self.stamina.min(self.max_stamina());
-        }
-        self.settle(was_below);
-    }
-
-    pub(super) fn make_noise(&mut self, noise: i32) {
-        let doubled = match self.floor {
-            Floor::Nans => true,
-            Floor::ChangingRoom => !self.holds_own_in_the_locker_room(),
-            _ => false,
-        };
-        self.add_suspicion(if doubled { noise * 2 } else { noise });
-    }
-
-    fn add_suspicion(&mut self, amount: i32) {
-        self.suspicion =
-            u8::try_from((i32::from(self.suspicion) + amount).clamp(0, i32::from(SUSPICION_LIMIT)))
-                .unwrap_or(SUSPICION_LIMIT);
-    }
-
-    /// The part of a turn the house takes part in, whatever the action was.
-    pub(super) fn settle(&mut self, was_below: bool) {
-        self.maybe_summon_mum(was_below);
-        if let Some(observer) = self.floor.observer()
-            && self.chance(
-                self.decision("observed", "Has someone quietly noticed what is going on?"),
-                OBSERVED,
-            )
-        {
-            self.observed = Some(observer);
-            self.shame += 1;
-            if observer == Observer::Cat
-                && self.chance(
-                    self.decision("cat-takes-towel", "Has the cat taken the towel?"),
-                    CAT_TAKES_TOWEL,
-                )
-            {
-                self.here.towel_stolen = true;
-            }
-        }
-        if self.items.ring
-            && self.eq > HOT_EQ
-            && self.chance(
-                self.decision(
-                    "ring-priapism",
-                    "With the ring still on and everything this warm, will it not go down?",
-                ),
-                if self.girth > GIRTH_THICK {
-                    RING_TIGHT_PRIAPISM
-                } else {
-                    RING_PRIAPISM
-                },
-            )
-        {
-            self.conditions.priapism_turns = PRIAPISM_TURNS;
-        }
-        if self.conditions.priapism_turns > 0 {
-            self.conditions.priapism_turns -= 1;
-            self.eq = self.eq.max(PRIAPISM_EQ);
-        }
-        if self.turn == BRANCH_TURN && self.story == Story::Unopened {
-            self.story = Story::Pending;
-            self.notices
-                .push("Somewhere, a forum thread from 2009 still has replies.");
-        }
-    }
-
-    /// HOLD. A pause between strokes, offered when the band has been left or the stamina is gone.
-    pub fn can_hold(&self) -> bool {
-        self.eq > DANGER_EQ || self.stamina <= 2
-    }
-
-    pub fn hold(&mut self) -> Result<Outcome, Problem> {
-        if self.story == Story::Pending {
-            return Ok(self.branch_offer());
-        }
-        if self.items.cage {
-            return Err(Problem::new(
-                StatusCode::LOCKED,
-                "caged",
-                "The cage is locked. The key is not in the box.",
-            ));
-        }
-        self.touch();
-        self.turn += 1;
-        self.here.turns += 1;
-        self.realise();
-        if self.oracle.chance_not(
-            self.decision("rupture", "The pause is uneventful"),
-            RUPTURE_HOLD,
-        ) {
-            return Err(self.rupture());
-        }
-        let was_below = self.suspicion < SUSPICION_LIMIT;
-        if self.exhausted {
-            self.recover();
-            self.shed(FRICTION_HOLD);
-            self.settle(was_below);
-            let detail = if self.conditions.priapism_turns > 0 {
-                "The count went well past ten. Stamina is back. It went down a little. Maybe. You hope."
-            } else {
-                "The count went well past ten. Stamina is back. Everything else has gone quiet, and you are cold again."
-            };
-            return Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })));
-        }
-        if self.chance(
-            self.decision(
-                "reflection",
-                "In the quiet afterwards, have you caught your own eye in the mirror?",
-            ),
-            REFLECTION,
-        ) {
-            self.eq = 0;
-            self.shame += 1;
-            self.notices
-                .push("the count reached ten, and then the reflection started");
-        } else {
-            self.eq = (self.eq - HOLD_EQ).clamp(0, 100);
-        }
-        self.stamina = (self.stamina + 1).min(self.max_stamina());
-        self.shed(FRICTION_HOLD);
-        self.settle(was_below);
-        Ok(Outcome::empty(StatusCode::NO_CONTENT))
-    }
-
-    /// The breathing technique from the forum's replies. It spends no stamina and the turn is
-    /// not the floor's, but each floor allows it once.
-    fn meditate(&mut self) -> Result<Outcome, Problem> {
-        if self.here.meditated {
-            return Err(Problem::new(
-                StatusCode::CONFLICT,
-                "already-meditated",
-                "This floor has had its meditation.",
-            ));
-        }
-        self.here.meditated = true;
-        self.step_away();
-        self.reset_eq(self.eq - MEDITATION_EQ);
-        self.shed(FRICTION_MEDITATE);
-        self.touch();
-        Ok(Outcome::json(
-            StatusCode::OK,
-            json!({
-                "detail": "In through the nose, out through the mouth. EQ falls by ten.",
-            }),
-        ))
-    }
-
-    pub(super) fn maybe_summon_mum(&mut self, was_below: bool) {
-        if !self.floor.has_mum() || self.mum.is_some() {
-            return;
-        }
-        let summoned = was_below && self.suspicion == SUSPICION_LIMIT;
-        let mut visits = u32::from(self.suspicion) + 1;
-        if self.here.brother_told {
-            visits *= 2;
-        }
-        if summoned
-            || self.oracle.ratio(
-                self.decision(
-                    "mum-summon",
-                    "With this much noise in the house, is Mum on her way up?",
-                ),
-                visits,
-                super::balance::MUM_VISIT,
-            )
-        {
-            let errand = self.errand(summoned);
-            let nonce = self.fresh_nonce();
-            self.mum = Some(MumVisit {
-                errand,
-                nonce,
-                strikes: 0,
-                knocked: false,
-            });
-        }
-    }
-
-    fn roll(
-        &mut self,
-        training: Training,
-        intensity: i32,
-        lube: Option<Lube>,
-    ) -> Result<Outcome, Problem> {
-        let profile = training.profile();
-        let natural: i32 = self.oracle.span_int(
-            self.decision(
-                "natural",
-                "What does the twenty-sided die show for this technique?",
-            ),
-            1,
-            20,
-        );
-        let band = if EQ_BAND.contains(&self.eq) {
-            BAND_BONUS
-        } else {
-            0
-        };
-        let grip = match (self.grip, training) {
-            (Grip::Underhand, Training::Stretch) => 2,
-            (Grip::Underhand, Training::Wet) => -1,
-            _ => 0,
-        };
-        let arrival = if self.here.warm_arrival {
-            ARRIVAL_BONUS
-        } else {
-            0
-        };
-        let modifier = lube.map_or(0, Lube::modifier) + band + grip + arrival;
-        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 (length, girth) = self.scaled_gains(&profile, intensity);
-        let burn = self.burn();
-        let rupture_line = if self.items.ring {
-            RING_RUPTURE_LINE
-        } else {
-            RUPTURE_LINE
-        };
-
-        if natural == 1 {
-            return Err(timed(self.critical_failure(training, &profile)));
-        }
-        self.here.warm_arrival = false;
-        if natural == 2 && self.eq > DANGER_EQ - burn {
-            return Err(timed(self.rupture()));
-        }
-        if self.eq > rupture_line - burn && 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::PERMANENT_REDIRECT,
-                json!({
-                    "detail": "Your length has moved permanently.",
-                    "length": round3(length * 2.0),
-                    "girth": round3(girth * 2.0),
-                }),
-            )
-            .header(header::LOCATION, self.path("/length"))
-            .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 < *EQ_BAND.start() {
-            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.oracle.span_int(
-                self.decision("eta", "In how many turns will the queued gains arrive?"),
-                1,
-                4,
-            ) as u32;
-            self.pending.push(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 scaled_gains(&self, profile: &Profile, intensity: i32) -> (f64, f64) {
-        let scale = f64::from(intensity);
-        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
-        let greed = if self.eq > HOT_EQ {
-            GREED_HOT
-        } else if self.eq > DANGER_EQ {
-            GREED_WARM
-        } else {
-            1.0
-        };
-        length *= greed;
-        girth *= greed;
-        if self.here.teapot {
-            length *= 0.5;
-            girth *= 1.5;
-        }
-        if self.items.ring {
-            girth *= 2.0;
-        }
-        if self.conditions.friction_burn {
-            length *= 0.5;
-            girth *= 0.5;
-        }
-        (length, girth)
-    }
-
-    fn critical_failure(&mut self, training: Training, profile: &Profile) -> Problem {
-        let uses_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);
-        if uses_foreskin && self.foreskin.is_some() {
-            self.foreskin = None;
-            self.shame += 25;
-            return Problem::new(
-                StatusCode::GONE,
-                "foreskin-lost",
-                "The technique has removed the foreskin. It will not be returning.",
-            )
-            .header(header::CONTENT_LOCATION, self.path("/foreskin"));
-        }
-        if self.eq > DANGER_EQ - self.burn() {
-            return self.rupture();
-        }
-        if training == Training::Stretch && !self.here.teapot {
-            self.here.teapot = true;
-            self.items.teapot_spout = true;
-            self.shame += 5;
-            return 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 training == Training::Uli && !self.conditions.peyronie {
-            self.conditions.peyronie = true;
-            self.shame += 5;
-            return Problem::new(
-                StatusCode::MISDIRECTED_REQUEST,
-                "curvature",
-                "A curvature has developed. Techniques will land slightly to the left until a professional is consulted.",
-            );
-        }
-        not_extended()
-    }
-
-    fn gossip(&mut self, mut outcome: Outcome) -> Outcome {
-        let reportable = matches!(outcome.status.as_u16(), 200 | 202 | 206 | 308);
-        if !self.here.brother_told || !reportable {
-            return outcome;
-        }
-        self.here.brother_told = false;
-        outcome.status = StatusCode::ALREADY_REPORTED;
-        if let Payload::Json(body) = &mut outcome.payload {
-            body["detail"] = json!("Your brother has already told Mum.");
-        }
-        outcome
-    }
-}

Modified file: src/game/utility.rs+21 additions−21 deletions@@ -19,7 +19,7 @@ const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);
 
 impl Run {
     pub(super) fn warm_up(&mut self) -> Result<Outcome, Problem> {
-        if self.warmed_up && !self.here.kettle_boiled {
+        if self.body.warmed_up && !self.here.kitchen.kettle_boiled {
             return Err(Problem::new(
                 StatusCode::CONFLICT,
                 "towel-cold",
@@ -57,16 +57,16 @@ impl Run {
         };
         self.touch();
         self.step_away();
-        if self.warmed_up {
-            self.here.kettle_boiled = false;
+        if self.body.warmed_up {
+            self.here.kitchen.kettle_boiled = false;
         }
-        self.warmed_up = true;
-        self.eq = (self.eq + boost).min(100);
+        self.body.warmed_up = true;
+        self.body.eq = (self.body.eq + boost).min(100);
         Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })))
     }
 
     pub(super) fn ice(&mut self) -> Result<Outcome, Problem> {
-        if self.items.ice_packs == 0 {
+        if self.items.stores.ice_packs == 0 {
             return Err(Problem::new(
                 StatusCode::FAILED_DEPENDENCY,
                 "no-ice",
@@ -75,16 +75,16 @@ impl Run {
         }
         self.touch();
         self.step_away();
-        self.items.ice_packs -= 1;
-        if self.conditions.priapism_turns > 0 {
+        self.items.stores.ice_packs -= 1;
+        if self.body.conditions.priapism_turns > 0 {
             return Ok(Outcome::json(
                 StatusCode::OK,
                 json!({ "detail": "The ice has no effect. The condition persists. The ice pack is gone." }),
             ));
         }
-        self.eq = (self.eq - ICE_EQ).max(0);
-        let detail = if self.conditions.friction_burn {
-            self.conditions.friction_burn = false;
+        self.body.eq = (self.body.eq - ICE_EQ).max(0);
+        let detail = if self.body.conditions.friction_burn {
+            self.body.conditions.friction_burn = false;
             "The friction burn is treated. EQ has been reduced. The ice pack is gone."
         } else {
             "EQ has been reduced. The ice pack is gone."
@@ -93,16 +93,16 @@ impl Run {
     }
 
     pub(super) fn energy(&mut self) -> Result<Outcome, Problem> {
-        if self.items.energy_drinks == 0 {
+        if self.items.stores.energy_drinks == 0 {
             return Err(Problem::new(
                 StatusCode::FAILED_DEPENDENCY,
                 "no-energy-drink",
                 "The energy technique depends on an energy drink.",
             ));
         }
-        self.items.energy_drinks -= 1;
+        self.items.stores.energy_drinks -= 1;
         self.step_away();
-        self.stamina = (self.stamina + ENERGY_STAMINA).min(self.max_stamina());
+        self.body.stamina = (self.body.stamina + ENERGY_STAMINA).min(self.max_stamina());
         self.touch();
         Ok(Outcome::json(
             StatusCode::OK,
@@ -111,14 +111,14 @@ impl Run {
     }
 
     pub(super) fn supplement(&mut self) -> Result<Outcome, Problem> {
-        if self.items.supplements == 0 {
+        if self.items.stores.supplements == 0 {
             return Err(Problem::new(
                 StatusCode::FAILED_DEPENDENCY,
                 "no-supplement",
                 "The supplement technique depends on a supplement.",
             ));
         }
-        self.items.supplements -= 1;
+        self.items.stores.supplements -= 1;
         self.step_away();
         self.touch();
         if self.chance(
@@ -128,9 +128,9 @@ impl Run {
             ),
             SUPPLEMENT_WORKS,
         ) {
-            self.stamina = self.max_stamina();
-            self.conditions.priapism_turns = PRIAPISM_TURNS;
-            self.eq = self.eq.max(PRIAPISM_EQ);
+            self.body.stamina = self.max_stamina();
+            self.body.conditions.priapism_turns = PRIAPISM_TURNS;
+            self.body.eq = self.body.eq.max(PRIAPISM_EQ);
             return Ok(Outcome::json(
                 StatusCode::OK,
                 json!({ "detail": "The upstream returned a valid response. It is still returning it. Stamina is fully restored." }),
@@ -151,8 +151,8 @@ impl Run {
             return Ok(interrupted);
         }
         self.here.edges += 1;
-        self.eq = (self.eq + EDGE_EQ).min(100);
-        self.girth += EDGE_GIRTH;
+        self.body.eq = (self.body.eq + EDGE_EQ).min(100);
+        self.body.girth += EDGE_GIRTH;
         if self.here.edges >= EDGE_LOOP {
             self.here.edges = 0;
             self.exhaust();

Modified file: src/http/ctx.rs+41 additions−11 deletions@@ -1,4 +1,4 @@
-use std::{collections::HashMap, time::Instant};
+use std::{collections::HashMap, fmt::Write as _, time::Instant};
 
 use axum::{
     body::Bytes,
@@ -10,19 +10,19 @@ use hyper::upgrade::OnUpgrade;
 
 use crate::problem::Problem;
 
-const BODY_LIMIT: usize = 64 * 1024;
+pub const BODY_LIMIT: usize = 64 * 1024;
 
 /// Everything a handler may look at, gathered once per request.
 pub struct Ctx {
-    pub method: Method,
-    pub uri: Uri,
-    pub version: Version,
-    pub headers: HeaderMap,
-    pub query: HashMap<String, String>,
-    pub params: HashMap<String, String>,
-    pub body: Bytes,
-    pub now: Instant,
-    pub upgrade: Option<OnUpgrade>,
+    method: Method,
+    uri: Uri,
+    version: Version,
+    headers: HeaderMap,
+    query: HashMap<String, String>,
+    params: HashMap<String, String>,
+    body: Bytes,
+    now: Instant,
+    upgrade: Option<OnUpgrade>,
 }
 
 impl Ctx {
@@ -48,6 +48,36 @@ impl Ctx {
     pub fn query(&self, name: &str) -> Option<&str> {
         self.query.get(name).map(String::as_str)
     }
+
+    pub fn method(&self) -> &Method {
+        &self.method
+    }
+
+    pub fn body(&self) -> &[u8] {
+        &self.body
+    }
+
+    pub fn now(&self) -> Instant {
+        self.now
+    }
+
+    pub fn take_upgrade(&mut self) -> Option<OnUpgrade> {
+        self.upgrade.take()
+    }
+
+    /// The request as it arrived, which is what TRACE sends back.
+    pub fn echo(&self) -> String {
+        let mut message = format!("{} {} {:?}\r\n", self.method, self.uri, self.version);
+        for (name, value) in &self.headers {
+            let _ = write!(
+                message,
+                "{name}: {}\r\n",
+                value.to_str().unwrap_or("<binary>")
+            );
+        }
+        message.push_str("\r\n");
+        message
+    }
 }
 
 impl<S: Send + Sync> FromRequest<S> for Ctx {

Added file: src/http/inventory.rs+44 additions@@ -0,0 +1,44 @@
+use axum::{
+    Json,
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+use serde_json::json;
+
+use super::{ctx::Ctx, response::respond};
+use crate::{
+    game::{Item, Run},
+    problem::Problem,
+};
+
+pub(super) fn get_inventory(run: &mut Run, _: &Ctx) -> Response {
+    Json(run.inventory_view()).into_response()
+}
+
+pub(super) fn owned_item(run: &Run, ctx: &Ctx) -> Result<Item, Problem> {
+    Item::parse(ctx.param("item"))
+        .filter(|&item| run.holds(item))
+        .ok_or_else(|| {
+            Problem::new(
+                StatusCode::NOT_FOUND,
+                "no-such-item",
+                "You do not have that.",
+            )
+        })
+}
+
+pub(super) fn get_item(run: &mut Run, ctx: &Ctx) -> Response {
+    match owned_item(run, ctx) {
+        Ok(item) => {
+            Json(json!({ "name": item.slug(), "description": item.description() })).into_response()
+        }
+        Err(problem) => problem.into_response(),
+    }
+}
+
+pub(super) fn delete_item(run: &mut Run, ctx: &Ctx) -> Response {
+    match owned_item(run, ctx) {
+        Ok(item) => respond(run.drop_item(item)),
+        Err(problem) => problem.into_response(),
+    }
+}

Added file: src/http/leaderboard.rs+183 additions@@ -0,0 +1,183 @@
+//! The public listings, paged fifty at a time with RFC 8288 `next` and `prev` links.
+
+use axum::{
+    Json,
+    http::{StatusCode, header},
+    response::{IntoResponse, Response},
+};
+use serde_json::{Value, json};
+
+use super::{Shared, ctx::Ctx, run::records_unavailable};
+use crate::{
+    game::{balance::MM_PER_INCH, volume},
+    problem::{PROBLEM_BASE, Problem},
+    records::{Ranking, Record},
+};
+
+const PAGE: usize = 50;
+
+fn page(ctx: &Ctx) -> Result<usize, Problem> {
+    match ctx.query("page").map(str::parse::<usize>) {
+        None => Ok(1),
+        Some(Ok(page)) if page >= 1 => Ok(page),
+        Some(_) => Err(Problem::new(
+            StatusCode::BAD_REQUEST,
+            "bad-page",
+            "Pages are counted from 1.",
+        )),
+    }
+}
+
+/// `query` is everything but the page, already encoded, so the links keep the caller's sort.
+fn paged(body: Value, path: &str, query: &str, page: usize, full: bool) -> Response {
+    let link = |page: usize, rel: &str| {
+        let separator = if query.is_empty() { "" } else { "&" };
+        format!("<{path}?{query}{separator}page={page}>; rel=\"{rel}\"")
+    };
+    let mut links = Vec::new();
+    if page > 1 {
+        links.push(link(page - 1, "prev"));
+    }
+    if full {
+        links.push(link(page + 1, "next"));
+    }
+    let mut response = Json(body).into_response();
+    if links.is_empty() {
+        return response;
+    }
+    if let Ok(value) = links.join(", ").parse() {
+        response.headers_mut().insert(header::LINK, value);
+    }
+    response
+}
+
+pub fn graveyard(state: &mut Shared, ctx: &Ctx) -> Response {
+    let page = match page(ctx) {
+        Ok(page) => page,
+        Err(problem) => return problem.into_response(),
+    };
+    let dead = match state.records.dead((page - 1) * PAGE, PAGE) {
+        Ok(dead) => dead,
+        Err(error) => return records_unavailable(&error),
+    };
+    let full = dead.len() == PAGE;
+    let runs: Vec<Value> = dead
+        .into_iter()
+        .filter_map(|record| {
+            let cause = record.cause?;
+            Some(json!({
+                "public_id": record.public_id,
+                "cause": format!("{PROBLEM_BASE}{}", cause.slug()),
+                "detail": cause.detail(),
+                "turn": record.turn,
+            }))
+        })
+        .collect();
+    paged(json!({ "runs": runs }), "/graveyard", "", page, full)
+}
+
+fn ranking(state: &Shared, ctx: &Ctx) -> Result<Ranking, Problem> {
+    match ctx.query("sort") {
+        None | Some("self-reported-length") => Ok(Ranking::SelfReported),
+        Some("volume") => Ok(Ranking::Volume),
+        Some("content-length") => match ctx.cookie("ruler") {
+            Some(ruler) if state.config.secret.verify("ruler", ruler) == Some("1") => {
+                Ok(Ranking::ContentLength)
+            }
+            Some(_) => Err(Problem::new(
+                StatusCode::BAD_REQUEST,
+                "exaggeration",
+                "The server has measured. Lying is not a technique.",
+            )
+            .with("cookie", "ruler")),
+            None => Err(Problem::new(
+                StatusCode::FORBIDDEN,
+                "ruler-required",
+                "Sorting by the truth requires a Ruler.",
+            )),
+        },
+        Some(_) => Err(Problem::new(
+            StatusCode::BAD_REQUEST,
+            "unknown-sort",
+            "The leaderboard sorts by self-reported-length, volume or content-length.",
+        )),
+    }
+}
+
+fn score(ranking: Ranking, record: &Record) -> f64 {
+    match ranking {
+        Ranking::SelfReported => record.self_reported,
+        Ranking::ContentLength => record.length,
+        Ranking::Volume => volume(record.self_reported, record.girth),
+    }
+}
+
+fn entry(ranking: Ranking, record: &Record) -> Value {
+    let mut entry = json!({
+        "public_id": record.public_id,
+        "status": record.status.name(),
+        "floor": record.floor,
+        "self_reported_length": (record.self_reported * 100.0).round() / 100.0,
+        "ranked": !record.seeded,
+        "viral": record.viral,
+    });
+    match ranking {
+        Ranking::Volume => {
+            entry["volume"] = json!((score(ranking, record) * 100.0).round() / 100.0);
+        }
+        Ranking::ContentLength => {
+            entry["content_length"] = json!((record.length * MM_PER_INCH).round());
+        }
+        Ranking::SelfReported => {}
+    }
+    entry
+}
+
+/// Live runs are ranked alongside the recorded ones, and a live run outranks its own stale record.
+pub fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
+    let (ranking, page) = match ranking(state, ctx).and_then(|r| Ok((r, page(ctx)?))) {
+        Ok(parsed) => parsed,
+        Err(problem) => return problem.into_response(),
+    };
+    let seeded = ctx.query("seeded") == Some("include");
+    let mut entries: Vec<Record> = state
+        .runs
+        .each(Record::of)
+        .into_iter()
+        .filter(|record| seeded || !record.seeded)
+        .collect();
+    let wanted = page * PAGE;
+    match state
+        .records
+        .top(ranking, seeded, 0, wanted + entries.len())
+    {
+        Ok(recorded) => entries.extend(
+            recorded
+                .into_iter()
+                .filter(|record| !state.runs.contains(&record.id)),
+        ),
+        Err(error) => return records_unavailable(&error),
+    }
+    entries.sort_by(|a, b| score(ranking, b).total_cmp(&score(ranking, a)));
+    let full = entries.len() > wanted;
+    let listed: Vec<Value> = entries
+        .iter()
+        .skip(wanted - PAGE)
+        .take(PAGE)
+        .map(|record| entry(ranking, record))
+        .collect();
+    let mut query = Vec::new();
+    if let Some(sort) = ctx.query("sort") {
+        query.push(format!("sort={sort}"));
+    }
+    if seeded {
+        query.push("seeded=include".to_owned());
+    }
+    paged(
+        json!({ "entries": listed }),
+        "/leaderboard",
+        &query.join("&"),
+        page,
+        full,
+    )
+}

Added file: src/http/links.rs+122 additions@@ -0,0 +1,122 @@
+use std::fmt::Write as _;
+
+use super::{meta, run::RunResource, runs};
+use crate::game::{Branch, FORUM_THREAD, Run, SHOP};
+
+pub const REL_BASE: &str = "https://jelq.dev/rels/";
+
+/// One RFC 8288 link. `allow` and `lubricant` are extension attributes (§3), so a client never
+/// has to guess what a target accepts.
+struct Link<'a> {
+    href: &'a str,
+    rel: &'a str,
+    allow: &'a str,
+    title: Option<&'a str>,
+    lubricant: Option<&'a str>,
+}
+
+impl Link<'_> {
+    fn write(&self, out: &mut String) {
+        if !out.is_empty() {
+            out.push_str(", ");
+        }
+        let _ = write!(out, "<{}>; rel=\"{REL_BASE}{}\"", self.href, self.rel);
+        if let Some(title) = self.title {
+            let _ = write!(out, "; title=\"{title}\"");
+        }
+        let _ = write!(out, "; allow=\"{}\"", self.allow);
+        if let Some(rule) = self.lubricant {
+            let _ = write!(out, "; lubricant=\"{rule}\"");
+        }
+    }
+}
+
+pub fn header(run: &Run) -> String {
+    let reach = run.reach();
+    let mut out = String::new();
+    let resources: [(&str, &RunResource, bool); 15] = [
+        ("", &runs::RUN, true),
+        ("floor", &runs::FLOOR, true),
+        ("length", &runs::LENGTH, true),
+        ("foreskin", &runs::FORESKIN, reach.foreskin),
+        ("inventory", &runs::INVENTORY, true),
+        ("techniques", &runs::TECHNIQUES, true),
+        ("drawer", &runs::DRAWER, reach.drawer),
+        ("kitchen", &runs::KITCHEN, reach.kitchen),
+        ("re-read", &runs::REREAD, reach.thread),
+        ("grip", &runs::GRIP, true),
+        ("shop", &runs::SHOP, reach.shop),
+        ("portal", &runs::PORTAL, reach.portal),
+        ("elder", &runs::ELDER, reach.elder),
+        ("footage", &runs::FOOTAGE, reach.footage),
+        ("diagnosis", &runs::DIAGNOSIS, reach.diagnosis),
+    ];
+    for (rel, target, _) in resources.iter().filter(|(_, _, relevant)| *relevant) {
+        let href = if rel.is_empty() {
+            run.path("")
+        } else {
+            run.path(&format!("/{rel}"))
+        };
+        Link {
+            href: &href,
+            rel: if rel.is_empty() { "run" } else { rel },
+            allow: &target.resource.allow(run),
+            title: None,
+            lubricant: None,
+        }
+        .write(&mut out);
+    }
+    if reach.thread {
+        Link {
+            href: FORUM_THREAD,
+            rel: "thread",
+            allow: &meta::THREAD.allow_any(),
+            title: None,
+            lubricant: None,
+        }
+        .write(&mut out);
+    }
+    if reach.branch_pending {
+        for (branch, title) in [
+            (Branch::Forum, "Read the forum"),
+            (Branch::CloseTab, "Close the tab"),
+        ] {
+            Link {
+                href: &run.path(&format!("/branches/{}", branch.slug())),
+                rel: "branch",
+                allow: "POST",
+                title: Some(title),
+                lubricant: None,
+            }
+            .write(&mut out);
+        }
+    }
+    let run_path = run.path("");
+    for technique in run.techniques_now() {
+        let name = technique.name();
+        Link {
+            href: &format!("{run_path}?technique={name}"),
+            rel: "technique",
+            allow: "JELQ",
+            title: Some(name),
+            lubricant: technique.lubricant(),
+        }
+        .write(&mut out);
+    }
+    if reach.shopping {
+        for item in SHOP {
+            let Some(price) = run.price(item) else {
+                continue;
+            };
+            Link {
+                href: &run.path(&format!("/shop/{}", item.slug())),
+                rel: "shop-item",
+                allow: "POST",
+                title: Some(&format!("{} for {price}", item.slug())),
+                lubricant: None,
+            }
+            .write(&mut out);
+        }
+    }
+    out
+}

Modified file: src/http/meta.rs+22 additions−125 deletions@@ -6,23 +6,21 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use rand::Rng;
-use serde_json::{Value, json};
+use serde_json::json;
 
 use super::{
     Shared,
     ctx::Ctx,
+    leaderboard::{graveyard, leaderboard},
     resource::{Resource, Verb},
-    run,
+    run::{self, records_unavailable},
 };
 use crate::{
-    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, balance::MM_PER_INCH, forum_thread, volume},
+    game::{ELDER_LAST_MODIFIED, FORUM_THREAD, Run, forum_thread},
     headers::X_SEED,
-    problem::{PROBLEM_BASE, Problem},
-    records::Record,
+    problem::Problem,
 };
 
-use super::registry::hold;
-
 pub static INDEX: Resource<Shared> = Resource::new(&[Verb::new("GET", index)]);
 pub static RUNS: Resource<Shared> = Resource::new(&[Verb::new("POST", create_run)]);
 pub static THREAD: Resource<Shared> = Resource::new(&[Verb::new("GET", thread)]);
@@ -69,9 +67,6 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
         }
     };
     let config = &state.config;
-    for slot in state.runs.evict_idle(ctx.now, config.idle_ttl) {
-        state.records.save(&Record::of(&hold(&slot)));
-    }
     if state.runs.len() >= config.max_runs {
         return Problem::new(
             StatusCode::SERVICE_UNAVAILABLE,
@@ -81,21 +76,21 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
         .header(header::RETRY_AFTER, "600")
         .into_response();
     }
-    let id = loop {
+    let mut run = loop {
         let id = format!("{:032x}", rand::rng().random::<u128>());
-        if !state.runs.contains(&id) && state.records.find(&id).is_none() {
-            break id;
+        match state.records.find(&id) {
+            Ok(None) => {}
+            Ok(Some(_)) => continue,
+            Err(error) => return records_unavailable(&error),
         }
+        break Run::with_oracle(
+            id,
+            format!("{:08x}", rand::rng().random::<u32>()),
+            config.secret.mix_seed(seed),
+            seeded,
+            &config.oracle,
+        );
     };
-    let public_id = format!("{:08x}", rand::rng().random::<u32>());
-    let mut run = Run::with_oracle(
-        id.clone(),
-        public_id,
-        config.secret.mix_seed(seed),
-        &config.oracle,
-    );
-    run.seeded = seeded;
-    run.last_seen = ctx.now;
     let response = (
         StatusCode::CREATED,
         [
@@ -107,8 +102,11 @@ fn create_run(state: &mut Shared, ctx: &Ctx) -> Response {
     )
         .into_response();
     let response = run::finish(&mut run, ctx, &config.secret, response);
-    state.runs.insert(run);
-    response
+    if state.runs.insert_new(run) {
+        response
+    } else {
+        create_run(state, ctx)
+    }
 }
 
 fn thread(_: &mut Shared, ctx: &Ctx) -> Response {
@@ -135,107 +133,6 @@ fn thread(_: &mut Shared, ctx: &Ctx) -> Response {
     }
 }
 
-fn graveyard(state: &mut Shared, _: &Ctx) -> Response {
-    let dead: Vec<Value> = state
-        .records
-        .dead()
-        .into_iter()
-        .filter_map(|record| {
-            let ending = record.ending?;
-            Some(json!({
-                "public_id": record.public_id,
-                "cause": format!("{PROBLEM_BASE}{}", ending.cause),
-                "detail": ending.detail,
-                "turn": record.turn,
-            }))
-        })
-        .collect();
-    Json(json!({ "runs": dead })).into_response()
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Sort {
-    SelfReported,
-    ContentLength,
-    /// Self-reported length against real girth, the only metric the forum respects.
-    Volume,
-}
-
-fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
-    let sort = match ctx.query("sort") {
-        None | Some("self-reported-length") => Sort::SelfReported,
-        Some("volume") => Sort::Volume,
-        Some("content-length") => match ctx.cookie("ruler") {
-            Some(ruler) if state.config.secret.verify("ruler", ruler) == Some("1") => {
-                Sort::ContentLength
-            }
-            Some(_) => {
-                return Problem::new(
-                    StatusCode::BAD_REQUEST,
-                    "exaggeration",
-                    "The server has measured. Lying is not a technique.",
-                )
-                .with("cookie", "ruler")
-                .into_response();
-            }
-            None => {
-                return Problem::new(
-                    StatusCode::FORBIDDEN,
-                    "ruler-required",
-                    "Sorting by the truth requires a Ruler.",
-                )
-                .into_response();
-            }
-        },
-        Some(_) => {
-            return Problem::new(
-                StatusCode::BAD_REQUEST,
-                "unknown-sort",
-                "The leaderboard sorts by self-reported-length, volume or content-length.",
-            )
-            .into_response();
-        }
-    };
-    let include_seeded = ctx.query("seeded") == Some("include");
-    let mut entries: Vec<Record> = state.runs.each(Record::of);
-    entries.extend(
-        state
-            .records
-            .all()
-            .into_iter()
-            .filter(|record| !state.runs.contains(&record.id)),
-    );
-    entries.retain(|record| include_seeded || !record.seeded);
-    let key = |record: &Record| match sort {
-        Sort::SelfReported => record.self_reported,
-        Sort::ContentLength => record.length,
-        Sort::Volume => volume(record.self_reported, record.girth),
-    };
-    entries.sort_by(|a, b| key(b).total_cmp(&key(a)));
-    let entries: Vec<Value> = entries
-        .into_iter()
-        .map(|record| {
-            let mut entry = json!({
-                "public_id": record.public_id,
-                "status": record.status,
-                "floor": record.floor,
-                "self_reported_length": (record.self_reported * 100.0).round() / 100.0,
-                "ranked": !record.seeded,
-                "viral": record.viral,
-            });
-            if sort == Sort::Volume {
-                entry["volume"] =
-                    json!((volume(record.self_reported, record.girth) * 100.0).round() / 100.0);
-            }
-            if sort == Sort::ContentLength {
-                entry["content_length"] = json!((record.length * MM_PER_INCH).round());
-            }
-            entry
-        })
-        .collect();
-    Json(json!({ "entries": entries })).into_response()
-}
-
 pub async fn not_found() -> Problem {
     Problem::new(
         StatusCode::NOT_FOUND,

Modified file: src/http/middleware.rs+10 additions−3 deletions@@ -19,6 +19,9 @@ use crate::{
 
 const MAX_URI: usize = 512;
 const MAX_HEADER: usize = 1024;
+const MAX_HEADERS: usize = 64;
+/// Responses are re-read to be translated or gzipped. The listings are paged, so none comes close.
+const BUFFER_LIMIT: usize = 1 << 20;
 
 /// Marks a response for gzip, which the cock ring asks for.
 #[derive(Clone)]
@@ -39,7 +42,11 @@ fn reject(request: &Request) -> Option<Problem> {
             "The URI is longer than anything else here.",
         ));
     }
-    if request.headers().values().any(|v| v.len() > MAX_HEADER) {
+    let headers = request.headers();
+    let oversized = headers
+        .iter()
+        .any(|(name, value)| name.as_str().len() + value.len() > MAX_HEADER);
+    if oversized || headers.len() > MAX_HEADERS {
         return Some(Problem::new(
             StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,
             "head-too-large",
@@ -74,7 +81,7 @@ async fn compress(response: Response) -> Response {
         return response;
     }
     let (mut parts, body) = response.into_parts();
-    let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
+    let Ok(bytes) = axum::body::to_bytes(body, BUFFER_LIMIT).await else {
         return Response::from_parts(parts, Body::empty());
     };
     let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
@@ -122,7 +129,7 @@ async fn localise(response: Response, locale: Locale) -> Response {
     if !json || parts.status == StatusCode::PARTIAL_CONTENT {
         return Response::from_parts(parts, body);
     }
-    let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
+    let Ok(bytes) = axum::body::to_bytes(body, BUFFER_LIMIT).await else {
         return Response::from_parts(parts, Body::empty());
     };
     let Ok(mut value) = serde_json::from_slice::<Value>(&bytes) else {

Modified file: src/http/mod.rs+48 additions−17 deletions@@ -1,14 +1,23 @@
 mod ctx;
+mod inventory;
+mod leaderboard;
+mod links;
 mod meta;
 mod middleware;
+mod parse;
 mod registry;
 mod resource;
 mod response;
 mod run;
 mod runs;
+mod shaft;
+mod shame;
 mod ui;
 
-use std::sync::Arc;
+use std::{
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use axum::{
     Router,
@@ -19,9 +28,12 @@ use axum::{
 
 use tower_http::catch_panic::CatchPanicLayer;
 
-use crate::{config::Config, records::Records};
+use crate::{
+    config::Config,
+    records::{Record, Records},
+};
 use ctx::Ctx;
-use registry::Registry;
+use registry::{Lock, Registry};
 use resource::Resource;
 use run::RunResource;
 
@@ -32,36 +44,58 @@ pub struct AppState {
 }
 
 impl AppState {
-    pub fn new(config: Config) -> Self {
+    pub fn new(config: Config) -> rusqlite::Result<Self> {
         let records = match &config.db {
-            Some(path) => Records::open(path).unwrap_or_else(|e| {
-                panic!("the records at {} could not be opened: {e}", path.display())
-            }),
+            Some(path) => Records::open(path)?,
             None => Records::in_memory(),
         };
-        Self {
+        Ok(Self {
             runs: Registry::default(),
             records,
             config,
+        })
+    }
+
+    /// Records and forgets the runs that have gone idle. The server calls it on a timer.
+    pub fn sweep(&self, now: Instant) -> rusqlite::Result<()> {
+        for slot in self.runs.evict_idle(now, self.config.idle_ttl) {
+            let record = match Lock::take(&slot) {
+                Lock::Held(run) | Lock::Poisoned(run) => Record::of(&run),
+            };
+            self.records.save(&record)?;
         }
+        Ok(())
     }
 
     #[cfg(test)]
     pub(crate) fn insert(&self, run: crate::game::Run) {
-        self.runs.insert(run);
+        self.runs.insert_new(run);
     }
 }
 
 impl Default for AppState {
     fn default() -> Self {
-        Self::new(Config::default())
+        Self::new(Config::default()).expect("an in-memory database always opens")
     }
 }
 
 type Shared = Arc<AppState>;
 
-pub fn app(config: Config) -> Router {
-    router(Arc::new(AppState::new(config)))
+pub fn app(config: Config) -> rusqlite::Result<Router> {
+    Ok(router(Arc::new(AppState::new(config)?)))
+}
+
+/// Sweeps idle runs into the records every minute, so a quiet server still keeps its graveyard.
+pub async fn sweep_forever(state: Arc<AppState>) {
+    let mut ticks = tokio::time::interval(Duration::from_secs(60));
+    loop {
+        ticks.tick().await;
+        let swept = Arc::clone(&state);
+        let result = tokio::task::spawn_blocking(move || swept.sweep(Instant::now())).await;
+        if let Ok(Err(error)) = result {
+            eprintln!("jelqd could not sweep idle runs into the records: {error}");
+        }
+    }
 }
 
 pub fn router(state: Shared) -> Router {
@@ -87,15 +121,12 @@ fn scoped(resource: &'static RunResource) -> MethodRouter<Shared> {
     })
 }
 
-/// The model oracle blocks on HTTP for every roll, so its turns run on the blocking pool and
-/// leave the async workers free. Dice are quick enough to roll in place.
+/// Game turns block, on SQLite always and on HTTP for every roll under the model oracle, so they
+/// run on the blocking pool and leave the async workers free.
 async fn offload<F>(state: Shared, work: F) -> Response
 where
     F: FnOnce(Shared) -> Response + Send + 'static,
 {
-    if !state.config.oracle.blocks() {
-        return work(state);
-    }
     tokio::task::spawn_blocking(move || work(state))
         .await
         .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic()))

Added file: src/http/parse.rs+49 additions@@ -0,0 +1,49 @@
+use axum::http::StatusCode;
+
+use super::ctx::Ctx;
+use crate::{
+    game::{Run, Technique},
+    problem::Problem,
+};
+
+pub(super) fn parse_techniques(run: &Run, ctx: &Ctx) -> Result<Vec<Technique>, Problem> {
+    let required = || {
+        Problem::new(
+            StatusCode::BAD_REQUEST,
+            "technique-required",
+            "No technique was specified.",
+        )
+        .with("techniques", run.path("/techniques"))
+    };
+    let names = ctx
+        .query("technique")
+        .filter(|n| !n.trim().is_empty())
+        .ok_or_else(required)?;
+    names
+        .split(',')
+        .map(str::trim)
+        .filter(|n| !n.is_empty())
+        .map(|name| {
+            Technique::parse(name).ok_or_else(|| {
+                Problem::new(
+                    StatusCode::BAD_REQUEST,
+                    "unknown-technique",
+                    format!("{name} is not a technique."),
+                )
+                .with("techniques", run.path("/techniques"))
+            })
+        })
+        .collect()
+}
+
+pub(super) fn parse_intensity(ctx: &Ctx) -> Result<i32, Problem> {
+    match ctx.query("intensity").map(str::parse::<i32>) {
+        None => Ok(5),
+        Some(Ok(i)) if (1..=10).contains(&i) => Ok(i),
+        Some(_) => Err(Problem::new(
+            StatusCode::BAD_REQUEST,
+            "intensity-out-of-range",
+            "Intensity is measured from 1 to 10.",
+        )),
+    }
+}

Modified file: src/http/registry.rs+52 additions−26 deletions@@ -1,9 +1,13 @@
 //! The live runs. The table is only locked long enough to find a run, and each run has its own
-//! lock, so one slow turn never holds up anyone else's.
+//! lock, so one slow turn never holds up anyone else's. Nothing ever waits on a run's lock while
+//! holding the table's, which is what keeps the two from deadlocking.
 
 use std::{
-    collections::HashMap,
-    sync::{Arc, Mutex, MutexGuard, PoisonError, RwLock, TryLockError},
+    collections::{HashMap, hash_map::Entry},
+    sync::{
+        Arc, Mutex, MutexGuard, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard,
+        TryLockError,
+    },
     time::{Duration, Instant},
 };
 
@@ -16,9 +20,27 @@ pub struct Registry {
     runs: RwLock<HashMap<String, Slot>>,
 }
 
-/// A panic mid-request must not take the run down with it, so a poisoned lock is recovered.
-pub fn hold(slot: &Slot) -> MutexGuard<'_, Run> {
-    slot.lock().unwrap_or_else(PoisonError::into_inner)
+/// A run's lock as it was found. A panic mid-turn poisons it, and that run cannot be trusted.
+pub enum Lock<'a> {
+    Held(MutexGuard<'a, Run>),
+    Poisoned(MutexGuard<'a, Run>),
+}
+
+impl<'a> Lock<'a> {
+    pub fn take(slot: &'a Slot) -> Self {
+        match slot.lock() {
+            Ok(run) => Self::Held(run),
+            Err(poisoned) => Self::Poisoned(poisoned.into_inner()),
+        }
+    }
+}
+
+fn peek(slot: &Slot) -> Option<MutexGuard<'_, Run>> {
+    match slot.try_lock() {
+        Ok(run) => Some(run),
+        Err(TryLockError::Poisoned(poisoned)) => Some(poisoned.into_inner()),
+        Err(TryLockError::WouldBlock) => None,
+    }
 }
 
 impl Registry {
@@ -30,48 +52,52 @@ impl Registry {
         self.read().len()
     }
 
-    pub fn insert(&self, run: Run) {
-        let id = run.id.clone();
-        self.write().insert(id, Arc::new(Mutex::new(run)));
+    pub fn contains(&self, id: &str) -> bool {
+        self.read().contains_key(id)
     }
 
-    pub fn remove(&self, id: &str) {
-        self.write().remove(id);
+    /// Refuses to replace a live run, so a colliding id can never evict one.
+    pub fn insert_new(&self, run: Run) -> bool {
+        match self.write().entry(run.id().to_owned()) {
+            Entry::Occupied(_) => false,
+            Entry::Vacant(slot) => {
+                slot.insert(Arc::new(Mutex::new(run)));
+                true
+            }
+        }
     }
 
-    pub fn contains(&self, id: &str) -> bool {
-        self.read().contains_key(id)
+    pub fn remove(&self, id: &str) {
+        self.write().remove(id);
     }
 
-    /// Every live run, each visited under its own lock.
+    /// Every live run not mid-turn. A busy run is skipped rather than waited for.
     pub fn each<T>(&self, mut visit: impl FnMut(&Run) -> T) -> Vec<T> {
         let slots: Vec<Slot> = self.read().values().cloned().collect();
-        slots.iter().map(|slot| visit(&hold(slot))).collect()
+        slots
+            .iter()
+            .filter_map(|slot| peek(slot).map(|run| visit(&run)))
+            .collect()
     }
 
-    /// Takes out the runs nobody has touched for `ttl`, and hands them back for the record.
     pub fn evict_idle(&self, now: Instant, ttl: Duration) -> Vec<Slot> {
-        let mut runs = self.write();
-        let idle: Vec<String> = runs
+        let idle: Vec<String> = self
+            .read()
             .iter()
             .filter(|(_, slot)| {
-                let idle = |run: &Run| now.duration_since(run.last_seen) >= ttl;
-                match slot.try_lock() {
-                    Ok(run) => idle(&run),
-                    Err(TryLockError::Poisoned(poisoned)) => idle(&poisoned.into_inner()),
-                    Err(TryLockError::WouldBlock) => false,
-                }
+                peek(slot).is_some_and(|run| now.duration_since(run.last_seen()) >= ttl)
             })
             .map(|(id, _)| id.clone())
             .collect();
+        let mut runs = self.write();
         idle.iter().filter_map(|id| runs.remove(id)).collect()
     }
 
-    fn read(&self) -> std::sync::RwLockReadGuard<'_, HashMap<String, Slot>> {
+    fn read(&self) -> RwLockReadGuard<'_, HashMap<String, Slot>> {
         self.runs.read().unwrap_or_else(PoisonError::into_inner)
     }
 
-    fn write(&self) -> std::sync::RwLockWriteGuard<'_, HashMap<String, Slot>> {
+    fn write(&self) -> RwLockWriteGuard<'_, HashMap<String, Slot>> {
         self.runs.write().unwrap_or_else(PoisonError::into_inner)
     }
 }

Modified file: src/http/resource.rs+28 additions−5 deletions@@ -15,6 +15,14 @@ pub type Handler<T> = fn(&mut T, &Ctx) -> Response;
 /// A predicate for when a method is available, and the refusal when it is not.
 type Guard<T> = (fn(&T) -> bool, &'static str);
 
+fn never<T>(_: &T) -> bool {
+    false
+}
+
+fn unanswered<T>(_: &mut T, _: &Ctx) -> Response {
+    StatusCode::METHOD_NOT_ALLOWED.into_response()
+}
+
 pub struct Verb<T: 'static> {
     method: &'static str,
     handle: Handler<T>,
@@ -30,7 +38,15 @@ impl<T> Verb<T> {
         }
     }
 
-    /// Makes the method available only while `available` holds, refusing with `refusal` otherwise.
+    /// A method named only to be refused, so that its `405` can say why.
+    pub const fn refused(method: &'static str, refusal: &'static str) -> Self {
+        Self {
+            method,
+            handle: unanswered::<T>,
+            guard: Some((never::<T>, refusal)),
+        }
+    }
+
     pub const fn only_when(self, available: fn(&T) -> bool, refusal: &'static str) -> Self {
         Self {
             guard: Some((available, refusal)),
@@ -45,8 +61,8 @@ impl<T> Verb<T> {
 
 /// The methods a resource supports. `Allow`, `OPTIONS` and `405` are all derived from this list.
 pub struct Resource<T: 'static> {
-    pub verbs: &'static [Verb<T>],
-    pub accept_patch: bool,
+    verbs: &'static [Verb<T>],
+    accept_patch: bool,
 }
 
 impl<T> Resource<T> {
@@ -57,6 +73,13 @@ impl<T> Resource<T> {
         }
     }
 
+    pub const fn patchable(verbs: &'static [Verb<T>]) -> Self {
+        Self {
+            verbs,
+            accept_patch: true,
+        }
+    }
+
     pub fn allow(&self, target: &T) -> String {
         Self::listed(self.verbs.iter().filter(|verb| verb.available(target)))
     }
@@ -79,7 +102,7 @@ impl<T> Resource<T> {
     }
 
     pub fn dispatch(&self, target: &mut T, ctx: &Ctx) -> Response {
-        let requested = ctx.method.as_str();
+        let requested = ctx.method().as_str();
         let lookup = if requested == "HEAD" {
             "GET"
         } else {
@@ -92,7 +115,7 @@ impl<T> Resource<T> {
                 method_not_allowed(refusal.to_owned(), &self.allow(target))
             }
             None if requested == "OPTIONS" => options(&self.allow(target), self.accept_patch),
-            None => unsupported(&ctx.method, &self.allow(target)),
+            None => unsupported(ctx.method(), &self.allow(target)),
         }
     }
 }

Modified file: src/http/response.rs+8 additions−7 deletions@@ -8,14 +8,15 @@ use crate::game::{Outcome, Payload};
 
 impl IntoResponse for Outcome {
     fn into_response(self) -> Response {
-        let mut response = match self.payload {
+        let (status, payload, extra) = self.into_parts();
+        let mut response = match 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 => {
+            Payload::Json(body) if status == StatusCode::PARTIAL_CONTENT => {
                 let full = body.to_string().into_bytes();
                 let half = full.len() / 2;
                 let range = format!("bytes 0-{}/{}", half.saturating_sub(1), full.len());
                 (
-                    self.status,
+                    status,
                     [
                         (header::CONTENT_TYPE, "application/json".to_owned()),
                         (header::CONTENT_RANGE, range),
@@ -24,14 +25,14 @@ impl IntoResponse for Outcome {
                 )
                     .into_response()
             }
-            Payload::Json(body) => (self.status, Json(body)).into_response(),
+            Payload::Json(body) => (status, Json(body)).into_response(),
             Payload::Raw(content_type, body) => {
-                (self.status, [(header::CONTENT_TYPE, content_type)], body).into_response()
+                (status, [(header::CONTENT_TYPE, content_type)], body).into_response()
             }
-            Payload::Empty => self.status.into_response(),
+            Payload::Empty => status.into_response(),
         };
         let headers = response.headers_mut();
-        for (name, value) in self.headers {
+        for (name, value) in extra {
             if let Ok(value) = HeaderValue::from_str(&value) {
                 headers.append(name, value);
             }

Modified file: src/http/run.rs+89 additions−175 deletions@@ -8,12 +8,12 @@ use hyper_util::rt::TokioIo;
 use tokio::io::AsyncWriteExt;
 
 use super::{
-    AppState, ctx::Ctx, meta, middleware::Compress, registry::hold, resource::Resource, runs,
+    AppState, ctx::Ctx, links, middleware::Compress, registry::Lock, resource::Resource, shame,
 };
 use crate::{
     game::{
-        Elder, FORUM_THREAD, Floor, Run, SHOP, Story,
-        balance::{FRICTION_MAX, KITCHEN_TELLINGS, SUSPICION_LIMIT},
+        Cause, Gauges, Run, Shown,
+        balance::{FRICTION_MAX, SUSPICION_LIMIT},
     },
     headers::{
         X_CASH, X_EQ, X_FLOOR, X_FORESKIN, X_FRICTION, X_GIRTH, X_LENGTH, X_OBSERVED_BY,
@@ -25,8 +25,6 @@ use crate::{
     secret::Secret,
 };
 
-pub const REL_BASE: &str = "https://jelq.dev/rels/";
-const COOKIE_ATTRIBUTES: &str = "Max-Age=31536000; Path=/; HttpOnly; SameSite=Strict";
 /// Which household hazards stand between a request and the run.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Scope {
@@ -43,40 +41,59 @@ pub struct RunResource {
 #[derive(Clone)]
 pub struct Greeting(pub String);
 
+pub fn records_unavailable(error: &rusqlite::Error) -> Response {
+    Problem::new(
+        StatusCode::SERVICE_UNAVAILABLE,
+        "records-unavailable",
+        "The records are unavailable. Nothing has been forgotten, it is only out of reach.",
+    )
+    .with("error", error.to_string())
+    .into_response()
+}
+
 pub fn serve(state: &AppState, mut ctx: Ctx, target: &RunResource) -> Response {
     let id = ctx.param("id").to_owned();
     let Some(slot) = state.runs.get(&id) else {
         return match state.records.find(&id) {
-            Some(Record {
-                ending: Some(ending),
+            Ok(Some(Record {
+                cause: Some(cause),
                 turn,
                 ..
-            }) => gone(&ending.cause, turn),
-            _ => Problem::new(
+            })) => gone(cause.slug(), turn),
+            Ok(_) => Problem::new(
                 StatusCode::NOT_FOUND,
                 "no-such-run",
                 "There is no such run. There may never have been.",
             )
             .into_response(),
+            Err(error) => records_unavailable(&error),
         };
     };
-    let mut guard = hold(&slot);
-    let run = &mut *guard;
-    if let Some(ending) = &run.ended {
-        return gone(ending.cause.slug(), ending.turn);
-    }
-    run.last_seen = ctx.now;
-    run.observed = None;
-    let response =
-        gate(run, &ctx, target.scope).unwrap_or_else(|| target.resource.dispatch(run, &ctx));
-    let response = finish(run, &ctx, &state.config.secret, response);
-    if run.status().finished() {
-        state.records.save(&Record::of(run));
-    }
-    let ended = run.ended.is_some();
-    drop(guard);
-    if ended {
-        state.runs.remove(&id);
+    let (response, record) = match Lock::take(&slot) {
+        Lock::Poisoned(mut run) => {
+            run.lose();
+            let response = gone(Cause::Lost.slug(), run.turn);
+            (response, Some(Record::of(&run)))
+        }
+        Lock::Held(mut run) => {
+            if let Some(ending) = &run.ended {
+                return gone(ending.cause.slug(), ending.turn);
+            }
+            run.seen(ctx.now());
+            let response = gate(&mut run, &ctx, target.scope)
+                .unwrap_or_else(|| target.resource.dispatch(&mut run, &ctx));
+            let response = finish(&mut run, &ctx, &state.config.secret, response);
+            let record = run.status().finished().then(|| Record::of(&run));
+            (response, record)
+        }
+    };
+    if let Some(record) = record {
+        if let Err(error) = state.records.save(&record) {
+            return records_unavailable(&error);
+        }
+        if record.cause.is_some() {
+            state.runs.remove(&id);
+        }
     }
     greet(response, &mut ctx)
 }
@@ -93,7 +110,7 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
     if scope == Scope::Pockets {
         return None;
     }
-    if run.floor == Floor::Hotel && !run.here.wifi_accepted {
+    if run.needs_portal() {
         let portal = run.path("/portal");
         return Some(
             Problem::new(
@@ -102,7 +119,10 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
                 "The network requires authentication. The hotel would like you to agree to some terms.",
             )
             .with("portal", portal.as_str())
-            .header(header::LINK, format!("<{portal}>; rel=\"{REL_BASE}portal\""))
+            .header(
+                header::LINK,
+                format!("<{portal}>; rel=\"{}portal\"", links::REL_BASE),
+            )
             .into_response(),
         );
     }
@@ -114,174 +134,68 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
         .map(IntoResponse::into_response)
 }
 
-/// Every resource the run can reach right now, then every technique a JELQ could use. The `allow`
-/// and `lubricant` extension attributes (RFC 8288 §3) say what each accepts, so a client never guesses.
-fn links(run: &Run) -> String {
-    let thread_reachable = run.thread_reachable();
-    let linked: [(&str, &RunResource, bool); 15] = [
-        ("", &runs::RUN, true),
-        ("floor", &runs::FLOOR, true),
-        ("length", &runs::LENGTH, true),
-        ("foreskin", &runs::FORESKIN, run.foreskin.is_some()),
-        ("inventory", &runs::INVENTORY, true),
-        ("techniques", &runs::TECHNIQUES, true),
-        ("drawer", &runs::DRAWER, run.drawer_worth_searching()),
-        ("kitchen", &runs::KITCHEN, {
-            run.floor.has_kitchen() && run.kitchen_tellings < KITCHEN_TELLINGS
-        }),
-        ("re-read", &runs::REREAD, thread_reachable),
-        ("grip", &runs::GRIP, true),
-        ("shop", &runs::SHOP, run.floor.shop_open()),
+fn stats(gauges: &Gauges, shame: u32) -> Vec<(HeaderName, String)> {
+    let mut stats = vec![
+        match gauges.length {
+            Shown::Measured(length) => (X_LENGTH, format!("{length:.2}")),
+            Shown::SelfReported(length) => (X_SELF_REPORTED_LENGTH, format!("{length:.2}")),
+        },
+        (X_GIRTH, format!("{:.2}", gauges.girth)),
         (
-            "portal",
-            &runs::PORTAL,
-            run.floor == Floor::Hotel && !run.here.wifi_accepted,
+            X_FORESKIN,
+            gauges.foreskin.map_or("gone".into(), |f| format!("{f:.2}")),
         ),
+        (X_FRICTION, format!("{}/{FRICTION_MAX}", gauges.friction)),
+        (X_EQ, gauges.eq.to_string()),
         (
-            "elder",
-            &runs::ELDER,
-            run.floor == Floor::Forum && run.elder != Elder::Beaten,
+            X_STAMINA,
+            format!("{}/{}", gauges.stamina, gauges.max_stamina),
         ),
-        ("footage", &runs::FOOTAGE, run.filmed_at.is_some()),
-        ("diagnosis", &runs::DIAGNOSIS, run.floor == Floor::Clinic),
-    ];
-    linked
-        .into_iter()
-        .filter(|(_, _, relevant)| *relevant)
-        .map(|(rel, target, _)| {
-            let (path, name) = if rel.is_empty() {
-                (run.path(""), "run")
-            } else {
-                (run.path(&format!("/{rel}")), rel)
-            };
-            let allow = target.resource.allow(run);
-            format!("<{path}>; rel=\"{REL_BASE}{name}\"; allow=\"{allow}\"")
-        })
-        .chain(thread_reachable.then(|| {
-            format!(
-                "<{FORUM_THREAD}>; rel=\"{REL_BASE}thread\"; allow=\"{}\"",
-                meta::THREAD.allow_any()
-            )
-        }),)
-        .chain((run.story == Story::Pending).then(|| {
-            let choice = |slug: &str, title: &str| {
-                format!(
-                    "<{}>; rel=\"{REL_BASE}branch\"; title=\"{title}\"; allow=\"POST\"",
-                    run.path(&format!("/branches/{slug}"))
-                )
-            };
-            [choice("forum", "Read the forum"), choice("close-tab", "Close the tab")].join(", ")
-        }))
-        .chain(run.techniques_now().into_iter().map(|technique| {
-            let name = technique.name();
-            let lubricant = technique
-                .lubricant()
-                .map_or(String::new(), |rule| format!("; lubricant=\"{rule}\""));
-            format!(
-                "<{}?technique={name}>; rel=\"{REL_BASE}technique\"; title=\"{name}\"; allow=\"JELQ\"{lubricant}",
-                run.path("")
-            )
-        }))
-        .chain(run.here.shopping.then(|| {
-            SHOP.iter()
-                .filter_map(|item| {
-                    let price = run.price(*item)?;
-                    Some(format!(
-                        "<{}>; rel=\"{REL_BASE}shop-item\"; title=\"{} for {price}\"; allow=\"POST\"",
-                        run.path(&format!("/shop/{}", item.slug())),
-                        item.slug()
-                    ))
-                })
-                .collect::<Vec<_>>()
-                .join(", ")
-        }))
-        .collect::<Vec<_>>()
-        .join(", ")
-}
-
-/// Shame lives in a signed cookie so it follows the player across runs. Each response adds this
-/// run's new shame to whatever total the client presents, so two runs at once both count.
-fn settle_shame(run: &mut Run, ctx: &Ctx, secret: &Secret) -> u32 {
-    let presented = ctx
-        .cookie("shame")
-        .and_then(|signed| secret.verify("shame", signed))
-        .and_then(|total| total.parse::<u32>().ok());
-    let total = presented.unwrap_or(run.shame_total) + (run.shame - run.shame_reported);
-    run.shame_reported = run.shame;
-    run.shame_total = total;
-    total
-}
-
-pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response) -> Response {
-    let status = response.status();
-    if status == StatusCode::NOT_MODIFIED {
-        return response;
-    }
-    let shame = settle_shame(run, ctx, secret);
-    let mut stats: Vec<(HeaderName, String)> = vec![
-        if run.items.ruler {
-            (X_LENGTH, format!("{:.2}", run.current_length()))
-        } else {
-            (
-                X_SELF_REPORTED_LENGTH,
-                format!("{:.2}", run.self_reported()),
-            )
-        },
-        (X_GIRTH, format!("{:.2}", run.girth)),
         (
-            X_FORESKIN,
-            run.foreskin.map_or("gone".into(), |f| format!("{f:.2}")),
+            X_SUSPICION,
+            format!("{}/{SUSPICION_LIMIT}", gauges.suspicion),
         ),
-        (X_FRICTION, format!("{}/{}", run.friction, FRICTION_MAX)),
-        (X_EQ, run.eq.to_string()),
-        (X_STAMINA, format!("{}/{}", run.stamina, run.max_stamina())),
-        (X_SUSPICION, format!("{}/{SUSPICION_LIMIT}", run.suspicion)),
         (X_SHAME, shame.to_string()),
-        (X_CASH, run.cash.to_string()),
-        (X_FLOOR, run.floor.number().to_string()),
-        (header::LINK, links(run)),
+        (X_CASH, gauges.cash.to_string()),
+        (X_FLOOR, gauges.floor.to_string()),
     ];
-    if let Some(observer) = run.observed {
+    if let Some(observer) = gauges.observed {
         stats.push((X_OBSERVED_BY, observer.name().into()));
     }
-    if run.mum.is_some() {
+    if gauges.mum_at_door {
         stats.push((header::VIA, "1.1 mum".into()));
         stats.push((header::VARY, "Mum".into()));
     }
     // RFC 9111 obsoleted Warning, which is why nobody heeds it.
-    if run.conditions.pulled_muscle {
-        stats.push((header::WARNING, "199 - \"a muscle has been pulled\"".into()));
-    }
-    if run.conditions.friction_burn {
-        stats.push((header::WARNING, "199 - \"friction burn\"".into()));
-    }
-    for notice in run.notices.drain(..) {
-        stats.push((header::WARNING, format!("199 - \"{notice}\"")));
-    }
-    if run.eq > 70 && run.ended.is_none() {
-        stats.push((header::WARNING, "199 - \"it is turning purple\"".into()));
+    for warning in &gauges.warnings {
+        stats.push((header::WARNING, format!("199 - \"{warning}\"")));
     }
-    stats.push((
-        header::SET_COOKIE,
-        format!(
-            "shame={}; {COOKIE_ATTRIBUTES}",
-            secret.sign("shame", &shame.to_string())
-        ),
-    ));
-    if run.items.ruler {
-        stats.push((
-            header::SET_COOKIE,
-            format!("ruler={}; {COOKIE_ATTRIBUTES}", secret.sign("ruler", "1")),
-        ));
+    stats
+}
+
+pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response) -> Response {
+    let status = response.status();
+    if status == StatusCode::NOT_MODIFIED {
+        return response;
     }
+    let (shame, shame_cookie) = shame::settle(run, ctx, secret);
+    let gauges = run.gauges();
+    let link = links::header(run);
     let headers = response.headers_mut();
-    for (name, value) in stats {
+    for (name, value) in stats(&gauges, shame) {
         if let Ok(value) = HeaderValue::from_str(&value) {
             headers.append(name, value);
         }
     }
+    if let Ok(link) = HeaderValue::from_str(&link) {
+        headers.append(header::LINK, link);
+    }
+    headers.append(header::SET_COOKIE, shame_cookie);
+    if gauges.ruler {
+        headers.append(header::SET_COOKIE, shame::ruler_cookie(secret));
+    }
     let bodiless = status.is_informational() || status == StatusCode::NO_CONTENT;
-    if run.items.ring && !bodiless {
+    if gauges.ring && !bodiless {
         response.extensions_mut().insert(Compress);
     }
     response
@@ -293,7 +207,7 @@ fn greet(response: Response, ctx: &mut Ctx) -> Response {
     }
     let (Some(Greeting(text)), Some(upgrade)) = (
         response.extensions().get::<Greeting>().cloned(),
-        ctx.upgrade.take(),
+        ctx.take_upgrade(),
     ) else {
         return response;
     };

Modified file: src/http/runs.rs+37 additions−286 deletions@@ -1,10 +1,7 @@
 //! The resources under `/runs/{id}`.
 
-use std::{convert::Infallible, fmt::Write as _};
-
 use axum::{
     Json,
-    body::{Body, Bytes},
     http::{StatusCode, header},
     response::{IntoResponse, Response},
 };
@@ -12,15 +9,17 @@ use serde_json::{Value, json};
 
 use super::{
     ctx::Ctx,
+    inventory::{delete_item, get_inventory, get_item},
+    parse::{parse_intensity, parse_techniques},
     resource::{Resource, Verb},
     response::respond,
     run::{Greeting, RunResource, Scope},
+    shaft::{get_foreskin, get_length},
 };
 use crate::{
     game::{
-        Cause, Floor, Grip, Item, LUBRICANTS, Lube, PatchOp, Run, Technique,
-        balance::{EQ_BAND, MM_PER_INCH},
-        shaft,
+        Branch, Cause, Floor, Grip, Item, LUBRICANTS, Lube, PatchOp, Run, Technique,
+        balance::{EQ_BAND, VIEWS_PER_SECOND},
     },
     headers::ACCEPT_PATCH,
     problem::Problem,
@@ -44,32 +43,20 @@ fn not_in_clinic(run: &Run) -> bool {
     run.floor != Floor::Clinic
 }
 
-fn never(_: &Run) -> bool {
-    false
-}
-
-fn unreachable_handler(_: &mut Run, _: &Ctx) -> Response {
-    StatusCode::METHOD_NOT_ALLOWED.into_response()
-}
-
 pub static RUN: RunResource = RunResource {
     scope: Scope::Home,
-    resource: Resource {
-        verbs: &[
-            Verb::new("GET", get_run),
-            Verb::new("JELQ", jelq)
-                .only_when(not_in_clinic, "JELQ is not performed in the clinic."),
-            Verb::new("HOLD", hold_run).only_when(
-                Run::can_hold,
-                "HOLD is only available above 70 EQ or at 2 stamina or less.",
-            ),
-            Verb::new("PUT", put_run),
-            Verb::new("PATCH", patch_run),
-            Verb::new("DELETE", delete_run),
-            Verb::new("TRACE", trace_run),
-        ],
-        accept_patch: true,
-    },
+    resource: Resource::patchable(&[
+        Verb::new("GET", get_run),
+        Verb::new("JELQ", jelq).only_when(not_in_clinic, "JELQ is not performed in the clinic."),
+        Verb::new("HOLD", hold_run).only_when(
+            Run::can_hold,
+            "HOLD is only available above 70 EQ or at 2 stamina or less.",
+        ),
+        Verb::new("PUT", put_run),
+        Verb::new("PATCH", patch_run),
+        Verb::new("DELETE", delete_run),
+        Verb::new("TRACE", trace_run),
+    ]),
 };
 pub static LENGTH: RunResource = home(&[Verb::new("GET", get_length)]);
 pub static FORESKIN: RunResource = home(&[
@@ -98,8 +85,8 @@ pub static GRIP: RunResource = home(&[Verb::new("GET", get_grip)]);
 pub static DIAGNOSIS: RunResource = pockets(&[Verb::new("GET", get_diagnosis)]);
 pub static FOOTAGE: RunResource = pockets(&[
     Verb::new("GET", get_footage),
-    Verb::new("DELETE", unreachable_handler).only_when(
-        never,
+    Verb::refused(
+        "DELETE",
         "The footage has been cached by intermediaries. It cannot be deleted.",
     ),
 ]);
@@ -124,48 +111,6 @@ fn get_run(run: &mut Run, ctx: &Ctx) -> Response {
         .into_response()
 }
 
-fn parse_techniques(run: &Run, ctx: &Ctx) -> Result<Vec<Technique>, Problem> {
-    let required = || {
-        Problem::new(
-            StatusCode::BAD_REQUEST,
-            "technique-required",
-            "No technique was specified.",
-        )
-        .with("techniques", run.path("/techniques"))
-    };
-    let names = ctx
-        .query("technique")
-        .filter(|n| !n.trim().is_empty())
-        .ok_or_else(required)?;
-    names
-        .split(',')
-        .map(str::trim)
-        .filter(|n| !n.is_empty())
-        .map(|name| {
-            Technique::parse(name).ok_or_else(|| {
-                Problem::new(
-                    StatusCode::BAD_REQUEST,
-                    "unknown-technique",
-                    format!("{name} is not a technique."),
-                )
-                .with("techniques", run.path("/techniques"))
-            })
-        })
-        .collect()
-}
-
-fn parse_intensity(ctx: &Ctx) -> Result<i32, Problem> {
-    match ctx.query("intensity").map(str::parse::<i32>) {
-        None => Ok(5),
-        Some(Ok(i)) if (1..=10).contains(&i) => Ok(i),
-        Some(_) => Err(Problem::new(
-            StatusCode::BAD_REQUEST,
-            "intensity-out-of-range",
-            "Intensity is measured from 1 to 10.",
-        )),
-    }
-}
-
 fn jelq(run: &mut Run, ctx: &Ctx) -> Response {
     let parsed = parse_techniques(run, ctx).and_then(|techniques| {
         let intensity = parse_intensity(ctx)?;
@@ -199,7 +144,7 @@ fn patch_run(run: &mut Run, ctx: &Ctx) -> Response {
         .header(ACCEPT_PATCH, "application/json-patch+json")
         .into_response();
     }
-    match serde_json::from_slice::<Vec<PatchOp>>(&ctx.body) {
+    match serde_json::from_slice::<Vec<PatchOp>>(ctx.body()) {
         Ok(ops) => respond(run.patch(&ops)),
         Err(_) => Problem::new(
             StatusCode::BAD_REQUEST,
@@ -216,160 +161,11 @@ fn delete_run(run: &mut Run, _: &Ctx) -> Response {
 }
 
 fn trace_run(run: &mut Run, ctx: &Ctx) -> Response {
-    run.shame += 1;
-    let mut message = format!("{} {} {:?}\r\n", ctx.method, ctx.uri, ctx.version);
-    for (name, value) in &ctx.headers {
-        let _ = write!(
-            message,
-            "{name}: {}\r\n",
-            value.to_str().unwrap_or("<binary>")
-        );
-    }
-    message.push_str("\r\n");
+    run.trace();
     (
         StatusCode::OK,
         [(header::CONTENT_TYPE, "message/http")],
-        message,
-    )
-        .into_response()
-}
-
-fn millimetres(inches: f64) -> usize {
-    (inches * MM_PER_INCH).round() as usize
-}
-
-enum InchRange {
-    Satisfiable(f64, f64),
-    Unsatisfiable,
-}
-
-/// `None` means the header is not a valid range, which RFC 9110 §14.2 says to ignore rather than refuse.
-fn parse_inch_range(range: &str, total: f64) -> Option<InchRange> {
-    let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;
-    let number = |text: &str| {
-        text.parse::<f64>()
-            .ok()
-            .filter(|n| n.is_finite() && *n >= 0.0)
-    };
-    let (start, end) = match (start.trim(), end.trim()) {
-        ("", "") => return None,
-        ("", suffix) => ((total - number(suffix)?).max(0.0), total),
-        (start, "") => (number(start)?, total),
-        (start, end) => {
-            let (start, end) = (number(start)?, number(end)?);
-            if start > end {
-                return None;
-            }
-            (start, end)
-        }
-    };
-    Some(if start < total {
-        InchRange::Satisfiable(start, end.min(total))
-    } else {
-        InchRange::Unsatisfiable
-    })
-}
-
-fn unsatisfied_range(inches: f64) -> Response {
-    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()
-}
-
-fn partial_inches(body: &str, offset: usize, start: f64, end: f64, total: f64) -> Response {
-    let from = (millimetres(start) + offset).min(body.len() - 1);
-    let to = (millimetres(end) + offset).clamp(from + 1, body.len());
-    (
-        StatusCode::PARTIAL_CONTENT,
-        [
-            (
-                header::CONTENT_TYPE,
-                "text/plain; charset=us-ascii".to_owned(),
-            ),
-            (header::ACCEPT_RANGES, "inches".to_owned()),
-            (
-                header::CONTENT_RANGE,
-                format!("inches {start:.2}-{end:.2}/{total:.2}"),
-            ),
-        ],
-        body[from..to].to_owned(),
-    )
-        .into_response()
-}
-
-fn get_length(run: &mut Run, ctx: &Ctx) -> 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) = ctx
-        .header(header::RANGE)
-        .and_then(|range| parse_inch_range(range, inches))
-    {
-        match range {
-            InchRange::Satisfiable(start, end) => {
-                return partial_inches(&body, 0, start, end, inches);
-            }
-            InchRange::Unsatisfiable => return unsatisfied_range(inches),
-        }
-    }
-
-    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()
-}
-
-fn get_foreskin(run: &mut Run, ctx: &Ctx) -> Response {
-    let Some(inches) = run.foreskin else {
-        return Problem::new(
-            StatusCode::GONE,
-            "foreskin-gone",
-            "The foreskin is gone. It will not be returning.",
-        )
-        .into_response();
-    };
-    let body = format!("8({})D", "~".repeat(millimetres(inches)));
-    if let Some(range) = ctx
-        .header(header::RANGE)
-        .and_then(|range| parse_inch_range(range, inches))
-    {
-        match range {
-            InchRange::Satisfiable(start, end) => {
-                return partial_inches(&body, 2, start, end, inches);
-            }
-            InchRange::Unsatisfiable => return unsatisfied_range(inches),
-        }
-    }
-    (
-        StatusCode::OK,
-        [
-            (header::ETAG, run.etag()),
-            (
-                header::CONTENT_TYPE,
-                "text/plain; charset=us-ascii".to_owned(),
-            ),
-            (header::ACCEPT_RANGES, "inches".to_owned()),
-        ],
-        body,
+        ctx.echo(),
     )
         .into_response()
 }
@@ -378,59 +174,10 @@ fn delete_foreskin(run: &mut Run, ctx: &Ctx) -> Response {
     respond(run.delete_foreskin(ctx.header(header::IF_MATCH)))
 }
 
-fn get_inventory(run: &mut Run, _: &Ctx) -> Response {
-    let items: Vec<Value> = run
-        .items
-        .owned()
-        .into_iter()
-        .map(|item| {
-            json!({
-                "name": item.slug(),
-                "href": run.path(&format!("/inventory/{}", item.slug())),
-            })
-        })
-        .collect();
-    Json(json!({
-        "items": items,
-        "ice_packs": run.items.ice_packs,
-        "supplements": run.items.supplements,
-        "excuses": run.excuses(),
-    }))
-    .into_response()
-}
-
-fn owned_item(run: &Run, ctx: &Ctx) -> Result<Item, Problem> {
-    Item::parse(ctx.param("item"))
-        .filter(|&item| run.items.has(item))
-        .ok_or_else(|| {
-            Problem::new(
-                StatusCode::NOT_FOUND,
-                "no-such-item",
-                "You do not have that.",
-            )
-        })
-}
-
-fn get_item(run: &mut Run, ctx: &Ctx) -> Response {
-    match owned_item(run, ctx) {
-        Ok(item) => {
-            Json(json!({ "name": item.slug(), "description": item.description() })).into_response()
-        }
-        Err(problem) => problem.into_response(),
-    }
-}
-
-fn delete_item(run: &mut Run, ctx: &Ctx) -> Response {
-    match owned_item(run, ctx) {
-        Ok(item) => respond(run.drop_item(item)),
-        Err(problem) => problem.into_response(),
-    }
-}
-
 fn get_techniques(run: &mut Run, _: &Ctx) -> Response {
     let listed: Vec<Value> = Technique::ALL
         .into_iter()
-        .map(|t| t.describe(run.uli_taught))
+        .map(|t| t.describe(run.knows_uli()))
         .collect();
     Json(json!({
         "usage": format!("JELQ {}?technique=<name>[,<name>]&intensity=<1-10>", run.path("")),
@@ -447,7 +194,15 @@ fn search_drawer(run: &mut Run, _: &Ctx) -> Response {
 }
 
 fn choose_branch(run: &mut Run, ctx: &Ctx) -> Response {
-    respond(run.choose(ctx.param("choice")))
+    match ctx.param("choice").parse::<Branch>() {
+        Ok(choice) => respond(run.choose(choice)),
+        Err(()) => Problem::new(
+            StatusCode::NOT_FOUND,
+            "no-such-choice",
+            "That was not one of the choices.",
+        )
+        .into_response(),
+    }
 }
 
 fn get_floor(run: &mut Run, _: &Ctx) -> Response {
@@ -459,15 +214,11 @@ fn leave_floor(run: &mut Run, _: &Ctx) -> Response {
 }
 
 fn get_shop(run: &mut Run, _: &Ctx) -> Response {
-    let view = run.shop_view();
-    if view.is_ok() {
-        run.here.shopping = true;
-    }
-    respond(view.map(Json))
+    respond(run.browse_shop().map(Json))
 }
 
 fn buy(run: &mut Run, ctx: &Ctx) -> Response {
-    respond(run.buy(ctx.param("item")))
+    respond(run.buy(Item::parse(ctx.param("item"))))
 }
 
 fn raid_kitchen(run: &mut Run, _: &Ctx) -> Response {
@@ -508,7 +259,7 @@ fn requested_grip(ctx: &Ctx) -> Option<Grip> {
     }
     ctx.header(header::UPGRADE)?
         .split(',')
-        .find_map(|protocol| Grip::parse(protocol.trim()))
+        .find_map(|protocol| protocol.trim().parse::<Grip>().ok())
 }
 
 fn get_grip(run: &mut Run, ctx: &Ctx) -> Response {
@@ -539,7 +290,7 @@ fn get_grip(run: &mut Run, ctx: &Ctx) -> Response {
     (
         StatusCode::OK,
         [(header::UPGRADE, "overhand, underhand")],
-        Json(json!({ "grip": run.grip.name(), "detail": detail })),
+        Json(json!({ "grip": run.grip().name(), "detail": detail })),
     )
         .into_response()
 }
@@ -571,7 +322,7 @@ fn get_footage(run: &mut Run, _: &Ctx) -> Response {
         ],
         Json(json!({
             "detail": "A recording. It is grainy. It is unmistakably you. It has been shared.",
-            "views": 1 + age * 37,
+            "views": 1 + age * VIEWS_PER_SECOND,
         })),
     )
         .into_response()

Added file: src/http/shaft.rs+157 additions@@ -0,0 +1,157 @@
+use std::convert::Infallible;
+
+use axum::{
+    body::{Body, Bytes},
+    http::{StatusCode, header},
+    response::{IntoResponse, Response},
+};
+
+use super::ctx::Ctx;
+use crate::{
+    game::{Run, balance::MM_PER_INCH, shaft},
+    problem::Problem,
+};
+
+const SHAFT_CHUNK: usize = 16;
+
+pub(super) fn millimetres(inches: f64) -> usize {
+    (inches * MM_PER_INCH).round() as usize
+}
+
+pub(super) enum InchRange {
+    Satisfiable(f64, f64),
+    Unsatisfiable,
+}
+
+/// `None` means the header is not a valid range, which RFC 9110 §14.2 says to ignore rather than refuse.
+pub(super) fn parse_inch_range(range: &str, total: f64) -> Option<InchRange> {
+    let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;
+    let number = |text: &str| {
+        text.parse::<f64>()
+            .ok()
+            .filter(|n| n.is_finite() && *n >= 0.0)
+    };
+    let (start, end) = match (start.trim(), end.trim()) {
+        ("", "") => return None,
+        ("", suffix) => ((total - number(suffix)?).max(0.0), total),
+        (start, "") => (number(start)?, total),
+        (start, end) => {
+            let (start, end) = (number(start)?, number(end)?);
+            if start > end {
+                return None;
+            }
+            (start, end)
+        }
+    };
+    Some(if start < total {
+        InchRange::Satisfiable(start, end.min(total))
+    } else {
+        InchRange::Unsatisfiable
+    })
+}
+
+pub(super) fn unsatisfied_range(inches: f64) -> Response {
+    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()
+}
+
+pub(super) fn partial_inches(
+    body: &str,
+    offset: usize,
+    start: f64,
+    end: f64,
+    total: f64,
+) -> Response {
+    let from = (millimetres(start) + offset).min(body.len() - 1);
+    let to = (millimetres(end) + offset).clamp(from + 1, body.len());
+    (
+        StatusCode::PARTIAL_CONTENT,
+        [
+            (
+                header::CONTENT_TYPE,
+                "text/plain; charset=us-ascii".to_owned(),
+            ),
+            (header::ACCEPT_RANGES, "inches".to_owned()),
+            (
+                header::CONTENT_RANGE,
+                format!("inches {start:.2}-{end:.2}/{total:.2}"),
+            ),
+        ],
+        body[from..to].to_owned(),
+    )
+        .into_response()
+}
+
+pub(super) fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
+    let inches = run.shown_length();
+    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) = ctx
+        .header(header::RANGE)
+        .and_then(|range| parse_inch_range(range, inches))
+    {
+        match range {
+            InchRange::Satisfiable(start, end) => {
+                return partial_inches(&body, 0, start, end, inches);
+            }
+            InchRange::Unsatisfiable => return unsatisfied_range(inches),
+        }
+    }
+
+    if run.measured() {
+        return (StatusCode::OK, [content_type, accept_ranges], body).into_response();
+    }
+    let chunks: Vec<Result<Bytes, Infallible>> = body
+        .into_bytes()
+        .chunks(SHAFT_CHUNK)
+        .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()
+}
+
+pub(super) fn get_foreskin(run: &mut Run, ctx: &Ctx) -> Response {
+    let Some(inches) = run.foreskin() else {
+        return Problem::new(
+            StatusCode::GONE,
+            "foreskin-gone",
+            "The foreskin is gone. It will not be returning.",
+        )
+        .into_response();
+    };
+    let body = format!("8({})D", "~".repeat(millimetres(inches)));
+    if let Some(range) = ctx
+        .header(header::RANGE)
+        .and_then(|range| parse_inch_range(range, inches))
+    {
+        match range {
+            InchRange::Satisfiable(start, end) => {
+                return partial_inches(&body, 2, start, end, inches);
+            }
+            InchRange::Unsatisfiable => return unsatisfied_range(inches),
+        }
+    }
+    (
+        StatusCode::OK,
+        [
+            (header::ETAG, run.etag()),
+            (
+                header::CONTENT_TYPE,
+                "text/plain; charset=us-ascii".to_owned(),
+            ),
+            (header::ACCEPT_RANGES, "inches".to_owned()),
+        ],
+        body,
+    )
+        .into_response()
+}

Added file: src/http/shame.rs+30 additions@@ -0,0 +1,30 @@
+use axum::http::HeaderValue;
+
+use super::ctx::Ctx;
+use crate::{game::Run, secret::Secret};
+
+pub const COOKIE_ATTRIBUTES: &str = "Max-Age=31536000; Path=/; HttpOnly; SameSite=Strict";
+
+pub fn settle(run: &mut Run, ctx: &Ctx, secret: &Secret) -> (u32, HeaderValue) {
+    let presented = ctx
+        .cookie("shame")
+        .and_then(|signed| secret.verify("shame", signed))
+        .and_then(|total| total.parse::<u32>().ok());
+    let total = run.settle_shame(presented);
+    let cookie = format!(
+        "shame={}; {COOKIE_ATTRIBUTES}",
+        secret.sign("shame", &total.to_string())
+    );
+    (
+        total,
+        HeaderValue::from_str(&cookie).expect("a signed number is a valid header value"),
+    )
+}
+
+pub fn ruler_cookie(secret: &Secret) -> HeaderValue {
+    HeaderValue::from_str(&format!(
+        "ruler={}; {COOKIE_ATTRIBUTES}",
+        secret.sign("ruler", "1")
+    ))
+    .expect("a signed constant is a valid header value")
+}

Modified file: src/http/ui.rs+4 additions−1 deletions@@ -12,7 +12,7 @@ use serde::Deserialize;
 use serde_json::json;
 use tower::ServiceExt;
 
-use super::resource::unsupported;
+use super::{ctx::BODY_LIMIT, resource::unsupported};
 use crate::problem::{Problem, reason};
 
 const RESPONSE_LIMIT: usize = 1 << 20;
@@ -54,6 +54,9 @@ fn decode(headers: &HeaderMap, bytes: Bytes) -> Vec<u8> {
 // Browsers hide 3xx responses from fetch and refuse TRACE, Upgrade, and Expect, so the page
 // replays requests in-process to show the player exactly what the API said.
 pub async fn send(State(api): State<Router>, headers: HeaderMap, body: Bytes) -> Response {
+    if body.len() > BODY_LIMIT {
+        return bad_envelope("The envelope is larger than any request the server would take.");
+    }
     let Ok(envelope) = serde_json::from_slice::<Envelope>(&body) else {
         return bad_envelope("The envelope could not be parsed.");
     };

Modified file: src/lib.rs+1−1

@@ -11,4 +11,4 @@ mod secret;

1111 mod tests;

1212

1313 pub use config::Config;

14-pub use http::{AppState, app, router};

14+pub use http::{AppState, app, router, sweep_forever};

Modified file: src/main.rs+10 additions−4 deletions@@ -1,7 +1,13 @@
+use std::sync::Arc;
+
 #[tokio::main]
-async fn main() -> std::io::Result<()> {
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let config = jelqd::Config::from_env();
-    let listener = tokio::net::TcpListener::bind(&config.addr).await?;
-    eprintln!("jelqd listening on http://{}", config.addr);
-    axum::serve(listener, jelqd::app(config)).await
+    let addr = config.addr.clone();
+    let state = Arc::new(jelqd::AppState::new(config)?);
+    tokio::spawn(jelqd::sweep_forever(Arc::clone(&state)));
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    eprintln!("jelqd listening on http://{addr}");
+    axum::serve(listener, jelqd::router(state)).await?;
+    Ok(())
 }

Modified file: src/records.rs+144 additions−88 deletions@@ -8,34 +8,37 @@ use std::{
 
 use rusqlite::{Connection, OptionalExtension, Row, params};
 
-use crate::game::Run;
-
-const SCHEMA: &str = "
-CREATE TABLE IF NOT EXISTS runs (
-    id TEXT PRIMARY KEY,
-    public_id TEXT NOT NULL,
-    seeded INTEGER NOT NULL,
-    status TEXT NOT NULL,
-    cause TEXT,
-    detail TEXT,
-    turn INTEGER NOT NULL,
-    floor INTEGER NOT NULL,
-    length REAL NOT NULL,
-    self_reported REAL NOT NULL,
-    girth REAL NOT NULL,
-    viral INTEGER NOT NULL,
-    recorded_at INTEGER NOT NULL
-);
-CREATE INDEX IF NOT EXISTS runs_by_cause ON runs (cause);
-";
-
-/// What the graveyard and the leaderboard need to know about a run, live or long gone.
+use crate::game::{Cause, Run, RunStatus};
+
+/// Each entry moves the schema up one `user_version`. Never edit one that has shipped.
+const MIGRATIONS: [&str; 2] = [
+    "CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        public_id TEXT NOT NULL,
+        seeded INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        cause TEXT,
+        detail TEXT,
+        turn INTEGER NOT NULL,
+        floor INTEGER NOT NULL,
+        length REAL NOT NULL,
+        self_reported REAL NOT NULL,
+        girth REAL NOT NULL,
+        viral INTEGER NOT NULL,
+        recorded_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS runs_by_cause ON runs (cause);",
+    "ALTER TABLE runs ADD COLUMN ice_unused INTEGER NOT NULL DEFAULT 0;
+    ALTER TABLE runs DROP COLUMN detail;
+    CREATE INDEX runs_by_recorded ON runs (recorded_at);",
+];
+
 pub struct Record {
     pub id: String,
     pub public_id: String,
     pub seeded: bool,
-    pub status: String,
-    pub ending: Option<Ending>,
+    pub status: RunStatus,
+    pub cause: Option<Cause>,
     pub turn: u32,
     pub floor: u8,
     pub length: f64,
@@ -44,42 +47,44 @@ pub struct Record {
     pub viral: bool,
 }
 
-pub struct Ending {
-    pub cause: String,
-    pub detail: String,
-}
-
 impl Record {
     pub fn of(run: &Run) -> Self {
         Self {
-            id: run.id.clone(),
-            public_id: run.public_id.clone(),
-            seeded: run.seeded,
-            status: run.status().name().to_owned(),
-            ending: run.ended.as_ref().map(|ending| Ending {
-                cause: ending.cause.slug().to_owned(),
-                detail: ending.cause.detail().to_owned(),
-            }),
+            id: run.ident.id.clone(),
+            public_id: run.ident.public_id.clone(),
+            seeded: run.ident.seeded,
+            status: run.status(),
+            cause: run.ended.as_ref().map(|ending| ending.cause),
             turn: run.ended.as_ref().map_or(run.turn, |ending| ending.turn),
             floor: run.floor.number(),
             length: run.current_length(),
             self_reported: run.self_reported(),
-            girth: run.girth,
-            viral: run.filmed_at.is_some(),
+            girth: run.body.girth,
+            viral: run.online.filmed_at.is_some(),
         }
     }
 
     fn from_row(row: &Row) -> rusqlite::Result<Self> {
-        let cause: Option<String> = row.get("cause")?;
-        let detail: Option<String> = row.get("detail")?;
+        let unknown = |column: &str, value: String| {
+            rusqlite::Error::FromSqlConversionFailure(
+                0,
+                rusqlite::types::Type::Text,
+                format!("unknown {column} {value:?}").into(),
+            )
+        };
+        let status: String = row.get("status")?;
+        let cause = row
+            .get::<_, Option<String>>("cause")?
+            .map(|slug| {
+                Cause::parse(&slug, row.get("ice_unused")?).ok_or_else(|| unknown("cause", slug))
+            })
+            .transpose()?;
         Ok(Self {
             id: row.get("id")?,
             public_id: row.get("public_id")?,
             seeded: row.get("seeded")?,
-            status: row.get("status")?,
-            ending: cause
-                .zip(detail)
-                .map(|(cause, detail)| Ending { cause, detail }),
+            status: RunStatus::parse(&status).ok_or_else(|| unknown("status", status))?,
+            cause,
             turn: row.get("turn")?,
             floor: row.get("floor")?,
             length: row.get("length")?,
@@ -90,6 +95,24 @@ impl Record {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Ranking {
+    SelfReported,
+    ContentLength,
+    /// Self-reported length against real girth, the only metric the forum respects.
+    Volume,
+}
+
+impl Ranking {
+    fn order(self) -> &'static str {
+        match self {
+            Self::SelfReported => "self_reported",
+            Self::ContentLength => "length",
+            Self::Volume => "girth * girth * self_reported",
+        }
+    }
+}
+
 pub struct Records {
     db: Mutex<Connection>,
 }
@@ -97,19 +120,31 @@ pub struct Records {
 impl Records {
     /// WAL lets the leaderboard read while a run is being buried.
     pub fn open(path: &Path) -> rusqlite::Result<Self> {
+        if let Some(dir) = path.parent().filter(|dir| !dir.as_os_str().is_empty()) {
+            std::fs::create_dir_all(dir)
+                .map_err(|_| rusqlite::Error::InvalidPath(path.to_owned()))?;
+        }
         let db = Connection::open(path)?;
         db.pragma_update(None, "journal_mode", "WAL")?;
         db.pragma_update(None, "synchronous", "NORMAL")?;
-        Self::with(db)
+        Self::migrated(db)
     }
 
     pub fn in_memory() -> Self {
-        Self::with(Connection::open_in_memory().expect("an in-memory database always opens"))
-            .expect("the schema applies to an empty database")
+        Connection::open_in_memory()
+            .and_then(Self::migrated)
+            .expect("an empty in-memory database always takes the schema")
     }
 
-    fn with(db: Connection) -> rusqlite::Result<Self> {
-        db.execute_batch(SCHEMA)?;
+    fn migrated(mut db: Connection) -> rusqlite::Result<Self> {
+        let version: i64 = db.pragma_query_value(None, "user_version", |row| row.get(0))?;
+        let done = usize::try_from(version).unwrap_or(0);
+        for (step, migration) in (1_i64..).zip(MIGRATIONS).skip(done) {
+            let tx = db.transaction()?;
+            tx.execute_batch(migration)?;
+            tx.pragma_update(None, "user_version", step)?;
+            tx.commit()?;
+        }
         Ok(Self { db: Mutex::new(db) })
     }
 
@@ -117,60 +152,81 @@ impl Records {
         self.db.lock().unwrap_or_else(PoisonError::into_inner)
     }
 
-    /// A record that cannot be written is a 500, the same as any other broken promise to persist.
-    pub fn save(&self, record: &Record) {
-        let recorded_at = SystemTime::now()
+    /// The first save stamps the record. Later saves update it in place and keep its place in line.
+    pub fn save(&self, record: &Record) -> rusqlite::Result<()> {
+        let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .map_or(0, |since| {
                 i64::try_from(since.as_secs()).unwrap_or(i64::MAX)
             });
-        self.db()
-            .execute(
-                "INSERT OR REPLACE INTO runs (id, public_id, seeded, status, cause, detail, turn,
-                     floor, length, self_reported, girth, viral, recorded_at)
-                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
-                params![
-                    record.id,
-                    record.public_id,
-                    record.seeded,
-                    record.status,
-                    record.ending.as_ref().map(|e| &e.cause),
-                    record.ending.as_ref().map(|e| &e.detail),
-                    record.turn,
-                    record.floor,
-                    record.length,
-                    record.self_reported,
-                    record.girth,
-                    record.viral,
-                    recorded_at,
-                ],
-            )
-            .unwrap_or_else(|e| panic!("run {} could not be recorded: {e}", record.id));
+        self.db().execute(
+            "INSERT INTO runs (id, public_id, seeded, status, cause, ice_unused, turn, floor,
+                 length, self_reported, girth, viral, recorded_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)
+             ON CONFLICT (id) DO UPDATE SET
+                 status = excluded.status, cause = excluded.cause,
+                 ice_unused = excluded.ice_unused, turn = excluded.turn, floor = excluded.floor,
+                 length = excluded.length, self_reported = excluded.self_reported,
+                 girth = excluded.girth, viral = excluded.viral",
+            params![
+                record.id,
+                record.public_id,
+                record.seeded,
+                record.status.name(),
+                record.cause.map(Cause::slug),
+                matches!(record.cause, Some(Cause::Ruptured { ice_unused: true })),
+                record.turn,
+                record.floor,
+                record.length,
+                record.self_reported,
+                record.girth,
+                record.viral,
+                now,
+            ],
+        )?;
+        Ok(())
     }
 
-    pub fn find(&self, id: &str) -> Option<Record> {
+    pub fn find(&self, id: &str) -> rusqlite::Result<Option<Record>> {
         self.db()
             .query_row("SELECT * FROM runs WHERE id = ?1", [id], Record::from_row)
             .optional()
-            .unwrap_or_else(|e| panic!("the records could not be read: {e}"))
     }
 
-    pub fn dead(&self) -> Vec<Record> {
-        self.query("SELECT * FROM runs WHERE cause IS NOT NULL ORDER BY recorded_at")
+    pub fn dead(&self, offset: usize, limit: usize) -> rusqlite::Result<Vec<Record>> {
+        self.query(
+            "SELECT * FROM runs WHERE cause IS NOT NULL
+             ORDER BY recorded_at DESC, id LIMIT ?1 OFFSET ?2",
+            offset,
+            limit,
+        )
     }
 
-    pub fn all(&self) -> Vec<Record> {
-        self.query("SELECT * FROM runs")
+    pub fn top(
+        &self,
+        ranking: Ranking,
+        seeded: bool,
+        offset: usize,
+        limit: usize,
+    ) -> rusqlite::Result<Vec<Record>> {
+        let filter = if seeded { "" } else { "WHERE seeded = 0" };
+        self.query(
+            &format!(
+                "SELECT * FROM runs {filter} ORDER BY {} DESC, id LIMIT ?1 OFFSET ?2",
+                ranking.order()
+            ),
+            offset,
+            limit,
+        )
     }
 
-    fn query(&self, sql: &str) -> Vec<Record> {
+    fn query(&self, sql: &str, offset: usize, limit: usize) -> rusqlite::Result<Vec<Record>> {
         let db = self.db();
-        let mut statement = db
-            .prepare_cached(sql)
-            .unwrap_or_else(|e| panic!("the records could not be read: {e}"));
+        let mut statement = db.prepare_cached(sql)?;
+        let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        let offset = i64::try_from(offset).unwrap_or(i64::MAX);
         statement
-            .query_map([], Record::from_row)
-            .and_then(Iterator::collect)
-            .unwrap_or_else(|e| panic!("the records could not be read: {e}"))
+            .query_map(params![limit, offset], Record::from_row)?
+            .collect()
     }
 }

Deleted file: src/tests.rs−2117 deletions@@ -1,2117 +0,0 @@
-use std::{sync::Arc, time::Duration};
-
-use axum::{
-    Router,
-    body::{Body, to_bytes},
-    http::{Method, Request, StatusCode, Version, header},
-    response::Response,
-};
-use serde_json::Value;
-use tower::ServiceExt;
-
-use crate::{
-    AppState, Config,
-    game::{
-        Floor, MumVisit, Run, Story,
-        balance::{BRANCH_TURN, SUSPICION_LIMIT},
-    },
-    router,
-};
-
-async fn send(
-    app: &Router,
-    method: &str,
-    uri: &str,
-    headers: &[(&str, &str)],
-    body: &str,
-) -> Response {
-    let mut request = Request::builder()
-        .method(Method::from_bytes(method.as_bytes()).unwrap())
-        .uri(uri);
-    for (name, value) in headers {
-        request = request.header(*name, *value);
-    }
-    app.clone()
-        .oneshot(request.body(Body::from(body.to_owned())).unwrap())
-        .await
-        .unwrap()
-}
-
-async fn json(response: Response) -> Value {
-    serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap()
-}
-
-async fn text(response: Response) -> String {
-    String::from_utf8(
-        to_bytes(response.into_body(), usize::MAX)
-            .await
-            .unwrap()
-            .to_vec(),
-    )
-    .unwrap()
-}
-
-fn header<'a>(response: &'a Response, name: &str) -> &'a str {
-    response.headers()[name].to_str().unwrap()
-}
-
-fn fixture() -> Run {
-    Run::new("cafebabe".into(), "cafe".into(), 69)
-}
-
-fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {
-    let state = Arc::new(AppState::default());
-    let mut run = fixture();
-    run.floor = floor;
-    setup(&mut run);
-    state.insert(run);
-    router(state)
-}
-
-fn seeded(floor: Floor) -> (Router, String) {
-    let state = Arc::new(AppState::default());
-    let mut run = fixture();
-    run.floor = floor;
-    let etag = run.origin_etag();
-    state.insert(run);
-    (router(state), etag)
-}
-
-fn app() -> Router {
-    crate::app(Config::default())
-}
-
-fn mum_at_the_door(run: &mut Run) {
-    run.mum = Some(MumVisit {
-        errand: "She heard a noise.",
-        nonce: "abc".into(),
-        strikes: 0,
-        knocked: false,
-    });
-}
-
-#[tokio::test]
-async fn creating_a_run_returns_location_and_etag() {
-    let response = send(&app(), "POST", "/runs?seed=1", &[], "").await;
-    assert_eq!(response.status(), StatusCode::CREATED);
-    assert!(header(&response, "location").starts_with("/runs/"));
-    assert!(response.headers().contains_key(header::ETAG));
-    assert_eq!(header(&response, "server"), "jelqd/0.6.9");
-}
-
-#[tokio::test]
-async fn bodies_do_not_repeat_the_headers() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(response.headers().contains_key("x-eq"));
-    let body = json(response).await;
-    for stat in [
-        "eq",
-        "girth",
-        "foreskin",
-        "stamina",
-        "cash",
-        "self_reported_length",
-    ] {
-        assert!(body.get(stat).is_none(), "{stat} is already a header");
-    }
-}
-
-#[tokio::test]
-async fn jelqing_cold_fails_the_precondition() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let response = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;
-    assert_eq!(response.status(), StatusCode::PRECONDITION_FAILED);
-    assert_eq!(
-        header(&response, "content-type"),
-        "application/problem+json"
-    );
-}
-
-#[tokio::test]
-async fn wet_without_lube_is_unsupported_media() {
-    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);
-    let images = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet",
-        &[("content-type", "image/jpeg")],
-        "",
-    )
-    .await;
-    assert_eq!(json(images).await["detail"], "No.");
-}
-
-#[tokio::test]
-async fn unknown_methods_are_not_implemented() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let response = send(&app, "MILK", "/runs/cafebabe", &[], "").await;
-    assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);
-    let teapot = send(&app, "BREW", "/runs/cafebabe", &[], "").await;
-    assert_eq!(teapot.status(), StatusCode::IM_A_TEAPOT);
-}
-
-#[tokio::test]
-async fn the_clinic_does_not_advertise_jelq() {
-    let (app, _) = seeded(Floor::Clinic);
-    let options = send(&app, "OPTIONS", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&options, "allow").contains("JELQ"));
-    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &[], "").await;
-    assert_eq!(jelq.status(), StatusCode::METHOD_NOT_ALLOWED);
-    assert!(!header(&jelq, "allow").contains("JELQ"));
-    let (bedroom, _) = seeded(Floor::Bedroom);
-    let options = send(&bedroom, "OPTIONS", "/runs/cafebabe", &[], "").await;
-    assert!(header(&options, "allow").contains("JELQ"));
-}
-
-#[tokio::test]
-async fn patch_only_accepts_the_truth() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let patch = [("content-type", "application/json-patch+json")];
-    let replace = send(
-        &app,
-        "PATCH",
-        "/runs/cafebabe",
-        &patch,
-        r#"[{"op":"replace","path":"/length","value":12}]"#,
-    )
-    .await;
-    assert_eq!(replace.status(), StatusCode::UNPROCESSABLE_ENTITY);
-    let lie = send(
-        &app,
-        "PATCH",
-        "/runs/cafebabe",
-        &patch,
-        r#"[{"op":"test","path":"/length","value":40}]"#,
-    )
-    .await;
-    assert_eq!(
-        json(lie).await["type"],
-        "https://jelq.dev/problems/exaggeration"
-    );
-}
-
-#[tokio::test]
-async fn deleting_the_foreskin_requires_certainty() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let response = send(&app, "DELETE", "/runs/cafebabe/foreskin", &[], "").await;
-    assert_eq!(response.status(), StatusCode::PRECONDITION_REQUIRED);
-    let look = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
-    assert_eq!(look.status(), StatusCode::OK);
-    let etag = header(&look, "etag").to_owned();
-    assert!(text(look).await.contains('~'));
-    let response = send(
-        &app,
-        "DELETE",
-        "/runs/cafebabe/foreskin",
-        &[("if-match", &etag)],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::NO_CONTENT);
-    let response = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
-    assert_eq!(response.status(), StatusCode::GONE);
-}
-
-#[tokio::test]
-async fn length_is_chunked_until_the_ruler() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let lie = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;
-    assert!(!lie.headers().contains_key(header::CONTENT_LENGTH));
-    let app = seeded_with(Floor::Bedroom, |run| run.items.ruler = true);
-    let truth = send(&app, "GET", "/runs/cafebabe/length", &[], "").await;
-    let declared: usize = header(&truth, "content-length").parse().unwrap();
-    let body = text(truth).await;
-    assert_eq!(body.len(), declared);
-    assert!(body.starts_with("8=") && body.ends_with('D'));
-}
-
-#[tokio::test]
-async fn length_supports_inch_ranges() {
-    let (app, _) = seeded(Floor::Bedroom);
-    let response = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/length",
-        &[("range", "inches=0-1")],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
-    assert!(header(&response, "content-range").starts_with("inches 0.00-1.00/"));
-    assert_eq!(text(response).await.len(), 25);
-    let absurd = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/length",
-        &[("range", "inches=40-50")],
-        "",
-    )
-    .await;
-    assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);
-    let malformed = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/length",
-        &[("range", "inches=6.17")],
-        "",
-    )
-    .await;
-    assert_eq!(malformed.status(), StatusCode::OK);
-    let suffix = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/length",
-        &[("range", "inches=-1")],
-        "",
-    )
-    .await;
-    assert_eq!(suffix.status(), StatusCode::PARTIAL_CONTENT);
-    assert!(text(suffix).await.ends_with('D'));
-    for (range, status) in [
-        ("inches=1-", StatusCode::PARTIAL_CONTENT),
-        ("inches=40-", StatusCode::RANGE_NOT_SATISFIABLE),
-        ("inches=-0", StatusCode::RANGE_NOT_SATISFIABLE),
-        ("inches=2-1", StatusCode::OK),
-        ("inches=NaN-2", StatusCode::OK),
-        ("inches=0-inf", StatusCode::OK),
-    ] {
-        let response = send(
-            &app,
-            "GET",
-            "/runs/cafebabe/length",
-            &[("range", range)],
-            "",
-        )
-        .await;
-        assert_eq!(response.status(), status, "{range}");
-    }
-}
-
-#[tokio::test]
-async fn the_clinic_escalates_toward_honesty() {
-    let (app, _) = seeded(Floor::Clinic);
-    let mut hints = Vec::new();
-    for _ in 0..3 {
-        let response = send(
-            &app,
-            "GET",
-            "/runs/cafebabe/diagnosis",
-            &[("authorization", "Excuse \"changing\"")],
-            "",
-        )
-        .await;
-        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
-        hints.push(header(&response, "www-authenticate").to_owned());
-    }
-    assert!(hints[2].contains("Be honest."));
-}
-
-#[tokio::test]
-async fn the_true_ending_is_not_modified() {
-    let (early, _) = seeded(Floor::Bedroom);
-    let response = send(&early, "GET", "/runs/cafebabe/diagnosis", &[], "").await;
-    assert_eq!(response.status(), StatusCode::TOO_EARLY);
-
-    let (app, etag) = seeded(Floor::Clinic);
-    assert!(
-        !etag.contains("cafebabe"),
-        "the origin ETag must not be derivable from the id"
-    );
-    let response = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/diagnosis",
-        &[
-            ("authorization", "Bearer honesty"),
-            ("if-none-match", &etag),
-        ],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
-    assert_eq!(header(&response, "x-diagnosis"), "normal");
-}
-
-#[tokio::test]
-async fn mum_accepts_a_known_excuse() {
-    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
-    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
-    assert_eq!(header(&response, "via"), "1.1 mum");
-    let response = send(
-        &app,
-        "GET",
-        "/runs/cafebabe",
-        &[("authorization", "Excuse \"homework\"")],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn mum_runs_out_of_patience() {
-    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
-    let lie = [("authorization", "Excuse \"it is for science\"")];
-    for _ in 0..2 {
-        let response = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
-        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
-    }
-    let caught = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
-    assert_eq!(caught.status(), StatusCode::GONE);
-    assert_eq!(
-        json(caught).await["type"],
-        "https://jelq.dev/problems/caught"
-    );
-}
-
-#[tokio::test]
-async fn mum_remembers_excuses_by_christmas() {
-    let app = seeded_with(Floor::Nans, |run| {
-        mum_at_the_door(run);
-        run.heard.push("homework".into());
-    });
-    let basic = send(
-        &app,
-        "GET",
-        "/runs/cafebabe",
-        &[("authorization", "Excuse \"changing\"")],
-        "",
-    )
-    .await;
-    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);
-    assert!(header(&basic, "www-authenticate").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=\"wrapping presents\", nonce=\"abc\"",
-        )],
-        "",
-    )
-    .await;
-    assert_eq!(fresh.status(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn a_pulled_muscle_is_a_true_excuse() {
-    let app = seeded_with(Floor::Nans, |run| {
-        mum_at_the_door(run);
-        run.conditions.pulled_muscle = true;
-        run.heard.push("pulled a muscle".into());
-    });
-    let response = send(
-        &app,
-        "GET",
-        "/runs/cafebabe",
-        &[(
-            "authorization",
-            "Digest username=\"pulled a muscle\", nonce=\"abc\"",
-        )],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::OK);
-    assert!(header(&response, "x-stamina").ends_with("/7"));
-}
-
-#[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.here.turns = 6);
-    let next = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
-    assert!(
-        next.status() == StatusCode::SEE_OTHER || next.status() == StatusCode::CONFLICT,
-        "either the floor changed or the zip did"
-    );
-}
-
-#[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::ChangingRoom, |_| {});
-    let pump = send(&app, "POST", "/runs/cafebabe/shop/pump", &[], "").await;
-    assert_eq!(pump.status(), StatusCode::UPGRADE_REQUIRED);
-    assert_eq!(header(&pump, "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 only_the_key_opens_the_cage() {
-    let app = seeded_with(Floor::ChangingRoom, |run| run.items.cage = true);
-    send(&app, "POST", "/runs/cafebabe/shop/ice-pack", &[], "").await;
-    let still = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/inventory/chastity-cage",
-        &[],
-        "",
-    )
-    .await;
-    assert_eq!(still.status(), StatusCode::OK);
-    send(&app, "POST", "/runs/cafebabe/shop/cage-key", &[], "").await;
-    let gone = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/inventory/chastity-cage",
-        &[],
-        "",
-    )
-    .await;
-    assert_eq!(gone.status(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn combos_are_multi_status_xml() {
-    let app = seeded_with(Floor::Bathroom, |run| {
-        run.foreskin = Some(1.0);
-        run.items.blinds = true;
-    });
-    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);
-    assert!(text(response).await.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);
-}
-
-#[tokio::test]
-async fn the_displayed_length_is_accepted_as_honest() {
-    let app = seeded_with(Floor::Forum, |run| run.length = 5.2496);
-    let response = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/elder",
-        &[("proxy-authorization", "Ruler 5.25")],
-        "",
-    )
-    .await;
-    assert_eq!(response.status(), StatusCode::OK);
-}
-
-#[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 the_internet_never_forgets() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.filmed_at = Some(std::time::SystemTime::now());
-    });
-    let footage = send(&app, "GET", "/runs/cafebabe/footage", &[], "").await;
-    assert_eq!(footage.status(), StatusCode::OK);
-    assert_eq!(
-        header(&footage, "cache-control"),
-        "public, max-age=31536000, immutable"
-    );
-    assert!(footage.headers().contains_key(header::AGE));
-    let delete = send(&app, "DELETE", "/runs/cafebabe/footage", &[], "").await;
-    assert_eq!(delete.status(), StatusCode::METHOD_NOT_ALLOWED);
-    assert!(!header(&delete, "allow").contains("DELETE"));
-}
-
-#[tokio::test]
-async fn forged_ruler_cookies_are_lies() {
-    let forged = send(
-        &app(),
-        "GET",
-        "/leaderboard?sort=content-length",
-        &[("cookie", "ruler=1")],
-        "",
-    )
-    .await;
-    assert_eq!(forged.status(), StatusCode::BAD_REQUEST);
-}
-
-#[tokio::test]
-async fn listings_never_reveal_the_private_id() {
-    let app = app();
-    let created = send(&app, "POST", "/runs", &[], "").await;
-    let location = header(&created, "location").to_owned();
-    let board = text(send(&app, "GET", "/leaderboard", &[], "").await).await;
-    let private = location.trim_start_matches("/runs/");
-    assert!(!board.contains(private));
-    let entry: Value = serde_json::from_str(&board).unwrap();
-    let public = entry["entries"][0]["public_id"].as_str().unwrap();
-    let guess = send(&app, "DELETE", &format!("/runs/{public}"), &[], "").await;
-    assert_eq!(guess.status(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn seeded_runs_are_unranked() {
-    let app = app();
-    send(&app, "POST", "/runs?seed=7", &[], "").await;
-    let board = json(send(&app, "GET", "/leaderboard", &[], "").await).await;
-    assert_eq!(board["entries"].as_array().unwrap().len(), 0);
-    let all = json(send(&app, "GET", "/leaderboard?seeded=include", &[], "").await).await;
-    assert_eq!(all["entries"][0]["ranked"], false);
-}
-
-#[tokio::test]
-async fn idle_runs_are_evicted_and_the_server_has_a_limit() {
-    let forgetful = crate::app(Config {
-        idle_ttl: Duration::ZERO,
-        ..Config::default()
-    });
-    let first = send(&forgetful, "POST", "/runs", &[], "").await;
-    let location = header(&first, "location").to_owned();
-    send(&forgetful, "POST", "/runs", &[], "").await;
-    let gone = send(&forgetful, "GET", &location, &[], "").await;
-    assert_eq!(gone.status(), StatusCode::NOT_FOUND);
-
-    let tiny = crate::app(Config {
-        max_runs: 1,
-        ..Config::default()
-    });
-    send(&tiny, "POST", "/runs", &[], "").await;
-    let full = send(&tiny, "POST", "/runs", &[], "").await;
-    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
-}
-
-#[tokio::test]
-async fn shame_from_two_runs_adds_up() {
-    let state = Arc::new(AppState::default());
-    state.insert(fixture());
-    state.insert(Run::new("deadbeef".into(), "dead".into(), 7));
-    let app = router(state);
-    let first = send(&app, "TRACE", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&first, "x-shame"), "1");
-    let cookie = header(&first, "set-cookie")
-        .split(';')
-        .next()
-        .unwrap()
-        .to_owned();
-    let second = send(&app, "TRACE", "/runs/deadbeef", &[("cookie", &cookie)], "").await;
-    assert_eq!(header(&second, "x-shame"), "2");
-}
-
-#[tokio::test]
-async fn the_root_negotiates() {
-    let app = app();
-    let browser = send(&app, "GET", "/", &[("accept", "text/html,*/*")], "").await;
-    assert_eq!(browser.status(), StatusCode::SEE_OTHER);
-    assert_eq!(header(&browser, "location"), "/ui/");
-    let curl = send(&app, "GET", "/", &[("accept", "*/*")], "").await;
-    assert_eq!(json(curl).await["ui"], "/ui/");
-    let page = send(&app, "GET", "/ui/", &[], "").await;
-    assert_eq!(page.status(), StatusCode::OK);
-}
-
-#[tokio::test]
-async fn the_ui_replays_what_browsers_cannot_send() {
-    let app = app();
-    let envelope =
-        r#"{"method": "TRACE", "path": "/graveyard", "headers": [["X-Confession", "I did it"]]}"#;
-    let traced = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
-    assert_eq!(traced["status"], 405);
-    let envelope = r#"{"method": "GET", "path": "/", "headers": [["Accept", "text/html"]]}"#;
-    let redirected = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
-    assert_eq!(redirected["status"], 303);
-    assert_eq!(redirected["reason"], "See Other");
-}
-
-#[tokio::test]
-async fn the_ui_decodes_gzip_for_display() {
-    let app = seeded_with(Floor::Bedroom, |run| run.items.ring = true);
-    let envelope =
-        r#"{"method": "GET", "path": "/runs/cafebabe", "headers": [["Accept-Encoding", "gzip"]]}"#;
-    let shown = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
-    assert!(
-        shown["body"]
-            .as_str()
-            .unwrap()
-            .contains("\"public_id\":\"cafe\"")
-    );
-    let encoding = shown["headers"]
-        .as_array()
-        .unwrap()
-        .iter()
-        .any(|h| h[0] == "content-encoding" && h[1] == "gzip");
-    assert!(encoding);
-}
-
-#[tokio::test]
-async fn http_1_0_gets_the_pdf_treatment() {
-    let request = Request::builder()
-        .uri("/graveyard")
-        .version(Version::HTTP_10)
-        .body(Body::empty())
-        .unwrap();
-    let response = app().oneshot(request).await.unwrap();
-    assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
-}
-
-#[tokio::test]
-async fn mom_speaks_american() {
-    let app = seeded_with(Floor::Nans, mum_at_the_door);
-    let us = [("accept-language", "en-US")];
-    let knock = send(&app, "GET", "/runs/cafebabe", &us, "").await;
-    assert_eq!(header(&knock, "content-language"), "en-US");
-    assert_eq!(header(&knock, "via"), "1.1 mom");
-    assert!(
-        json(knock).await["detail"]
-            .as_str()
-            .unwrap()
-            .contains("Someone is at the door.")
-    );
-    let excuse = [
-        ("accept-language", "en-US"),
-        (
-            "authorization",
-            "Digest username=\"carving the turkey\", nonce=\"abc\"",
-        ),
-    ];
-    let answered = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;
-    assert_eq!(answered.status(), StatusCode::OK);
-    let floor = json(send(&app, "GET", "/runs/cafebabe/floor", &us, "").await).await;
-    assert_eq!(floor["name"], "Grandma's house for Thanksgiving");
-}
-
-#[tokio::test]
-async fn the_default_locale_is_british() {
-    let (app, _) = seeded(Floor::Nans);
-    let floor = send(&app, "GET", "/runs/cafebabe/floor", &[], "").await;
-    assert_eq!(header(&floor, "content-language"), "en-GB");
-    assert!(header(&floor, "vary").contains("Accept-Language"));
-    assert_eq!(json(floor).await["name"], "Nan's house at Christmas");
-}
-
-fn advertised(response: &Response) -> Vec<String> {
-    header(response, "link")
-        .split(", <")
-        .filter(|entry| entry.contains("rels/technique"))
-        .filter_map(|entry| {
-            entry
-                .split("title=\"")
-                .nth(1)?
-                .split('"')
-                .next()
-                .map(str::to_owned)
-        })
-        .collect()
-}
-
-#[tokio::test]
-async fn links_offer_only_usable_techniques() {
-    let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));
-    let cold = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(advertised(&cold), ["warmup", "ice", "meditate"]);
-    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    let usable = advertised(&warm);
-    assert!(usable.contains(&"wet".to_owned()) && usable.contains(&"dry".to_owned()));
-    assert!(!usable.contains(&"uli".to_owned()), "uli needs the forum");
-    assert!(!usable.contains(&"pump".to_owned()), "pump needs a pump");
-    assert!(
-        header(&warm, "link").contains("title=\"wet\"; allow=\"JELQ\"; lubricant=\"required\"")
-    );
-
-    let (forum, _) = seeded(Floor::Forum);
-    let response = send(&forum, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(advertised(&response).is_empty());
-}
-
-fn linked_rels(response: &Response) -> Vec<String> {
-    header(response, "link")
-        .split(", <")
-        .filter_map(|entry| {
-            entry
-                .split("rels/")
-                .nth(1)?
-                .split('"')
-                .next()
-                .map(str::to_owned)
-        })
-        .filter(|rel| rel != "technique")
-        .collect()
-}
-
-#[tokio::test]
-async fn links_hide_resources_that_would_do_nothing() {
-    let (bedroom, _) = seeded(Floor::Bedroom);
-    let before = linked_rels(&send(&bedroom, "GET", "/runs/cafebabe", &[], "").await);
-    assert!(before.contains(&"drawer".to_owned()));
-    assert!(!before.contains(&"diagnosis".to_owned()));
-    assert!(!before.contains(&"thread".to_owned()));
-    let searched = send(&bedroom, "POST", "/runs/cafebabe/drawer", &[], "").await;
-    assert!(!linked_rels(&searched).contains(&"drawer".to_owned()));
-
-    let (clinic, _) = seeded(Floor::Clinic);
-    let rels = linked_rels(&send(&clinic, "GET", "/runs/cafebabe", &[], "").await);
-    assert!(rels.contains(&"diagnosis".to_owned()) && rels.contains(&"thread".to_owned()));
-}
-
-#[tokio::test]
-async fn ignoring_mum_has_consequences() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        mum_at_the_door(run);
-        run.here.turns = 6;
-    });
-    let knock = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(
-        json(knock).await["type"],
-        "https://jelq.dev/problems/someone-at-the-door"
-    );
-    let leave = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
-    assert_eq!(
-        leave.status(),
-        StatusCode::UNAUTHORIZED,
-        "no leaving with Mum at the door"
-    );
-    send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    let opened = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(opened.status(), StatusCode::GONE);
-    assert_eq!(
-        json(opened).await["type"],
-        "https://jelq.dev/problems/opened"
-    );
-}
-
-#[tokio::test]
-async fn caged_drawers_are_noisy_and_eventually_give_up_the_key() {
-    let app = seeded_with(Floor::ChangingRoom, |run| run.items.cage = true);
-    let mut statuses = Vec::new();
-    for _ in 0..12 {
-        let response = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
-        statuses.push(response.status());
-        if response.status() == StatusCode::OK {
-            break;
-        }
-    }
-    assert_eq!(statuses.last(), Some(&StatusCode::OK), "{statuses:?}");
-    assert!(
-        statuses[..statuses.len() - 1]
-            .iter()
-            .all(|s| *s == StatusCode::NO_CONTENT)
-    );
-}
-
-#[tokio::test]
-async fn the_ruler_replaces_the_self_report() {
-    let app = seeded_with(Floor::Bedroom, |_| {});
-    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(before.headers().contains_key("x-self-reported-length"));
-    assert!(!before.headers().contains_key("x-length"));
-
-    let app = seeded_with(Floor::Bedroom, |run| run.items.ruler = true);
-    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!after.headers().contains_key("x-self-reported-length"));
-    assert!(after.headers().contains_key("x-length"));
-}
-
-#[tokio::test]
-async fn an_open_tab_is_linked_and_jelq_still_answers_with_choices() {
-    let app = seeded_with(Floor::Bathroom, |run| {
-        run.story = Story::Pending;
-        run.warmed_up = true;
-    });
-    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    let links = header(&response, "link");
-    assert!(links.contains("/branches/forum>; rel=\"https://jelq.dev/rels/branch\""));
-    assert!(links.contains("/branches/close-tab>; rel=\"https://jelq.dev/rels/branch\""));
-    assert!(links.contains("?technique=wet>"));
-    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(jelq.status(), StatusCode::MULTIPLE_CHOICES);
-}
-
-#[tokio::test]
-async fn either_story_choice_is_reachable_during_cooldown() {
-    for choice in ["forum", "close-tab"] {
-        let app = seeded_with(Floor::Bathroom, |run| {
-            run.turn = 9;
-            run.warmed_up = true;
-            run.eq = 45;
-            run.stamina = 1;
-            run.items.door_locks = 1;
-        });
-        let tenth = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-        assert_eq!(tenth.status(), StatusCode::OK);
-        let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-        assert!(!header(&response, "link").contains("?technique="));
-        let path = format!("/runs/cafebabe/branches/{choice}");
-        assert!(
-            header(&response, "link")
-                .contains(&format!("<{path}>; rel=\"https://jelq.dev/rels/branch\""))
-        );
-        let chosen = send(&app, "POST", &path, &[], "").await;
-        assert_eq!(chosen.status(), StatusCode::SEE_OTHER);
-        assert!(!header(&chosen, "link").contains("/branches/"));
-        let repeated = send(&app, "POST", &path, &[], "").await;
-        assert_eq!(repeated.status(), StatusCode::CONFLICT);
-    }
-}
-
-#[tokio::test]
-async fn a_door_lock_says_when_it_was_used() {
-    let app = seeded_with(Floor::Bathroom, |run| {
-        run.items.door_locks = 1;
-        run.suspicion = SUSPICION_LIMIT;
-        run.warmed_up = true;
-    });
-    let response = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
-    assert_ne!(response.status(), StatusCode::CONFLICT);
-    assert!(
-        response
-            .headers()
-            .get_all("warning")
-            .iter()
-            .any(|w| w.to_str().unwrap().contains("your brother tried the door"))
-    );
-}
-
-#[tokio::test]
-async fn shopping_survives_browsing_but_not_jelqing() {
-    let app = seeded_with(Floor::ChangingRoom, |run| run.cash = 50);
-    send(&app, "GET", "/runs/cafebabe/shop", &[], "").await;
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&view, "link").contains("shop-item"));
-    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    assert_ne!(jelq.status(), StatusCode::METHOD_NOT_ALLOWED);
-    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&after, "link").contains("shop-item"));
-}
-
-#[tokio::test]
-async fn the_thread_announces_itself_at_the_branch() {
-    let app = seeded_with(Floor::Bathroom, |run| {
-        run.turn = 8;
-        run.warmed_up = true;
-        run.items.baby_oil = 9;
-    });
-    send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet",
-        &[("content-type", "application/baby-oil")],
-        "",
-    )
-    .await;
-    let ninth = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&ninth, "link").contains("/forum/threads/2009"));
-    let tenth = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet",
-        &[("content-type", "application/baby-oil")],
-        "",
-    )
-    .await;
-    assert!(
-        tenth
-            .headers()
-            .get_all("warning")
-            .iter()
-            .any(|w| w.to_str().unwrap().contains("a forum thread from 2009"))
-    );
-    assert!(header(&tenth, "link").contains("/forum/threads/2009"));
-    let announced = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&announced, "link").contains("/forum/threads/2009"));
-}
-
-#[tokio::test]
-async fn rereading_the_thread_teaches_uli() {
-    let mut taught_runs = 0;
-    for seed in 0..100u64 {
-        let app = app_with(Floor::Bedroom, seed, |run| {
-            run.turn = BRANCH_TURN;
-            run.warmed_up = true;
-            run.story = Story::ClosedTab;
-        });
-        let mut taught = false;
-        for _ in 0..2 {
-            let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
-            match read.status() {
-                StatusCode::NOT_MODIFIED => {
-                    assert!(header(&read, "warning").contains("2009"));
-                }
-                StatusCode::OK => {
-                    assert!(header(&read, "location").contains("/techniques"));
-                    taught = true;
-                    break;
-                }
-                other => panic!("seed {seed} read the thread into {other}"),
-            }
-        }
-        let state = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-        assert_eq!(header(&state, "x-stamina"), "10/10", "reading is free");
-        if taught {
-            taught_runs += 1;
-            let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
-            assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
-        } else {
-            let cached = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
-            assert_eq!(cached.status(), StatusCode::OK);
-            assert!(header(&cached, "warning").starts_with("112"));
-            assert!(header(&cached, "age").parse::<u64>().unwrap() > 0);
-        }
-    }
-    assert!(
-        (30..=58).contains(&taught_runs),
-        "{taught_runs}/100 learned uli in two reads"
-    );
-}
-
-#[tokio::test]
-async fn meditation_is_free_but_only_once_per_floor() {
-    let app = seeded_with(Floor::Bedroom, |_| {});
-    let response = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
-    assert_eq!(response.status(), StatusCode::OK);
-    assert_eq!(header(&response, "x-eq"), "10");
-    assert_eq!(header(&response, "x-stamina"), "10/10");
-    let again = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
-    assert_eq!(again.status(), StatusCode::CONFLICT);
-}
-
-#[tokio::test]
-async fn meditation_is_listed_from_the_start() {
-    let app = seeded_with(Floor::Bedroom, |_| {});
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&view, "link").contains("technique=meditate"));
-    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
-    assert_eq!(jelq.status(), StatusCode::OK);
-}
-
-fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {
-    let state = Arc::new(AppState::default());
-    let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-    run.floor = floor;
-    setup(&mut run);
-    state.insert(run);
-    router(state)
-}
-
-#[tokio::test]
-async fn hold_is_offered_only_at_the_edges() {
-    let calm = seeded_with(Floor::Bedroom, |_| {});
-    let refused = send(&calm, "HOLD", "/runs/cafebabe", &[], "").await;
-    assert_eq!(refused.status(), StatusCode::METHOD_NOT_ALLOWED);
-    assert!(!header(&refused, "allow").contains("HOLD"));
-    let view = send(&calm, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&view, "link").contains("HOLD"));
-    let options = send(&calm, "OPTIONS", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&options, "allow").contains("HOLD"));
-
-    let winded = seeded_with(Floor::Bedroom, |run| run.stamina = 2);
-    let listed = send(&winded, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&listed, "link").contains("HOLD"));
-    let options = send(&winded, "OPTIONS", "/runs/cafebabe", &[], "").await;
-    assert!(header(&options, "allow").contains("HOLD"));
-
-    let hot = seeded_with(Floor::Bedroom, |run| {
-        run.eq = 75;
-        run.warmed_up = true;
-    });
-    let held = send(&hot, "HOLD", "/runs/cafebabe", &[], "").await;
-    assert_eq!(held.status(), StatusCode::NO_CONTENT);
-    assert_eq!(header(&held, "x-stamina"), "10/10");
-}
-
-#[tokio::test]
-async fn holding_calms_and_sometimes_reflects() {
-    let mut calmed = 0;
-    let mut reflected = 0;
-    let mut ruptured = 0;
-    for seed in 0..120u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        run.eq = 75;
-        match run.hold() {
-            Ok(_) if run.eq == 0 => reflected += 1,
-            Ok(_) => calmed += 1,
-            Err(_) => ruptured += 1,
-        }
-    }
-    assert!(
-        calmed > 100 && reflected > 0,
-        "one HOLD in twelve should reflect, got {calmed} calm and {reflected} reflective of 120"
-    );
-    assert!(
-        calmed + reflected + ruptured == 120 && ruptured <= 4,
-        "the flat 1 in 250 ruptured {ruptured} of 120 holds"
-    );
-}
-
-#[tokio::test]
-async fn leaving_the_band_warms_the_next_floor() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.eq = 60;
-        run.warmed_up = true;
-        run.here.turns = 6;
-        run.items.baby_oil = 9;
-    });
-    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
-    assert_eq!(left.status(), StatusCode::SEE_OTHER);
-    let detail = json(left).await["detail"].as_str().unwrap().to_owned();
-    assert!(detail.contains("the warmth came with you"));
-
-    let lube = [("content-type", "application/baby-oil")];
-    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    // The shower is a +35 warm-up, so EQ lands in the band and the band bonus rides along.
-    // The arrival bonus is the one point the second jelq loses.
-    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-    assert!(
-        header(&first, "server-timing").contains("d20+4"),
-        "the first jelq of a warm arrival rolls with +1, got {}",
-        header(&first, "server-timing")
-    );
-    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-    assert!(header(&second, "server-timing").contains("d20+3"));
-}
-
-#[tokio::test]
-async fn greed_multiplies_gains_above_the_band() {
-    let lube = [("content-type", "application/baby-oil")];
-    for seed in 0..60u64 {
-        let app = app_with(Floor::Bedroom, seed, |run| {
-            run.eq = 60;
-            run.warmed_up = true;
-        });
-        let in_band = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-        let app = app_with(Floor::Bedroom, seed, |run| {
-            run.eq = 75;
-            run.warmed_up = true;
-        });
-        let greedy = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-        if in_band.status() != StatusCode::OK || greedy.status() != StatusCode::OK {
-            continue;
-        }
-        let steady = json(in_band).await["length"].as_f64().unwrap();
-        let eager = json(greedy).await["length"].as_f64().unwrap();
-        assert!(
-            (eager - steady * 1.5).abs() < 1e-9,
-            "seed {seed} gained {eager} above the band against {steady} inside it"
-        );
-        return;
-    }
-    panic!("no seed in 60 produced two clean rolls to compare");
-}
-
-#[tokio::test]
-async fn the_kitchen_is_only_on_the_home_floors() {
-    let absent = seeded_with(Floor::Bathroom, |_| {});
-    let no_kitchen = send(&absent, "POST", "/runs/cafebabe/kitchen", &[], "").await;
-    assert_eq!(no_kitchen.status(), StatusCode::NOT_FOUND);
-    let view = send(&absent, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&view, "link").contains("/kitchen"));
-
-    let app = seeded_with(Floor::Bedroom, |_| {});
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&view, "link").contains("/kitchen"));
-    let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
-    assert_ne!(raid.status(), StatusCode::NOT_FOUND);
-}
-
-#[tokio::test]
-async fn raids_cost_the_turn_and_the_fridge_pays_out_sometimes() {
-    let mut bounties = std::collections::BTreeSet::new();
-    let mut told = 0;
-    for seed in 0..80u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        let Ok(outcome) = run.raid_kitchen() else {
-            panic!("the first raid should never fail");
-        };
-        assert_eq!(run.turn, 1, "a raid costs the floor turn");
-        assert!(!run.here.melon_offered, "no melon at starting EQ");
-        if outcome.status == StatusCode::NO_CONTENT {
-            bounties.insert("empty");
-        } else {
-            bounties.insert("loot");
-        }
-        told += u32::from(run.kitchen_tellings);
-    }
-    assert!(bounties.contains("loot") && bounties.contains("empty"));
-    assert!(
-        (0..80).any(|seed| {
-            let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-            run.raid_kitchen().is_ok() && run.kitchen_tellings == 0
-        }),
-        "most raids go unremarked"
-    );
-    assert!(told > 0, "someone should have been told across 80 raids");
-}
-
-#[tokio::test]
-async fn the_watermelon_offers_itself_above_ninety() {
-    let mut offered = 0;
-    let mut caught = 0;
-    let mut survived = 0;
-    for seed in 0..120u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        run.eq = 95;
-        let Ok(outcome) = run.raid_kitchen() else {
-            continue;
-        };
-        if outcome.status != StatusCode::MULTIPLE_CHOICES {
-            continue;
-        }
-        offered += 1;
-        let gains = run.length;
-        let disgrace = run.shame;
-        if run.commit_melon().is_err() {
-            caught += 1;
-            assert_eq!(run.ended.as_ref().unwrap().cause.slug(), "watermelon");
-        } else {
-            survived += 1;
-            assert_eq!(run.eq, 0);
-            assert_eq!(run.shame, disgrace + 5);
-            assert_eq!(run.length, gains, "the gains are kept");
-        }
-    }
-    assert!(
-        offered > 20,
-        "the melon should appear in two fifths of raids"
-    );
-    assert!(caught > 0 && survived > 0, "caught is one in three");
-}
-
-#[tokio::test]
-async fn a_melon_offer_does_not_survive_a_non_kitchen_turn() {
-    for seed in 0..60u64 {
-        let jelq_app = app_with(Floor::Bedroom, seed, |run| {
-            run.warmed_up = true;
-            run.here.melon_offered = true;
-        });
-        let stroked = send(
-            &jelq_app,
-            "JELQ",
-            "/runs/cafebabe?technique=wet&intensity=2",
-            &[],
-            "",
-        )
-        .await;
-        if stroked.status() != StatusCode::OK && stroked.status() != StatusCode::PARTIAL_CONTENT {
-            continue;
-        }
-        let bite = send(
-            &jelq_app,
-            "POST",
-            "/runs/cafebabe/kitchen/watermelon",
-            &[],
-            "",
-        )
-        .await;
-        assert_eq!(
-            bite.status(),
-            StatusCode::CONFLICT,
-            "seed {seed} kept the melon through a jelq"
-        );
-
-        let hold_app = app_with(Floor::Bedroom, seed, |run| {
-            run.stamina = 2;
-            run.here.melon_offered = true;
-        });
-        let held = send(&hold_app, "HOLD", "/runs/cafebabe", &[], "").await;
-        if held.status() != StatusCode::NO_CONTENT {
-            continue;
-        }
-        let bite = send(
-            &hold_app,
-            "POST",
-            "/runs/cafebabe/kitchen/watermelon",
-            &[],
-            "",
-        )
-        .await;
-        assert_eq!(
-            bite.status(),
-            StatusCode::CONFLICT,
-            "seed {seed} kept the melon through a hold"
-        );
-
-        let read_app = app_with(Floor::Bedroom, seed, |run| {
-            run.story = Story::ClosedTab;
-            run.here.melon_offered = true;
-        });
-        let read = send(&read_app, "POST", "/runs/cafebabe/re-read", &[], "").await;
-        if read.status() == StatusCode::INTERNAL_SERVER_ERROR {
-            continue;
-        }
-        let bite = send(
-            &read_app,
-            "POST",
-            "/runs/cafebabe/kitchen/watermelon",
-            &[],
-            "",
-        )
-        .await;
-        assert_eq!(
-            bite.status(),
-            StatusCode::CONFLICT,
-            "seed {seed} kept the melon through a re-read"
-        );
-    }
-
-    let mut stood = 0;
-    for seed in 0..60u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        run.eq = 95;
-        run.here.melon_offered = true;
-        if run.raid_kitchen().is_err() {
-            continue;
-        }
-        stood += 1;
-        assert!(
-            run.here.melon_offered,
-            "seed {seed} lost the melon to another raid"
-        );
-    }
-    assert!(stood > 40, "raids at eq 95 rarely rupture");
-}
-
-#[tokio::test]
-async fn the_kitchen_closes_after_two_tellings() {
-    let mut closed = None;
-    for seed in 0..300u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        let first = run.raid_kitchen();
-        let second = run.raid_kitchen();
-        if second.is_err() && first.is_ok() {
-            assert_eq!(run.kitchen_tellings, 2);
-            let Err(third) = run.raid_kitchen() else {
-                panic!("the kitchen should be gone");
-            };
-            assert_eq!(third.status(), StatusCode::GONE);
-            closed = Some(seed);
-            break;
-        }
-    }
-    assert!(
-        closed.is_some(),
-        "two tellings should occur within 300 seeds"
-    );
-}
-
-#[tokio::test]
-async fn lubes_run_out_but_spit_never_does() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.items.baby_oil = 1;
-    });
-    let lube = [("content-type", "application/baby-oil")];
-    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-    assert_ne!(first.status(), StatusCode::PRECONDITION_FAILED);
-    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-    assert_eq!(second.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
-
-    let spit = [("content-type", "text/plain; charset=spit")];
-    for _ in 0..3 {
-        let wet = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
-        assert_ne!(wet.status(), StatusCode::PRECONDITION_FAILED);
-    }
-}
-
-#[tokio::test]
-async fn energy_drinks_add_three_stamina() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.stamina = 2;
-        run.items.energy_drinks = 1;
-    });
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&view, "link").contains("technique=energy"));
-    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
-    assert_eq!(drink.status(), StatusCode::OK);
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-stamina"), "5/10");
-    let again = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
-    assert_eq!(again.status(), StatusCode::FAILED_DEPENDENCY);
-}
-
-#[tokio::test]
-async fn the_working_supplement_resets_stamina() {
-    let mut worked = 0;
-    let mut bunk = 0;
-    for seed in 0..60u64 {
-        let app = app_with(Floor::Bedroom, seed, |run| {
-            run.stamina = 1;
-            run.items.supplements = 1;
-        });
-        let taken = send(&app, "JELQ", "/runs/cafebabe?technique=supplement", &[], "").await;
-        if taken.status() == StatusCode::OK {
-            worked += 1;
-            let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-            assert_eq!(header(&view, "x-stamina"), "10/10");
-        } else {
-            assert_eq!(taken.status(), StatusCode::BAD_GATEWAY);
-            bunk += 1;
-        }
-    }
-    assert!(worked > 0 && bunk > 0, "one in five should work too well");
-}
-
-#[tokio::test]
-async fn dry_jelqs_build_friction_and_real_lube_does_not() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.foreskin = Some(0.9);
-    });
-    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
-    assert_eq!(header(&dry, "x-friction"), "2/10");
-    let lube = [("content-type", "application/baby-oil")];
-    let wet = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &lube,
-        "",
-    )
-    .await;
-    assert_eq!(header(&wet, "x-friction"), "2/10");
-    let spit = [("content-type", "text/plain; charset=spit")];
-    let glisten = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &spit,
-        "",
-    )
-    .await;
-    assert_eq!(header(&glisten, "x-friction"), "3/10");
-}
-
-#[tokio::test]
-async fn switching_grips_makes_the_friction_cheaper() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.foreskin = Some(0.9);
-    });
-    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
-    assert_eq!(header(&dry, "x-friction"), "2/10");
-    send(
-        &app,
-        "GET",
-        "/runs/cafebabe/grip",
-        &[("upgrade", "underhand"), ("connection", "upgrade")],
-        "",
-    )
-    .await;
-    let switched = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
-    assert_eq!(header(&switched, "x-friction"), "3/10");
-    let settled = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
-    assert_eq!(header(&settled, "x-friction"), "5/10");
-}
-
-#[tokio::test]
-async fn holding_and_meditating_shed_friction() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.eq = 80;
-        run.friction = 5;
-    });
-    let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
-    assert_eq!(held.status(), StatusCode::NO_CONTENT);
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-friction"), "3/10");
-
-    let taught = seeded_with(Floor::Bedroom, |run| {
-        run.friction = 5;
-    });
-    let calmed = send(
-        &taught,
-        "JELQ",
-        "/runs/cafebabe?technique=meditate",
-        &[],
-        "",
-    )
-    .await;
-    assert_eq!(calmed.status(), StatusCode::OK);
-    let view = send(&taught, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-friction"), "3/10");
-}
-
-#[tokio::test]
-async fn a_friction_burn_halves_the_gains() {
-    let lube = [("content-type", "application/baby-oil")];
-    let path = "/runs/cafebabe?technique=wet&intensity=5";
-    for seed in 0..60u64 {
-        let steady = app_with(Floor::Bedroom, seed, |run| {
-            run.warmed_up = true;
-            run.eq = 60;
-            run.items.baby_oil = 9;
-        });
-        let hurt_app = app_with(Floor::Bedroom, seed, |run| {
-            run.warmed_up = true;
-            run.eq = 60;
-            run.items.baby_oil = 9;
-            run.conditions.friction_burn = true;
-        });
-        let calm = send(&steady, "JELQ", path, &lube, "").await;
-        let hurt = send(&hurt_app, "JELQ", path, &lube, "").await;
-        if calm.status() != StatusCode::OK || hurt.status() != StatusCode::OK {
-            continue;
-        }
-        let calm_gain = json(calm).await["length"].as_f64().unwrap();
-        let hurt_gain = json(hurt).await["length"].as_f64().unwrap();
-        assert!(
-            (hurt_gain * 2.0 - calm_gain).abs() < 1e-9,
-            "seed {seed} burned {hurt_gain} against {calm_gain}"
-        );
-        return;
-    }
-    panic!("no seed in 60 produced two clean rolls to compare");
-}
-
-#[tokio::test]
-async fn the_burn_warns_and_the_ice_treats_it() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.eq = 60;
-        run.items.baby_oil = 9;
-        run.friction = 7;
-        run.conditions.friction_burn = true;
-    });
-    let lube = [("content-type", "application/baby-oil")];
-    let jelq = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &lube,
-        "",
-    )
-    .await;
-    let warnings: Vec<_> = jelq
-        .headers()
-        .get_all("warning")
-        .iter()
-        .filter_map(|w| w.to_str().ok())
-        .collect();
-    assert!(warnings.contains(&"199 - \"friction burn\""));
-    send(&app, "JELQ", "/runs/cafebabe?technique=ice", &[], "").await;
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    let warnings: Vec<_> = view
-        .headers()
-        .get_all("warning")
-        .iter()
-        .filter_map(|w| w.to_str().ok())
-        .collect();
-    assert!(!warnings.contains(&"199 - \"friction burn\""));
-}
-
-#[tokio::test]
-async fn the_burn_shifts_the_rupture_tiers() {
-    async fn ruptures(burned: bool) -> u32 {
-        let mut gone = 0;
-        for seed in 0..400u64 {
-            let app = app_with(Floor::Bedroom, seed, |run| {
-                run.warmed_up = true;
-                run.eq = 60;
-                run.items.baby_oil = 9;
-                run.conditions.friction_burn = burned;
-            });
-            let lube = [("content-type", "application/baby-oil")];
-            let jelq = send(
-                &app,
-                "JELQ",
-                "/runs/cafebabe?technique=wet&intensity=5",
-                &lube,
-                "",
-            )
-            .await;
-            if jelq.status() == StatusCode::INTERNAL_SERVER_ERROR {
-                gone += 1;
-            }
-        }
-        gone
-    }
-    let burned = ruptures(true).await;
-    let calm = ruptures(false).await;
-    assert!(
-        burned >= 8 && calm <= 4,
-        "burned {burned} ruptures against {calm}"
-    );
-}
-
-#[tokio::test]
-async fn meditation_respects_the_priapism_floor() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.eq = 80;
-        run.conditions.priapism_turns = 3;
-    });
-    let calmed = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
-    assert_eq!(calmed.status(), StatusCode::OK);
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-eq"), "75");
-}
-
-#[tokio::test]
-async fn the_kitchen_pays_out_at_the_documented_odds() {
-    let mut oil = 0;
-    let mut drinks = 0;
-    let mut packs = 0;
-    for seed in 0..600u64 {
-        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
-        run.kitchen_tellings = 0;
-        let held = (
-            run.items.coconut_oil,
-            run.items.energy_drinks,
-            run.items.ice_packs,
-        );
-        let _ = run.raid_kitchen();
-        oil += u32::from(run.items.coconut_oil > held.0);
-        drinks += u32::from(run.items.energy_drinks > held.1);
-        packs += u32::from(run.items.ice_packs > held.2);
-    }
-    assert!((170..=230).contains(&oil), "coconut {oil} in 600");
-    assert!((90..=150).contains(&drinks), "energy {drinks} in 600");
-    assert!((45..=105).contains(&packs), "ice {packs} in 600");
-}
-
-#[tokio::test]
-async fn a_refused_jelq_leaves_the_lube_alone() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.items.extender = true;
-        run.girth = 6.0;
-        run.length = 6.0;
-    });
-    let lube = [("content-type", "application/baby-oil")];
-    let full = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &lube,
-        "",
-    )
-    .await;
-    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);
-    let inv = send(&app, "GET", "/runs/cafebabe/inventory", &[], "").await;
-    let body = json(inv).await;
-    let held = body["items"].as_array().unwrap();
-    assert!(held.iter().any(|i| i["name"] == "baby-oil"));
-}
-
-#[tokio::test]
-async fn an_empty_bottle_is_declined_before_the_enemy_stirs() {
-    let control = seeded_with(Floor::ChangingRoom, |run| {
-        run.warmed_up = true;
-        run.suspicion = SUSPICION_LIMIT;
-    });
-    let lube = [("content-type", "application/baby-oil")];
-    let caught = send(
-        &control,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &lube,
-        "",
-    )
-    .await;
-    assert_eq!(caught.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
-
-    let app = seeded_with(Floor::ChangingRoom, |run| {
-        run.warmed_up = true;
-        run.suspicion = SUSPICION_LIMIT;
-        run.items.baby_oil = 0;
-    });
-    let refused = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=wet&intensity=5",
-        &lube,
-        "",
-    )
-    .await;
-    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
-    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-suspicion"), "5/5");
-    assert_eq!(header(&view, "x-shame"), "0");
-}
-
-#[tokio::test]
-async fn the_top_tier_rolls_a_single_third() {
-    let mut ruptures = 0;
-    let mut early = 0;
-    for seed in 0..400u64 {
-        let app = app_with(Floor::Bedroom, seed, |run| {
-            run.warmed_up = true;
-            run.eq = 96;
-            run.items.baby_oil = 9;
-            run.items.blinds = true;
-        });
-        let lube = [("content-type", "application/baby-oil")];
-        let jelq = send(
-            &app,
-            "JELQ",
-            "/runs/cafebabe?technique=wet&intensity=5",
-            &lube,
-            "",
-        )
-        .await;
-        match jelq.status() {
-            StatusCode::INTERNAL_SERVER_ERROR => ruptures += 1,
-            StatusCode::TOO_EARLY => early += 1,
-            other => panic!("seed {seed} ended in {other}"),
-        }
-    }
-    assert!(
-        (90..=175).contains(&ruptures),
-        "ruptures {ruptures} of 400 against {early} early"
-    );
-    assert!(
-        (225..=310).contains(&early),
-        "early {early} of 400 against {ruptures} ruptures"
-    );
-}
-
-#[tokio::test]
-async fn priapism_holds_the_floor_through_every_reset() {
-    let exit = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.eq = 90;
-        run.here.turns = 99;
-        run.conditions.priapism_turns = 3;
-    });
-    let out = send(&exit, "POST", "/runs/cafebabe/floor", &[], "").await;
-    assert_eq!(out.status(), StatusCode::SEE_OTHER);
-    let view = send(&exit, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-eq"), "75");
-
-    let melon = seeded_with(Floor::Bedroom, |run| {
-        run.eq = 95;
-        run.here.melon_offered = true;
-        run.conditions.priapism_turns = 2;
-    });
-    let bite = send(&melon, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
-    assert_eq!(bite.status(), StatusCode::OK);
-    let view = send(&melon, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&view, "x-eq"), "75");
-}
-
-#[tokio::test]
-async fn holding_rolls_a_flat_rupture_chance() {
-    async fn ruptures(eq: i32, stamina: i32) -> u32 {
-        let mut gone = 0;
-        for seed in 0..600u64 {
-            let app = app_with(Floor::Bedroom, seed, |run| {
-                run.warmed_up = true;
-                run.eq = eq;
-                run.stamina = stamina;
-            });
-            let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
-            if held.status() == StatusCode::INTERNAL_SERVER_ERROR {
-                gone += 1;
-            }
-        }
-        gone
-    }
-    let high = ruptures(90, 10).await;
-    let low = ruptures(30, 2).await;
-    assert!((0..=9).contains(&high), "high holds ruptured {high}/600");
-    assert!((0..=9).contains(&low), "low holds ruptured {low}/600");
-}
-
-#[tokio::test]
-async fn the_kitchen_rolls_the_normal_tiers() {
-    async fn ruptures(eq: i32) -> u32 {
-        let mut gone = 0;
-        for seed in 0..600u64 {
-            let app = app_with(Floor::Bedroom, seed, |run| run.eq = eq);
-            let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
-            if raid.status() == StatusCode::INTERNAL_SERVER_ERROR {
-                gone += 1;
-            }
-        }
-        gone
-    }
-    let hot = ruptures(96).await;
-    let cool = ruptures(40).await;
-    assert!((40..=80).contains(&hot), "hot kitchen ruptured {hot}/600");
-    assert!((0..=9).contains(&cool), "cool kitchen ruptured {cool}/600");
-}
-
-#[tokio::test]
-async fn the_thread_cannot_be_reread_before_anyone_mentions_it() {
-    let app = seeded_with(Floor::Bedroom, |run| run.warmed_up = true);
-    let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
-    assert_eq!(read.status(), StatusCode::NOT_FOUND);
-    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(header(&after, "x-floor"), "1");
-    assert!(!header(&after, "link").contains("/re-read"));
-}
-
-#[tokio::test]
-async fn any_other_action_takes_the_melon_off_the_table() {
-    for (method, uri) in [
-        ("JELQ", "/runs/cafebabe?technique=warmup"),
-        ("POST", "/runs/cafebabe/drawer"),
-    ] {
-        let app = seeded_with(Floor::Bedroom, |run| {
-            run.eq = 95;
-            run.here.melon_offered = true;
-        });
-        send(&app, method, uri, &[], "").await;
-        let melon = send(&app, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
-        assert_eq!(melon.status(), StatusCode::CONFLICT, "{method} {uri}");
-    }
-}
-
-#[tokio::test]
-async fn a_refused_jelq_does_not_break_the_edging_streak() {
-    let app = seeded_with(Floor::ChangingRoom, |run| {
-        run.warmed_up = true;
-        run.eq = 45;
-        run.here.edges = 2;
-    });
-    let refused = send(
-        &app,
-        "JELQ",
-        "/runs/cafebabe?technique=dry",
-        &[("content-type", "application/baby-oil")],
-        "",
-    )
-    .await;
-    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
-    let third = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(third.status(), StatusCode::LOOP_DETECTED);
-}
-
-#[tokio::test]
-async fn an_interrupted_edge_keeps_no_gains() {
-    let app = seeded_with(Floor::ChangingRoom, |run| {
-        run.warmed_up = true;
-        run.eq = 10;
-    });
-    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    let girth = header(&before, "x-girth").to_owned();
-    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(edge.status(), StatusCode::NOT_FOUND);
-    assert_eq!(header(&edge, "x-girth"), girth);
-}
-
-#[tokio::test]
-async fn rummaging_for_the_key_leaves_the_drawer_unsearched() {
-    let mut found = 0;
-    for seed in 0..20u64 {
-        let app = app_with(Floor::Hotel, seed, |run| {
-            run.here.wifi_accepted = true;
-            run.items.cage = true;
-        });
-        for _ in 0..30 {
-            let rummage = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
-            if rummage.status() == StatusCode::OK {
-                break;
-            }
-        }
-        let search = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
-        if search.status() == StatusCode::FOUND {
-            assert!(header(&search, "location").ends_with("/inventory/do-not-disturb-sign"));
-            found += 1;
-        }
-    }
-    assert!(
-        found >= 18,
-        "only {found} of 20 hotel drawers survived the rummage"
-    );
-}
-
-#[tokio::test]
-async fn a_full_server_buries_the_dead_to_make_room() {
-    let app = crate::app(Config {
-        max_runs: 1,
-        ..Config::default()
-    });
-    let first = send(&app, "POST", "/runs", &[], "").await;
-    let location = header(&first, "location").to_owned();
-    let full = send(&app, "POST", "/runs", &[], "").await;
-    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
-    send(&app, "DELETE", &location, &[], "").await;
-    let second = send(&app, "POST", "/runs", &[], "").await;
-    assert_eq!(second.status(), StatusCode::CREATED);
-}
-
-#[tokio::test]
-async fn the_towel_warms_once_until_the_kettle_boils() {
-    let app = seeded_with(Floor::Bedroom, |_| {});
-    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    assert_eq!(warm.status(), StatusCode::OK);
-    let again = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    assert_eq!(again.status(), StatusCode::CONFLICT);
-
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.here.kettle_boiled = true;
-    });
-    let reheated = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    assert_eq!(reheated.status(), StatusCode::OK);
-    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
-    assert_eq!(cold.status(), StatusCode::CONFLICT);
-}
-
-#[tokio::test]
-async fn the_refractory_period_is_the_next_hold() {
-    let app = seeded_with(Floor::Hotel, |run| {
-        run.here.wifi_accepted = true;
-        run.warmed_up = true;
-        run.eq = 60;
-        run.stamina = 0;
-        run.exhausted = true;
-    });
-    let tired = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(tired.status(), StatusCode::TOO_MANY_REQUESTS);
-    let hold = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
-    assert_eq!(hold.status(), StatusCode::OK);
-    assert_eq!(header(&hold, "x-stamina"), "10/10");
-    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(cold.status(), StatusCode::PRECONDITION_FAILED);
-}
-
-#[tokio::test]
-async fn friction_rises_with_vigour_and_edging_chafes() {
-    let spit = [("content-type", "text/plain; charset=spit")];
-    for (intensity, friction) in [(5, "1/10"), (7, "2/10"), (10, "3/10")] {
-        let app = seeded_with(Floor::Hotel, |run| {
-            run.here.wifi_accepted = true;
-            run.warmed_up = true;
-            run.eq = 55;
-            run.foreskin = Some(0.5);
-        });
-        let uri = format!("/runs/cafebabe?technique=wet&intensity={intensity}");
-        let jelq = send(&app, "JELQ", &uri, &spit, "").await;
-        assert_eq!(
-            header(&jelq, "x-friction"),
-            friction,
-            "intensity {intensity}"
-        );
-    }
-    let app = seeded_with(Floor::Hotel, |run| {
-        run.here.wifi_accepted = true;
-        run.warmed_up = true;
-        run.eq = 55;
-        run.foreskin = Some(0.5);
-    });
-    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-    assert_eq!(header(&edge, "x-friction"), "2/10");
-}
-
-#[tokio::test]
-async fn the_body_changes_how_the_skin_takes_it() {
-    let spit = [("content-type", "text/plain; charset=spit")];
-    for (foreskin, girth, friction) in [(0.5, 4.5, "1/10"), (1.2, 4.5, "0/10"), (0.5, 5.8, "2/10")]
-    {
-        let app = seeded_with(Floor::Hotel, |run| {
-            run.here.wifi_accepted = true;
-            run.warmed_up = true;
-            run.eq = 55;
-            run.foreskin = Some(foreskin);
-            run.girth = girth;
-        });
-        let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
-        assert_eq!(header(&jelq, "x-friction"), friction, "{foreskin} {girth}");
-    }
-}
-
-#[tokio::test]
-async fn a_thick_girth_outgrows_the_underhand_grip() {
-    let app = seeded_with(Floor::Bedroom, |run| run.girth = 5.8);
-    let grip = send(
-        &app,
-        "GET",
-        "/runs/cafebabe/grip",
-        &[("upgrade", "underhand"), ("connection", "upgrade")],
-        "",
-    )
-    .await;
-    assert_eq!(grip.status(), StatusCode::PAYLOAD_TOO_LARGE);
-}
-
-#[tokio::test]
-async fn respectable_girth_waves_off_the_gym_staff() {
-    for (girth, status) in [
-        (4.5, StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS),
-        (5.2, StatusCode::OK),
-    ] {
-        let app = seeded_with(Floor::ChangingRoom, |run| {
-            run.warmed_up = true;
-            run.eq = 45;
-            run.girth = girth;
-            run.suspicion = SUSPICION_LIMIT;
-        });
-        let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
-        if girth > 5.0 {
-            assert_ne!(edge.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
-            assert!(header(&edge, "warning").contains("gym staff"));
-        } else {
-            assert_eq!(edge.status(), status);
-        }
-    }
-}
-
-#[tokio::test]
-async fn kev_is_the_bar_in_the_changing_room() {
-    for (length, shamed) in [(5.0, true), (7.0, false)] {
-        let app = seeded_with(Floor::Bathroom, |run| {
-            run.length = length;
-            run.here.turns = 6;
-        });
-        let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
-        assert_eq!(header(&left, "x-floor"), "3");
-        let warning = left
-            .headers()
-            .get("warning")
-            .map(|w| w.to_str().unwrap().to_owned());
-        assert_eq!(
-            warning.is_some_and(|w| w.contains("Kev")),
-            shamed,
-            "length {length}"
-        );
-    }
-}
-
-#[tokio::test]
-async fn the_forum_respects_volume() {
-    let state = Arc::new(AppState::default());
-    for (id, length, girth) in [("slim", 7.0, 4.0), ("stout", 5.0, 5.5)] {
-        let mut run = Run::new(id.into(), id.into(), 1);
-        run.length = length;
-        run.girth = girth;
-        state.insert(run);
-    }
-    let app = router(state);
-    let board = json(
-        send(
-            &app,
-            "GET",
-            "/leaderboard?sort=volume&seeded=include",
-            &[],
-            "",
-        )
-        .await,
-    )
-    .await;
-    assert_eq!(board["entries"][0]["public_id"], "stout");
-    assert!(board["entries"][0]["volume"].as_f64().unwrap() > 0.0);
-}
-
-#[tokio::test]
-async fn the_dead_outlive_the_server() {
-    let path = std::env::temp_dir().join(format!("jelqd-{}.sqlite", std::process::id()));
-    let config = || Config {
-        db: Some(path.clone()),
-        ..Config::default()
-    };
-    let first = crate::app(config());
-    let created = send(&first, "POST", "/runs", &[], "").await;
-    let location = header(&created, "location").to_owned();
-    send(&first, "DELETE", &location, &[], "").await;
-    drop(first);
-
-    let second = crate::app(config());
-    let gone = send(&second, "GET", &location, &[], "").await;
-    assert_eq!(gone.status(), StatusCode::GONE);
-    let graveyard = json(send(&second, "GET", "/graveyard", &[], "").await).await;
-    assert_eq!(graveyard["runs"].as_array().unwrap().len(), 1);
-    let board = json(send(&second, "GET", "/leaderboard", &[], "").await).await;
-    assert_eq!(board["entries"][0]["status"], "gone");
-    for suffix in ["", "-wal", "-shm"] {
-        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
-    }
-}
-
-#[tokio::test]
-async fn pump_bro_charges_the_thin_more_for_girth() {
-    for (girth, ring, oil) in [(4.5, 11, 4), (5.2, 8, 4)] {
-        let app = seeded_with(Floor::ChangingRoom, |run| run.girth = girth);
-        let shop = json(send(&app, "GET", "/runs/cafebabe/shop", &[], "").await).await;
-        let price = |slug: &str| {
-            shop["stock"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|item| item["item"] == slug)
-                .unwrap()["price"]
-                .as_u64()
-                .unwrap()
-        };
-        assert_eq!(price("cock-ring"), ring, "girth {girth}");
-        assert_eq!(price("baby-oil"), oil, "girth {girth}");
-    }
-}
-
-#[tokio::test]
-async fn a_long_run_fills_the_jeans_before_a_thick_one() {
-    let app = seeded_with(Floor::Bedroom, |run| {
-        run.warmed_up = true;
-        run.items.extender = true;
-        run.girth = 4.8;
-        run.length = 7.5;
-    });
-    let lube = [("content-type", "application/baby-oil")];
-    let full = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
-    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);
-}

Added file: src/tests/body.rs+400 additions@@ -0,0 +1,400 @@
+use super::*;
+
+#[tokio::test]
+async fn deleting_the_foreskin_requires_certainty() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(&app, "DELETE", "/runs/cafebabe/foreskin", &[], "").await;
+    assert_eq!(response.status(), StatusCode::PRECONDITION_REQUIRED);
+    let look = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
+    assert_eq!(look.status(), StatusCode::OK);
+    let etag = header(&look, "etag").to_owned();
+    assert!(text(look).await.contains('~'));
+    let response = send(
+        &app,
+        "DELETE",
+        "/runs/cafebabe/foreskin",
+        &[("if-match", &etag)],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::NO_CONTENT);
+    let response = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
+    assert_eq!(response.status(), StatusCode::GONE);
+}
+
+#[tokio::test]
+async fn length_supports_inch_ranges() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=0-1")],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
+    assert!(header(&response, "content-range").starts_with("inches 0.00-1.00/"));
+    assert_eq!(text(response).await.len(), 25);
+    let absurd = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=40-50")],
+        "",
+    )
+    .await;
+    assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+    let malformed = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=6.17")],
+        "",
+    )
+    .await;
+    assert_eq!(malformed.status(), StatusCode::OK);
+    let suffix = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=-1")],
+        "",
+    )
+    .await;
+    assert_eq!(suffix.status(), StatusCode::PARTIAL_CONTENT);
+    assert!(text(suffix).await.ends_with('D'));
+    for (range, status) in [
+        ("inches=1-", StatusCode::PARTIAL_CONTENT),
+        ("inches=40-", StatusCode::RANGE_NOT_SATISFIABLE),
+        ("inches=-0", StatusCode::RANGE_NOT_SATISFIABLE),
+        ("inches=2-1", StatusCode::OK),
+        ("inches=NaN-2", StatusCode::OK),
+        ("inches=0-inf", StatusCode::OK),
+    ] {
+        let response = send(
+            &app,
+            "GET",
+            "/runs/cafebabe/length",
+            &[("range", range)],
+            "",
+        )
+        .await;
+        assert_eq!(response.status(), status, "{range}");
+    }
+}
+
+#[tokio::test]
+async fn the_displayed_length_is_accepted_as_honest() {
+    let app = seeded_with(Floor::Forum, |run| run.body.length = 5.2496);
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/elder",
+        &[("proxy-authorization", "Ruler 5.25")],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn dry_jelqs_build_friction_and_real_lube_does_not() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.body.foreskin = Some(0.9);
+    });
+    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+    assert_eq!(header(&dry, "x-friction"), "2/10");
+    let lube = [("content-type", "application/baby-oil")];
+    let wet = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &lube,
+        "",
+    )
+    .await;
+    assert_eq!(header(&wet, "x-friction"), "2/10");
+    let spit = [("content-type", "text/plain; charset=spit")];
+    let glisten = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &spit,
+        "",
+    )
+    .await;
+    assert_eq!(header(&glisten, "x-friction"), "3/10");
+}
+
+#[tokio::test]
+async fn switching_grips_makes_the_friction_cheaper() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.body.foreskin = Some(0.9);
+    });
+    let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+    assert_eq!(header(&dry, "x-friction"), "2/10");
+    send(
+        &app,
+        "GET",
+        "/runs/cafebabe/grip",
+        &[("upgrade", "underhand"), ("connection", "upgrade")],
+        "",
+    )
+    .await;
+    let switched = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+    assert_eq!(header(&switched, "x-friction"), "3/10");
+    let settled = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+    assert_eq!(header(&settled, "x-friction"), "5/10");
+}
+
+#[tokio::test]
+async fn holding_and_meditating_shed_friction() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.eq = 80;
+        run.body.friction = 5;
+    });
+    let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert_eq!(held.status(), StatusCode::NO_CONTENT);
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-friction"), "3/10");
+
+    let taught = seeded_with(Floor::Bedroom, |run| {
+        run.body.friction = 5;
+    });
+    let calmed = send(
+        &taught,
+        "JELQ",
+        "/runs/cafebabe?technique=meditate",
+        &[],
+        "",
+    )
+    .await;
+    assert_eq!(calmed.status(), StatusCode::OK);
+    let view = send(&taught, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-friction"), "3/10");
+}
+
+#[tokio::test]
+async fn a_friction_burn_halves_the_gains() {
+    let lube = [("content-type", "application/baby-oil")];
+    let path = "/runs/cafebabe?technique=wet&intensity=5";
+    for seed in 0..60u64 {
+        let steady = app_with(Floor::Bedroom, seed, |run| {
+            run.body.warmed_up = true;
+            run.body.eq = 60;
+            run.items.lubes.baby_oil = 9;
+        });
+        let hurt_app = app_with(Floor::Bedroom, seed, |run| {
+            run.body.warmed_up = true;
+            run.body.eq = 60;
+            run.items.lubes.baby_oil = 9;
+            run.body.conditions.friction_burn = true;
+        });
+        let calm = send(&steady, "JELQ", path, &lube, "").await;
+        let hurt = send(&hurt_app, "JELQ", path, &lube, "").await;
+        if calm.status() != StatusCode::OK || hurt.status() != StatusCode::OK {
+            continue;
+        }
+        let calm_gain = json(calm).await["length"].as_f64().unwrap();
+        let hurt_gain = json(hurt).await["length"].as_f64().unwrap();
+        assert!(
+            (hurt_gain * 2.0 - calm_gain).abs() < 1e-9,
+            "seed {seed} burned {hurt_gain} against {calm_gain}"
+        );
+        return;
+    }
+    panic!("no seed in 60 produced two clean rolls to compare");
+}
+
+#[tokio::test]
+async fn the_burn_warns_and_the_ice_treats_it() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.body.eq = 60;
+        run.items.lubes.baby_oil = 9;
+        run.body.friction = 7;
+        run.body.conditions.friction_burn = true;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    let jelq = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &lube,
+        "",
+    )
+    .await;
+    let warnings: Vec<_> = jelq
+        .headers()
+        .get_all("warning")
+        .iter()
+        .filter_map(|w| w.to_str().ok())
+        .collect();
+    assert!(warnings.contains(&"199 - \"friction burn\""));
+    send(&app, "JELQ", "/runs/cafebabe?technique=ice", &[], "").await;
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    let warnings: Vec<_> = view
+        .headers()
+        .get_all("warning")
+        .iter()
+        .filter_map(|w| w.to_str().ok())
+        .collect();
+    assert!(!warnings.contains(&"199 - \"friction burn\""));
+}
+
+#[tokio::test]
+async fn friction_rises_with_vigour_and_edging_chafes() {
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for (intensity, friction) in [(5, "1/10"), (7, "2/10"), (10, "3/10")] {
+        let app = seeded_with(Floor::Hotel, |run| {
+            run.here.wifi_accepted = true;
+            run.body.warmed_up = true;
+            run.body.eq = 55;
+            run.body.foreskin = Some(0.5);
+        });
+        let uri = format!("/runs/cafebabe?technique=wet&intensity={intensity}");
+        let jelq = send(&app, "JELQ", &uri, &spit, "").await;
+        assert_eq!(
+            header(&jelq, "x-friction"),
+            friction,
+            "intensity {intensity}"
+        );
+    }
+    let app = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.body.warmed_up = true;
+        run.body.eq = 55;
+        run.body.foreskin = Some(0.5);
+    });
+    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(header(&edge, "x-friction"), "2/10");
+}
+
+#[tokio::test]
+async fn the_body_changes_how_the_skin_takes_it() {
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for (foreskin, girth, friction) in [(0.5, 4.5, "1/10"), (1.2, 4.5, "0/10"), (0.5, 5.8, "2/10")]
+    {
+        let app = seeded_with(Floor::Hotel, |run| {
+            run.here.wifi_accepted = true;
+            run.body.warmed_up = true;
+            run.body.eq = 55;
+            run.body.foreskin = Some(foreskin);
+            run.body.girth = girth;
+        });
+        let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
+        assert_eq!(header(&jelq, "x-friction"), friction, "{foreskin} {girth}");
+    }
+}
+
+#[tokio::test]
+async fn a_thick_girth_outgrows_the_underhand_grip() {
+    let app = seeded_with(Floor::Bedroom, |run| run.body.girth = 5.8);
+    let grip = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/grip",
+        &[("upgrade", "underhand"), ("connection", "upgrade")],
+        "",
+    )
+    .await;
+    assert_eq!(grip.status(), StatusCode::PAYLOAD_TOO_LARGE);
+}
+
+#[tokio::test]
+async fn a_long_run_fills_the_jeans_before_a_thick_one() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.items.kit.extender = true;
+        run.body.girth = 4.8;
+        run.body.length = 7.5;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    let full = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);
+}
+
+#[tokio::test]
+async fn a_refused_jelq_leaves_the_lube_alone() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.items.kit.extender = true;
+        run.body.girth = 6.0;
+        run.body.length = 6.0;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    let full = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &lube,
+        "",
+    )
+    .await;
+    assert_eq!(full.status(), StatusCode::INSUFFICIENT_STORAGE);
+    let inv = send(&app, "GET", "/runs/cafebabe/inventory", &[], "").await;
+    let body = json(inv).await;
+    let held = body["items"].as_array().unwrap();
+    assert!(held.iter().any(|i| i["name"] == "baby-oil"));
+}
+
+#[tokio::test]
+async fn lubes_run_out_but_spit_never_does() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.items.lubes.baby_oil = 1;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert_eq!(second.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for _ in 0..3 {
+        let wet = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
+        assert_ne!(
+            wet.status(),
+            StatusCode::UNSUPPORTED_MEDIA_TYPE,
+            "spit never runs out"
+        );
+    }
+}
+
+#[tokio::test]
+async fn patching_costs_a_little_eq() {
+    let app = seeded_with(Floor::Bedroom, |run| run.body.eq = 50);
+    let patch = send(
+        &app,
+        "PATCH",
+        "/runs/cafebabe",
+        &[("content-type", "application/json-patch+json")],
+        r#"[{"op": "test", "path": "/girth", "value": 1.0}]"#,
+    )
+    .await;
+    assert_eq!(patch.status(), StatusCode::CONFLICT);
+    assert_eq!(header(&patch, "x-eq"), "47");
+}
+
+#[tokio::test]
+async fn a_combo_chafes_twice_and_costs_two_stamina() {
+    let app = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.body.warmed_up = true;
+        run.body.eq = 55;
+        run.body.foreskin = Some(0.5);
+    });
+    let spit = [("content-type", "text/plain; charset=spit")];
+    let combo = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet,stretch",
+        &spit,
+        "",
+    )
+    .await;
+    assert_eq!(header(&combo, "x-friction"), "2/10");
+    assert_eq!(header(&combo, "x-stamina"), "8/10");
+}

Added file: src/tests/floors.rs+456 additions@@ -0,0 +1,456 @@
+use super::*;
+
+#[tokio::test]
+async fn only_the_key_opens_the_cage() {
+    let app = seeded_with(Floor::ChangingRoom, |run| run.items.kit.cage = true);
+    send(&app, "POST", "/runs/cafebabe/shop/ice-pack", &[], "").await;
+    let still = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/inventory/chastity-cage",
+        &[],
+        "",
+    )
+    .await;
+    assert_eq!(still.status(), StatusCode::OK);
+    send(&app, "POST", "/runs/cafebabe/shop/cage-key", &[], "").await;
+    let gone = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/inventory/chastity-cage",
+        &[],
+        "",
+    )
+    .await;
+    assert_eq!(gone.status(), StatusCode::NOT_FOUND);
+}
+
+#[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::ChangingRoom, |_| {});
+    let pump = send(&app, "POST", "/runs/cafebabe/shop/pump", &[], "").await;
+    assert_eq!(pump.status(), StatusCode::UPGRADE_REQUIRED);
+    assert_eq!(header(&pump, "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 the_elder_is_stale() {
+    let app = seeded_with(Floor::Forum, |run| run.body.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);
+}
+
+#[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 caged_drawers_are_noisy_and_eventually_give_up_the_key() {
+    let app = seeded_with(Floor::ChangingRoom, |run| run.items.kit.cage = true);
+    let mut statuses = Vec::new();
+    for _ in 0..30 {
+        let response = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
+        statuses.push(response.status());
+        if response.status() == StatusCode::OK {
+            break;
+        }
+    }
+    assert_eq!(statuses.last(), Some(&StatusCode::OK), "{statuses:?}");
+    assert!(
+        statuses[..statuses.len() - 1]
+            .iter()
+            .all(|s| *s == StatusCode::NO_CONTENT)
+    );
+}
+
+#[tokio::test]
+async fn an_open_tab_is_linked_and_jelq_still_answers_with_choices() {
+    let app = seeded_with(Floor::Bathroom, |run| {
+        run.online.story = Story::Pending;
+        run.body.warmed_up = true;
+    });
+    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    let links = header(&response, "link");
+    assert!(links.contains("/branches/forum>; rel=\"https://jelq.dev/rels/branch\""));
+    assert!(links.contains("/branches/close-tab>; rel=\"https://jelq.dev/rels/branch\""));
+    assert!(links.contains("?technique=wet>"));
+    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(jelq.status(), StatusCode::MULTIPLE_CHOICES);
+}
+
+#[tokio::test]
+async fn either_story_choice_is_reachable_during_cooldown() {
+    for choice in ["forum", "close-tab"] {
+        let app = seeded_with(Floor::Bathroom, |run| {
+            run.turn = 9;
+            run.body.warmed_up = true;
+            run.body.eq = 45;
+            run.body.stamina = 1;
+            run.items.stores.door_locks = 1;
+        });
+        let tenth = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+        assert_eq!(tenth.status(), StatusCode::OK);
+        let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+        assert!(!header(&response, "link").contains("?technique="));
+        let path = format!("/runs/cafebabe/branches/{choice}");
+        assert!(
+            header(&response, "link")
+                .contains(&format!("<{path}>; rel=\"https://jelq.dev/rels/branch\""))
+        );
+        let chosen = send(&app, "POST", &path, &[], "").await;
+        assert_eq!(chosen.status(), StatusCode::SEE_OTHER);
+        assert!(!header(&chosen, "link").contains("/branches/"));
+        let repeated = send(&app, "POST", &path, &[], "").await;
+        assert_eq!(repeated.status(), StatusCode::CONFLICT);
+    }
+}
+
+#[tokio::test]
+async fn the_thread_announces_itself_at_the_branch() {
+    let app = seeded_with(Floor::Bathroom, |run| {
+        run.turn = 8;
+        run.body.warmed_up = true;
+        run.items.lubes.baby_oil = 9;
+    });
+    send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet",
+        &[("content-type", "application/baby-oil")],
+        "",
+    )
+    .await;
+    let ninth = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&ninth, "link").contains("/forum/threads/2009"));
+    let tenth = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet",
+        &[("content-type", "application/baby-oil")],
+        "",
+    )
+    .await;
+    assert!(
+        tenth
+            .headers()
+            .get_all("warning")
+            .iter()
+            .any(|w| w.to_str().unwrap().contains("a forum thread from 2009"))
+    );
+    assert!(header(&tenth, "link").contains("/forum/threads/2009"));
+    let announced = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&announced, "link").contains("/forum/threads/2009"));
+}
+
+#[tokio::test]
+async fn rereading_the_thread_teaches_uli() {
+    let mut taught_runs = 0;
+    for seed in 0..100u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.turn = BRANCH_TURN;
+            run.body.warmed_up = true;
+            run.online.story = Story::ClosedTab;
+        });
+        let mut taught = false;
+        for _ in 0..2 {
+            let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            match read.status() {
+                StatusCode::NOT_MODIFIED => {
+                    assert!(header(&read, "warning").contains("2009"));
+                }
+                StatusCode::OK => {
+                    assert!(header(&read, "location").contains("/techniques"));
+                    taught = true;
+                    break;
+                }
+                other => panic!("seed {seed} read the thread into {other}"),
+            }
+        }
+        let state = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+        assert_eq!(header(&state, "x-stamina"), "10/10", "reading is free");
+        if taught {
+            taught_runs += 1;
+            let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
+            assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
+        } else {
+            let cached = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            assert_eq!(cached.status(), StatusCode::OK);
+            assert!(header(&cached, "warning").starts_with("112"));
+            assert!(header(&cached, "age").parse::<u64>().unwrap() > 0);
+        }
+    }
+    assert!(
+        (30..=58).contains(&taught_runs),
+        "{taught_runs}/100 learned uli in two reads"
+    );
+}
+
+#[tokio::test]
+async fn the_thread_cannot_be_reread_before_anyone_mentions_it() {
+    let app = seeded_with(Floor::Bedroom, |run| run.body.warmed_up = true);
+    let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+    assert_eq!(read.status(), StatusCode::NOT_FOUND);
+    let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&after, "link").contains("/re-read"));
+}
+
+#[tokio::test]
+async fn rummaging_for_the_key_leaves_the_drawer_unsearched() {
+    let mut found = 0;
+    for seed in 0..20u64 {
+        let app = app_with(Floor::Hotel, seed, |run| {
+            run.here.wifi_accepted = true;
+            run.items.kit.cage = true;
+        });
+        for _ in 0..30 {
+            let rummage = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
+            if rummage.status() == StatusCode::OK {
+                break;
+            }
+        }
+        let search = send(&app, "POST", "/runs/cafebabe/drawer", &[], "").await;
+        if search.status() == StatusCode::FOUND {
+            assert!(header(&search, "location").ends_with("/inventory/do-not-disturb-sign"));
+            found += 1;
+        }
+    }
+    assert!(
+        found >= 18,
+        "only {found} of 20 hotel drawers survived the rummage"
+    );
+}
+
+#[tokio::test]
+async fn kev_is_the_bar_in_the_changing_room() {
+    for (length, shamed) in [(5.0, true), (7.0, false)] {
+        let app = seeded_with(Floor::Bathroom, |run| {
+            run.body.length = length;
+            run.here.turns = 6;
+        });
+        let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+        assert_eq!(header(&left, "x-floor"), "3");
+        let warning = left
+            .headers()
+            .get("warning")
+            .map(|w| w.to_str().unwrap().to_owned());
+        assert_eq!(
+            warning.is_some_and(|w| w.contains("Kev")),
+            shamed,
+            "length {length}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn pump_bro_charges_the_thin_more_for_girth() {
+    for (girth, ring, oil) in [(4.5, 11, 4), (5.2, 8, 4)] {
+        let app = seeded_with(Floor::ChangingRoom, |run| run.body.girth = girth);
+        let shop = json(send(&app, "GET", "/runs/cafebabe/shop", &[], "").await).await;
+        let price = |slug: &str| {
+            shop["stock"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|item| item["item"] == slug)
+                .unwrap()["price"]
+                .as_u64()
+                .unwrap()
+        };
+        assert_eq!(price("cock-ring"), ring, "girth {girth}");
+        assert_eq!(price("baby-oil"), oil, "girth {girth}");
+    }
+}
+
+#[tokio::test]
+async fn the_clinic_escalates_toward_honesty() {
+    let Harness { app, .. } = harness(Floor::Clinic, SEED, |_| {});
+    let mut hints = Vec::new();
+    for _ in 0..3 {
+        let response = send(
+            &app,
+            "GET",
+            "/runs/cafebabe/diagnosis",
+            &[("authorization", "Excuse \"changing\"")],
+            "",
+        )
+        .await;
+        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+        hints.push(header(&response, "www-authenticate").to_owned());
+    }
+    assert!(hints[2].contains("Be honest."));
+}
+
+#[tokio::test]
+async fn the_true_ending_is_not_modified() {
+    let Harness { app: early, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(&early, "GET", "/runs/cafebabe/diagnosis", &[], "").await;
+    assert_eq!(response.status(), StatusCode::TOO_EARLY);
+
+    let Harness {
+        app, origin: etag, ..
+    } = harness(Floor::Clinic, SEED, |_| {});
+    assert!(
+        !etag.contains("cafebabe"),
+        "the origin ETag must not be derivable from the id"
+    );
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/diagnosis",
+        &[
+            ("authorization", "Bearer honesty"),
+            ("if-none-match", &etag),
+        ],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
+    assert_eq!(header(&response, "x-diagnosis"), "normal");
+}
+
+#[tokio::test]
+async fn the_elder_bans_three_lies_unless_the_girth_impresses() {
+    let forum = |girth: f64| {
+        seeded_with(Floor::Forum, move |run| {
+            run.body.length = 6.0;
+            run.body.girth = girth;
+        })
+    };
+    let fib = [("proxy-authorization", "Ruler 6.5")];
+    let thin = forum(4.5);
+    for _ in 0..2 {
+        let strike = send(&thin, "GET", "/runs/cafebabe/elder", &fib, "").await;
+        assert_eq!(strike.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);
+    }
+    let banned = send(&thin, "GET", "/runs/cafebabe/elder", &fib, "").await;
+    assert_eq!(banned.status(), StatusCode::FORBIDDEN);
+    assert!(
+        json(banned).await["type"]
+            .as_str()
+            .unwrap()
+            .ends_with("banned")
+    );
+
+    let thick = forum(5.2);
+    for _ in 0..4 {
+        let excused = send(&thick, "GET", "/runs/cafebabe/elder", &fib, "").await;
+        assert_eq!(excused.status(), StatusCode::PROXY_AUTHENTICATION_REQUIRED);
+        assert!(header(&excused, "x-forum-note").contains("Girth is also a dimension"));
+    }
+}
+
+#[tokio::test]
+async fn the_zip_ends_one_exit_in_two_hundred() {
+    let mut zipped = 0;
+    for seed in 0..4000u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.here.turns = 6;
+        if run.advance().is_err() && run.ended.is_some() {
+            zipped += 1;
+        }
+    }
+    assert!(
+        (8..=35).contains(&zipped),
+        "{zipped} zips in 4000 exits, about 20 expected"
+    );
+}
+
+#[tokio::test]
+async fn a_prescription_ends_the_run_and_the_true_ending_still_waits() {
+    let Harness { app, origin, .. } = harness(Floor::Clinic, SEED, |_| {});
+    let honest = [("authorization", "Bearer honesty")];
+    let prescribed = send(&app, "GET", "/runs/cafebabe/diagnosis", &honest, "").await;
+    assert_eq!(prescribed.status(), StatusCode::OK);
+    assert!(header(&prescribed, "server-timing").contains("volume;"));
+    assert!(
+        json(prescribed).await["detail"]
+            .as_str()
+            .unwrap()
+            .starts_with("Congratulations")
+    );
+    let board = json(send(&app, "GET", "/leaderboard?seeded=include", &[], "").await).await;
+    assert_eq!(board["entries"][0]["status"], "prescribed");
+
+    let conditional = [
+        ("authorization", "Bearer honesty"),
+        ("if-none-match", origin.as_str()),
+    ];
+    let cured = send(&app, "GET", "/runs/cafebabe/diagnosis", &conditional, "").await;
+    assert_eq!(cured.status(), StatusCode::NOT_MODIFIED);
+    let view = json(send(&app, "GET", "/runs/cafebabe", &[], "").await).await;
+    assert_eq!(view["status"], "normal");
+}
+
+#[tokio::test]
+async fn the_foreskin_window_has_hard_edges() {
+    for (foreskin, refused) in [
+        (0.79, Some(StatusCode::LENGTH_REQUIRED)),
+        (0.8, None),
+        (2.0, None),
+        (2.01, Some(StatusCode::PAYLOAD_TOO_LARGE)),
+    ] {
+        let app = seeded_with(Floor::Hotel, |run| {
+            run.here.wifi_accepted = true;
+            run.body.warmed_up = true;
+            run.body.eq = 55;
+            run.body.foreskin = Some(foreskin);
+        });
+        let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+        match refused {
+            Some(status) => assert_eq!(dry.status(), status, "foreskin {foreskin}"),
+            None => assert!(
+                ![StatusCode::LENGTH_REQUIRED, StatusCode::PAYLOAD_TOO_LARGE]
+                    .contains(&dry.status()),
+                "foreskin {foreskin} sits inside the window"
+            ),
+        }
+    }
+}

Added file: src/tests/household.rs+339 additions@@ -0,0 +1,339 @@
+use super::*;
+
+#[tokio::test]
+async fn mum_accepts_a_known_excuse() {
+    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
+    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+    assert_eq!(header(&response, "via"), "1.1 mum");
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[("authorization", "Excuse \"homework\"")],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn mum_runs_out_of_patience() {
+    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
+    let lie = [("authorization", "Excuse \"it is for science\"")];
+    for _ in 0..2 {
+        let response = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
+        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+    }
+    let caught = send(&app, "GET", "/runs/cafebabe", &lie, "").await;
+    assert_eq!(caught.status(), StatusCode::GONE);
+    assert_eq!(
+        json(caught).await["type"],
+        "https://jelq.dev/problems/caught"
+    );
+}
+
+#[tokio::test]
+async fn mum_remembers_excuses_by_christmas() {
+    let app = seeded_with(Floor::Nans, |run| {
+        mum_at_the_door(run);
+        run.household.heard.push(Excuse::Homework);
+    });
+    let basic = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[("authorization", "Excuse \"changing\"")],
+        "",
+    )
+    .await;
+    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);
+    assert!(header(&basic, "www-authenticate").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=\"wrapping presents\", nonce=\"abc\"",
+        )],
+        "",
+    )
+    .await;
+    assert_eq!(fresh.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn a_pulled_muscle_is_a_true_excuse() {
+    let app = seeded_with(Floor::Nans, |run| {
+        mum_at_the_door(run);
+        run.body.conditions.pulled_muscle = true;
+        run.household.heard.push(Excuse::PulledAMuscle);
+    });
+    let response = send(
+        &app,
+        "GET",
+        "/runs/cafebabe",
+        &[(
+            "authorization",
+            "Digest username=\"pulled a muscle\", nonce=\"abc\"",
+        )],
+        "",
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn ignoring_mum_has_consequences() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        mum_at_the_door(run);
+        run.here.turns = 6;
+    });
+    let knock = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(
+        json(knock).await["type"],
+        "https://jelq.dev/problems/someone-at-the-door"
+    );
+    let leave = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(
+        leave.status(),
+        StatusCode::UNAUTHORIZED,
+        "no leaving with Mum at the door"
+    );
+    send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    let opened = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(opened.status(), StatusCode::GONE);
+    assert_eq!(
+        json(opened).await["type"],
+        "https://jelq.dev/problems/opened"
+    );
+}
+
+#[tokio::test]
+async fn mom_speaks_american() {
+    let app = seeded_with(Floor::Nans, mum_at_the_door);
+    let us = [("accept-language", "en-US")];
+    let knock = send(&app, "GET", "/runs/cafebabe", &us, "").await;
+    assert_eq!(header(&knock, "content-language"), "en-US");
+    assert_eq!(header(&knock, "via"), "1.1 mom");
+    assert!(
+        json(knock).await["detail"]
+            .as_str()
+            .unwrap()
+            .contains("Someone is at the door.")
+    );
+    let excuse = [
+        ("accept-language", "en-US"),
+        (
+            "authorization",
+            "Digest username=\"carving the turkey\", nonce=\"abc\"",
+        ),
+    ];
+    let answered = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;
+    assert_eq!(answered.status(), StatusCode::OK);
+    let floor = json(send(&app, "GET", "/runs/cafebabe/floor", &us, "").await).await;
+    assert_eq!(floor["name"], "Grandma's house for Thanksgiving");
+}
+
+#[tokio::test]
+async fn an_empty_bottle_is_declined_before_the_enemy_stirs() {
+    let control = seeded_with(Floor::ChangingRoom, |run| {
+        run.body.warmed_up = true;
+        run.standing.suspicion = SUSPICION_LIMIT;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    let caught = send(
+        &control,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &lube,
+        "",
+    )
+    .await;
+    assert_eq!(caught.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
+
+    let app = seeded_with(Floor::ChangingRoom, |run| {
+        run.body.warmed_up = true;
+        run.standing.suspicion = SUSPICION_LIMIT;
+        run.items.lubes.baby_oil = 0;
+    });
+    let refused = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet&intensity=5",
+        &lube,
+        "",
+    )
+    .await;
+    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-suspicion"), "5/5");
+    assert_eq!(header(&view, "x-shame"), "0");
+}
+
+#[tokio::test]
+async fn respectable_girth_waves_off_the_gym_staff() {
+    let staff = |girth: f64| {
+        seeded_with(Floor::ChangingRoom, move |run| {
+            run.body.warmed_up = true;
+            run.body.eq = 45;
+            run.body.girth = girth;
+            run.standing.suspicion = SUSPICION_LIMIT;
+        })
+    };
+    let thin = send(
+        &staff(4.5),
+        "JELQ",
+        "/runs/cafebabe?technique=edge",
+        &[],
+        "",
+    )
+    .await;
+    assert_eq!(thin.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
+    assert_eq!(header(&thin, "x-shame"), "5");
+
+    let thick = send(
+        &staff(5.2),
+        "JELQ",
+        "/runs/cafebabe?technique=edge",
+        &[],
+        "",
+    )
+    .await;
+    assert_eq!(thick.status(), StatusCode::OK);
+    assert!(
+        warnings(&thick)
+            .iter()
+            .any(|w| w.contains("the gym staff have seen worse"))
+    );
+}
+
+#[tokio::test]
+async fn the_kitchen_is_only_on_the_home_floors() {
+    let absent = seeded_with(Floor::Bathroom, |_| {});
+    let no_kitchen = send(&absent, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+    assert_eq!(no_kitchen.status(), StatusCode::NOT_FOUND);
+    let view = send(&absent, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&view, "link").contains("/kitchen"));
+
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&view, "link").contains("/kitchen"));
+    let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+    assert_ne!(raid.status(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn any_other_action_takes_the_melon_off_the_table() {
+    for (method, uri) in [
+        ("JELQ", "/runs/cafebabe?technique=warmup"),
+        ("POST", "/runs/cafebabe/drawer"),
+    ] {
+        let app = seeded_with(Floor::Bedroom, |run| {
+            run.body.eq = 95;
+            run.here.kitchen.melon_offered = true;
+        });
+        send(&app, method, uri, &[], "").await;
+        let melon = send(&app, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
+        assert_eq!(melon.status(), StatusCode::CONFLICT, "{method} {uri}");
+    }
+}
+
+#[tokio::test]
+async fn the_truth_works_under_any_scheme_and_costs_ten() {
+    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
+    let truth = [("authorization", "Whatever honesty")];
+    let confessed = send(&app, "GET", "/runs/cafebabe", &truth, "").await;
+    assert_eq!(confessed.status(), StatusCode::OK);
+    assert_eq!(header(&confessed, "x-shame"), "10");
+}
+
+#[tokio::test]
+async fn mum_refuses_basic_and_stale_nonces() {
+    let bedroom = seeded_with(Floor::Bedroom, mum_at_the_door);
+    let basic = send(
+        &bedroom,
+        "GET",
+        "/runs/cafebabe",
+        &[("authorization", "Basic aG9tZXdvcms=")],
+        "",
+    )
+    .await;
+    assert_eq!(basic.status(), StatusCode::UNAUTHORIZED);
+    assert!(
+        json(basic).await["type"]
+            .as_str()
+            .unwrap()
+            .ends_with("/basic")
+    );
+
+    let nans = seeded_with(Floor::Nans, mum_at_the_door);
+    let stale = [(
+        "authorization",
+        "Digest username=\"on a call\", nonce=\"yesterday\"",
+    )];
+    let refused = send(&nans, "GET", "/runs/cafebabe", &stale, "").await;
+    assert_eq!(refused.status(), StatusCode::UNAUTHORIZED);
+    assert!(
+        json(refused).await["type"]
+            .as_str()
+            .unwrap()
+            .ends_with("stale-nonce")
+    );
+}
+
+#[tokio::test]
+async fn american_players_can_say_studying() {
+    let app = seeded_with(Floor::Bedroom, mum_at_the_door);
+    let excuse = [
+        ("accept-language", "en-US"),
+        ("authorization", "Excuse \"Studying\""),
+    ];
+    let response = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;
+    assert_eq!(response.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn raids_get_noisier_and_the_household_notices() {
+    let told = |suspicion: u8| {
+        (0..400u64)
+            .filter(|&seed| {
+                let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+                run.body.eq = 40;
+                run.standing.suspicion = suspicion;
+                run.raid_kitchen().is_ok() && run.household.kitchen_tellings == 1
+            })
+            .count()
+    };
+    let quiet = told(0);
+    let noisy = told(4);
+    assert!(
+        (60..=150).contains(&quiet),
+        "a quiet house told {quiet} of 400 raids, about 100 expected"
+    );
+    assert!(
+        (240..=340).contains(&noisy),
+        "a noisy house told {noisy} of 400 raids, about 300 expected"
+    );
+
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);
+    run.body.eq = 40;
+    assert!(run.raid_kitchen().is_ok());
+    assert_eq!(run.standing.suspicion, 1, "every raid makes a little noise");
+}

Added file: src/tests/meta.rs+252 additions@@ -0,0 +1,252 @@
+use super::*;
+
+#[tokio::test]
+async fn forged_ruler_cookies_are_lies() {
+    let forged = send(
+        &app(),
+        "GET",
+        "/leaderboard?sort=content-length",
+        &[("cookie", "ruler=1")],
+        "",
+    )
+    .await;
+    assert_eq!(forged.status(), StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn listings_never_reveal_the_private_id() {
+    let app = app();
+    let created = send(&app, "POST", "/runs", &[], "").await;
+    let location = header(&created, "location").to_owned();
+    let board = text(send(&app, "GET", "/leaderboard", &[], "").await).await;
+    let private = location.trim_start_matches("/runs/");
+    assert!(!board.contains(private));
+    let entry: Value = serde_json::from_str(&board).unwrap();
+    let public = entry["entries"][0]["public_id"].as_str().unwrap();
+    let guess = send(&app, "DELETE", &format!("/runs/{public}"), &[], "").await;
+    assert_eq!(guess.status(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn seeded_runs_are_unranked() {
+    let app = app();
+    send(&app, "POST", "/runs?seed=7", &[], "").await;
+    let board = json(send(&app, "GET", "/leaderboard", &[], "").await).await;
+    assert_eq!(board["entries"].as_array().unwrap().len(), 0);
+    let all = json(send(&app, "GET", "/leaderboard?seeded=include", &[], "").await).await;
+    assert_eq!(all["entries"][0]["ranked"], false);
+}
+
+#[tokio::test]
+async fn idle_runs_are_evicted_and_the_server_has_a_limit() {
+    let state = Arc::new(
+        AppState::new(Config {
+            idle_ttl: Duration::ZERO,
+            ..Config::default()
+        })
+        .unwrap(),
+    );
+    let forgetful = router(Arc::clone(&state));
+    let first = send(&forgetful, "POST", "/runs", &[], "").await;
+    let location = header(&first, "location").to_owned();
+    state.sweep(std::time::Instant::now()).unwrap();
+    let gone = send(&forgetful, "GET", &location, &[], "").await;
+    assert_eq!(gone.status(), StatusCode::NOT_FOUND);
+    let board = json(send(&forgetful, "GET", "/leaderboard", &[], "").await).await;
+    assert_eq!(
+        board["entries"][0]["status"], "alive",
+        "a swept run keeps its place on the leaderboard"
+    );
+
+    let tiny = crate::app(Config {
+        max_runs: 1,
+        ..Config::default()
+    })
+    .unwrap();
+    send(&tiny, "POST", "/runs", &[], "").await;
+    let full = send(&tiny, "POST", "/runs", &[], "").await;
+    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
+}
+
+#[tokio::test]
+async fn shame_from_two_runs_adds_up() {
+    let state = Arc::new(AppState::default());
+    state.insert(Run::new("cafebabe".into(), "cafe".into(), SEED));
+    state.insert(Run::new("deadbeef".into(), "dead".into(), 7));
+    let app = router(state);
+    let first = send(&app, "TRACE", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&first, "x-shame"), "1");
+    let cookie = header(&first, "set-cookie")
+        .split(';')
+        .next()
+        .unwrap()
+        .to_owned();
+    let second = send(&app, "TRACE", "/runs/deadbeef", &[("cookie", &cookie)], "").await;
+    assert_eq!(header(&second, "x-shame"), "2");
+}
+
+#[tokio::test]
+async fn the_root_negotiates() {
+    let app = app();
+    let browser = send(&app, "GET", "/", &[("accept", "text/html,*/*")], "").await;
+    assert_eq!(browser.status(), StatusCode::SEE_OTHER);
+    assert_eq!(header(&browser, "location"), "/ui/");
+    let curl = send(&app, "GET", "/", &[("accept", "*/*")], "").await;
+    assert_eq!(json(curl).await["ui"], "/ui/");
+    let page = send(&app, "GET", "/ui/", &[], "").await;
+    assert_eq!(page.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn the_ui_replays_what_browsers_cannot_send() {
+    let app = app();
+    let envelope =
+        r#"{"method": "TRACE", "path": "/graveyard", "headers": [["X-Confession", "I did it"]]}"#;
+    let traced = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
+    assert_eq!(traced["status"], 405);
+    let envelope = r#"{"method": "GET", "path": "/", "headers": [["Accept", "text/html"]]}"#;
+    let redirected = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
+    assert_eq!(redirected["status"], 303);
+    assert_eq!(redirected["reason"], "See Other");
+}
+
+#[tokio::test]
+async fn the_ui_decodes_gzip_for_display() {
+    let app = seeded_with(Floor::Bedroom, |run| run.items.kit.ring = true);
+    let envelope =
+        r#"{"method": "GET", "path": "/runs/cafebabe", "headers": [["Accept-Encoding", "gzip"]]}"#;
+    let shown = json(send(&app, "POST", "/ui/send", &[], envelope).await).await;
+    assert!(
+        shown["body"]
+            .as_str()
+            .unwrap()
+            .contains("\"public_id\":\"cafe\"")
+    );
+    let encoding = shown["headers"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|h| h[0] == "content-encoding" && h[1] == "gzip");
+    assert!(encoding);
+}
+
+#[tokio::test]
+async fn the_default_locale_is_british() {
+    let Harness { app, .. } = harness(Floor::Nans, SEED, |_| {});
+    let floor = send(&app, "GET", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(header(&floor, "content-language"), "en-GB");
+    assert!(header(&floor, "vary").contains("Accept-Language"));
+    assert_eq!(json(floor).await["name"], "Nan's house at Christmas");
+}
+
+#[tokio::test]
+async fn a_full_server_buries_the_dead_to_make_room() {
+    let app = crate::app(Config {
+        max_runs: 1,
+        ..Config::default()
+    })
+    .unwrap();
+    let first = send(&app, "POST", "/runs", &[], "").await;
+    let location = header(&first, "location").to_owned();
+    let full = send(&app, "POST", "/runs", &[], "").await;
+    assert_eq!(full.status(), StatusCode::SERVICE_UNAVAILABLE);
+    send(&app, "DELETE", &location, &[], "").await;
+    let second = send(&app, "POST", "/runs", &[], "").await;
+    assert_eq!(second.status(), StatusCode::CREATED);
+}
+
+#[tokio::test]
+async fn the_forum_respects_volume() {
+    let state = Arc::new(AppState::default());
+    for (id, length, girth) in [("slim", 7.0, 4.0), ("stout", 5.0, 5.5)] {
+        let mut run = Run::new(id.into(), id.into(), 1);
+        run.body.length = length;
+        run.body.girth = girth;
+        state.insert(run);
+    }
+    let app = router(state);
+    let board = json(
+        send(
+            &app,
+            "GET",
+            "/leaderboard?sort=volume&seeded=include",
+            &[],
+            "",
+        )
+        .await,
+    )
+    .await;
+    assert_eq!(board["entries"][0]["public_id"], "stout");
+    assert!(board["entries"][0]["volume"].as_f64().unwrap() > 0.0);
+}
+
+#[tokio::test]
+async fn the_dead_outlive_the_server() {
+    let path = std::env::temp_dir().join(format!("jelqd-{}.sqlite", std::process::id()));
+    let config = || Config {
+        db: Some(path.clone()),
+        ..Config::default()
+    };
+    let first = crate::app(config()).unwrap();
+    let created = send(&first, "POST", "/runs", &[], "").await;
+    let location = header(&created, "location").to_owned();
+    send(&first, "DELETE", &location, &[], "").await;
+    drop(first);
+
+    let second = crate::app(config()).unwrap();
+    let gone = send(&second, "GET", &location, &[], "").await;
+    assert_eq!(gone.status(), StatusCode::GONE);
+    let graveyard = json(send(&second, "GET", "/graveyard", &[], "").await).await;
+    assert_eq!(graveyard["runs"].as_array().unwrap().len(), 1);
+    let board = json(send(&second, "GET", "/leaderboard", &[], "").await).await;
+    assert_eq!(board["entries"][0]["status"], "gone");
+    for suffix in ["", "-wal", "-shm"] {
+        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
+    }
+}
+
+#[tokio::test]
+async fn the_graveyard_pages_by_fifty() {
+    let app = app();
+    for _ in 0..51 {
+        let created = send(&app, "POST", "/runs", &[], "").await;
+        let location = header(&created, "location").to_owned();
+        send(&app, "DELETE", &location, &[], "").await;
+    }
+    let first = send(&app, "GET", "/graveyard", &[], "").await;
+    assert!(header(&first, "link").contains("page=2>; rel=\"next\""));
+    assert_eq!(json(first).await["runs"].as_array().unwrap().len(), 50);
+    let second = send(&app, "GET", "/graveyard?page=2", &[], "").await;
+    assert!(header(&second, "link").contains("page=1>; rel=\"prev\""));
+    assert_eq!(json(second).await["runs"].as_array().unwrap().len(), 1);
+}
+
+#[tokio::test]
+async fn a_prescribed_run_outlives_the_server() {
+    let path = std::env::temp_dir().join(format!("jelqd-prescribed-{}.sqlite", std::process::id()));
+    let config = || Config {
+        db: Some(path.clone()),
+        ..Config::default()
+    };
+    let state = Arc::new(AppState::new(config()).unwrap());
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);
+    run.floor = Floor::Clinic;
+    state.insert(run);
+    let first = router(state);
+    send(
+        &first,
+        "GET",
+        "/runs/cafebabe/diagnosis",
+        &[("authorization", "Bearer honesty")],
+        "",
+    )
+    .await;
+    drop(first);
+
+    let second = crate::app(config()).unwrap();
+    let board = json(send(&second, "GET", "/leaderboard?seeded=include", &[], "").await).await;
+    assert_eq!(board["entries"][0]["status"], "prescribed");
+    for suffix in ["", "-wal", "-shm"] {
+        let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
+    }
+}

Added file: src/tests/methods.rs+150 additions@@ -0,0 +1,150 @@
+use super::*;
+
+#[tokio::test]
+async fn creating_a_run_returns_location_and_etag() {
+    let response = send(&app(), "POST", "/runs?seed=1", &[], "").await;
+    assert_eq!(response.status(), StatusCode::CREATED);
+    assert!(header(&response, "location").starts_with("/runs/"));
+    assert!(response.headers().contains_key(header::ETAG));
+    assert_eq!(header(&response, "server"), "jelqd/0.6.9");
+}
+
+#[tokio::test]
+async fn bodies_do_not_repeat_the_headers() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(response.headers().contains_key("x-eq"));
+    let body = json(response).await;
+    for stat in [
+        "eq",
+        "girth",
+        "foreskin",
+        "stamina",
+        "cash",
+        "self_reported_length",
+    ] {
+        assert!(body.get(stat).is_none(), "{stat} is already a header");
+    }
+}
+
+#[tokio::test]
+async fn jelqing_cold_fails_the_precondition() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(&app, "JELQ", "/runs/cafebabe?technique=stretch", &[], "").await;
+    assert_eq!(response.status(), StatusCode::PRECONDITION_FAILED);
+    assert_eq!(
+        header(&response, "content-type"),
+        "application/problem+json"
+    );
+}
+
+#[tokio::test]
+async fn wet_without_lube_is_unsupported_media() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    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);
+    let images = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=wet",
+        &[("content-type", "image/jpeg")],
+        "",
+    )
+    .await;
+    assert_eq!(json(images).await["detail"], "No.");
+}
+
+#[tokio::test]
+async fn unknown_methods_are_not_implemented() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let response = send(&app, "MILK", "/runs/cafebabe", &[], "").await;
+    assert_eq!(response.status(), StatusCode::NOT_IMPLEMENTED);
+    let teapot = send(&app, "BREW", "/runs/cafebabe", &[], "").await;
+    assert_eq!(teapot.status(), StatusCode::IM_A_TEAPOT);
+}
+
+#[tokio::test]
+async fn the_clinic_does_not_advertise_jelq() {
+    let Harness { app, .. } = harness(Floor::Clinic, SEED, |_| {});
+    let options = send(&app, "OPTIONS", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&options, "allow").contains("JELQ"));
+    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &[], "").await;
+    assert_eq!(jelq.status(), StatusCode::METHOD_NOT_ALLOWED);
+    assert!(!header(&jelq, "allow").contains("JELQ"));
+    let Harness { app: bedroom, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let options = send(&bedroom, "OPTIONS", "/runs/cafebabe", &[], "").await;
+    assert!(header(&options, "allow").contains("JELQ"));
+}
+
+#[tokio::test]
+async fn patch_only_accepts_the_truth() {
+    let Harness { app, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let patch = [("content-type", "application/json-patch+json")];
+    let replace = send(
+        &app,
+        "PATCH",
+        "/runs/cafebabe",
+        &patch,
+        r#"[{"op":"replace","path":"/length","value":12}]"#,
+    )
+    .await;
+    assert_eq!(replace.status(), StatusCode::UNPROCESSABLE_ENTITY);
+    let lie = send(
+        &app,
+        "PATCH",
+        "/runs/cafebabe",
+        &patch,
+        r#"[{"op":"test","path":"/length","value":40}]"#,
+    )
+    .await;
+    assert_eq!(
+        json(lie).await["type"],
+        "https://jelq.dev/problems/exaggeration"
+    );
+}
+
+#[tokio::test]
+async fn http_1_0_gets_the_pdf_treatment() {
+    let request = Request::builder()
+        .uri("/graveyard")
+        .version(Version::HTTP_10)
+        .body(Body::empty())
+        .unwrap();
+    let response = app().oneshot(request).await.unwrap();
+    assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
+}
+
+#[tokio::test]
+async fn links_offer_only_usable_techniques() {
+    let app = seeded_with(Floor::Bedroom, |run| run.body.foreskin = Some(1.0));
+    let cold = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(advertised(&cold), ["warmup", "ice", "meditate"]);
+    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    let usable = advertised(&warm);
+    assert!(usable.contains(&"wet".to_owned()) && usable.contains(&"dry".to_owned()));
+    assert!(!usable.contains(&"uli".to_owned()), "uli needs the forum");
+    assert!(!usable.contains(&"pump".to_owned()), "pump needs a pump");
+    assert!(
+        header(&warm, "link").contains("title=\"wet\"; allow=\"JELQ\"; lubricant=\"required\"")
+    );
+
+    let Harness { app: forum, .. } = harness(Floor::Forum, SEED, |_| {});
+    let response = send(&forum, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(advertised(&response).is_empty());
+}
+
+#[tokio::test]
+async fn links_hide_resources_that_would_do_nothing() {
+    let Harness { app: bedroom, .. } = harness(Floor::Bedroom, SEED, |_| {});
+    let before = linked_rels(&send(&bedroom, "GET", "/runs/cafebabe", &[], "").await);
+    assert!(before.contains(&"drawer".to_owned()));
+    assert!(!before.contains(&"diagnosis".to_owned()));
+    assert!(!before.contains(&"thread".to_owned()));
+    let searched = send(&bedroom, "POST", "/runs/cafebabe/drawer", &[], "").await;
+    assert!(!linked_rels(&searched).contains(&"drawer".to_owned()));
+
+    let Harness { app: clinic, .. } = harness(Floor::Clinic, SEED, |_| {});
+    let rels = linked_rels(&send(&clinic, "GET", "/runs/cafebabe", &[], "").await);
+    assert!(rels.contains(&"diagnosis".to_owned()) && rels.contains(&"thread".to_owned()));
+}

Added file: src/tests/mod.rs+148 additions@@ -0,0 +1,148 @@
+mod body;
+mod floors;
+mod household;
+mod meta;
+mod methods;
+mod rolls;
+mod turns;
+
+pub use std::{sync::Arc, time::Duration};
+
+pub use axum::{
+    Router,
+    body::{Body, to_bytes},
+    http::{Method, Request, StatusCode, Version, header},
+    response::Response,
+};
+pub use serde_json::Value;
+use tower::ServiceExt;
+
+pub use crate::{
+    AppState, Config,
+    game::{
+        Excuse, Floor, MumVisit, Run, Story,
+        balance::{BRANCH_TURN, SUSPICION_LIMIT},
+    },
+    router,
+};
+
+pub const SEED: u64 = 69;
+
+pub async fn send(
+    app: &Router,
+    method: &str,
+    uri: &str,
+    headers: &[(&str, &str)],
+    body: &str,
+) -> Response {
+    let mut request = Request::builder()
+        .method(Method::from_bytes(method.as_bytes()).unwrap())
+        .uri(uri);
+    for (name, value) in headers {
+        request = request.header(*name, *value);
+    }
+    app.clone()
+        .oneshot(request.body(Body::from(body.to_owned())).unwrap())
+        .await
+        .unwrap()
+}
+
+pub async fn json(response: Response) -> Value {
+    serde_json::from_slice(&to_bytes(response.into_body(), usize::MAX).await.unwrap()).unwrap()
+}
+
+pub async fn text(response: Response) -> String {
+    String::from_utf8(
+        to_bytes(response.into_body(), usize::MAX)
+            .await
+            .unwrap()
+            .to_vec(),
+    )
+    .unwrap()
+}
+
+pub fn header<'a>(response: &'a Response, name: &str) -> &'a str {
+    response.headers()[name].to_str().unwrap()
+}
+
+/// Every `Warning` on a response, since a turn can carry several.
+pub fn warnings(response: &Response) -> Vec<String> {
+    response
+        .headers()
+        .get_all("warning")
+        .iter()
+        .map(|value| value.to_str().unwrap().to_owned())
+        .collect()
+}
+
+/// A server holding one run, `cafebabe`, set up by `setup` before anyone can reach it.
+pub struct Harness {
+    pub app: Router,
+    pub origin: String,
+}
+
+pub fn harness(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Harness {
+    let state = Arc::new(AppState::default());
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+    run.floor = floor;
+    setup(&mut run);
+    let origin = run.origin_etag();
+    state.insert(run);
+    Harness {
+        app: router(state),
+        origin,
+    }
+}
+
+pub fn seeded_with(floor: Floor, setup: impl FnOnce(&mut Run)) -> Router {
+    harness(floor, SEED, setup).app
+}
+
+pub fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {
+    harness(floor, seed, setup).app
+}
+
+pub fn app() -> Router {
+    crate::app(Config::default()).unwrap()
+}
+
+pub fn mum_at_the_door(run: &mut Run) {
+    run.household.mum = Some(MumVisit {
+        errand: "She heard a noise.",
+        nonce: "abc".into(),
+        strikes: 0,
+        knocked: false,
+    });
+}
+
+/// The `Link` entries on a response, as `(rel, title)` with the rel base stripped.
+pub fn links(response: &Response) -> Vec<(String, Option<String>)> {
+    header(response, "link")
+        .split(", <")
+        .filter_map(|entry| {
+            let rel = entry.split("rels/").nth(1)?.split('"').next()?.to_owned();
+            let title = entry
+                .split("title=\"")
+                .nth(1)
+                .and_then(|t| t.split('"').next())
+                .map(str::to_owned);
+            Some((rel, title))
+        })
+        .collect()
+}
+
+pub fn advertised(response: &Response) -> Vec<String> {
+    links(response)
+        .into_iter()
+        .filter(|(rel, _)| rel == "technique")
+        .filter_map(|(_, title)| title)
+        .collect()
+}
+
+pub fn linked_rels(response: &Response) -> Vec<String> {
+    links(response)
+        .into_iter()
+        .map(|(rel, _)| rel)
+        .filter(|rel| rel != "technique")
+        .collect()
+}

Added file: src/tests/rolls.rs+193 additions@@ -0,0 +1,193 @@
+use super::*;
+
+#[tokio::test]
+async fn holding_calms_and_sometimes_reflects() {
+    let mut calmed = 0;
+    let mut reflected = 0;
+    let mut ruptured = 0;
+    for seed in 0..600u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.body.eq = 75;
+        match run.hold() {
+            Ok(_) if run.body.eq == 0 => reflected += 1,
+            Ok(_) => calmed += 1,
+            Err(_) => ruptured += 1,
+        }
+    }
+    assert!(
+        (25..=80).contains(&reflected),
+        "one HOLD in twelve should reflect, about 50 of 600, got {reflected} and {calmed} calm"
+    );
+    assert!(
+        ruptured <= 7,
+        "the flat 1 in 250 ruptured {ruptured} of 600 holds, about 2.4 expected"
+    );
+}
+
+#[tokio::test]
+async fn the_burn_shifts_the_rupture_tiers() {
+    async fn ruptures(burned: bool) -> u32 {
+        let mut gone = 0;
+        for seed in 0..400u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| {
+                run.body.warmed_up = true;
+                run.body.eq = 60;
+                run.items.lubes.baby_oil = 9;
+                run.body.conditions.friction_burn = burned;
+            });
+            let lube = [("content-type", "application/baby-oil")];
+            let jelq = send(
+                &app,
+                "JELQ",
+                "/runs/cafebabe?technique=wet&intensity=5",
+                &lube,
+                "",
+            )
+            .await;
+            if jelq.status() == StatusCode::INTERNAL_SERVER_ERROR {
+                gone += 1;
+            }
+        }
+        gone
+    }
+    let burned = ruptures(true).await;
+    let calm = ruptures(false).await;
+    assert!(
+        burned >= 8 && calm <= 4,
+        "burned {burned} ruptures against {calm}"
+    );
+}
+
+#[tokio::test]
+async fn the_top_tier_rolls_a_single_third() {
+    let mut ruptures = 0;
+    let mut early = 0;
+    for seed in 0..400u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.body.warmed_up = true;
+            run.body.eq = 96;
+            run.items.lubes.baby_oil = 9;
+            run.items.kit.blinds = true;
+        });
+        let lube = [("content-type", "application/baby-oil")];
+        let jelq = send(
+            &app,
+            "JELQ",
+            "/runs/cafebabe?technique=wet&intensity=5",
+            &lube,
+            "",
+        )
+        .await;
+        match jelq.status() {
+            StatusCode::INTERNAL_SERVER_ERROR => ruptures += 1,
+            StatusCode::TOO_EARLY => early += 1,
+            other => panic!("seed {seed} ended in {other}"),
+        }
+    }
+    assert!(
+        (90..=175).contains(&ruptures),
+        "ruptures {ruptures} of 400 against {early} early"
+    );
+    assert!(
+        (225..=310).contains(&early),
+        "early {early} of 400 against {ruptures} ruptures"
+    );
+}
+
+#[tokio::test]
+async fn holding_rolls_a_flat_rupture_chance() {
+    async fn ruptures(eq: i32, stamina: i32) -> u32 {
+        let mut gone = 0;
+        for seed in 0..600u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| {
+                run.body.warmed_up = true;
+                run.body.eq = eq;
+                run.body.stamina = stamina;
+            });
+            let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
+            if held.status() == StatusCode::INTERNAL_SERVER_ERROR {
+                gone += 1;
+            }
+        }
+        gone
+    }
+    let high = ruptures(90, 10).await;
+    let low = ruptures(30, 2).await;
+    assert!((0..=7).contains(&high), "high holds ruptured {high}/600");
+    assert!((0..=7).contains(&low), "low holds ruptured {low}/600");
+}
+
+#[tokio::test]
+async fn the_kitchen_pays_out_at_the_documented_odds() {
+    let mut oil = 0;
+    let mut drinks = 0;
+    let mut packs = 0;
+    for seed in 0..600u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.household.kitchen_tellings = 0;
+        let held = (
+            run.items.lubes.coconut_oil,
+            run.items.stores.energy_drinks,
+            run.items.stores.ice_packs,
+        );
+        let _ = run.raid_kitchen();
+        oil += u32::from(run.items.lubes.coconut_oil > held.0);
+        drinks += u32::from(run.items.stores.energy_drinks > held.1);
+        packs += u32::from(run.items.stores.ice_packs > held.2);
+    }
+    assert!((170..=230).contains(&oil), "coconut {oil} in 600");
+    assert!((90..=150).contains(&drinks), "energy {drinks} in 600");
+    assert!((45..=105).contains(&packs), "ice {packs} in 600");
+}
+
+#[tokio::test]
+async fn the_kitchen_rolls_the_normal_tiers() {
+    async fn ruptures(eq: i32) -> u32 {
+        let mut gone = 0;
+        for seed in 0..600u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| run.body.eq = eq);
+            let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+            if raid.status() == StatusCode::INTERNAL_SERVER_ERROR {
+                gone += 1;
+            }
+        }
+        gone
+    }
+    let hot = ruptures(96).await;
+    let cool = ruptures(40).await;
+    assert!((40..=80).contains(&hot), "hot kitchen ruptured {hot}/600");
+    assert!((0..=9).contains(&cool), "cool kitchen ruptured {cool}/600");
+}
+
+#[tokio::test]
+async fn degloving_takes_one_hard_dry_stroke_in_sixty() {
+    let mut degloved = 0;
+    for seed in 0..1200u64 {
+        let app = app_with(Floor::Hotel, seed, |run| {
+            run.here.wifi_accepted = true;
+            run.body.warmed_up = true;
+            run.body.eq = 55;
+            run.body.foreskin = Some(1.0);
+        });
+        let dry = send(
+            &app,
+            "JELQ",
+            "/runs/cafebabe?technique=dry&intensity=8",
+            &[],
+            "",
+        )
+        .await;
+        if dry.status() == StatusCode::GONE
+            && json(dry).await["type"]
+                .as_str()
+                .unwrap()
+                .ends_with("degloved")
+        {
+            degloved += 1;
+        }
+    }
+    assert!(
+        (8..=35).contains(&degloved),
+        "{degloved} degloved in 1200 hard dry strokes, about 20 expected"
+    );
+}

Added file: src/tests/turns.rs+225 additions@@ -0,0 +1,225 @@
+use super::*;
+
+#[tokio::test]
+async fn meditation_is_free_but_only_once_per_floor() {
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let response = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
+    assert_eq!(response.status(), StatusCode::OK);
+    assert_eq!(header(&response, "x-eq"), "10");
+    assert_eq!(header(&response, "x-stamina"), "10/10");
+    let again = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
+    assert_eq!(again.status(), StatusCode::CONFLICT);
+}
+
+#[tokio::test]
+async fn meditation_respects_the_priapism_floor() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.eq = 80;
+        run.body.conditions.priapism_turns = 3;
+    });
+    let calmed = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
+    assert_eq!(calmed.status(), StatusCode::OK);
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-eq"), "75");
+}
+
+#[tokio::test]
+async fn priapism_holds_the_floor_through_every_reset() {
+    let exit = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.body.eq = 90;
+        run.here.turns = 99;
+        run.body.conditions.priapism_turns = 3;
+    });
+    let out = send(&exit, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(out.status(), StatusCode::SEE_OTHER);
+    let view = send(&exit, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-eq"), "75");
+
+    let melon = seeded_with(Floor::Bedroom, |run| {
+        run.body.eq = 95;
+        run.here.kitchen.melon_offered = true;
+        run.body.conditions.priapism_turns = 2;
+    });
+    let bite = send(&melon, "POST", "/runs/cafebabe/kitchen/watermelon", &[], "").await;
+    assert_eq!(bite.status(), StatusCode::OK);
+    let view = send(&melon, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-eq"), "75");
+}
+
+#[tokio::test]
+async fn the_towel_warms_once_until_the_kettle_boils() {
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(warm.status(), StatusCode::OK);
+    let again = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(again.status(), StatusCode::CONFLICT);
+
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.here.kitchen.kettle_boiled = true;
+    });
+    let reheated = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(reheated.status(), StatusCode::OK);
+    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    assert_eq!(cold.status(), StatusCode::CONFLICT);
+}
+
+#[tokio::test]
+async fn the_refractory_period_is_the_next_hold() {
+    let app = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.body.warmed_up = true;
+        run.body.eq = 60;
+        run.body.stamina = 0;
+        run.body.exhausted = true;
+    });
+    let tired = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(tired.status(), StatusCode::TOO_MANY_REQUESTS);
+    let hold = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert_eq!(hold.status(), StatusCode::OK);
+    assert_eq!(header(&hold, "x-stamina"), "10/10");
+    let cold = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(cold.status(), StatusCode::PRECONDITION_FAILED);
+}
+
+#[tokio::test]
+async fn a_refused_jelq_does_not_break_the_edging_streak() {
+    let app = seeded_with(Floor::ChangingRoom, |run| {
+        run.body.warmed_up = true;
+        run.body.eq = 45;
+        run.here.edges = 2;
+    });
+    let refused = send(
+        &app,
+        "JELQ",
+        "/runs/cafebabe?technique=dry",
+        &[("content-type", "application/baby-oil")],
+        "",
+    )
+    .await;
+    assert_eq!(refused.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    let third = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(third.status(), StatusCode::LOOP_DETECTED);
+}
+
+#[tokio::test]
+async fn an_interrupted_edge_keeps_no_gains() {
+    let app = seeded_with(Floor::ChangingRoom, |run| {
+        run.body.warmed_up = true;
+        run.body.eq = 10;
+    });
+    let before = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    let girth = header(&before, "x-girth").to_owned();
+    let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(edge.status(), StatusCode::NOT_FOUND);
+    assert_eq!(header(&edge, "x-girth"), girth);
+}
+
+#[tokio::test]
+async fn greed_multiplies_gains_above_the_band() {
+    let lube = [("content-type", "application/baby-oil")];
+    for (eq, greed) in [(75, 1.5), (88, 2.0)] {
+        let mut compared = false;
+        for seed in 0..120u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| {
+                run.body.eq = 60;
+                run.body.warmed_up = true;
+            });
+            let in_band = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+            let app = app_with(Floor::Bedroom, seed, |run| {
+                run.body.eq = eq;
+                run.body.warmed_up = true;
+            });
+            let greedy = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+            if in_band.status() != StatusCode::OK || greedy.status() != StatusCode::OK {
+                continue;
+            }
+            let steady = json(in_band).await["length"].as_f64().unwrap();
+            let eager = json(greedy).await["length"].as_f64().unwrap();
+            assert!(
+                (eager - steady * greed).abs() < 1e-9,
+                "seed {seed} gained {eager} at {eq} EQ against {steady} inside the band"
+            );
+            compared = true;
+            break;
+        }
+        assert!(compared, "no seed produced two clean rolls at {eq} EQ");
+    }
+}
+
+#[tokio::test]
+async fn queued_gains_arrive_on_their_turn() {
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);
+    run.body.eq = 75;
+    let before = run.body.length;
+    run.body.pending.push(crate::game::Pending {
+        due: run.turn + 1,
+        length: 0.5,
+        girth: 0.0,
+        foreskin: 0.0,
+    });
+    assert!(run.hold().is_ok());
+    assert!((run.body.length - before - 0.5).abs() < 1e-9);
+    assert!(run.body.pending.is_empty());
+}
+
+#[tokio::test]
+async fn hold_keeps_the_shop_and_the_melon_open() {
+    let hotel = seeded_with(Floor::Hotel, |run| {
+        run.here.wifi_accepted = true;
+        run.body.eq = 80;
+    });
+    send(&hotel, "GET", "/runs/cafebabe/shop", &[], "").await;
+    let held = send(&hotel, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert!(linked_rels(&held).contains(&"shop-item".to_owned()));
+
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), SEED);
+    run.body.eq = 80;
+    run.here.kitchen.melon_offered = true;
+    assert!(run.hold().is_ok());
+    assert!(run.here.kitchen.melon_offered, "the offer survives a HOLD");
+}
+
+#[tokio::test]
+async fn leaving_the_band_warms_the_next_floor() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.eq = 60;
+        run.body.warmed_up = true;
+        run.here.turns = 6;
+        run.items.lubes.baby_oil = 9;
+    });
+    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(left.status(), StatusCode::SEE_OTHER);
+    let detail = json(left).await["detail"].as_str().unwrap().to_owned();
+    assert!(detail.contains("the warmth came with you"));
+
+    let lube = [("content-type", "application/baby-oil")];
+    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    // The shower is a +35 warm-up, so EQ lands in the band and the band bonus rides along.
+    // The arrival bonus is the one point the second jelq loses.
+    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert!(
+        header(&first, "server-timing").contains("d20+4"),
+        "the first jelq of a warm arrival rolls with +1, got {}",
+        header(&first, "server-timing")
+    );
+    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert!(header(&second, "server-timing").contains("d20+3"));
+}
+
+#[tokio::test]
+async fn energy_drinks_add_three_stamina() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.stamina = 2;
+        run.items.stores.energy_drinks = 1;
+    });
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&view, "link").contains("technique=energy"));
+    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
+    assert_eq!(drink.status(), StatusCode::OK);
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-stamina"), "5/10");
+    let again = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
+    assert_eq!(again.status(), StatusCode::FAILED_DEPENDENCY);
+}

show truncated diff

jelq

Commit 8b8e83329a1d

Commit `8b8e83329a1d`