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+3 additions−2 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 ra

show full diff (262144 bytes truncated)

jelq

Commit 8b8e83329a1d

Commit `8b8e83329a1d`