sindicate 0.4.0 → 0.5.0

package/src/systems/coach.js

@@ -0,0 +1,1034 @@
+// THE STAGECOACH LINE — Dustwater's public transport.
+//
+// A coach is a box on four wheels, a team of two, and a man on the box. It runs a ROUTE between
+// the places on the map, and it does the one thing that makes a coach feel like a service rather
+// than set dressing: IT CALLS AT TOWN. It rolls in off the north road, pulls up at the depot,
+// the doors swing open, whoever was riding gets down and walks away into the town, whoever was
+// waiting climbs aboard, the doors shut, the driver takes them out again — and later you meet
+// the same coach on the road between two places, doing exactly what it said it was doing.
+//
+// WHAT IS AUTHORED, WHAT IS DERIVED:
+//   coachRig.json  — where the horses and the driver sit, RELATIVE TO THE COACH (tuned in
+//                    /coachtest.html, because that relationship is a thing you look at, not a
+//                    thing you calculate).
+//   ROUTE          — the stops, here. Everything else — headings, gaits, wheel spin, when a
+//                    passenger opens a door — falls out of the coach's own motion.
+//
+// PERF: everything is built ONCE, on the loading screen, and stays resident for life — the same
+// law the horses and the townsfolk obey (main.js:118: adding or toggling skinned meshes during
+// play triggers pipeline setup and multi-second freezes). Passengers do not spawn when a coach
+// arrives; they are already aboard, riding along inside the box with their models hidden, and
+// "getting out" is them becoming visible at the door and walking off.
+import * as THREE from 'three/webgpu';
+import { instantiate, loadClips, loadModel } from '../core/assets.js';
+import { RawAnimator } from '../core/anim.js';
+import { SeatedRider, SEAT, passengerPosture, driverPosture } from './seatedRider.js';
+import { rayCapsule } from './aim.js';
+import { makeSeatedPose, BIPED_TO_SYNTY } from './riding.js';
+// Coach content is GAME data, registered before construction (partials merge):
+//   setCoachContent({ characters, colliders, dropItemsFor, rig, route })
+// route = { ROUTE, LEGS, TOTAL_LEN, placeAt, LANE, EASE_M } (from the game's route derivation)
+let CHARACTERS = {}, colliders = [], dropItemsFor = () => null, RIG = {};
+let ROUTE = [], LEGS = [], TOTAL_LEN = 0, placeAt = () => null, LANE = 1.6, EASE_M = 6;
+export function setCoachContent(c = {}) {
+  if (c.characters) CHARACTERS = c.characters;
+  if (c.colliders) colliders = c.colliders;
+  if (c.dropItemsFor) dropItemsFor = c.dropItemsFor;
+  if (c.rig) RIG = c.rig;
+  if (c.route) ({ ROUTE = ROUTE, LEGS = LEGS, TOTAL_LEN = TOTAL_LEN, placeAt = placeAt, LANE = LANE, EASE_M = EASE_M } = c.route);
+}
+
+// WHO IS ON THE COACH TODAY. Not a fixed four: the same faces riding the same box past you every
+// half hour is the thing that turns a service into a prop. So each coach draws its own fares from
+// the pool, in their own clothes, and how many are actually aboard changes at every stop —
+// sometimes the coach rolls through empty, sometimes it is full.
+export const FARE_POOL = [
+  'Character_Woman_01', 'Character_Salesman_Male_01', 'Character_Priest_Male_01', 'Character_Cowgirl_01',
+  'Character_Business_Man_01', 'Character_Traveller_Female_01', 'Character_GoldMiner_Male_01',
+  'Character_Mexican_Male_01', 'Character_Mexican_Female_01', 'Character_Sheriff_01',
+];
+// The Synty bodies are UV'd for their own pack's atlas, but the pack ships several colourways of
+// it — so the same body in a different atlas is a different person in different clothes, for free.
+export const FARE_SKINS = [
+  '/assets/textures/atlas_western.png', '/assets/textures/atlas_western_b.png',
+  '/assets/textures/atlas_western_c.png', '/assets/textures/atlas_western_alt1.png',
+  '/assets/textures/atlas_western_alt2.png', '/assets/textures/atlas_western_alt3.png',
+];
+export const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
+// Draw a fresh coachload: n different bodies, each in a colourway of its own. Shared with
+// /coachtest.html so the fares you shuffle in the bench are the fares the game actually runs.
+export function castFares(n) {
+  const cast = [...FARE_POOL].sort(() => Math.random() - 0.5).slice(0, n);   // no twins aboard
+  return cast.map((id) => {
+    const known = CHARACTERS.find((c) => c.id === id) ?? CHARACTERS[0];
+    return { id, src: known.src, keep: id, tex: pick(FARE_SKINS) };
+  });
+}
+import { dist2D } from '../core/utils.js';
+import { alarmTown } from './npc.js';
+export { ROUTE };   // the timetable's shape is public, as it always was — it just isn't authored here
+
+const COACH_URL = '/assets/western/SM_Veh_Stagecoach_01.fbx';
+const ATLAS = '/assets/textures/atlas_western.png';
+const HORSE_URL = '/assets/horse/SyntyHorse.fbx';
+// Six coats in the pack. A team of two identical horses, on every coach, forever, is the kind of
+// thing you stop seeing after a week and a player notices in ten seconds — so each coach draws its
+// own pair. Deliberately allowed to draw the same coat twice: a MATCHED team is a real thing a
+// stage line would be proud of, and forbidding it would be a different kind of wrong.
+const HORSE_COATS = [
+  '/assets/textures/horse_01.png', '/assets/textures/horse_02.png', '/assets/textures/horse_03.png',
+  '/assets/textures/horse_04.png', '/assets/textures/horse_05.png', '/assets/textures/horse_06.png',
+];
+const HORSE_TEX = HORSE_COATS[0];
+const HA = '/assets/horse/anims';
+// A man on a BENCH, not on a horse: the Malbers chair sit (knees forward, feet down).
+const SIT_CLIP = `${HA}/Sit_Loop.fbx`;
+const DRIVER_DROOP = 0.3;   // radians: a coachman's hands rest lower than a rider's (tuned in /coachtest.html)
+
+// Road speeds, metres/sec — the same numbers the bench rolls at, so what you tuned is what runs.
+const GAIT_SPEED = { idle: 0, walk: 1.6, trot: 3.4, canter: 6.5, gallop: 10.5 };
+// A CANTER, NOT A TROT — AND THAT IS THE COUNTY DOUBLING, NOT A TASTE CHANGE.
+// The circuit (depot → fort → depot → mission → depot) was ~1,703 m and is ~3,406 m now. At a trot
+// (3.4 m/s) plus four 24 s stands that is an EIGHTEEN AND A HALF MINUTE lap, and with two coaches you
+// stand at the depot for nine minutes waiting for one. Unplayable. At a canter (6.5) with three coaches
+// (main.js: build(3)) it is a 10.3-minute lap and a coach at the depot every ~3.4 minutes — better than
+// it was before the resize. It is also simply more honest: a stage trotted through town and MADE TIME on
+// the open road, which is exactly what it now does. (Traffic braking is unchanged: LOOK scales with
+// speed, so she still sees further the faster she goes.)
+const CRUISE = 'canter';               // a working coach makes time on the open road; it does not gallop
+const STOP_SECS = 24;                  // how long it stands at a stop
+const DOOR_HOLD = 20;                  // ...of which the door stands OPEN for this long
+const DOOR_OPEN = 1.45;                // radians the door swings
+const DOOR_SECS = 0.8;                 // and how long the swing takes
+
+// TRAFFIC. A coach that drives through you, through the townsfolk and through the other coach is
+// not a vehicle, it is a poster of a vehicle sliding along a rail.
+// (LANE — metres right of the route line each coach drives — lives in coachRoute.js now, beside
+// the polylines it offsets and the deck that must cover it. The keep-right story is told there:
+// the return leg runs the same line the other way, so offsetting each direction to ITS OWN right
+// puts them on opposite sides of the road and they pass instead of sharing one strip of dirt.)
+const LOOK = 6.0;      // metres it looks ahead even at a DEAD STOP...
+const LOOK_PER_MS = 1.0;   // ...plus this much per m/s: a trotting coach looks ~9m ahead
+const HOLD_PAD = 1.5;  // once stopped, the way must be clear by THIS much more before she pulls
+                       // away. Without it the look-ahead shrinks as she slows, so she stops seeing
+                       // the man in front of her, pulls away, sees him again, stops — and creeps
+                       // into him at 1.8m/s forever. Hysteresis, not a bigger number.
+const CORRIDOR = 2.0;  // how wide the road ahead has to be clear (half-width, metres)
+const YIELD_NEAR = 7.0;   // people inside this are STRAGGLERS the coach swings round; further out it
+                          // keeps rolling — they have been shouted at and they are clearing
+const YELL_FLEE = 1.3;    // seconds of perpendicular scurry per shout (re-upped while in the corridor)
+const PASS_SHIFT = 2.6;   // opposing coaches: how far each pulls to her own right to pass
+const BRAKE = 3.2;     // how hard it hauls up (1/s). A loaded coach does not stop dead.
+const PULL = 0.6;      // and how lazily it gets going again
+const TURN_RATE = 0.9; // radians/sec at speed, when YOU are driving — she is four tons on wood
+const REVERSE = 1.4;   // m/s: what a team will back a coach at, and no more. She gets a reverse because
+                       // she now has COLLISION (BODY, below) — and without one, a coach nosed into the
+                       // front of the saloon is a coach that can never be driven again: the steering
+                       // bites off her speed, and her speed against a wall is nought.
+
+// HER BODY, for the world to push on. Four discs down her long axis: the box is 2.4 x 5.0 m (col:
+// hx 1.2, hz 2.5) and the team is hitched 3.5 m out in front of it (coachRig.json), so the thing
+// that actually reaches a wall first is a horse's nose, and leaving the team out would sink two
+// horses into the planking before anything touched. Local +z is forward — the same frame
+// _syncColliders already writes her horse colliders in.
+const BODY = [
+  { z: 3.5, r: 1.05 },    // the team
+  { z: 1.7, r: 1.20 },    // the box and the fore-carriage
+  { z: 0.0, r: 1.20 },
+  { z: -1.7, r: 1.20 },   // the boot
+];
+const _push = new THREE.Vector3();
+
+// THE ROOF. Sprint at her, jump, and you are riding on top — see game/platform.js, which owns the
+// primitive; the coach is only its first client.
+//
+// MEASURED, not guessed: the body mesh's top surface rasterised in coach-local metres (a 10cm grid,
+// max triangle Y per cell). The cabin top is DEAD FLAT at y = 2.71 from x -1.02..+1.08 and
+// z -1.27..+1.13, with a luggage rail 22cm proud of it around the rim. The rect below is pulled in
+// from that: off the rail at the sides and the back, and stopped short at the FRONT, because the
+// driver's pivot is at z 1.385 and his head sits 0.49m above the deck — walk any further and your
+// boots go through the coachman's hat. (Nothing would push you apart: a SeatedRider is in none of
+// separateFromPeople's lists.)
+const ROOF = { x0: -0.90, x1: 0.90, z0: -1.15, z1: 0.70, y: 2.71, surface: 'stone' };
+// ...and the BODY, as a wall for an entity only — never a collider, so it cannot stop a bullet and
+// the band that lets you shoot the driver (below) is preserved by construction. Its floor is the
+// footboard, where `col` stops. Its CEILING is the roof less the ledge-catch reach, which leaves
+// the top 0.85m of her open: that is the lip, and a man whose feet are up there is grabbing it, not
+// bouncing off it. Below that you are hitting the side of a coach, and you fall.
+const HULL = { x0: -1.10, x1: 1.10, z0: -1.30, z1: 1.15, y0: 1.50, y1: ROOF.y - 0.85 };
+
+// SHOOT THE MAN ON THE BOX.
+// Horses do not stand politely over a dead coachman. The reins go slack, the shot goes off behind
+// their ears, and they BOLT: she runs flat out with nobody steering — past the depot without
+// calling, straight through the traffic she would have braked for — until the team blows itself
+// out and drags her to a halt in the middle of the road with a corpse folded over the box. If the
+// guard beside him lived, he takes the reins from where he sits and the line goes on. If he did
+// not, that coach never runs again, and the road has a derelict on it. That is the price.
+const BOLT_SECS = 14;    // how long a panicked team can hold a flat canter before it is blown
+const BOLT_RUSH = 2.4;   // and how violently it gets there (PULL is 0.6 — this is not a working start)
+const DRAG_DOWN = 0.8;   // 1/s: a blown team hauling itself up is far slower than a driver braking (BRAKE 3.2)
+const REINS_SECS = 3.5;  // how long the guard looks at the body before he climbs onto the leather
+
+// WHAT THEY CARRY. The driver has the takings — the whole reason a man ever shot a coachman — the
+// guard beside him has his wages, and a fare has whatever was in his pocket.
+const TAKINGS = [70, 130];
+const WAGES = [18, 40];
+const FARE_PURSE = [4, 22];
+const roll = ([a, b]) => a + Math.floor(Math.random() * (b - a + 1));
+
+// THE LINE. Neither the stops nor the waypoints are declared here. The stops come from
+// world/data/coachStop.js — one list, two consumers, so the timetable and the stage buildings can
+// never drift apart — and the LEGS BETWEEN THEM come from the ROAD GRAPH (coachRoute.js, imported
+// above): the same net the minimap routes on, snapped at the stops, thinned, and threaded through
+// the bridge chord because the chord IS the spliced road. The generations of hand-authored
+// waypoints this block used to carry — the ±2 m offsets that fought the lane logic, the 'Town
+// North' on-ramp with its site-local scaling trap, the BRIDGE_SPOTS-derived chord pair — all
+// retire BY DERIVATION: the on-ramp is the route's own ≤6 m kerb stub (from live STOPS + live
+// ROADS, scale-proof by construction), the crossing falls out of the road line with 0.00 m of
+// deviation, and a leg that leaves the graded dirt cannot be authored at all. The complaint that
+// forced this ("has just taken me through a building… and now across a field") lived on ONE
+// straight 385 m leg that no waypoint patch was ever going to keep fixed; scripts/verify-coach.mjs
+// now walks every driven lane line at 1 m and fails the build on the first off-road metre.
+
+// One coach: the box, its team, its driver, and whoever is riding inside it.
+class Coach {
+  constructor(game, leg = 0, t = 0) {
+    this.game = game;
+    this.leg = leg;                    // which stretch of the route it is on
+    this.t = t;                         // progress along that stretch, 0..1
+    this.state = 'rolling';             // rolling | standing
+    this.wait = 0;
+    this.doorK = 0;                     // 0 shut … 1 open (eased)
+    this.speed = 0;
+    this.root = new THREE.Group();
+    this.passengers = [];               // NPCs riding inside
+    this.bolt = 0;                      // >0 = the team has run away with her (the driver is dead)
+    this.spent = false;                 // ...and now they're blown: dragging to a halt in the road
+    this.reinsT = 0;
+    this.crew = [];                     // who is aboard and shootable — combat.js walks this
+  }
+
+  async load() {
+    const coach = await instantiate(COACH_URL, { texture: ATLAS });   // GLB twin: already metres
+    this.root.add(coach);
+    // Wheels and doors are separate nodes, but every node sits at the origin with its geometry
+    // baked out at its real place — so re-pivot each one onto its own hub/hinge before turning
+    // it, or it swings around the coach's centre like a hammer throw. (Same as /coachtest.html.)
+    this.wheels = [];
+    this.doors = [];
+    const box = new THREE.Box3(), c = new THREE.Vector3();
+    coach.traverse((o) => {
+      if (!o.isMesh || !o.geometry) return;
+      const spin = /Wheel_(fl|fr|rl|rr)$/i.test(o.name);
+      const door = /Door_(l|r)$/i.test(o.name);
+      if (!spin && !door) return;
+      // COPY THE GEOMETRY BEFORE YOU MOVE IT.
+      // instantiate() clones the node tree but SHARES the geometry with the master — that is the
+      // whole point of the cache. Re-pivoting a wheel edits the geometry IN PLACE, so the second
+      // coach on the line re-pivoted the geometry the first coach had already re-pivoted: every
+      // wheel translated twice, hubs computed from an already-moved bounding box, and a coach that
+      // arrived with its wheels scattered across the desert. One coach hid it; two did not.
+      o.geometry = o.geometry.clone();
+      o.geometry.computeBoundingBox();
+      box.copy(o.geometry.boundingBox);
+      box.getCenter(c);
+      if (spin) {
+        o.geometry.translate(-c.x, -c.y, -c.z);
+        o.position.add(c);
+        this.wheels.push({ mesh: o, radius: (box.max.y - box.min.y) / 2 || 0.5 });
+      } else {
+        // hinge on the door's FORWARD edge, not its middle, or it scissors open through itself
+        const hinge = new THREE.Vector3(c.x, c.y, box.max.z);
+        o.geometry.translate(-hinge.x, -hinge.y, -hinge.z);
+        o.position.add(hinge);
+        // Which side of the coach this leaf is on. The coach's local +X is its RIGHT (it travels
+        // +Z), and the lane offset puts its right side against the kerb — so the right-hand door
+        // is the one that opens onto the depot, and the left one opens onto the road, which is
+        // where nobody gets out.
+        this.doors.push({ mesh: o, sign: c.x < 0 ? 1 : -1, right: c.x > 0, k: 0, want: 0 });
+      }
+    });
+
+    // the team
+    const clips = await loadClips({
+      idle: `${HA}/H_Idle_01.fbx`, walk: `${HA}/H_Walk_IP.fbx`,
+      trot: `${HA}/H_Trot_IP.fbx`, canter: `${HA}/H_Canter_IP.fbx`,
+      gallop: `${HA}/H_Gallop_IP.fbx`,   // Shift on the box asks for it, so the team must have it
+    });
+    this.team = [];
+    for (const h of RIG.horses) {
+      const model = await instantiate(HORSE_URL, { texture: pick(HORSE_COATS), scale: 0.01 });
+      model.scale.setScalar(0.01);
+      const pivot = new THREE.Group();
+      pivot.position.set(h.x, h.y, h.z);
+      pivot.rotation.y = h.ry;
+      pivot.add(model);
+      this.root.add(pivot);
+      const animator = new RawAnimator(model, clips);   // horse clips speak the horse's skeleton
+      animator.play('idle');
+      this.team.push({ animator, gait: 'idle' });
+    }
+
+    // THE PEOPLE. Driver, his mate beside him, and the fares on the benches inside — all of them
+    // SeatedRider, all of them wearing the ONE posture tuned in /coachtest.html. Nobody gets a
+    // bespoke sit: the day a driver's hands move, every passenger's hands move with him.
+    //
+    // The fares are BUILT NOW AND KEPT FOREVER, riding along inside the box with their models
+    // hidden — because adding a skinned mesh to a live scene costs a pipeline build and a
+    // multi-second freeze (main.js:118), and a coach pulling into town is precisely the worst
+    // moment to take one. "Getting out" is a man becoming visible, not a man being born.
+    const defOf = (role, fallbackId) => {
+      const id = RIG[`${role}Id`] ?? fallbackId;
+      const known = CHARACTERS.find((c2) => c2.id === id) ?? CHARACTERS[0];
+      return { id, src: RIG[`${role}Src`] ?? known.src, keep: id, tex: RIG[`${role}Tex`] ?? known.tex };
+    };
+    const PAX = passengerPosture(SEAT);          // hands in the lap — only the driver holds reins
+    const DRV = driverPosture(SEAT);
+    this.driver = await SeatedRider.create(this.root, defOf('driver', 'Character_Business_Man_01'), RIG.driver, DRV);
+    if (RIG.mate) {
+      this.mate = await SeatedRider.create(this.root, defOf('mate', 'Character_Cowboy_01'), RIG.mate, PAX);
+    }
+    this.fares = [];
+    const seats = RIG.fares ?? [];
+    for (const def of castFares(seats.length)) {
+      this.fares.push(await SeatedRider.create(this.root, def, seats[this.fares.length], PAX));
+    }
+    this.riders = [this.driver, this.mate, ...this.fares].filter(Boolean);
+    // EVERY MAN ABOARD IS A SHOOTABLE PERSON (the seatedRider.js contract). Hand him the world he
+    // lives in, the coach he is riding, and who he is on it — the role decides what his purse is
+    // worth and, for the driver, what happens to the team when he dies.
+    this._drvPosture = DRV;              // kept: the guard puts it on if he ever takes the reins
+    for (const r of this.riders) {
+      r.game = this.game;
+      r.coach = this;
+      r.role = r === this.driver ? 'driver' : r === this.mate ? 'mate' : 'fare';
+    }
+    this._seatFares();                   // (also builds this.crew — must come AFTER this.riders)
+
+    // SOLID. The world's collider list is walked live by World.collide, so a moving vehicle can
+    // simply keep its entry up to date each frame — the box for the coach, a circle for each horse.
+    // Without these you walk straight through the team and out the far side of the coach, which is
+    // the single fastest way to tell a player that none of this is real.
+    // A HEIGHT BAND, or the coach shoots down your bullets for you.
+    // World.collide kills a bullet that crosses a collider, and a box with no band is solid all the
+    // way to the sky — so every round fired at the DRIVER, who sits on top of the thing, died on
+    // the chassis 2m below his boots. You could not rob the stage because the stage was bulletproof
+    // in a way it had never agreed to be. The band is the body of the coach: below it you are
+    // stopped, above it (the box seat, the roof rack, the man on it) you are not. y0/y1 are world
+    // heights, so they ride with her over the ground (see _syncColliders).
+    this.col = { x: 0, z: 0, hx: 1.2, hz: 2.5, cs: 1, sn: 0, y0: 0, y1: 0 };
+    colliders.push(this.col);
+    this.horseCols = this.team.map(() => {
+      const c2 = { x: 0, z: 0, r: 0.85 };
+      colliders.push(c2);
+      return c2;
+    });
+    // WHAT SHE MUST NEVER BE PUSHED OUT OF: herself. One list, two readers — platform.js hands it to
+    // the man on her roof so her own box does not shove him off it, and _drive hands it to the world
+    // so she does not shove herself across the road.
+    this.myCols = [this.col, ...this.horseCols];
+
+    this._place();
+    this._syncColliders();
+    this._syncRiders();
+    return this;
+  }
+
+  doorsShut() { return this.doors.every((d) => d.k < 0.02); }
+
+  // WHERE EACH MAN ACTUALLY IS, IN THE WORLD. He is a child of a moving, turning coach, so his
+  // world position has to be PRODUCED, not read. Same rotate-the-offset arithmetic the horse
+  // colliders already use (_syncColliders), written into a Vector3 he already owns: no
+  // getWorldPosition matrix walk, no allocation, twelve riders a frame, called from the coach's
+  // own update and again from combat.js before it tests a bullet (main.js ticks combat BEFORE the
+  // coaches, so without that second call every round is fired at where he was last frame).
+  //
+  // The y is his STANDING DATUM, not his seat — see seatedRider.js's STAND_HEAD. It sits below the
+  // floorboards on purpose: it is the ground he would be standing on if he stood up, which is the
+  // only thing combat.js's HEAD_Y (1.5m above the feet) can be measured from.
+  _syncRiders() {
+    const ry = this.root.rotation.y;
+    const s = Math.sin(ry), c = Math.cos(ry);
+    const ox = this.root.position.x, oy = this.root.position.y, oz = this.root.position.z;
+    for (const r of this.riders) {
+      const p = r.pivot.position;
+      r.position.set(ox + p.x * c + p.z * s, oy + p.y - r.feetDrop, oz - p.x * s + p.z * c);
+    }
+  }
+
+  // Drag the colliders along with the thing they belong to. Cheap: three objects, no allocation.
+  _syncColliders() {
+    if (!this.col) return;
+    const ry = this.root.rotation.y;
+    // the prompts ride with her: the door on her kerb side, the box up front
+    if (this._itDoor) {
+      const c2 = Math.cos(ry), s2 = Math.sin(ry);
+      this._itDoor.x = this.root.position.x + c2 * 1.4;
+      this._itDoor.z = this.root.position.z - s2 * 1.4;
+      this._itBox.x = this.root.position.x + s2 * 1.4 + c2 * 0.9;
+      this._itBox.z = this.root.position.z + c2 * 1.4 - s2 * 0.9;
+    }
+    this.col.x = this.root.position.x;
+    this.col.z = this.root.position.z;
+    this.col.cs = Math.cos(ry);
+    this.col.sn = Math.sin(ry);
+    this.col.y0 = this.root.position.y - 0.2;      // the chassis...
+    this.col.y1 = this.root.position.y + 1.55;     // ...up to the footboard. The crew sit above it.
+    for (let i = 0; i < this.horseCols.length; i++) {
+      const h = RIG.horses[i];
+      const s2 = Math.sin(ry), c2 = Math.cos(ry);
+      this.horseCols[i].x = this.root.position.x + h.x * c2 + h.z * s2;
+      this.horseCols[i].z = this.root.position.z - h.x * s2 + h.z * c2;
+    }
+  }
+
+  // where the coach is right now, and which way it points: straight off the route line.
+  _place(dt = 0.05) {
+    const a = ROUTE[this.leg], b = ROUTE[(this.leg + 1) % ROUTE.length];
+    let x = a.x + (b.x - a.x) * this.t;
+    let z = a.z + (b.z - a.z) * this.t;
+    // KEEP RIGHT. Slide off the route line onto its own side of the road. The return leg runs the
+    // same polyline the other way, so ITS right is the other side of the dirt — which is why two
+    // coaches meeting head-on pass each other rather than driving through one another. The ease is
+    // over the STOP-TO-STOP PATH (LEGS carries where this leg sits on it), not over each leg: road
+    // legs are ~20 m now, and a per-leg ease would send her back to the centreline at every survey
+    // peg — a 1.15 m weave every 20 m, and two coaches meeting near any vertex on the same dirt.
+    // She pulls out, takes her side within EASE_M metres, and holds it to the next stop.
+    const dx = b.x - a.x, dz = b.z - a.z;
+    const len = Math.hypot(dx, dz) || 1;
+    const rx = dz / len, rz = -dx / len;          // the right-hand normal of the direction of travel
+    const meta = LEGS[this.leg];
+    const s = meta.s0 + this.t * meta.len;
+    const ease = Math.max(0, Math.min(1, s / EASE_M, (meta.pathLen - s) / EASE_M));
+    // THE OVERTAKE SWING (_blocked's dodge): a temporary extra lane offset, eased like a driver
+    // hauls the team — out, past the walker, and back to her side when the way ahead clears.
+    this._dodgeCur = (this._dodgeCur ?? 0) + ((this._dodgeTarget ?? 0) - (this._dodgeCur ?? 0)) * Math.min(1, dt * 1.6);
+    if (Math.abs(this._dodgeCur) < 0.02 && !this._dodgeTarget) this._dodgeCur = 0;
+    x += rx * (LANE * ease + this._dodgeCur);
+    z += rz * (LANE * ease + this._dodgeCur);
+    this.laneOffset = LANE * ease + this._dodgeCur;   // what the road view reports: how far right of her own leg
+    const y = this.game.world.groundAt(x, z);
+    this.root.position.set(x, y, z);
+    // face the way you are going (not the way you were told to) — a coach cannot crab sideways
+    const want = Math.atan2(b.x - a.x, b.z - a.z);
+    if (this.state === 'standing') {
+      // ...except while standing, when it parks the way the stop says to
+      const park = a.ry ?? want;
+      let d = park - this.root.rotation.y;
+      while (d > Math.PI) d -= Math.PI * 2;
+      while (d < -Math.PI) d += Math.PI * 2;
+      this.root.rotation.y += d * 0.06;
+    } else {
+      let d = want - this.root.rotation.y;
+      while (d > Math.PI) d -= Math.PI * 2;
+      while (d < -Math.PI) d += Math.PI * 2;
+      this.root.rotation.y += d * 0.08;      // eased, so it swings round a corner rather than snapping
+    }
+  }
+
+  // IS THE ROAD AHEAD CLEAR? Everything that can be stood in front of a coach gets asked: the
+  // player, the townsfolk, the other coach. The test is a CORRIDOR, not a radius — a man beside
+  // the road is not in the way, and a man ten metres back is not in the way either, but a man on
+  // the road in front is, and the further you are going the further ahead you have to care.
+  // THE COACH ROBBERY (the bloodless one — shooting the driver has always worked, and bolts the
+  // team). A drawn gun AIMED at the driver from the road (≤14m, ray-tested at his seat) reins the
+  // team up; hold it ~2 seconds and the takings come down off the box — a fat purse (dropFor
+  // 'driver' ×4), a 'coachRobbery' on the county's books, and a coach that stands trembling until
+  // you lower the iron or walk away, then drives on poorer. Once per coach per session.
+  _heldUp(dt) {
+    const g = this.game, p = g.player;
+    if (!p || this.rider || this.driver?.alive === false) return false;
+    const d = dist2D(this.root.position.x, this.root.position.z, p.position.x, p.position.z);
+    if (this._robbed) {
+      // stood and delivered already: she stays reined only while the gun still says so
+      return p.drawn && p.aiming && d < 16;
+    }
+    let aimedAtDriver = false;
+    if (p.drawn && p.aiming && d < 14 && !p.riding?.mounted) {
+      const dp = (this._drvPos ??= new THREE.Vector3());
+      this.driver?.pivot?.getWorldPosition?.(dp);
+      const from = (this._huFrom ??= new THREE.Vector3()).copy(p.position); from.y += 1.5;
+      const dir = p.aimDir?.((this._huDir ??= new THREE.Vector3()));
+      if (dir) { dp.y -= 1.0; aimedAtDriver = !!rayCapsule(from.x, from.y, from.z, dir.x, dir.y, dir.z, dp, 0.7); }
+    }
+    if (!aimedAtDriver) { this._holdT = 0; return false; }
+    this._holdT = (this._holdT ?? 0) + dt;
+    if (this._holdT < 0.3) g.ui?.toast?.(`The driver's hands come off the reins. Hold the iron on him.`, 3200);
+    if (this._holdT > 2.2) {
+      this._robbed = true; this._holdT = 0;
+      const at = this.root.position.clone(); at.x += Math.cos(this.root.rotation.y) * 2.2; at.z -= Math.sin(this.root.rotation.y) * 2.2;
+      at.y = g.world.groundAt(at.x, at.z) + 0.1;
+      g.loot?.dropFor?.('driver', at, 4);                       // the STRONGBOX takings, not his pocket
+      g.crime?.report?.('coachRobbery', this.root.position.clone());
+      g.missions?.addStat?.('reputation', -2);
+      g.ui?.toast?.(`The box comes down without a word. The line will wire every lawman in the county.`, 6500);
+    }
+    return true;
+  }
+
+  _blocked() {
+    const fwd = this.root.rotation.y;
+    const fx = Math.sin(fwd), fz = Math.cos(fwd);
+    const ox = this.root.position.x, oz = this.root.position.z;
+    const reach = LOOK + this.speed * LOOK_PER_MS + (this.held ? HOLD_PAD : 0);
+    // `shift` tests a corridor slid sideways — the overtake question: "if I swung out this far,
+    // would the way be clear?" (positive = to her right)
+    const inTheWay = (px, pz, pad = 0, shift = 0) => {
+      const dx = px - (ox + fz * shift), dz = pz - (oz - fx * shift);
+      const ahead = dx * fx + dz * fz;             // how far in front (negative = behind us)
+      if (ahead < 0.5 || ahead > reach + pad) return false;
+      const side = Math.abs(dx * fz - dz * fx);    // how far off the centreline
+      return side < CORRIDOR + pad;
+    };
+    // ...but NOT the man riding inside her. His position is the seat, which is half a metre forward
+    // of her centre — squarely inside her own look-ahead — so she braked for her own passenger and
+    // stood in the road forever, refusing to carry the person she was carrying.
+    // ...nor the man standing on her ROOF, for exactly the same reason: the front half of the deck
+    // is inside her own look-ahead corridor, so she would brake to a halt for her own passenger and
+    // stand in the road forever with him on top of her.
+    const people = [];   // { x, z, ent } — ent null for the player (a coach does not shout the player aside)
+    const p = this.game.player;
+    const pp = p?.position ?? p?.root?.position;
+    const mine = this.rider?.player === p || this.game.platforms?.carrier(p) === this;
+    if (pp && !mine) people.push({ x: pp.x, z: pp.z, ent: null });
+    for (const n of this.game.npcs ?? []) {
+      if (!n.alive) continue;             // a coach drives over a body. It does not queue behind one
+                                          // for the rest of the game, which is what it did.
+      const np = n.position ?? n.root?.position;
+      if (np) people.push({ x: np.x, z: np.z, ent: n });
+    }
+    // OTHER COACHES: two rules, by direction. SAME way → queue behind her (a bigger thing, more room,
+    // never overtaken). OPPOSING way → each keeps to her own RIGHT and they pass — the old rule braked
+    // BOTH of them nose to nose and they stood facing each other in the road until the end of days.
+    let oppose = false;
+    for (const other of this.game.coaches?.coaches ?? []) {
+      if (other === this) continue;
+      const ov = other.root.position;
+      const oy = other.root.rotation.y;
+      const sameWay = fx * Math.sin(oy) + fz * Math.cos(oy) >= -0.2;
+      if (sameWay) {
+        if (inTheWay(ov.x, ov.z, 2.6)) { this._dodgeTarget = 0; return true; }
+      } else {
+        // a WIDER ahead-window than the brake corridor, held through the pass itself (ahead > -4:
+        // don't straighten while we are abreast of her) so the swing lasts until she is truly behind
+        const dx = ov.x - ox, dz = ov.z - oz;
+        const ahead = dx * fx + dz * fz;
+        const side = Math.abs(dx * fz - dz * fx);
+        if (ahead > -4 && ahead < reach + 8 && side < CORRIDOR + 2.6) oppose = true;
+      }
+    }
+
+    // THE DRIVER'S SHOUT — people clear the road for a coach, not the coach for people (Nick).
+    // Everyone in the look-ahead corridor scurries PERPENDICULAR off her line: the scare point is a
+    // virtual spot planted a step to their road-centre side, so "run away from it" is exactly "step
+    // off the road", not the run-along-the-road-forever a scare at the coach itself produces. A
+    // seated rider's scare() spooks his horse aside instead — same effect from the saddle.
+    // Refresh while fleeT runs low so a man still in the corridor keeps clearing.
+    const blockers = people.filter((q) => inTheWay(q.x, q.z));
+    let nearest = Infinity;
+    for (const b of blockers) {
+      const dxq = b.x - ox, dzq = b.z - oz;
+      nearest = Math.min(nearest, dxq * fx + dzq * fz);
+      const n = b.ent;
+      if (n?.scare && (n.fleeT ?? 0) <= 0.35) {
+        const sgn = (dxq * fz - dzq * fx) >= 0 ? 1 : -1;   // which side of her line he is already on
+        n.scare(b.x - sgn * fz * 1.5, b.z + sgn * fx * 1.5, YELL_FLEE);
+      }
+    }
+
+    if (oppose) {
+      // pull to her own right and hold it; brake only while a person is standing in the passing lane
+      // (he has just been shouted at — he will clear)
+      if (!people.some((q) => inTheWay(q.x, q.z, 0.4, PASS_SHIFT))) { this._dodgeTarget = PASS_SHIFT; return false; }
+      this._dodgeTarget = 0;
+      return true;
+    }
+
+    if (!blockers.length) { this._dodgeTarget = 0; return false; }
+    // they are clearing: keep rolling while the nearest man is still a team's length out
+    if (nearest > YIELD_NEAR) { this._dodgeTarget = 0; return false; }
+    // a CLOSE straggler (the player, a man who will not flee): swing round him like before. Try a
+    // sidestep either side; take the first whose slid corridor is clear of EVERY person. Blocked
+    // both sides (a crowd, a wall of folk) → brake like before.
+    for (const shift of [2.0, -2.0]) {
+      if (!people.some((q) => inTheWay(q.x, q.z, 0.4, shift))) { this._dodgeTarget = shift; return false; }
+    }
+    this._dodgeTarget = 0;
+    return true;
+  }
+
+  // ── GETTING ABOARD ────────────────────────────────────────────────────────────────────────
+  // Two ways on, and they mean different things. At the DOOR you are a fare: you get in, she runs
+  // her route, you look out of the window. At the BOX you take the reins: she stops being a
+  // timetable and starts being a vehicle, and the man who was driving her gets down.
+  //
+  // The player is not reparented onto the coach. His position is written to the seat every frame
+  // instead — because every other system in this game (collision, the camera, the aim, the law's
+  // line of sight) reads player.position, and a player who is secretly a child of a moving group is
+  // a player none of them can find.
+  seatWorld(out, kind) {
+    const r = kind === 'box' ? RIG.driver : (RIG.fares?.[0] ?? RIG.driver);
+    const ry = this.root.rotation.y;
+    const c = Math.cos(ry), sn = Math.sin(ry);
+    return out.set(
+      this.root.position.x + r.x * c + r.z * sn,
+      this.root.position.y + r.y,
+      this.root.position.z - r.x * sn + r.z * c,
+    );
+  }
+
+  // WHO HAS THE REINS IS A FACT, NOT A FLAG.
+  // This used to be a boolean: set in board(), cleared in alight() — and alight() is not the only way
+  // a man leaves the box. Get shot on it and main.js respawns you at the trough without ever telling
+  // the coach; mount a horse from it and the same. She kept the flag, and `driven` is the ONLY gate on
+  // _drive(), which reads the LIVE KEYBOARD. So she went on being steered by a man who was not there:
+  // walking away with A held turned her at 55 deg/s — TURN_RATE exactly — which is a closed circle,
+  // for the rest of the game, through the station building and anything else in the way, because the
+  // driven path consults neither the route nor a collider. Derived from the rider, it cannot lie.
+  get driven() { return this.rider?.kind === 'box'; }
+
+  board(player, kind) {
+    // a man who sits down is no longer a man standing on the roof (and `aboard` writes his position
+    // from the seat, so the two states must never both be live)
+    this.game.platforms?.leave(player, 'aboard');
+    this.rider = { player, kind };
+    // POINT THE CAMERA WHERE SHE IS GOING. It orbits the player at camYaw, and camYaw is whatever
+    // you happened to be looking at when you climbed up — so you took the reins and found yourself
+    // staring at the side of your own coach. The camera's forward is -(sin,cos) of camYaw, so
+    // looking along her heading means camYaw = ry + PI. (player.js keeps easing it there while you
+    // drive, so she stays in front of you through a turn.)
+    player.camYaw = this.root.rotation.y + Math.PI;
+    player.aboard = this;                       // player.js reads this and stops walking about
+    // he stays visible: he is the man on the box (player.js applies the seated pose each frame)
+    if (kind === 'box') {
+      this.speed = 0;
+      // the man on the box gets down and walks away — you cannot have two drivers
+      if (this.driver) this.driver.pivot.visible = false;
+      if (this.mate) this.mate.pivot.visible = false;
+      this.game.ui?.toast?.('You have the reins. W drives, S brakes and backs her, A/D steer, E to get down.');
+    } else {
+      this.game.ui?.toast?.('Aboard. E to get out.');
+    }
+  }
+
+  alight(player) {
+    if (!this.rider) return;
+    player._visualY = undefined;      // let the smoother re-latch onto wherever he lands
+    // step down on the KERB side (her right), clear of the wheels
+    const ry = this.root.rotation.y;
+    const rx = Math.cos(ry), rz = -Math.sin(ry);
+    const x = this.root.position.x + rx * 2.4;
+    const z = this.root.position.z + rz * 2.4;
+    player.position.set(x, this.game.world.groundAt(x, z), z);
+    this._dropRider();                // ...and the one owner of the transition does the rest
+  }
+
+  // THE ONE PLACE A RIDE ENDS. Getting down is one way; being shot off the box, being teleported off
+  // it, respawning at the trough and throwing a leg over a horse are the others, and none of them
+  // used to say a word to the coach. So they don't have to: they only ever touch player.aboard, and
+  // update() calls this the instant the man on the box stops being hers. Whatever ends the ride, the
+  // reins are put down in exactly one place.
+  _dropRider() {
+    const r = this.rider;
+    if (!r) return;
+    this.rider = null;                             // `driven` is derived from this — she is nobody's now
+    if (r.player.aboard === this) r.player.aboard = null;
+    if (r.kind !== 'box') return;
+    if (this.driver?.alive) this.driver.pivot.visible = true;
+    if (this.mate?.alive) this.mate.pivot.visible = true;
+    this._rejoinRoute();                           // she picks her timetable back up from where you left her
+  }
+
+  // Back on the timetable: find the leg she is nearest to, and how far along it she is. Without
+  // this she would teleport back to wherever she was when you took the reins.
+  _rejoinRoute() {
+    let bestD = Infinity;
+    for (let i = 0; i < ROUTE.length; i++) {
+      const a = ROUTE[i], b = ROUTE[(i + 1) % ROUTE.length];
+      const dx = b.x - a.x, dz = b.z - a.z;
+      const L2 = dx * dx + dz * dz || 1;
+      let t = ((this.root.position.x - a.x) * dx + (this.root.position.z - a.z) * dz) / L2;
+      t = Math.max(0, Math.min(1, t));
+      const px = a.x + dx * t, pz = a.z + dz * t;
+      const d = dist2D(px, pz, this.root.position.x, this.root.position.z);
+      if (d < bestD) { bestD = d; this.leg = i; this.t = t; }
+    }
+    this.state = 'rolling';
+    this.wait = 0;
+  }
+
+  // YOU are driving her. No route, no waypoints — a heading and a throttle, which is all a coach
+  // has ever been. She steers like the thing she is: four tons on wooden wheels, so she does not
+  // turn on the spot and she does not stop dead.
+  _drive(dt, input) {
+    const fwd = input?.down?.('KeyW') ? 1 : 0;
+    const brake = input?.down?.('KeyS') ? 1 : 0;
+    // SHIFT PUTS THEM AT A GALLOP. A team at a canter is a coach going somewhere; a team at a
+    // gallop is a coach being got away with. Same key that sprints a man, because that is the key
+    // your hand is already on.
+    const whip = input?.down?.('ShiftLeft') || input?.down?.('ShiftRight');
+    // S is the brake. S with nothing left to brake is the team BACKING her — a walk, no more, and
+    // the only way out of a wall now that a wall is a thing she can hit.
+    const want = brake ? (this.speed <= 0.05 ? -REVERSE : 0)
+      : fwd ? (whip ? GAIT_SPEED.gallop : GAIT_SPEED.canter) : 0;
+    const rate = brake ? BRAKE : (fwd ? PULL : 0.35);
+    this.speed += (want - this.speed) * Math.min(1, dt * rate);
+    if (Math.abs(this.speed) < 0.02) this.speed = 0;
+    // steering only bites when she is rolling — a stationary coach cannot be turned by the reins.
+    // The bite is SIGNED, so backing up swings her the other way, exactly as a wagon does.
+    const steer = (input?.down?.('KeyA') ? 1 : 0) - (input?.down?.('KeyD') ? 1 : 0);
+    const bite = Math.max(-1, Math.min(1, this.speed / 3));
+    this.root.rotation.y += steer * TURN_RATE * bite * dt;
+    const ry = this.root.rotation.y;
+    const s = Math.sin(ry), c = Math.cos(ry);
+    const ox = this.root.position.x, oz = this.root.position.z;
+    let x = ox + s * this.speed * dt;
+    let z = oz + c * this.speed * dt;
+    // AND SHE IS SOLID. This is the ONE path on which a coach's position is not written from the
+    // route — the timetable goes through _place(), and _place() is not called here — so nothing else
+    // in the game was ever going to stop her, and nothing did: driven at the station building she went
+    // straight through the middle of it at 6.3 m/s and came out the far side without losing a tenth of
+    // it (measured: closest approach to its centre, 0.1 m; speed through it, 6.25 → 6.37). So ask the
+    // same world the player walks in, at four points down her body, and take the DEEPEST push rather
+    // than the sum of them: her step is 11 cm at a canter, so a frame's penetration is small and the
+    // next contact resolves on the next frame, where summing four probes that are all in the same wall
+    // would fling her off it.
+    const W = this.game.world;
+    let bx = 0, bz = 0, worst = 0;
+    for (const b of BODY) {
+      W.solidPush(x + b.z * s, this.root.position.y, z + b.z * c, b.r, _push, this.myCols);
+      const m = _push.x * _push.x + _push.z * _push.z;
+      if (m > worst) { worst = m; bx = _push.x; bz = _push.z; }
+    }
+    if (worst > 0) {
+      x += bx; z += bz;
+      // ...and what she ACTUALLY made along her own heading is what she is actually doing. Head-on
+      // that is nothing, and she stands against the wall; at a graze it is most of it, and she scrapes
+      // along the front of the saloon and drives on. Her wheels and her team's gait both read
+      // this.speed, so a coach a wall has stopped stops her wheels too, instead of spinning them at a
+      // canter against the planking.
+      const made = ((x - ox) * s + (z - oz) * c) / Math.max(dt, 1e-4);
+      this.speed = this.speed >= 0 ? Math.min(this.speed, Math.max(0, made))
+        : Math.max(this.speed, Math.min(0, made));
+    }
+    this.root.position.set(x, W.groundAt(x, z), z);
+  }
+
+  update(dt) {
+    // IS THE MAN ON THE BOX STILL ON THE BOX? player.aboard is the one fact about who is riding what,
+    // and everything that can end a ride already maintains it — so ask it, every frame, instead of
+    // trusting a flag that four other systems would have to remember to clear. He is gone if he is
+    // aboard something else (or nothing), if he is dead, or if he is on a horse: any of those and the
+    // reins go down here. Without it she kept the reins after he died and drove herself in circles.
+    const r = this.rider;
+    if (r && (r.player.aboard !== this || !r.player.alive || r.player.riding?.mounted)) this._dropRider();
+
+    // DRIVEN BY THE PLAYER: she is a vehicle now, not a timetable.
+    if (this.driven) {
+      this._drive(dt, this.game.input);
+      for (const d of this.doors) d.want = 0;      // doors shut while she's rolling under your hand
+      this._syncColliders();
+      this._syncRiders();
+      this._afterMove(dt);
+      return;
+    }
+
+    const a = ROUTE[this.leg], b = ROUTE[(this.leg + 1) % ROUTE.length];
+    const legLen = Math.max(1, Math.hypot(b.x - a.x, b.z - a.z));
+
+    if (this.state === 'standing') {
+      this.speed = 0;
+      this.wait -= dt;
+      // THE KERB-SIDE DOOR. It swings open the moment she pulls up, stands open for DOOR_HOLD
+      // while they get down and the next lot climb in, and is shut before she pulls away — the
+      // coach physically cannot leave until it is (see the doorsShut test below). The road-side
+      // door stays shut: nobody steps down into the traffic.
+      const open = this.wait > STOP_SECS - DOOR_HOLD ? 1 : 0;
+      for (const d of this.doors) d.want = d.right ? open : 0;
+      if (this.wait <= 0 && this.doorsShut()) {
+        this.state = 'rolling';
+        this.t = 0;
+      }
+    } else {
+      for (const d of this.doors) d.want = 0;
+      if (this.bolt > 0) {
+        // RUNAWAY. _blocked() is not even asked: a bolting team does not brake for a man in the
+        // road. The coach's colliders are walked live by World.collide, so whoever is in front of
+        // her gets shoved out of the way — being in the road is now HIS problem, and that is
+        // exactly the point of the beat.
+        this.bolt -= dt;
+        this.held = false;
+        this.speed += (GAIT_SPEED.canter - this.speed) * Math.min(1, dt * BOLT_RUSH);
+        if (this.bolt <= 0) this.spent = true;
+      } else if (this.spent) {
+        // BLOWN. Nobody on the reins, the team has had enough, and she drags herself down to a
+        // dead stop wherever she happens to be — in the road, across the road, it doesn't matter.
+        this.held = true;
+        this.speed += (0 - this.speed) * Math.min(1, dt * DRAG_DOWN);
+        if (this.speed < 0.05) this.speed = 0;
+        this._tryTheReins(dt);
+      } else {
+        // WHOA. Brake for whatever is in the road — or for the GUN ON THE DRIVER (_heldUp);
+        // pull away again only once the road is clear and the iron is down.
+        this.held = this._blocked() || this._heldUp(dt);
+        const want = this.held ? 0 : GAIT_SPEED[CRUISE];
+        const rate = this.held ? BRAKE : PULL;
+        this.speed += (want - this.speed) * Math.min(1, dt * rate);
+        if (this.speed < 0.02) this.speed = 0;
+      }
+      this.t += (this.speed * dt) / legLen;
+      if (this.t >= 1) {
+        this.t = 1;
+        this.leg = (this.leg + 1) % ROUTE.length;
+        this.t = 0;
+        const stop = ROUTE[this.leg];
+        // A runaway does not call at the depot, and a coach with a dead man on the box does not
+        // pull up and open its doors for fares.
+        if (stop.stop && this.bolt <= 0 && !this.spent) {
+          this.state = 'standing';
+          this.wait = STOP_SECS;
+          this._callAt(stop);
+        }
+      }
+    }
+
+    this._place(dt);
+    this._syncColliders();
+    this._syncRiders();
+
+    this._afterMove(dt);
+  }
+
+  // EVERYTHING THAT FOLLOWS FROM HER HAVING MOVED — however she came to move. The timetable and the
+  // player's hands on the reins both end up here, so a coach you are driving turns its wheels,
+  // works its team and holds its passengers exactly as one you are watching does. Two copies of
+  // this would drift apart the first time either was touched.
+  _afterMove(dt) {
+    // the wheels are turned BY THE GROUND: radians = distance / radius. Never by a guess.
+    for (const w of this.wheels) w.mesh.rotation.x += (this.speed * dt) / w.radius;
+    // Each leaf runs its own swing, eased — a door is heavy off the latch and it settles, it does
+    // not snap. (One shared angle meant both leaves always did the same thing, so the coach opened
+    // its road-side door into the traffic every time it called anywhere.)
+    for (const d of this.doors) {
+      const step = dt / DOOR_SECS;
+      d.k = Math.max(0, Math.min(1, d.k + Math.sign(d.want - d.k) * step));
+      const e = d.k * d.k * (3 - 2 * d.k);
+      d.mesh.rotation.y = d.sign * DOOR_OPEN * e;
+    }
+    // Everyone aboard holds their pose. It is four two-bone solves a man, no mixer, no clip — and
+    // it must run every frame because the IK is solved fresh from the base pose each time (solve on
+    // top of yesterday's solve and he shakes himself apart; see seatedRider.js).
+    // A DEAD MAN IS NOT SOLVED. He was solved once, limp, at the moment he was shot; from then on
+    // he only falls (slump), because re-solving him would sit him back up straight with his hands
+    // out for the reins — every frame, forever.
+    for (const r of this.riders) {
+      if (!r.pivot.visible) continue;
+      if (r.alive) r.solve();
+      else r.slump(dt);
+    }
+
+    // the team's gait follows the coach's actual speed, so they never trot on the spot
+    // THE GAIT FOLLOWS THE GROUND SPEED, and there is a gait for every speed she can reach. The
+    // ceiling used to be 'canter' — so the moment you took the whip to them (Shift: 10.5m/s) the
+    // team ran at gallop pace while still playing a canter, legs turning over half as fast as the
+    // ground going under them. The thresholds are where each gait's stride actually covers the
+    // ground: below them the horse moonwalks, above them he skates.
+    // ...off her GROUND SPEED, not her signed one: a team backing a coach at 1.4 m/s is walking, and
+    // asking a negative number which gait it is gets you a team standing stock still while the coach
+    // slides backwards out of the front of the saloon.
+    const v = Math.abs(this.speed);
+    const gait = v < 0.3 ? 'idle' : v < 2.4 ? 'walk' : v < 5 ? 'trot' : v < 8.2 ? 'canter' : 'gallop';
+    for (const t of this.team) {
+      if (t.gait !== gait) { t.gait = gait; t.animator.play(gait, { fade: 0.25 }); }
+      t.animator.update(dt);
+    }
+  }
+
+  // How full is she leaving? Nought to four, drawn fresh each time she pulls out — the coach that
+  // is always half full is as fake as the coach that is always empty.
+  //
+  // A DEAD FARE IS NOT A FARE. He does not get down at the next stop, and he is certainly not
+  // shuffled out of existence to hide the evidence: he rides on, visible, in the seat he was shot
+  // in. Only the living are re-drawn.
+  _seatFares() {
+    const live = this.fares.filter((f) => f.alive);
+    const n = Math.floor(Math.random() * (live.length + 1));
+    const who = live.map((_, i) => i).sort(() => Math.random() - 0.5).slice(0, n);
+    live.forEach((f, i) => { f.pivot.visible = who.includes(i); });
+    this._crew();
+    return n;
+  }
+
+  // Who is actually aboard, and therefore who can be shot: the list combat.js walks. Rebuilt only
+  // when the load changes (at a stop, or when a man dies) — never per frame. A hidden fare is a
+  // man who isn't on this coach today, and a bullet must pass straight through where he isn't.
+  _crew() {
+    this.crew = this.riders.filter((r) => r.pivot.visible);
+  }
+
+  // Somebody aboard has been killed (called by SeatedRider.die). His purse hits the DIRT — not the
+  // floor of a box that is about to run away with it — the town hears about it, and if it was the
+  // man on the box, the team goes.
+  _crewDown(r, killer = null) {
+    const g = this.game;
+    const x = r.position.x, z = r.position.z;
+    const at = new THREE.Vector3(x, g.world.groundAt(x, z), z);
+    // only the player's kills are the player's crimes — an outlaw's stray round is not a robbery
+    if (killer == null || killer === g.player) {
+      g.crime?.report('coachRobbery', at);
+      g.loot?.drop(at, roll(r.role === 'driver' ? TAKINGS : r.role === 'mate' ? WAGES : FARE_PURSE), dropItemsFor(r.role));
+    }
+    alarmTown(g, x, z, 26, 6);
+    this._crew();                        // (he stays in it — combat skips the dead — but keep it honest)
+    if (r === this.driver) this._boltTeam();
+  }
+
+  // The reins go slack. See the BOLT block at the top of the file.
+  _boltTeam() {
+    if (this.bolt > 0) return;
+    this.bolt = BOLT_SECS;
+    this.spent = false;
+    this.reinsT = 0;
+    // she leaves NOW, whatever she was doing — the doors swing shut behind her as she goes
+    if (this.state === 'standing') { this.state = 'rolling'; this.wait = 0; this.t = 0; }
+    for (const d of this.doors) d.want = 0;
+    console.log('[coach] the driver is down — the team has bolted');
+  }
+
+  // THE GUARD TAKES THE REINS. He does not change seats: he is sitting eighteen inches from the
+  // driver on the same box, so taking the reins is a POSTURE, not a journey — his hands come up off
+  // his lap and onto the leather, and the dead man stays folded over beside him for the rest of the
+  // run. (Moving him into the driver's seat would have put two bodies in one seat, one of them a
+  // corpse.) He keeps his own role: the strongbox went into the road with the man who was carrying
+  // it, and shooting the guard now does not pay twice.
+  _tryTheReins(dt) {
+    if (this.speed > 0.05) return;                    // not until she has actually stopped
+    const m = this.mate;
+    if (!m || !m.alive || !m.pivot.visible) return;   // nobody left who can drive — she stands here for good
+    this.reinsT += dt;
+    if (this.reinsT < REINS_SECS) return;
+    m.posture = this._drvPosture;
+    this.driver = m;                                  // whoever is on the leather IS the driver now
+    this.mate = null;
+    this.spent = false;
+    this.reinsT = 0;
+    console.log('[coach] the guard takes the reins — the line goes on');
+  }
+
+  // Pulling in somewhere: put down whoever is aboard, take up whoever is waiting.
+  // (The NPC board/alight walk is the next piece of work; for now the load changes at each stop.)
+  _callAt(stop) {
+    this._seatFares();
+    const world = this.root.position;
+    for (const p of this.passengers) {
+      p.alight(world.x, world.z);           // step down and walk off into wherever this is
+    }
+    this.passengers = [];
+    // and take up anyone standing about at this stop who fancies the ride
+    const board = (this.game.coachPool ?? []).filter((n) => n.wantsCoach && !n.aboard
+      && dist2D(n.position.x, n.position.z, world.x, world.z) < 14).slice(0, 3);
+    for (const n of board) { n.board(this); this.passengers.push(n); }
+    if (board.length || stop.stop) {
+      console.log(`[coach] calling at ${stop.name} — ${board.length} aboard`);
+    }
+  }
+}
+
+export class CoachLine {
+  constructor(game) { this.game = game; this.coaches = []; }
+
+  // Built on the loading screen, resident for life. The coaches are staggered by DISTANCE around
+  // the circuit — an equal share of TOTAL_LEN each, resolved to (leg, t) — so the road always has
+  // one on it somewhere and the depot is neither always empty nor always full. (It used to stagger
+  // by leg INDEX, which was fair when the legs were four uniform quarters; the road-derived legs
+  // run 6–630 m, and an index stagger would put the whole line nose to tail.)
+  async build(count = 2) {
+    for (let i = 0; i < count; i++) {
+      try {
+        const start = placeAt((TOTAL_LEN / count) * i);
+        const c = new Coach(this.game, start.leg, start.t);
+        await c.load();
+        this.game.scene.add(c.root);
+        this.coaches.push(c);
+        // A THING YOU CAN STAND ON. The registry measures her motion itself, so this is the whole
+        // of it — no per-frame hook, nothing for the coach to remember, and the same four lines
+        // will put a man on a boxcar. `cols` is what he stops being pushed by while he is up there.
+        c.plat = this.game.platforms?.register({
+          root: c.root, owner: c, decks: [ROOF], hull: HULL,
+          cols: c.myCols, radius: 4,
+        });
+        // TWO WAYS ON. The prompts are ordinary interactables — but a coach MOVES, so their points
+        // are rewritten every frame (_syncColliders) instead of being planted once in the dirt.
+        // `when` is what makes one prompt turn into the other: standing beside a coach you are
+        // already aboard, the only thing you want offered is the way OUT.
+        const p = this.game;
+        c._itDoor = {
+          x: 0, z: 0, r: 3.0,
+          get label() { return c.rider ? 'E — Get out' : 'E — Ride the stage'; },
+          // ...but not from her own roof: a man up there is offered the REINS (the box prompt
+          // below), not a seat in the cabin he is standing on.
+          when: () => c.rider?.player === p.player
+            || (!c.rider && c.speed < 1.2 && p.platforms?.carrier(p.player) !== c),
+          action: () => (c.rider ? c.alight(p.player) : c.board(p.player, 'inside')),
+        };
+        c._itBox = {
+          x: 0, z: 0, r: 2.6,
+          get label() { return c.rider?.kind === 'box' ? 'E — Get down' : 'E — Take the reins'; },
+          when: () => c.rider?.kind === 'box' || (!c.rider && c.speed < 1.2),
+          action: () => (c.rider ? c.alight(p.player) : c.board(p.player, 'box')),
+        };
+        this.game.interactables.push(c._itDoor, c._itBox);
+      } catch (e) { console.warn('[coach] build failed', e); }
+    }
+    // AND A SEAT FOR YOU. Baked HERE, on the loading screen, because makeSeatedPose does a retarget
+    // and a retarget in the middle of a gunfight is a stall. The player is a Synty body on the same
+    // skeleton as everyone else, so he wears the same posture the coach's own driver does — which
+    // means the man on the box looks like a man on the box, and not like an empty seat with a
+    // camera behind it. (He used to be simply HIDDEN when he boarded. Nobody was driving.)
+    // AND A SEAT FOR YOU. Baked HERE, on the loading screen, because makeSeatedPose does a retarget
+    // and a retarget in the middle of a gunfight is a stall. The player is a Synty body on the same
+    // skeleton as everyone else, so he wears the same posture the coach's own driver does.
+    const pl = this.game.player;
+    if (pl?.model) {
+      try {
+        const r = new SeatedRider(pl.root, pl.model, driverPosture(SEAT));
+        // NEVER TOUCH THE LIVE PLAYER'S SKELETON. I called skeleton.pose() here once to read his
+        // bind — and main.js runs newGame() AFTER the coaches are built, so respawning re-ran
+        // _groundFeet(), which measures the model's lowest BONE. It measured the bind skeleton,
+        // computed a foot-drop of TWENTY-FOUR METRES, and fired the player into the sky.
+        const { pose, pbone } = await makeSeatedPose(pl.model, BIPED_TO_SYNTY);
+        r.bones = pbone;
+        r.pose = pose;
+        for (const n of ['UpperLeg_L', 'LowerLeg_L', 'Ankle_L', 'UpperLeg_R', 'LowerLeg_R', 'Ankle_R']) {
+          if (pbone[n]) r.bind[n] = pbone[n].quaternion.clone();
+        }
+        // Which side his left is on, asked of the POSE (arms out) rather than of whatever frame of
+        // the idle he happens to be on — then his bones go back exactly as they were.
+        const was = {};
+        for (const n of Object.keys(pose)) if (pbone[n]) was[n] = pbone[n].quaternion.clone();
+        for (const [n, q] of Object.entries(pose)) pbone[n]?.quaternion.copy(q);
+        pl.model.updateWorldMatrix(true, true);
+        r._measureSide();
+        for (const [n, q] of Object.entries(was)) pbone[n].quaternion.copy(q);
+        pl.model.updateWorldMatrix(true, true);
+        this.playerRider = r;
+      } catch (e) { console.warn('[coach] no seated pose for the player', e); }
+    }
+
+    console.log(`[coach] the line is running: ${this.coaches.length} coaches on ${ROUTE.length} legs`);
+    return this;
+  }
+
+  update(dt) {
+    for (const c of this.coaches) c.update(dt);
+  }
+
+  // Bring every rider's world position up to date RIGHT NOW. combat.js calls this immediately
+  // before it sweeps its bullets, because main.js ticks combat BEFORE the coaches: without it,
+  // every round is tested against where the crew were a frame ago (11cm out at a canter — which
+  // is survivable, but being exact is two sines and a loop).
+  syncRiders() {
+    for (const c of this.coaches) c._syncRiders();
+  }
+}