sindicate 0.4.0 → 0.5.0

package/src/systems/train.js

@@ -0,0 +1,1957 @@
+// THE DUSTWATER & COPPERHEAD RAILROAD — the trains that run on it.
+//
+// A train is the coach's bigger, heavier cousin, and almost every idea in here is lifted from
+// game/coach.js on purpose: a vehicle following a route polyline, wheels turned BY THE GROUND
+// (radians = distance / radius, never a guess), a look-ahead that brakes for whatever is in the way,
+// moving colliders pushed into the world list and rewritten every frame, seated crew who can be
+// shot, E-key interactables that travel with the vehicle, and player.aboard for the ride.
+// Where it differs, it differs because eighty tons is not four:
+//
+//   IT CANNOT SWERVE AND IT CANNOT STOP.  0.35 m/s^2 up, 0.9 m/s^2 down, 16 m/s cruise — so from
+//   line speed it needs 142 m of clear road to come to a stand. Everything about how it is driven
+//   falls out of that one number: it asks for the road a long way out, and it brakes on a CURVE
+//   (v = sqrt(2*a*d)), not by easing toward a target. An exponential ease is how a COACH stops; it
+//   approaches the stop asymptotically and would put the loco through the buffers every time.
+//
+//   IT IS ON RAILS, SO THE POLYLINE IS THE CENTRELINE.  coach.js's LANE offset is the only thing
+//   that puts a coach beside its own route line; a train has no lane, so the offset is ABSENT, not
+//   zeroed. And it does not take its height from groundAt(): a rigid 55 m consist reading raw
+//   terrain at each car articulates over every bump, and the ground under this line kinks 12.8 deg
+//   at one joint and steps 1.1 m at the level crossing where the road's own bench lifts it. It rides
+//   a GRADED PROFILE, baked once on the loading screen (see makePath).
+//
+//   TWO TRAINS ON ONE TRACK WILL MEET.  See THE SIGNALMAN. That is the whole ballgame.
+//
+// PERF: every car, every crewman, the whole fleet is built ONCE on the loading screen and stays
+// resident for life (main.js:118 — a skinned mesh entering the scene mid-play is a pipeline build
+// and a multi-second freeze). Nothing is spawned when a train arrives. A train that has left the
+// county is not removed from the scene: it is STABLED — dropped below the world with its colliders
+// switched off — and it climbs back onto the rails when its next path is granted.
+import * as THREE from 'three/webgpu';
+import { instantiate, loadModel, loadTexture } from '../core/assets.js';
+import { SeatedRider, SEAT, passengerPosture, driverPosture } from './seatedRider.js';
+// Train content is GAME data, registered before construction (partials merge):
+//   setTrainContent({ colliders, dropItemsFor, railPaths, railStops, crossing, halts })
+let colliders = [], dropItemsFor = () => null;
+let SURVEY_PATHS = [], SURVEY_STOPS = [], SURVEY_CROSSING = null, RAIL_HALTS = [];
+export function setTrainContent(c = {}) {
+  if (c.colliders) colliders = c.colliders;
+  if (c.dropItemsFor) dropItemsFor = c.dropItemsFor;
+  if (c.railPaths) SURVEY_PATHS = c.railPaths;
+  if (c.railStops) SURVEY_STOPS = c.railStops;
+  if (c.crossing !== undefined) SURVEY_CROSSING = c.crossing;
+  if (c.halts) RAIL_HALTS = c.halts;
+}
+import { dist2D } from '../core/utils.js';
+import { rayCapsule } from './aim.js';
+import { alarmTown } from './npc.js';
+import { castFares } from './coach.js';
+import { attachTrainCamera } from './trainCamera.js';
+
+// ── WHERE THE TRACK IS ────────────────────────────────────────────────────────────────────────
+// The permanent way is somebody else's module (src/world/railway.js — the track author's). It may
+// not exist yet, and a bare `import` of a missing file is a BUILD ERROR, not a runtime warning — so
+// it comes in through import.meta.glob, which resolves to {} when the file is absent and lets the
+// build stay green either way. The fallback below is the SITED route — the one that was checked
+// clear of every settlement, farm, ranch and the quarry works — and deliberately NOT the old draft
+// in world/data/railway.js, which puts the line at z=-150 with the spur leaving east of the
+// crossing. A train laid on that draft would run eighty metres from the nearest rail.
+// THE TRACK'S OWN SURVEY, from the file that solved it.
+//
+// This globbed ../world/railway.js — the BUILDER — which exports buildRailway() and nothing else.
+// So RAIL.RAIL_PATHS was undefined, the fallback took over, and the trains ran on a flat polyline
+// with heights of their own invention while the track sat on the graded formation: the rails on the
+// ground and the train seven to ten METRES above them, sailing over the county.
+//
+// The survey lives in ../world/data/railway.js — headless, no three, a plain import — and it is the
+// same module the builder laid every sleeper from. One survey, one railway.
+// THE TRACK AUTHOR'S MODULE. src/world/railway.js LAYS the permanent way; src/world/data/railway.js
+// says WHERE it goes, and publishes the only three things a train needs to know:
+//
+//   RAIL_LINES      the surveyed centreline as a dense node table — {x, y, z, s} per node, where y is
+//                   the GRADED FORMATION HEIGHT. That is the gift. The raw ground under this line
+//                   ranges over 25 m, kinks 12.8 degrees at a joint and steps 1.1 m at the level
+//                   crossing where the road's own bench lifts it; a rigid 55 m consist reading
+//                   groundAt() at each car saws up and down like a caterpillar. The formation is the
+//                   surface his rails are actually laid on, so the trains ride HIS ballast rather
+//                   than my guess at it, and the wheels sit on the iron instead of hovering over it.
+//   RAIL_STOPS      the calls, as arc length along a named line. Not an (x,z) to be projected — the
+//                   graded centreline is up to 1.25 m off the surveyed polyline, so projecting a pin
+//                   onto it is a guess where he has an answer.
+//   LEVEL_CROSSING  where the north road crosses the rails, found rather than assumed.
+//   JUNCTION        where the ore spur leaves the main line (the spur's own s = 0).
+//
+// Both files come in through import.meta.glob, which resolves to {} when a file is absent — a bare
+// import of a module that has not landed yet is a BUILD ERROR, not a runtime warning, and this had
+// to compile green before the track existed. The polyline fallback below is the SITED route, and it
+// bakes its own grade (see gradePolyline). It is dead code the moment the track author lands, and it
+// stays because a game that will not boot without another author's file is a game with a fuse in it.
+const _mods = import.meta.glob(['../world/railway.js', '../world/data/railway.js'], { eager: true });
+const RD = _mods['../world/data/railway.js'] ?? {};
+
+const LINES_IN = RD.RAIL_LINES ?? null;         // { main: {nodes,len}, spur: {nodes,len} }
+const STOPS_IN = RD.RAIL_STOPS ?? null;         // [{ id, name, line, s, platformSide, wait }]
+const XING_IN = RD.LEVEL_CROSSING ?? null;      // { line, s, x, z }
+const JUNC_IN = RD.JUNCTION ?? null;            // { line, s, x, z }
+
+// The railhead above the formation — his number, not mine. A car's origin sits at RAILHEAD CONTACT
+// (measured: min.y = 0 on all four models), so this is exactly how high off the ballast it rides,
+// less a flange: the wheel's lowest point is its flange, not its tread, and standing the tread ON
+// the rail is what closes the hairline of daylight under a stationary loco.
+const RAIL_TOP = RD.RAIL_TOP ?? 0.3285;
+const FLANGE = 0.06;
+const RAIL_Y = RAIL_TOP - FLANGE;
+
+// ── THE FALLBACK ROUTE (only if data/railway.js has not landed) ───────────────────────────────
+const FALLBACK_PATHS = [
+  { id: 'main', pts: [
+    { x: -1040, z: -230 }, { x: -520, z: -230 }, { x: -160, z: -232 }, { x: 0, z: -230 },
+    { x: 200, z: -215 }, { x: 520, z: -208 }, { x: 1040, z: -202 },
+  ] },
+  { id: 'spur', pts: [
+    { x: -300, z: -230 }, { x: -340, z: -224 }, { x: -368, z: -212 }, { x: -372, z: -200 },
+  ] },
+];
+const FALLBACK_STOPS = [
+  { id: 'dustwater', name: 'Dustwater Station', line: 'main', x: -20, z: -230, wait: 16 },
+  { id: 'bonebreak', name: 'Bonebreak Loading', line: 'spur', x: -372, z: -200, wait: 26 },
+];
+const FALLBACK_CROSSINGS = [{ x: 0, z: -230 }];
+
+// ── THE MODELS ────────────────────────────────────────────────────────────────────────────────
+const W = '/assets/western/';
+const ATLAS = '/assets/textures/atlas_western.png';
+
+// MEASURED off the loaded geometry's bounding box, never guessed — the stagecoach came out the size
+// of a matchbox once for exactly this reason. Metres, after the cm→m scale (there are no GLB twins
+// for the train assets, so they load as raw FBX at 0.01).
+//   len   IS the coupling pitch. Synty's own demo spaces these cars at (len_n + len_{n+1}) / 2 with
+//         3–10 cm of NEGATIVE slack: the boxes already contain their buffers. The old draft's
+//         COUPLING = 0.6 would leave a hand's width of daylight between every vehicle in the train.
+//   top   is the collider's y1. A collider with no height band is solid all the way to the sky, so
+//         the tender becomes a bulletproof wall, you cannot shoot the man on the footplate (he
+//         stands on top of the thing), and you cannot shoot over a van at the man behind it.
+//         coach.js:281 paid for that lesson once already.
+const MODELS = {
+  loco:     { url: `${W}SM_Veh_Train_01.fbx`,          len: 12.495, halfW: 1.64, top: 4.10 },
+  tender:   { url: `${W}SM_Veh_Train_Coal_01.fbx`,     len: 7.559,  halfW: 1.64, top: 3.30 },
+  carriage: { url: `${W}SM_Veh_Train_Carriage_01.fbx`, len: 17.336, halfW: 1.88, top: 4.20 },
+  freight:  { url: `${W}SM_Veh_Train_Freight_01.fbx`,  len: 13.884, halfW: 1.85, top: 4.30 },
+};
+
+// The loco faces +Z: the pony truck (r 0.514) and the smokestack are at +Z, the driving wheels
+// (r 0.931) and the cab at -Z.
+const ROD_THROW = 0.22;   // metres of piston stroke, converted into the node's own (cm) space at load
+const CAB_FLOOR = 1.94;   // measured: the strongest horizontal plane in the cab (263 verts at y=1.94)
+const STACK = { y: 5.80, z: 3.12 };    // the top of SM_Veh_Train_01_Alt_Smokestack
+
+// ── THE INSIDE OF THE CARRIAGE, AS THE MODEL ACTUALLY BUILT IT ────────────────────────────────
+// Every number here came off the loaded geometry — traverse the car, transform each triangle into
+// car.root's own frame, cluster the up-facing ones — because the seat table that used to be here was
+// authored by eye, and the whole of it was wrong: four seats in a car that has thirty-six, two of
+// them landing in the gangway between the benches, and all four of them 0.59 m too high. The fares
+// rode to Dustwater sitting on nothing, with their heads level with the window glass.
+//
+//   DECK        y = 1.578   one continuous plane, x ±1.481, z −8.13…8.04
+//   BENCH PAN   y = 2.109   18 a side, each 1.055 wide (|x| 0.407…1.462, centre 0.934) and 0.292 deep
+//   BACKREST    2.109 → 2.653
+//   GLASS       x = ±1.521, y 2.319…3.640 — the sill is 0.21 above the pan, which is what a window is
+//
+// The saloon is NINE BAYS: two benches facing each other across a window, neighbouring bays sharing
+// a backrest back to back. Every bay is centred on a pane (9 for 9, to within 0.15 m). There is no
+// such thing as a bad seat in this car.
+const DECK = 1.578;
+const PAN = 2.109;
+
+// WHAT seat.y MEANS — AND IT IS NEITHER THE ARSE NOR THE BOOTS.
+// A seat is the rider's MODEL ORIGIN (seatedRider.js:167), and the seated pose only ROTATES bones:
+// his hips stay at their standing height above it and his boots fold up above it too. Measured off
+// the posed skin of a live fare, and identical on every one of them, so these are constants of the
+// pose and not of the man: boot sole +0.456, ARSE UNDERSIDE +0.742, head bone +1.556, hat +1.871.
+// To put a man's arse on a surface at height H there is exactly one answer: seat.y = H − 0.742.
+const ARSE = 0.742;
+const SEAT_Y = PAN - ARSE;   // 1.367 — thighs on the pan, head bone dead centre of the glass
+
+// HIS BOOTS DO NOT REACH THE DECK, AND NO NUMBER IN THIS FILE CAN MAKE THEM. The pan stands 0.531
+// above the floor and this rig's arse-to-sole is 0.286 (0.742 − 0.456) with the shin already hanging
+// vertical — 0.245 short, and straightening the knee buys back less than half of it. Of the two lies
+// on offer, boots tucked 0.245 over the deck is the one nobody sees; boots ON the deck sinks a
+// quarter of a metre of him into the bench, which is the bug we came here to fix, upside down.
+
+// The nine bays, as the z of each pan (measured, both sides identical). The lower one of a pair faces
+// +Z, the upper faces −Z, and the two of them look at each other across the window between them.
+const BAYS = [
+  [-6.427, -5.450], [-4.810, -3.887], [-3.247, -2.361], [-1.721, -0.799], [-0.159, 0.764],
+  [1.405, 2.278], [2.918, 3.840], [4.481, 5.403], [6.044, 7.213],
+];
+const PAN_X = 0.934;
+// A seat entry, from a bay. side: −1 or +1. half: 0 = the forward-facing bench, 1 = the backward one.
+const bench = (side, bay, half) => ({ x: side * PAN_X, y: SEAT_Y, z: BAYS[bay][half], ry: half ? Math.PI : 0 });
+
+// FOUR FARES, FOUR REAL BENCHES — spread down the car, both sides, both facings, the way a half-empty
+// branch-line coach fills up. Bay 5 is left clear: that one is yours.
+const FARE_SEATS = [bench(1, 1, 0), bench(-1, 2, 1), bench(1, 5, 1), bench(-1, 7, 0)];
+const PLAYER_BAY = 4;        // mid-car, so the lens has 7 m of saloon behind him whichever way he sits
+
+// KEEPING THE LENS INSIDE THE COACH. The saloon is 2.98 m wall to wall and the follow camera wants to
+// be metres behind him; player.js's pull-in ray only knows about BUILDINGS (its BVH is baked out of
+// the town at world build — the train is not in it), so the lens would simply sit outside the
+// planking looking at the outside of it. That is why the man who wrote this first put the player on
+// the veranda and called the inside "invisible". It isn't: it just needs to be told where the walls
+// are, in the car's own frame, once a frame (Train.makeSeat → camConfine).
+const SALOON = { hx: 1.30, y0: DECK + 0.35, y1: 4.10, z0: -6.50, z1: 7.30 };
+
+// ── THE BOXCAR, AND WHY YOU RIDE ON TOP OF IT ─────────────────────────────────────────────────
+// Two of the four trains have no carriage in them at all — the ore is a loco, a tender and three
+// vans — and a train standing at a platform with nothing to press E on is a train the county cannot
+// use. There is nowhere INSIDE a van to sit: it has no end platform, no step and no ladder (measured:
+// the only things down there are the brake gear), and both its side doors are shut flush in the wall.
+// But the roof is enormous and it is dead flat:
+//
+//   ROOF        y = 4.270, x ±1.77, z ±6.4 — 45 m² of it
+//   CLERESTORY  a raised centre: y = 4.612 out to x ±1.30, 4.747 out to x ±0.70
+//
+// which leaves a 0.47 m shoulder of flat roof outboard of the clerestory, running the whole length of
+// the van. So he rides it hobo-fashion: arse on the shoulder, back against the clerestory, boots
+// swinging over the side of a moving boxcar. Every surface in that sentence is one the model has.
+const ROOF = 4.270;
+const HOBO = { x: 1.52, y: ROOF - ARSE, z: 0, ry: Math.PI / 2 };   // 1.52 = the middle of the shoulder
+
+// ── WHAT IT WEIGHS ────────────────────────────────────────────────────────────────────────────
+const CRUISE = 16.0;      // m/s — ~36 mph, a respectable branch-line speed for 1880
+const SHUNT = 4.5;        // ...but not down the ore spur, which is a siding with a 40 m radius on it
+const ACCEL = 0.35;       // m/s^2. Half a minute to line speed. It does not leap away from a platform.
+const BRAKE = 0.9;        // m/s^2. 16^2 / (2*0.9) = 142 m to stop. THIS number drives everything below:
+                          // the brake curve v = sqrt(2*BRAKE*d) means she shuts off 142 m from the
+                          // platform, which is where a driver actually shuts off.
+const STOP_PAD = 2.5;     // ...aiming two and a half metres short of it, because a discrete
+                          // integrator tracks a hair ABOVE the curve and would otherwise roll
+                          // through the buffer stops at walking pace
+const CREEP = 0.8;        // and the last couple of metres at a crawl: she kisses the stop
+
+// THE LOOK-AHEAD, coach.js's _blocked() in a bigger hat: how far in front do I care, and how wide is
+// the corridor. The reach must cover the braking distance or it is decoration — a train that sees
+// 30 m ahead at 16 m/s has already hit whatever it saw. LOOK_PER_MS is 9.5 seconds of road: at line
+// speed that is 30 + 152 = 182 m, which is the 142 m stopping distance plus the margin plus slack.
+const LOOK = 30;
+const LOOK_PER_MS = 9.5;
+const CORRIDOR = 3.4;     // half-width, metres
+const SAFE_GAP = 26;      // ...and it stops THIS far short. A train does not nose up against another
+                          // train's buffers; it stands off, and the guard walks up with a lamp.
+
+// THE DWELLS. A minute at the platform: long enough to walk up, get on, and find a seat before she
+// pulls out, which sixteen seconds was not. The cost is the level crossing — the platform is twenty
+// metres from it and a fifty-five metre train cannot stand at one without standing on the other, so
+// the gates are shut for that minute and the road waits. The berth clamp (berthLead) already stands
+// her as clear of it as the geometry allows; the rest is what a level crossing has always cost.
+const DWELL_STATION = 60;
+const DWELL_LOAD = 26;      // Bonebreak: they are shovelling ore into it. It takes longer.
+const DWELL_TERMINAL = 10;  // the layover INSIDE THE TUNNEL before she works back out turned
+                            // (Nick's edge-of-world design: in, ten seconds, out the other way)
+const TUNNEL_S = 15;        // the main line's first/last metres are BORED — a car wholly inside
+                            // the hill is invisible (the portals are dressed in world/railway.js)
+const ASK_EVERY = 1.0;      // a signalman does not re-ask for the road a hundred and twenty times a second
+
+// SHOOT THE MAN ON THE REGULATOR. The stage bolts (coach.js:106). A train cannot bolt — it is already
+// doing sixteen metres a second and there is nowhere for it to go — so it does the worse thing: it
+// RUNS ON. Nobody shuts the regulator, it does not make its booked call, it storms through Dustwater
+// without stopping. If the fireman lives he gets across the footplate and shuts it off. If he does
+// not, she runs to the end of the line and stands there with her fire dying until the company sends
+// out another driver — because a railroad does not stop because a man was shot on it, and without
+// the relief crew a single bullet retires a train permanently and the fleet bleeds out over an
+// afternoon, one loco at a time.
+const REGULATOR_SECS = 34;
+const RELIEF_SECS = 75;
+const FOOTPLATE_PURSE = [40, 80];   // the driver's pay tin — the railroad's money, and heavier than a stage's
+const FIREMAN_PURSE = [14, 32];
+const PASSENGER_PURSE = [5, 26];
+const roll = ([a, b]) => a + Math.floor(Math.random() * (b - a + 1));
+
+// ── THE PERMANENT WAY, AS SOMETHING A TRAIN CAN BE AT A POINT ON ──────────────────────────────
+// A path is a polyline turned into arc length, plus a HEIGHT PROFILE — and the profile is the whole
+// reason this exists. `groundAt` along the main line ranges over 25 metres, kinks up to 12.8 degrees
+// at a joint and steps 1.1 m at the level crossing where the road's own bench lifts it. Put a rigid
+// 55 m train on that and the cars saw up and down against each other like a caterpillar. So the
+// ground is sampled once, at load, gradient-limited to a ruling grade, and smoothed — and THAT is
+// what the trains ride. It is a railway engineer's answer rather than a graphics one: you do not
+// follow the ground, you cut and fill until the ground follows you.
+const STEP = 8;                // metres between profile samples
+const RULING_GRADE = 0.02;     // 1 in 50. Steeper and no loco on earth lifts the ore out of Bonebreak.
+
+function gradePolyline(id, pts, world) {
+  const P = { id, pts, cum: [0], len: 0 };
+  for (let i = 1; i < pts.length; i++) {
+    P.len += Math.hypot(pts[i].x - pts[i - 1].x, pts[i].z - pts[i - 1].z);
+    P.cum.push(P.len);
+  }
+  const n0 = pts.length;
+
+  // Where the line is, at arc length s. It EXTRAPOLATES off both ends on purpose: a 55 m train
+  // berthed at the end of the line has thirty metres of itself behind the last sleeper, and a clamp
+  // there would concertina every car in the consist into the same point.
+  P.pos = (s, out) => {
+    if (s <= 0) {
+      const dx = pts[1].x - pts[0].x, dz = pts[1].z - pts[0].z;
+      const L = Math.hypot(dx, dz) || 1;
+      return out.set(pts[0].x + (dx / L) * s, 0, pts[0].z + (dz / L) * s);
+    }
+    if (s >= P.len) {
+      const dx = pts[n0 - 1].x - pts[n0 - 2].x, dz = pts[n0 - 1].z - pts[n0 - 2].z;
+      const L = Math.hypot(dx, dz) || 1;
+      const o = s - P.len;
+      return out.set(pts[n0 - 1].x + (dx / L) * o, 0, pts[n0 - 1].z + (dz / L) * o);
+    }
+    let i = 1;
+    while (i < n0 - 1 && P.cum[i] < s) i++;
+    const a = pts[i - 1], b = pts[i];
+    const t = (s - P.cum[i - 1]) / (P.cum[i] - P.cum[i - 1] || 1);
+    return out.set(a.x + (b.x - a.x) * t, 0, a.z + (b.z - a.z) * t);
+  };
+
+  // ---- CUT AND FILL ---------------------------------------------------------------------------
+  const n = Math.max(2, Math.ceil(P.len / STEP) + 1);
+  const h = new Float32Array(n);
+  const _v = new THREE.Vector3();
+  for (let i = 0; i < n; i++) {
+    P.pos(i * STEP, _v);
+    h[i] = world.groundAt(_v.x, _v.z);
+  }
+  {
+    // One sweep of a gradient limiter run FORWARD, one run BACK, then averaged. A single pass biases
+    // the whole formation the way it swept (every summit shaved, every hollow left, or the reverse);
+    // averaging the two keeps the line near the natural ground while making the grade legal, which is
+    // exactly the trade a surveyor makes with a theodolite and a budget.
+    const maxStep = RULING_GRADE * STEP;
+    const up = Float32Array.from(h), dn = Float32Array.from(h);
+    for (let i = 1; i < n; i++) up[i] = Math.max(Math.min(up[i], up[i - 1] + maxStep), up[i - 1] - maxStep);
+    for (let i = n - 2; i >= 0; i--) dn[i] = Math.max(Math.min(dn[i], dn[i + 1] + maxStep), dn[i + 1] - maxStep);
+    for (let i = 0; i < n; i++) h[i] = (up[i] + dn[i]) * 0.5;
+    // ...and then smooth it, because a limiter leaves corners and a train notices corners.
+    for (let pass = 0; pass < 6; pass++) {
+      const c = Float32Array.from(h);
+      for (let i = 1; i < n - 1; i++) h[i] = c[i - 1] * 0.25 + c[i] * 0.5 + c[i + 1] * 0.25;
+    }
+  }
+  P.h = h;
+  P.height = (s) => {
+    const u = s / STEP;
+    if (u <= 0) return h[0];
+    if (u >= n - 1) return h[n - 1];
+    const i = Math.floor(u);
+    return h[i] + (h[i + 1] - h[i]) * (u - i);
+  };
+  // The arc position of the point on this path nearest (x,z) — how a station PIN becomes a place on
+  // the line, and how the spur's first point becomes the junction.
+  P.sNear = (x, z) => {
+    let best = 0, bd = Infinity;
+    for (let i = 1; i < pts.length; i++) {
+      const a = pts[i - 1], b = pts[i];
+      const dx = b.x - a.x, dz = b.z - a.z;
+      const L2 = dx * dx + dz * dz || 1;
+      let t = Math.max(0, Math.min(1, ((x - a.x) * dx + (z - a.z) * dz) / L2));
+      const px = a.x + dx * t, pz = a.z + dz * t;
+      const d = dist2D(px, pz, x, z);
+      if (d < bd) { bd = d; best = P.cum[i - 1] + Math.hypot(px - a.x, pz - a.z); }
+    }
+    return best;
+  };
+  return P;
+}
+
+// THE TRACK AUTHOR'S OWN CENTRELINE, as something a train can be at a point on. His node table is
+// dense (~1 m) and already carries the graded formation in y, so there is nothing to bake: read it.
+//
+// It EXTRAPOLATES off both ends, and that is not a nicety — a 55 m train berthed at the end of the
+// line has thirty metres of itself behind the last sleeper, and a clamp there would concertina every
+// car in the consist into the same point.
+function pathFromNodes(id, line) {
+  const N = line.nodes;
+  const n = N.length;
+  const P = { id, len: line.len ?? N[n - 1].s, nodes: N };
+  const idx = (s) => {
+    let lo = 0, hi = n - 1;
+    while (lo < hi - 1) { const m = (lo + hi) >> 1; if (N[m].s <= s) lo = m; else hi = m; }
+    return lo;
+  };
+  const ends = (s, out, key) => {
+    // linear run-out along the end tangent
+    const a = s <= 0 ? N[0] : N[n - 1], b = s <= 0 ? N[1] : N[n - 2];
+    const d = Math.abs(a.s - b.s) || 1;
+    const k = (s <= 0 ? s - a.s : s - a.s) / d;
+    const dx = (a.x - b.x) / 1, dz = (a.z - b.z) / 1, dy = (a.y - b.y) / 1;
+    const t = s <= 0 ? (a.s - s) / d : (s - a.s) / d;
+    if (key === 'y') return a.y + dy * t;
+    return out.set(a.x + dx * t, 0, a.z + dz * t);
+  };
+  P.pos = (s, out) => {
+    if (s <= 0 || s >= P.len) return ends(s, out, 'pos');
+    const i = idx(s), a = N[i], b = N[i + 1];
+    const t = (s - a.s) / ((b.s - a.s) || 1);
+    return out.set(a.x + (b.x - a.x) * t, 0, a.z + (b.z - a.z) * t);
+  };
+  P.height = (s) => {
+    if (s <= 0 || s >= P.len) return ends(s, null, 'y');
+    const i = idx(s), a = N[i], b = N[i + 1];
+    const t = (s - a.s) / ((b.s - a.s) || 1);
+    return a.y + (b.y - a.y) * t;
+  };
+  P.sNear = (x, z) => {
+    let bs = 0, bd = Infinity;
+    for (let i = 0; i < n; i++) {
+      const d = (N[i].x - x) ** 2 + (N[i].z - z) ** 2;
+      if (d < bd) { bd = d; bs = N[i].s; }
+    }
+    return bs;
+  };
+  return P;
+}
+
+// A ROUTE is a train's AUTHORITY: the run from one standing place to the next, as legs on the
+// physical paths. It exists because the ore train's run from Dustwater to Bonebreak is two legs —
+// back down the main line to the junction, then out along the spur — and the train in the middle of
+// it is on both. `u` is distance along the route; each leg knows which way it runs on its path, so a
+// train working back down the line has an INCREASING u and a DECREASING s, and nothing else in this
+// file has to know that.
+function makeRoute(legs, from, to) {
+  const R = { legs, from, to, base: 0, len: 0, off: [] };
+  for (const l of legs) {
+    R.off.push(R.base);
+    l.len = Math.abs(l.s1 - l.s0);
+    l.dir = Math.sign(l.s1 - l.s0) || 1;
+    R.base += l.len;
+  }
+  R.len = R.base;   // the caller extends this by the train's berth overrun (see Train.berthLead)
+  R.at = (u) => {
+    let i = 0;
+    while (i < legs.length - 1 && u > R.off[i] + legs[i].len) i++;
+    const l = legs[i];
+    return { l, s: l.s0 + l.dir * (u - R.off[i]) };   // extrapolates off both ends; P.pos/P.height do too
+  };
+  R.pos = (u, out) => { const { l, s } = R.at(u); return l.path.pos(s, out); };
+  R.height = (u) => { const { l, s } = R.at(u); return l.path.height(s); };
+  return R;
+}
+
+// ── THE SIGNALMAN ─────────────────────────────────────────────────────────────────────────────
+//
+// THE PROBLEM, STATED HONESTLY: this is a SINGLE TRACK with no passing loops. Two trains running at
+// each other on it will meet, and a look-ahead alone does NOT save you — it stops them a safe
+// distance apart and then they sit there, nose to nose, forever. A brake is not a signalling system.
+// Deadlock is not a bug you fix afterwards; avoiding it is the thing the system exists to do.
+//
+// So there are two mechanisms and they do different jobs:
+//
+//   1. THE INTERLOCKING (here). A train may not leave a standing place until the WHOLE road to the
+//      next standing place is clear — every metre of it, and the berth at the far end — and it holds
+//      that authority until it arrives. This is the electric-token system, and it is what makes a
+//      head-on meeting IMPOSSIBLE rather than merely survivable.
+//
+//   2. THE LOOK-AHEAD (Train._roadAhead — coach.js's _blocked pattern). The safety net. If the
+//      interlocking is right it never fires. If anything ever goes wrong with it, the train still
+//      brakes and HOLDS instead of driving through another train. Belt, and braces.
+//
+// WHY IT CANNOT DEADLOCK. A waiting train holds only the berth it is standing in. A moving train
+// holds a road nothing else can enter, so it always arrives, so it always releases. The two ends of
+// the line are SINKS — a train that reaches one has left the county, is stabled, and blocks nothing.
+// So the only contended berth is Dustwater (and Bonebreak, which only the ore train ever visits). A
+// circular wait needs TWO contended berths. There is one. Therefore there is no cycle.
+//
+// That is why the terminals must be sinks and not sidings, and it is the single most load-bearing
+// decision in this file. Give the west end a capacity of one and the fleet deadlocks within the
+// hour: the Flyer stands at the west end wanting Dustwater, the Goods stands at Dustwater wanting
+// the west end, and neither will ever move again.
+const CLEAR_R = 24;   // metres: how close another train's iron may come to my road and still be
+                      // "clear". Wider than the vehicles on purpose — it is the clearance a
+                      // signalman gives, not the width of a carriage.
+const SAMPLE = 14;    // metres between the samples the clearance test runs on
+
+class Signalman {
+  constructor(trains) { this.trains = trains; this.grants = []; }
+
+  // Everything a train currently makes unavailable: the iron it is standing on, and the road it has
+  // already been given. A STABLED train contributes NOTHING — that is the sink rule, above, and it
+  // is what the deadlock-freedom argument rests on.
+  _footprint(t, out) {
+    if (t.stabled) return out;
+    // A CAR IS SEVENTEEN METRES LONG, NOT A POINT. This used to push the car's centre and test it
+    // against CLEAR_R — which quietly gives a carriage 8.7 m of itself OUTSIDE the clearance, and
+    // that was enough slack for the signalman to thread a second train into Dustwater alongside one
+    // already standing there. They then wanted to leave through each other, and the railway stopped
+    // for good. Carry the half-length with the point.
+    for (const c of t.cars) out.push({ p: c.root.position, r: c.len / 2 });
+    if (t.route && t.state === 'running') {
+      for (let u = t.u; u <= t.route.len + 1; u += SAMPLE) out.push({ p: t.route.pos(u, new THREE.Vector3()), r: 0 });
+    }
+    return out;
+  }
+
+  clear(route, me) {
+    const foot = [];
+    for (const t of this.trains) if (t !== me) this._footprint(t, foot);
+    if (!foot.length) return true;
+    const p = _sv;
+    for (let u = -me.len; u <= route.len + 1; u += SAMPLE) {   // -me.len: my own tail sweeps the road behind me too
+      route.pos(u, p);
+      for (const f of foot) if (dist2D(f.p.x, f.p.z, p.x, p.z) < CLEAR_R + f.r) return false;
+    }
+    return true;
+  }
+
+  // THE TOKEN. Granted or refused; there is no third answer and no queue. A refused train simply
+  // asks again in a second, from where it is standing — which is a berth, and the only safe place
+  // for it to be.
+  //
+  // TWO tests, and the first one is the one the whole deadlock argument rests on. A BERTH HOLDS ONE
+  // TRAIN. I tried to get that for free out of the geometry — if two trains cannot be within CLEAR_R
+  // of each other then surely they cannot both be at Dustwater — and it is not true: the berth clamp
+  // (Train.berthLead) legitimately stands a westbound train one side of the level crossing and an
+  // eastbound one the other side, 32 m apart, both of them "at Dustwater", and both of them then
+  // wanting to leave through the other. Measured: the fleet ran for 187 seconds and stopped forever.
+  // So the berth is a TOKEN, held explicitly, and only the sinks (which are off the county) may hold
+  // more than one train.
+  grant(t, route) {
+    const B = t.line.places[route.to];
+    if (!B.sink) {
+      for (const o of this.trains) {
+        if (o === t || o.stabled) continue;
+        if (o.state === 'standing' ? o.place === route.to : o.route?.to === route.to) return false;
+      }
+    }
+    if (!this.clear(route, t)) return false;
+    this.grants.push({ train: t.id, from: route.from, to: route.to });
+    if (this.grants.length > 300) this.grants.shift();
+    return true;
+  }
+}
+const _sv = new THREE.Vector3();
+
+// ── THE GLASS ─────────────────────────────────────────────────────────────────────────────────
+// The carriage's windows came out of the FBX as OPAQUE PLANKING — nine flat panels a side that you
+// cannot see a thing through, which is why the man sitting behind them looked like he was buried in
+// the wall. The panes are their own sub-meshes (SM_..._Glass, plus one per door), so the fix is a
+// material and not a mesh; the trap is WHICH material.
+//
+// applyAtlas (assets.js:268) hands every mesh that shares an atlas and a transparency flag the SAME
+// MATERIAL OBJECT, game-wide — and the FBX does not flag its glass transparent, so the panes are
+// holding the identical MeshStandardMaterial as the carriage's own planking, the loco, the bell, the
+// smokestack and every wheel on the railway (113 meshes in the live scene, counted). assets.js:265
+// says it in plain words: never mutate one on an instance; clone first. Set .transparent on that one
+// and the western prop set turns to fog.
+//
+// So: ONE clone, made the first time a pane is seen, wearing the house transparency (transparent,
+// depthWrite off, DoubleSide, an explicit renderOrder — weather.js:73, sky.js:173, water.js:148 and
+// this file's own smoke all do exactly this), and handed to every pane in the fleet. It keeps the
+// atlas map, because a window with no texel in it is not glass, it is a hole. One material, one extra
+// pipeline, built on the loading screen with everything else.
+let _glass = null;
+function glassLike(src) {
+  if (!_glass) {
+    _glass = src.clone();
+    _glass.transparent = true;
+    _glass.opacity = 0.30;       // enough to read the seats and the fares through it from the platform
+    _glass.depthWrite = false;
+    _glass.side = THREE.DoubleSide;   // the panes are single-sided quads; you sit on the inside of them
+    _glass.roughness = 0.12;     // and glass is not sawn timber, whatever the atlas says
+    _glass.metalness = 0;
+    _glass.flatShading = false;
+    _glass.name = 'trainGlass';
+  }
+  return _glass;
+}
+
+// ── THE WHEELS THAT WERE NOT WHEELS ───────────────────────────────────────────────────────────
+//
+// ONLY THE LOCO HAS WHEELS YOU CAN GRAB. SM_Veh_Train_01 carries eight of them as named children —
+// SM_Veh_Train_01_Wheel_L_01…04 and the same to starboard — and those are the ones that turn. The
+// other three models do not have them at all: the carriage, the van and the tender have their wheels
+// BAKED INTO THE BODY MESH, welded into the same lump of triangles as the solebar and the buffer
+// beam, with not one node in the file carrying the word Wheel in its name. Everything on the railway
+// that was not a locomotive skidded the length of the county on frozen iron.
+//
+// So the wheels are FOUND, and found from the SHAPE, because a railway wheel is geometrically
+// unmistakable. Break the body into the parts it was modelled from — connected components of its
+// triangles — and put every part through a sieve:
+//
+//   ROUND     a wheel is a disc. Its bounding box is as tall as it is long: |sy − sz| / max measures
+//             0.049 on every wheel in this pack and 0.001 on the loco's drivers, against 0.35–0.65
+//             for the axleboxes and spring hangers that live in the same corner of the underframe.
+//   THIN      ...and thin across the axle: sx / diameter is 0.203, where those boxes are 0.45–0.95.
+//   BIG       ...and it is HALF A METRE in the radius. This is the test that earns its keep. The
+//             carriage's own axlebox is 0.290 m and the loco's crank pin 0.211 m, and BOTH of them
+//             are round AND thin AND low AND outboard — every other test passes them. Only the size
+//             tells a wheel from the bearing it turns in.
+//   LOW       ...it is under the solebar (0.91 m) and nowhere near the deck (1.578 m).
+//   OUTBOARD  ...and it is out on the end of an axle: the hubs are at x = ±0.855 m. Nothing on the
+//             centreline of a railway carriage is a wheel.
+//
+// THE THRESHOLDS ARE CALIBRATED ON THE LOCO'S OWN AUTHORED WHEELS, which is the only honest way to
+// set them: measure the thing the artist himself called a wheel, then go and look for what it looks
+// like. And the sieve is CROSS-CHECKED, because a classifier that cannot be wrong is a classifier
+// nobody has tested. Run over the loco's body — 232 components, an entire steam engine — it finds
+// NOTHING, which is exactly right, and is the proof that it does not invent wheels out of boiler
+// bands. Run over the other three it finds 8, 8 and 4: two four-wheel bogies under the carriage, four
+// axles under the tender, and a plain four-wheel van. Every one of them comes out in an exact
+// left/right pair at a matching z, and every one of them has a radius of 0.5143 m — because they are
+// all the SAME 180-triangle casting, the one the loco's own pony truck is turned out of (0.514).
+// The triangles balance to the last one: carriage 3698 + 1440 = 5138, van 2076 + 720 = 2796, tender
+// 936 + 1440 = 2376. Nothing is dropped and nothing is duplicated.
+const WHEEL_ROUND = 0.12;   // |sy − sz| / diameter. The real wheels are 0.001 and 0.049 — the 0.049 is
+                            // the pack's ten-sided rim, flat to vertex, and not a modelling error.
+const WHEEL_THIN = 0.35;    // sx / diameter. The real wheels are 0.093 (drivers) and 0.203 (the rest).
+const WHEEL_MIN_R = 0.35;   // metres. Wheels 0.514; axlebox 0.290; crank pin 0.211. It splits them.
+const WHEEL_LOW = 1.20;     // metres, hub height: between the solebar (0.91) and the deck (1.578)
+const WHEEL_OUT = 0.40;     // metres, |hub x|: the axles put them at 0.855
+const WELD = 0.01;          // the geometry is in centimetres, so this is a tenth of a millimetre
+
+// THE BODY, BROKEN INTO THE PARTS IT WAS MODELLED FROM. Union-find over the triangles, joined where
+// they touch — and touching means SHARING A POSITION, not sharing an index. Synty's FBX geometry is
+// non-indexed: three corners per triangle, each its own vertex, so no two triangles share an index
+// with anything and an index-based union-find hands back one component per triangle and no wheels at
+// all. Weld on a grid instead. A tenth of a millimetre is far below the smallest rivet in the pack
+// and far above float noise.
+function components(geom) {
+  const P = geom.attributes.position.array;
+  const nT = P.length / 9;
+  const vid = new Int32Array(nT * 3);
+  const seen = new Map();
+  const q = 1 / WELD;
+  for (let i = 0; i < nT * 3; i++) {
+    const k = `${Math.round(P[i * 3] * q)},${Math.round(P[i * 3 + 1] * q)},${Math.round(P[i * 3 + 2] * q)}`;
+    let v = seen.get(k);
+    if (v === undefined) seen.set(k, v = seen.size);
+    vid[i] = v;
+  }
+  const par = new Int32Array(seen.size);
+  for (let i = 0; i < par.length; i++) par[i] = i;
+  const find = (a) => { while (par[a] !== a) { par[a] = par[par[a]]; a = par[a]; } return a; };
+  for (let t = 0; t < nT; t++) {
+    const a = find(vid[t * 3]), b = find(vid[t * 3 + 1]), c = find(vid[t * 3 + 2]);
+    if (b !== a) par[b] = a;
+    if (c !== a) par[find(c)] = a;
+  }
+  const out = new Map();
+  for (let t = 0; t < nT; t++) {
+    const r = find(vid[t * 3]);
+    let co = out.get(r);
+    if (!co) out.set(r, co = { tris: [], box: new THREE.Box3() });
+    co.tris.push(t);
+    for (let k = 0; k < 3; k++) co.box.expandByPoint(_wc.fromArray(P, (t * 3 + k) * 3));
+  }
+  return [...out.values()];
+}
+
+// Lift a list of triangles out into a BufferGeometry of their own, carrying every attribute across
+// (this pack has position, normal and uv, and no index). Given a hub, the positions are translated
+// onto it — which is the whole trick: a wheel whose geometry is centred on its own axle turns about
+// that axle when you touch its node's rotation.x, and a wheel that is not turns about the car.
+function cut(geom, tris, hub) {
+  const src = geom.attributes;
+  const g = new THREE.BufferGeometry();
+  for (const name of Object.keys(src)) {
+    const a = src[name], n = a.itemSize;
+    const arr = new a.array.constructor(tris.length * 3 * n);
+    let w = 0;
+    for (const t of tris) {
+      for (let k = 0; k < 3; k++) {
+        const v = (t * 3 + k) * n;
+        for (let c = 0; c < n; c++) arr[w++] = a.array[v + c];
+      }
+    }
+    g.setAttribute(name, new THREE.BufferAttribute(arr, n));
+  }
+  if (hub) g.translate(-hub.x, -hub.y, -hub.z);
+  return g;
+}
+
+// Cut the baked wheels out of one mesh and hang them back on it as nodes of their own. Returns how
+// many it took, which is the only number worth logging.
+function cutWheels(body) {
+  const geom = body.geometry;
+  const comps = components(geom);
+  if (comps.length < 2) return 0;   // a mesh that is ONE part has no part to take out of it
+  const s = body.getWorldScale(_ws).y || 1;   // the cm→m scale, so the sieve can think in metres
+  const hits = [];
+  for (const co of comps) {
+    co.box.getSize(_wz);
+    co.box.getCenter(_wc);
+    const dia = Math.max(_wz.y, _wz.z);
+    if (Math.abs(_wz.y - _wz.z) / dia > WHEEL_ROUND) continue;               // not a disc
+    if (_wz.x / dia > WHEEL_THIN) continue;                                  // not thin across the axle
+    if ((_wz.y / 2) * s < WHEEL_MIN_R) continue;                             // an axlebox, or a crank pin
+    if (_wc.y * s > WHEEL_LOW || Math.abs(_wc.x) * s < WHEEL_OUT) continue;  // not down on the rail, out on an axle
+    hits.push({ tris: co.tris, hub: _wc.clone() });
+  }
+  if (!hits.length) return 0;
+
+  // Named and numbered the way the pack does it, so they are indistinguishable from the loco's own
+  // and the registration below does not have to know which kind it is holding: L is the −x side, and
+  // they run up the car from the back (SM_Veh_Train_01_Wheel_L_01…04 are in ascending z).
+  hits.sort((a, b) => a.hub.z - b.hub.z);
+  const taken = new Set();
+  const n = { L: 0, R: 0 };
+  for (const h of hits) {
+    for (const t of h.tris) taken.add(t);
+    const side = h.hub.x < 0 ? 'L' : 'R';
+    const w = new THREE.Mesh(cut(geom, h.tris, h.hub), body.material);
+    w.name = `${body.name}_Wheel_${side}_${String(++n[side]).padStart(2, '0')}`;
+    w.position.copy(h.hub);
+    w.castShadow = body.castShadow;        // applyAtlas set these on the body before this mesh existed
+    w.receiveShadow = body.receiveShadow;  // (assets.js:343) and a wheel that casts no shadow floats
+    // A CHILD OF THE BODY MESH — which is where the loco keeps its own wheels: they are children of
+    // SM_Veh_Train_01, at the identity. A child of a mesh lives in the frame that mesh's GEOMETRY is
+    // written in, so the hub we just measured off that geometry IS the child's position, with no
+    // assumption about the body node's own transform, and the child's local X is the axle: the very
+    // axis the loco's wheels have always spun about.
+    body.add(w);
+  }
+  // AND TAKE THEM OUT OF THE BODY. A body that keeps the triangles it has just given away has a
+  // wheel standing still inside every wheel that turns — which is the ghost the loco's old re-pivot
+  // comment was warning about, and it is far more obvious than no wheels at all.
+  const nT = geom.attributes.position.count / 3;
+  const keep = [];
+  for (let t = 0; t < nT; t++) if (!taken.has(t)) keep.push(t);
+  body.geometry = cut(geom, keep, null);
+  return hits.length;
+}
+
+// ── PREPARING A MODEL, ONCE, ON THE MASTER ────────────────────────────────────────────────────
+//
+// ONCE PER MODEL, NOT ONCE PER CAR, and that distinction is the entire safety argument.
+//
+// instantiate() clones the node tree but SHARES the geometry with the master — that is what the
+// cache is FOR (assets.js:214). So a car that re-pivots its own wheels is editing geometry every
+// other car of its class is looking at: the second loco re-pivots what the first has already
+// re-pivoted, hubs come out of an already-moved bounding box, and she arrives with her wheels
+// scattered across the desert. The coach paid for that once (coach.js:194) and this file used to pay
+// its way out of it by CLONING the geometry of every wheel of every car — a hundred and twelve
+// copies across the fleet, each one made so it could be translated by the same vector as the last.
+//
+// Cutting the baked wheels out of the body kills that dodge stone dead anyway: the body geometry is
+// shared, so if the first carriage cut its wheels out of it the second would find none left to cut
+// and ride to Dustwater on nothing. There is exactly one right place to do this and it is the MASTER,
+// before a single car is cloned off it. It runs on the loading screen, it runs once per model, and
+// every car in the fleet then inherits a model whose wheels are already nodes standing on their own
+// hubs. Nothing whatever is added to the scene during play — this file's first law.
+//
+// The contract is the ordering: Car.load() awaits this BEFORE it calls instantiate(). Both go
+// through the same cached master promise, so the surgery is always finished before the first clone.
+const _prepped = new Map();   // url → promise. loadModel keys its master by url|texture|scale, and this
+                              // file asks for exactly one texture at exactly one scale, so url is the key.
+function prepareWheels(url) {
+  if (!_prepped.has(url)) {
+    _prepped.set(url, loadModel(url, { texture: ATLAS }).then((master) => {
+      if (master.userData.wheelsReady) return master;   // the memo is the braces; this is the belt
+      master.userData.wheelsReady = true;
+
+      // Sieve everything that is not already a wheel, a rod or a pane. On the loco that is the body,
+      // the bell and the smokestack, and it yields nothing; on the other three it is the body (which
+      // yields the wheels), the saloon interior and the doors, which yield nothing.
+      let found = 0;
+      const bodies = [];
+      master.traverse((o) => { if (o.isMesh && o.geometry && !/(_Wheel_[LR]_\d+|_Stick_\d+|_Glass)$/i.test(o.name)) bodies.push(o); });
+      for (const b of bodies) found += cutWheels(b);
+
+      // AND NOW EVERY WHEEL IN THE MODEL GETS ITS HUB — the loco's authored ones and the ones just
+      // cut, through the same three lines. One place in this file measures a wheel, and it measures
+      // both kinds the same way.
+      const wheels = [];
+      master.traverse((o) => { if (o.isMesh && /_Wheel_[LR]_\d+$/i.test(o.name)) wheels.push(o); });
+      for (const o of wheels) {
+        o.geometry.computeBoundingBox();
+        const box = o.geometry.boundingBox;
+        const dia = box.max.y - box.min.y;
+        box.getCenter(_wc);
+        // The re-pivot is a no-op on a wheel that was cut (it came out hub-centred) and the whole job
+        // on one that was authored. o.position lives in the same centimetres the geometry does, so it
+        // needs no conversion; see below for the one number that does.
+        o.geometry.translate(-_wc.x, -_wc.y, -_wc.z);
+        o.position.add(_wc);
+        // THE GEOMETRY IS IN CENTIMETRES. THE WORLD IS IN METRES.
+        //
+        // None of the train assets has a .glb twin, so instantiate() loads the raw FBX and hangs the
+        // cm→m conversion on the model's SCALE (assets.js:177, SYNTY_SCALE). The node tree and the
+        // geometry under it are still Synty's centimetres — so a bounding box read here measures the
+        // driving wheel at 93.12, not 0.931. Feed THAT to `radians = distance / radius` and every
+        // wheel on the railway turns a HUNDRED TIMES TOO SLOWLY: the fleet skates the length of the
+        // county with its wheels almost still. The coach never had to know (it loads a GLB twin,
+        // already in metres) — which is precisely why copying its loader was not enough.
+        //
+        // Measured: drivers 0.931 m, pony truck 0.514, and every carriage, van and tender wheel
+        // 0.514 — they are the same casting. A loco whose leading truck turns at the drivers' rate is
+        // a loco dragging its front wheels down the rail, so the radius is read off each wheel's own
+        // geometry and never off a guess. It rides in userData because Object3D.copy deep-copies it
+        // (three's Object3D.js:1618), so every car cloned off this master is handed the measurement
+        // instead of taking it again.
+        o.userData.radius = (dia / 2) * (o.getWorldScale(_ws).y || 1) || 0.5;
+      }
+      if (found) console.log(`[train] ${url.split('/').pop()}: ${found} wheels cut out of the body (${wheels.length} on the car)`);
+      return master;
+    }));
+  }
+  return _prepped.get(url);
+}
+const _wc = new THREE.Vector3(), _wz = new THREE.Vector3();
+
+// ── ONE CAR ───────────────────────────────────────────────────────────────────────────────────
+class Car {
+  constructor(train, kind) {
+    this.train = train;
+    this.kind = kind;
+    this.def = MODELS[kind];
+    this.len = this.def.len;
+    this.root = new THREE.Group();
+    this.root.rotation.order = 'YXZ';   // yaw round the line, then pitch onto the bank
+    this.wheels = [];
+    this.sticks = [];
+    this.crew = [];     // combat.js walks this (through the proxy, below)
+    this.riders = [];   // crime.js walks this
+    this.back = 0;      // metres from the train's NOSE to this car's centre
+  }
+
+  async load() {
+    // THE SURGERY FIRST, AND ON THE MASTER — see prepareWheels. By the time instantiate() hands this
+    // car its clone, every wheel in the model is already a node standing on its own hub with its own
+    // measured radius, whether the artist put it there or we cut it out of the body. So this traverse
+    // has nothing left to do but WRITE THEM DOWN, and there is not a geometry copy in it.
+    await prepareWheels(this.def.url);
+    const model = await instantiate(this.def.url, { texture: ATLAS });
+    this.root.add(model);
+    this.root.updateWorldMatrix(false, true);   // so getWorldScale below tells the truth (see the cm/m note)
+    model.traverse((o) => {
+      if (!o.isMesh || !o.geometry) return;
+      // THE WINDOWS. Done here, on the loading screen, and never again — a material swap at runtime is
+      // a pipeline build and this file's first law forbids it.
+      if (/_Glass$/i.test(o.name)) { o.material = glassLike(o.material); o.renderOrder = 2; return; }
+      if (/_Wheel_[LR]_\d+$/i.test(o.name)) { this.wheels.push({ mesh: o, radius: o.userData.radius || 0.5 }); return; }
+      if (!/_Stick_\d+$/i.test(o.name)) return;
+      // The rods are NOT re-pivoted. A rod swung about a wheel hub it does not sit on is a hammer
+      // throw — and these sit at y 1.94–3.24, well above the 0.93 hub. They are slid fore-and-aft
+      // in the loco's own axis, which is what a piston rod actually does, and at speed it is enough.
+      // The throw is authored in metres and converted INTO the node's own space (which is Synty's
+      // centimetres), for the same reason prepareWheels converts the radius out of it.
+      o.getWorldScale(_ws);
+      this.sticks.push({ mesh: o, z0: o.position.z, phase: this.sticks.length * 2.1, throw: ROD_THROW / (_ws.z || 1) });
+    });
+
+    // SOLID — one oriented box per car, pushed ONCE, rewritten every frame (coach.js:288). Nothing
+    // removes it: World.collide walks the array live, so a moving vehicle just keeps its entry
+    // current. Without these you walk through eighty tons of iron and out the far side.
+    this.col = { x: 0, z: 0, hx: this.def.halfW, hz: this.len / 2, cs: 1, sn: 0, y0: 0, y1: 0 };
+    colliders.push(this.col);
+    return this;
+  }
+
+  // THE PROXY THAT MAKES THE STAGECOACH STOP FOR THE TRAIN.
+  //
+  // coach.js is not mine to edit, and its look-ahead already scans exactly one kind of moving thing:
+  // the other coaches — `for (const other of this.game.coaches?.coaches ?? [])`, testing
+  // `other.root.position`. So each train car is registered in that same array as something that
+  // duck-types a coach. That is not a hack in the pejorative sense: game.coaches.coaches is the one
+  // list in this game that means "a large vehicle, somewhere, right now", and a railway carriage is
+  // precisely that. What it buys, with no edit to any file I do not own:
+  //
+  //   coach.js:414    the stage brakes for a train instead of driving through it
+  //   combat.js:525   the bullet sweep tests the footplate crew (it iterates c.crew)
+  //   crime.js:259    the crew are WITNESSES to what you do in front of them (it iterates c.riders)
+  //   player.js:984   they are aim-assist targets like anybody else
+  //   ui.js:558       the train draws on the map as the string of white dots that it is
+  //
+  // The price is that CoachLine.update() and CoachLine.syncRiders() will call update() and
+  // _syncRiders() on it, so it must answer both. update() is a no-op: TrainLine has already moved us.
+  proxy() {
+    const car = this;
+    return {
+      root: this.root,
+      get crew() { return car.crew; },
+      get riders() { return car.riders; },
+      update() { /* the TrainLine drives us — this exists so CoachLine.update() can call it */ },
+      _syncRiders() { car.syncRiders(); },
+    };
+  }
+
+  // Every crewman is a child of a moving car and has no world position of his own, so he is GIVEN one
+  // — the same rotate-the-offset arithmetic the coach uses: no getWorldPosition matrix walk, no
+  // allocation. combat.js calls this (through the proxy) immediately before it sweeps its bullets,
+  // because main.js ticks combat BEFORE the vehicles: without it every round is fired at where he was
+  // last frame, which at 16 m/s is a quarter of a metre behind him.
+  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);
+    }
+  }
+
+  syncCollider(stabled) {
+    // hx <= 0 is OFF (world.js:238). A stabled train has left the county and must not go on being an
+    // invisible wall in the middle of the desert with nothing standing where it is.
+    this.col.hx = stabled ? 0 : this.def.halfW;
+    if (stabled) return;
+    const ry = this.root.rotation.y;
+    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.4;            // the frames and the wheels...
+    this.col.y1 = this.root.position.y + this.def.top;   // ...up to the roof. Above that you are shooting sky.
+  }
+}
+
+// A car is standing ON the road when its END is within this of the crossing. Used by the berth clamp
+// (Train.berthLead) as well as the guard, so the two can never disagree about what "fouling" means.
+const FOUL_M = 6;
+
+// ── ONE TRAIN ─────────────────────────────────────────────────────────────────────────────────
+class Train {
+  constructor(line, spec) {
+    this.line = line;
+    this.game = line.game;
+    this.id = spec.id;
+    this.name = spec.name;
+    this.spec = spec;
+    this.consist = spec.consist;
+    this.cars = [];
+    this.speed = 0;
+    this.u = 0;                // arc position of the LEADING END of the movement, along this.route
+    this.route = null;
+    this.state = 'standing';   // standing | running
+    this.stabled = false;
+    this.reversed = false;     // the loco is at the BACK, propelling (see _reverseFor)
+    this.place = spec.start;
+    this.sched = 0;
+    this.dwell = 0;
+    this.askT = 0;
+    this.held = false;         // refused the road: standing with the regulator shut
+    this.heldT = 0;            // ...for this long, in total. The proof that it waited.
+    this.runaway = 0;
+    this.relief = 0;
+    this.dist = 0;             // metres run. The wheels are turned by THIS and by nothing else.
+    this.travelYaw = 0;        // the way the TRAIN is going (a reversed loco points the other way)
+    this.locoS = 0;            // the loco's arc position on its current PATH — the anchor that
+    this.locoPath = null;      // survives a change of route, and therefore a reversal (see _adopt)
+  }
+
+  get len() { return this.consist.reduce((a, k) => a + MODELS[k].len, 0); }
+
+  async load() {
+    let back = 0;
+    for (const kind of this.consist) {
+      const car = new Car(this, kind);
+      await car.load();
+      car.back = back + car.len / 2;
+      back += car.len;
+      this.game.scene.add(car.root);
+      this.cars.push(car);
+    }
+
+    // THE FOOTPLATE. Driver on the right, fireman on the left, on the cab floor — measured at y=1.94,
+    // not guessed at. They are SeatedRiders: the same class, the same posture and the same shootable
+    // contract as the men on the stagecoach, so a bullet through the cab does what a bullet through
+    // the cab ought to do and the railroad's pay tin goes into the dirt with the man carrying it.
+    const loco = this.cars[0];
+    const cast = castFares(2);
+    this.driver = await SeatedRider.create(loco.root, cast[0], { x: 0.72, y: CAB_FLOOR + 0.40, z: -4.95, ry: 0 }, driverPosture(SEAT));
+    this.fireman = await SeatedRider.create(loco.root, cast[1], { x: -0.72, y: CAB_FLOOR + 0.40, z: -4.95, ry: 0 }, passengerPosture(SEAT));
+    loco.riders.push(this.driver, this.fireman);
+
+    // THE FARES — only in carriages. Four men sitting in a freight van is a mystery, not a detail.
+    // Built NOW and kept forever, riding with their models hidden when they are not aboard today
+    // (coach.js:244): a man is not BORN when a train pulls in, he becomes visible.
+    this.fares = [];
+    const PAX = passengerPosture(SEAT);
+    for (const car of this.cars) {
+      if (car.kind !== 'carriage') continue;
+      for (const def of castFares(FARE_SEATS.length)) {
+        const r = await SeatedRider.create(car.root, def, FARE_SEATS[car.riders.length], PAX);
+        car.riders.push(r);
+        this.fares.push(r);
+      }
+    }
+
+    this.riders = [this.driver, this.fireman, ...this.fares].filter(Boolean);
+    for (const r of this.riders) {
+      r.game = this.game;
+      r.coach = this;          // SeatedRider.die() calls coach._crewDown() — that is us
+      r.role = r === this.driver ? 'driver' : r === this.fireman ? 'mate' : 'fare';
+    }
+    this._seatFares();
+    this._park();
+    return this;
+  }
+
+  // How full is she today? Drawn fresh at every call, because the train that is always half empty is
+  // as fake as the one that is always full. A DEAD fare is not re-drawn: he rides on, visible, in the
+  // seat he was shot in, which is the entire point.
+  _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); });
+    for (const car of this.cars) car.crew = car.riders.filter((r) => r.pivot.visible);
+  }
+
+  // WHERE THE TRAIN STOPS RELATIVE TO THE PIN. Not ON it — a berth is where the PASSENGERS are, so
+  // the leading end runs past the station by however far back in the train the carriages sit, and the
+  // carriages come to rest at the platform. A train with nothing to put at a platform stops on the pin.
+  _carriageLead() {
+    let a = null, b = 0, at = 0;
+    for (const k of this.consist) {
+      if (k === 'carriage') { if (a === null) a = at; b = at + MODELS[k].len; }
+      at += MODELS[k].len;
+    }
+    if (a === null) return 0;
+    const fromNose = (a + b) / 2;
+    return this.reversed ? this.len - fromNose : fromNose;
+  }
+
+  // ...AND IT MUST NOT STAND ON THE LEVEL CROSSING.
+  //
+  // Dustwater's platform is TWENTY METRES from the road, and the shortest train on this railway is
+  // thirty-seven. Berth it by the platform and half the fleet parks its tender squarely across the
+  // north road — measured: the gates were shut 74% of the time and the stagecoach simply never got
+  // over. So the berth is CLAMPED: of the two places a train can stand clear of the road (short of
+  // it, or drawn right through it), take whichever is nearer to where the carriages want to be.
+  //
+  // It works out better than it sounds. Westbound the clamp moves the train four metres and the
+  // carriages land exactly on the platform. Eastbound it stops her 23 m short, which stands the LOCO
+  // at the platform with her carriages trailing back down the line — which is what every branch-line
+  // station with a short platform looks like anyway. The alternative was gates that are never open.
+  berthLead(route) {
+    const ideal = this._carriageLead();
+    const B = route && this.line.places[route.to];
+    // A SINK IS A TUNNEL NOW: pull the WHOLE consist past the last sleeper before stopping, so the
+    // stable happens with every car inside the hill. Half-in-half-out (the carriage-centred lead)
+    // left a third of the train blinking out on open desert.
+    if (B?.sink) return this.len + 6;
+    if (!B || B.path !== this.line.paths.main || !this.line.crossS.length) return ideal;
+    const last = route.legs[route.legs.length - 1];
+    const dir = last.dir;
+    // work in TRAVEL coordinate (tau = dir * s), so the train always runs forwards and the two
+    // options are simply "stop before it" and "pull past it"
+    const pin = dir * B.s, L = this.len;
+    const M = FOUL_M + 4;   // ...with slack, or she berths EXACTLY on the guard's trip-wire and the
+                            // gates flicker shut for a train that is standing still
+    let lead = ideal;
+    for (const cs of this.line.crossS) {
+      const tc = dir * cs;
+      const head = pin + lead;
+      if (head - L > tc + M || head < tc - M) continue;   // already clear of the road
+      const before = tc - M - pin;          // leading end stops short of the road
+      const beyond = tc + M + L - pin;      // ...or the whole train is drawn past it
+      lead = Math.abs(before - ideal) <= Math.abs(beyond - ideal) ? before : beyond;
+    }
+    return lead;
+  }
+
+  // Distance from the LEADING END of the movement to car i's centre. When the loco is propelling,
+  // the leading end is the far end of the train and every offset is measured from there instead.
+  _off(car) { return this.reversed ? this.len - car.back : car.back; }
+
+  // ── the timetable ──────────────────────────────────────────────────────────────────────────
+  _nextPlace() { return this.spec.calls[(this.sched + 1) % this.spec.calls.length]; }
+
+  // IS THE LOCO POINTING THE WAY WE ARE ABOUT TO GO? If not, she PROPELS — the loco stays at the
+  // quarry end and pushes the wagons out ahead of her.
+  //
+  // This is the dead-end problem and it must be solved or the loco teleports. The ore train runs
+  // nose-first into Bonebreak, which is a stub with no run-round; it cannot come out nose-first, so
+  // it must come out backwards, and the whole consist keeps its facing while the DIRECTION OF TRAVEL
+  // reverses. Anchor everything on the loco's own position on the path (this.locoS) and the maths
+  // works out exactly: every car's world position and heading are unchanged across the reversal,
+  // which is the test — nothing moves, only the direction it is about to move in.
+  //
+  // Out of a SINK she always leads: the ends of the line are off the county, and a loco that runs
+  // round its train in the yard at the end of the line is a loco doing its job where nobody is looking.
+  _reverseFor(route, fromSink) {
+    if (fromSink || !this.locoPath) return false;
+    const l0 = route.legs[0];
+    if (l0.path !== this.locoPath) return this.reversed;   // shouldn't happen: a berth is on one path
+    const uLoco = l0.dir * (this.locoS - l0.s0);
+    route.pos(uLoco + 3, _a); route.pos(uLoco - 3, _b);
+    const tx = _a.x - _b.x, tz = _a.z - _b.z;              // the way the ROUTE goes, here
+    const ly = this.cars[0].root.rotation.y;
+    return (Math.sin(ly) * tx + Math.cos(ly) * tz) < 0;    // ...against the way the LOCO points
+  }
+
+  // Take up a new route without moving an inch. The loco's arc position on the path is the anchor;
+  // everything else follows from it, including a reversal.
+  _adopt(route) {
+    const l0 = route.legs[0];
+    const uLoco = l0.dir * (this.locoS - l0.s0);
+    this.route = route;
+    this.u = uLoco + this._off(this.cars[0]);
+  }
+
+  // ASK FOR THE ROAD. Refused, she stands where she is — which is a berth, which is safe — and asks
+  // again in a second. She does NOT creep forward to have a look, which is how a train ends up
+  // fouling the very section it was refused.
+  // TRAIN ROBBERY (the platform hold-up — see the 'standing' branch). Mirrors the coach's
+  // _heldUp: drawn gun AIMED at the driver (ray-tested at the cab, <=12m) while she stands; hold
+  // ~2s and the FOOTPLATE pay tin comes down — the railroad's money, heavier than the stage's —
+  // plus a 'coachRobbery' on the books and the county's regard down two. Once per train per session.
+  _heldUp(dt) {
+    const g = this.game, p = g.player;
+    if (!p || this.driver?.alive === false) return false;
+    const lp = this.cars?.[0]?.root?.position ?? this.driver?.pivot?.position;
+    if (!lp) return false;
+    const d = dist2D(lp.x, lp.z, p.position.x, p.position.z);
+    if (this._robbed) return p.drawn && p.aiming && d < 14;
+    let aimed = false;
+    if (p.drawn && p.aiming && d < 12 && !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; aimed = !!rayCapsule(from.x, from.y, from.z, dir.x, dir.y, dir.z, dp, 0.8); }
+    }
+    if (!aimed) { this._holdT = 0; return false; }
+    this._holdT = (this._holdT ?? 0) + dt;
+    if (this._holdT < 0.3) g.ui?.toast?.(`The driver's hands leave the regulator. Hold the iron on him.`, 3200);
+    if (this._holdT > 2.2) {
+      this._robbed = true; this._holdT = 0;
+      const at = (this._drvPos ?? this.driver?.pivot?.position ?? p.position).clone(); at.y = g.world.groundAt(at.x, at.z) + 0.1; at.x += 1.6;
+      g.loot?.dropFor?.('driver', at, 5);                     // the railroad's tin — heavier than the stage's
+      g.crime?.report?.('coachRobbery', at.clone());
+      g.missions?.addStat?.('reputation', -2);
+      g.ui?.toast?.(`The pay tin hits the platform. The railroad has lawyers AND rifles — ride wide a while.`, 6500);
+    }
+    return true;
+  }
+
+  _askForTheRoad() {
+    const to = this._nextPlace();
+    const from = this.place;
+    const route = this.line.route(from, to);
+    if (!route) return false;
+    const wasSink = !!this.line.places[from].sink;
+    const rev = this._reverseFor(route, wasSink);
+    const was = this.reversed;
+    this.reversed = rev;
+    route.len = route.base + this.berthLead(route);
+    if (!this.line.signals.grant(this, route)) {
+      this.reversed = was;                      // refused: nothing changes, not even which way she faces
+      if (!this.held) { this.held = true; this.line.holds.push({ train: this.id, at: from, want: to, t: this.line.clock }); }
+      return false;
+    }
+    this.held = false;
+    this._adopt(route);
+    this.stabled = false;
+    this.state = 'running';
+    this.sched = (this.sched + 1) % this.spec.calls.length;
+    this._planHalts(route);
+    console.log(`[train] ${this.id}: road cleared ${from} → ${to}${rev ? ' (propelling)' : ''}`);
+    return true;
+  }
+
+  // ── THE END-OF-LINE HALTS (Nick's design) ────────────────────────────────────────────────────
+  // A halt is a PAUSE ON THE ROAD, not a standing place: the train keeps its whole granted road and
+  // simply stands a moment at the boards — so the interlocking, and the deadlock-freedom argument it
+  // rests on (ONE contended berth), are untouched. Carriage trains only: the ore empties have no
+  // fares and run through. The halt nearest a TUNNEL end is where a riding player is put off —
+  // nobody gets carried into the hill.
+  _planHalts(route) {
+    this._halts = [];
+    this._haltDwell = 0;
+    const lead = this._carriageLead();
+    if (!lead) return;                                     // no carriages, no call
+    const main = this.line.paths.main;
+    for (const H of RAIL_HALTS) {
+      for (let i = 0; i < route.legs.length; i++) {
+        const l = route.legs[i];
+        if (l.path !== main) continue;
+        const lo = Math.min(l.s0, l.s1), hi = Math.max(l.s0, l.s1);
+        if (H.s <= lo + 2 || H.s >= hi - 2) continue;      // a halt AT a route end is that end's berth, not a call
+        this._halts.push({ name: H.name, u: route.off[i] + Math.abs(H.s - l.s0) + lead, wait: H.wait ?? 12, stand: H.stand });
+        break;
+      }
+    }
+    this._halts.sort((a, b) => a.u - b.u);
+    if (this.line.places[route.to]?.sink && this._halts.length) this._halts[this._halts.length - 1].eject = true;
+  }
+
+  _callAtHalt(h) {
+    console.log(`[train] ${this.id}: calling at ${h.name}`);
+    const seat = this.seats?.find((s) => s.rider?.player);
+    if (seat && h.eject) {
+      const player = seat.rider.player;
+      seat.alight(player);
+      if (h.stand) {
+        const py = this.game.world?.walkSurfaceAt?.(h.stand.x, h.stand.z);
+        player.setPosition?.(h.stand.x, py ?? player.position.y, h.stand.z);
+        player._camSnap = true;
+      }
+      this.game.ui?.toast?.(`End of the line — ${h.name}. She turns in the hill; catch one going the other way.`, 5600);
+    }
+  }
+
+  // THE LOOK-AHEAD — the safety net, and coach.js's _blocked() almost line for line. How far in front
+  // of my chimney is the nearest piece of somebody else's train, inside MY corridor?
+  //
+  // What it does NOT ask about is the point: it does not brake for the player, it does not brake for
+  // the townsfolk, and it does not brake for the stagecoach. A TRAIN DOES NOT STOP FOR A MAN ON THE
+  // LINE. The colliders shove him aside and being there is his problem — the same trade coach.js's
+  // runaway branch already makes (coach.js:554), and the reason the crossing has a guard on it.
+  _roadAhead() {
+    const lead = this.reversed ? this.cars[this.cars.length - 1] : this.cars[0];
+    const fx = Math.sin(this.travelYaw), fz = Math.cos(this.travelYaw);
+    const ox = lead.root.position.x, oz = lead.root.position.z;
+    const reach = LOOK + this.speed * LOOK_PER_MS;
+    let nearest = Infinity;
+    for (const other of this.line.trains) {
+      if (other === this || other.stabled) continue;
+      for (const c of other.cars) {
+        const dx = c.root.position.x - ox, dz = c.root.position.z - oz;
+        const ahead = dx * fx + dz * fz;
+        if (ahead < 0.5 || ahead > reach) continue;
+        const side = Math.abs(dx * fz - dz * fx);
+        if (side > CORRIDOR + c.def.halfW) continue;
+        nearest = Math.min(nearest, ahead - c.len / 2);   // stop short of his BUFFERS, not his middle
+      }
+    }
+    return nearest;
+  }
+
+  update(dt) {
+    if (this.runaway > 0) this.runaway -= dt;
+    if (this.relief > 0) { this.relief -= dt; if (this.relief <= 0) this._reliefCrew(); }
+    if (this.held) this.heldT += dt;
+
+    if (this.state === 'standing') {
+      this.speed = 0;
+      // A GUN ON THE FOOTPLATE (train robbery v1 — the PLATFORM version; nobody flags down 140
+      // tons at line speed). Iron aimed at the driver while she stands: the dwell holds — she
+      // will not leave a platform with her driver's hands up — and two seconds buys the pay tin.
+      if (this._heldUp(dt)) this.dwell = Math.max(this.dwell, 1.2);
+      this.dwell -= dt;
+      if (this.dwell <= 0) {
+        this.askT -= dt;
+        if (this.askT <= 0) { this.askT = ASK_EVERY; this._askForTheRoad(); }
+      }
+      this._place();
+      this._after(dt);
+      return;
+    }
+
+    // CALLING AT A HALT: stand at the boards for `wait` seconds without giving up the road.
+    const nextHalt = this._halts?.find((h) => !h.done);
+    if (nextHalt && this._haltDwell > 0) {
+      this.speed = 0;
+      this._haltDwell -= dt;
+      if (this._haltDwell <= 0) nextHalt.done = true;
+      this._place();
+      this._after(dt);
+      return;
+    }
+    if (nextHalt && this.u >= nextHalt.u - 0.6 && this.speed < 0.06) {
+      this._haltDwell = nextHalt.wait;
+      this._callAtHalt(nextHalt);
+    }
+
+    // HOW FAST AM I ALLOWED TO BE GOING? The authority runs out at the far end of the route (my
+    // berth); the look-ahead may shorten it. Then brake on the CURVE that gets me stopped exactly
+    // there: v = sqrt(2 a d). Anything else and the stopping distance depends on how fast I happened
+    // to be going, which is not how a brake works.
+    let limit = this.route.len - this.u;
+    if (nextHalt) limit = Math.min(limit, nextHalt.u - this.u);   // the brake curve aims at the halt first
+    const obstacle = this._roadAhead();
+    if (obstacle < Infinity) limit = Math.min(limit, obstacle - SAFE_GAP);
+    this.held = obstacle < Infinity && obstacle - SAFE_GAP < 80;
+
+    const lineSpeed = this.route.shunt ? SHUNT : CRUISE;
+    let want = Math.min(lineSpeed, Math.sqrt(2 * BRAKE * Math.max(0, limit - STOP_PAD)));
+    if (limit <= 0.4) want = 0;
+    else if (want < CREEP) want = Math.min(CREEP, limit);   // kiss the stop; do not lurch into it
+
+    if (want > this.speed) this.speed = Math.min(want, this.speed + ACCEL * dt);
+    else this.speed = Math.max(want, this.speed - BRAKE * dt);
+    // A DEADBAND BELONGS ON THE WAY DOWN, NOT ON THE WAY UP.
+    // This used to be `if (this.speed < 0.02) this.speed = 0` — lifted straight from coach.js, where
+    // it is harmless because a coach's speed is an exponential ease that clears 0.02 in its first
+    // frame. A train accelerates at 0.35 m/s^2, so at 120 fps it gains THREE MILLIMETRES PER SECOND
+    // of speed per frame — less than the deadband — and the next line took it away again. Every
+    // frame. Forever. The fleet could not start: it only ever moved when a frame ran long enough
+    // (>57 ms) to clear the band in one go, which is why it looked intermittent rather than broken,
+    // and why the whole railway then deadlocked behind whichever train had got away. So the snap to
+    // zero applies only when we are ASKING for zero.
+    if (want <= 0 && this.speed < 0.05) this.speed = 0;
+
+    const step = this.speed * dt;
+    this.u += step;
+    this.dist += step;
+
+    if (this.u >= this.route.len - 0.6 && this.speed < 0.06) {
+      this.u = this.route.len;
+      this.place = this.route.to;
+      this.state = 'standing';
+      this.askT = 0;
+      const P = this.line.places[this.place];
+      // THE ENDS OF THE LINE ARE OFF THE COUNTY. A train that reaches one is STABLED: dropped below
+      // the world, colliders off, blocking nothing — the property the whole signalling argument rests
+      // on. It is NOT removed from the scene; that would be a pipeline build on the way back in.
+      if (P.sink) {
+        // ...AND HE IS NOT GOING WITH HER. `stabled` drops every car 400 m (see _place), and it did it
+        // with the man still on his bench: ride the Flyer east out of Dustwater — which is the ride the
+        // dev flag gives you, and the only one the timetable offers most of the time — and the journey
+        // ends with the player at y = −396, inside the ground, in the dark, until she is booked out
+        // again. Put him off FIRST, on the dirt, at the end of the line. alight() takes its x,z from
+        // the car (still up here, still on the rails) and probes him down onto the real world.
+        const seat = this.seats?.find((s) => s.rider?.player);
+        if (seat) {
+          const player = seat.rider.player;
+          seat.alight(player);
+          // ...and NOT inside the mountain. The full pull-through berths his car beyond the last
+          // sleeper, so alight()'s beside-the-seat spot is in the dark of the bore. Walk him back
+          // out: set him down beside the PORTAL, on the county side of the mouth.
+          const outS = P.s === 0 ? TUNNEL_S + 9 : P.s - TUNNEL_S - 9;
+          P.path.pos(outS, _a);
+          const py = this.game.world?.walkSurfaceAt?.(_a.x, _a.z + 5.5) ?? _a.y;
+          player.setPosition?.(_a.x, py, _a.z + 5.5);
+          this.game.ui?.toast?.(`End of the line — ${P.name}. She runs into the hill and stables.`, 4200);
+        }
+        this.stabled = true;
+        this.dwell = DWELL_TERMINAL + Math.random() * 6;
+        this.runaway = 0;                    // she is in the yard: they find her another driver
+        this.relief = 0;
+      } else if (this.runaway > 0) {
+        this.dwell = 0;                      // she does not stop for anybody
+        console.log(`[train] ${this.id}: RAN THROUGH ${P.name} — nobody on the regulator`);
+      } else {
+        this.dwell = P.wait ?? DWELL_STATION;
+        this._seatFares();
+        if (P.id === 'dustwater') this.game.ui?.toast?.(`${this.name} — calling at Dustwater`, 2400);
+      }
+    }
+    this._place();
+    this._after(dt);
+  }
+
+  // ── where every car is, and which way it points ─────────────────────────────────────────────
+  // A car sits on its TWO BOGIES, not on its centre: sample the route at centre ± 0.32 * len, put the
+  // body on the midpoint and point it along the chord. That is what lets a rigid 17 m carriage take a
+  // corner on a polyline whose joints kink up to 12.8 degrees without snapping its heading at every
+  // waypoint and snaking the whole consist.
+  _place() {
+    const R = this.route;
+    if (!R) return;
+    for (const car of this.cars) {
+      const u = this.u - this._off(car);
+      const half = car.len * 0.32;
+      R.pos(u + half, _a); _a.y = R.height(u + half) + RAIL_Y;
+      R.pos(u - half, _b); _b.y = R.height(u - half) + RAIL_Y;
+      car.root.position.set((_a.x + _b.x) / 2, (_a.y + _b.y) / 2, (_a.z + _b.z) / 2);
+      // IN THE HILL, OUT OF SIGHT: a car wholly inside the main line's bored ends vanishes into the
+      // dark of the portal (railway.js dresses the mouths). This is what makes the sink's
+      // stable/book-out blink invisible — it happens where nobody can see it (Nick's tunnels).
+      const atLeg = R.at(u);
+      const onMain = atLeg.l.path === this.line.paths.main;
+      const inHill = onMain && (atLeg.s < TUNNEL_S - car.len / 2 || atLeg.s > atLeg.l.path.len - TUNNEL_S + car.len / 2);
+      car.root.visible = !inHill;
+      if (this.stabled) car.root.position.y -= 400;
+      const yaw = Math.atan2(_a.x - _b.x, _a.z - _b.z);
+      car.root.rotation.y = this.reversed ? yaw + Math.PI : yaw;
+      // ...and she leans back going up the bank. The cheapest thing in this file and the first thing
+      // you notice the absence of. (The sign flips with the car: a reversed car's own +Z is astern.)
+      const run = Math.hypot(_a.x - _b.x, _a.z - _b.z) || 1;
+      const pitch = Math.atan2(_a.y - _b.y, run);
+      car.root.rotation.x = this.reversed ? pitch : -pitch;
+      car.syncCollider(this.stabled);
+      car.syncRiders();
+    }
+    // The anchor that survives a change of route — and therefore a reversal. Everything else about
+    // where the train is can be rebuilt from the loco's own place on the iron.
+    const hit = R.at(this.u - this._off(this.cars[0]));
+    this.locoS = hit.s;
+    this.locoPath = hit.l.path;
+    R.pos(this.u + 3, _a); R.pos(this.u - 3, _b);
+    this.travelYaw = Math.atan2(_a.x - _b.x, _a.z - _b.z);
+    // The E-prompts ride WITH the car they belong to — a prompt planted in the dirt is a prompt beside
+    // an empty platform. There is a row of them down each flank of each rideable car now (see
+    // TrainLine.build), so this walks the list rather than writing one point.
+    if (this._its) {
+      for (const it of this._its) {
+        _a.set(it.cx, 0, it.cz);
+        it.car.root.localToWorld(_a);
+        it.x = _a.x;
+        it.z = _a.z;
+      }
+    }
+  }
+
+  // Put the train in its berth at build: give it the road it is ABOUT to work and stand it at the far
+  // end of nothing — u = berthLead is exactly where it would be standing had it just arrived.
+  _park() {
+    const R = this.line.route(this.place, this._nextPlace());
+    if (!R) { console.warn('[train] no road out of', this.place); return; }
+    this.reversed = false;
+    this.route = R;
+    R.len = R.base + this.berthLead(R);
+    this.u = this._carriageLead();   // stood in its start berth as though it had just arrived
+    this.state = 'standing';
+    this.stabled = !!this.line.places[this.place].sink;
+    this.dwell = 3 + Math.random() * 26;   // ...staggered, so the fleet does not all leave at once
+    this._place();
+  }
+
+  // ── everything that follows from having moved ───────────────────────────────────────────────
+  _after(dt) {
+    // THE WHEELS ARE TURNED BY THE GROUND: radians = distance / radius. Never by a rate — a wheel on
+    // a rate slips the instant the train changes speed, and a slipping wheel is the most obvious lie
+    // a vehicle can tell.
+    //
+    // ...AND THE GROUND GOES THE OTHER WAY WHEN SHE IS PROPELLING. A reversed working keeps its
+    // facing and reverses its direction of travel (see _place: every car is turned a half turn), so
+    // the wheel spinning about its own local axis comes out turning FORWARD while the train runs
+    // BACKWARD — which is exactly what it looked like. The sign belongs on the distance, because the
+    // distance is what turns them.
+    //
+    // AND IT IS EVERY WHEEL ON THE TRAIN NOW, not just the loco's. This loop never changed; what
+    // changed is that car.wheels is no longer empty on a carriage, a van or a tender (prepareWheels
+    // cuts their wheels out of the body mesh on the loading screen, because the model has them welded
+    // into the planking and offers nothing to turn). 112 wheels across the fleet, all of them turned
+    // by the same one line, none of them turned by a rate.
+    const rolled = this.speed * dt * (this.reversed ? -1 : 1);
+    for (const car of this.cars) {
+      for (const w of car.wheels) w.mesh.rotation.x += rolled / w.radius;
+      if (car.sticks.length) {
+        const ph = this.dist / 0.931;    // the rods reciprocate with the DRIVERS: one stroke a revolution
+        for (const s of car.sticks) s.mesh.position.z = s.z0 + Math.sin(ph + s.phase) * s.throw;
+      }
+    }
+    // Everyone aboard holds his pose — four two-bone solves a man, no mixer, no clip. 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 — seatedRider.js). A DEAD man is not re-solved;
+    // he only falls.
+    for (const r of this.riders) {
+      if (!r.pivot.visible) continue;
+      if (r.alive) r.solve();
+      else r.slump(dt);
+    }
+    if (!this.stabled && this.cars[0]?.root.visible !== false) this.line.smoke.chuff(this, dt);   // no smoke rising out of the hill
+  }
+
+  // ── SHOOT THE MAN ON THE REGULATOR ──────────────────────────────────────────────────────────
+  _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.
+    // The kind is 'coachRobbery' because that is the heaviest carrier-robbery HEAT crime.js knows
+    // (crime.js:68) and it means the right thing: the county's money, taken off a common carrier. A
+    // railroad payroll ought to out-price a stage's takings and deserves its own HEAT row — crime.js
+    // is not mine to edit, so the PURSE is heavier and the heat is the same. Flagged for Nick.
+    if (killer == null || killer === g.player) {
+      g.crime?.report('coachRobbery', at);
+      g.loot?.drop(at, roll(r.role === 'driver' ? FOOTPLATE_PURSE : r.role === 'mate' ? FIREMAN_PURSE : PASSENGER_PURSE), dropItemsFor(r.role));
+    }
+    alarmTown(g, x, z, 30, 6);
+    for (const car of this.cars) car.crew = car.riders.filter((c) => c.pivot.visible);
+    if (r === this.driver) this._noHandOnTheRegulator();
+  }
+
+  _noHandOnTheRegulator() {
+    if (this.runaway > 0) return;
+    this.runaway = REGULATOR_SECS;
+    if (!(this.fireman?.alive && this.fireman.pivot.visible)) this.relief = RELIEF_SECS;
+    this.dwell = 0;
+    console.log(`[train] ${this.id}: the driver is down — she runs on`);
+  }
+
+  _reliefCrew() { this.runaway = 0; console.log(`[train] ${this.id}: relief crew aboard — she works her booked path again`); }
+
+  // ── THE RIDE ────────────────────────────────────────────────────────────────────────────────
+  // player.aboard expects a COACH (player.js:513). It reads root.rotation.y, seatWorld(), rider and
+  // driven off it — and now two more things, because a stagecoach is an open box and a railway
+  // carriage is a room with a roof on: how long the follow camera may be (camDist), and where its lens
+  // is allowed to go (camConfine). Both are read through `?? default` in player.js, so the stagecoach,
+  // which answers neither, behaves exactly as it did.
+  //
+  // He used to ride the REAR VERANDA — except this carriage has no veranda. It is a closed-vestibule
+  // coach: the deck stops at z = 8.04 and the end wall is at 8.11, so the old seat (y 1.75, z 8.15)
+  // stood him on the outer lip of a door sill, half outside the end wall, with 0.63 m of air under his
+  // boots. That is the whole of "we dont sit in it properly". He sits on a bench now.
+  //
+  // `root` is a bare Object3D that never enters the scene. It exists only to carry the heading
+  // player.js reads, and player.js takes a QUARTER TURN off whatever it finds there (a coachman sits
+  // across his box) — so it is pre-loaded with that quarter turn on top of the bench's own facing.
+  makeSeat(car) {
+    const t = this;
+    const inside = car.kind === 'carriage';
+    const host = {
+      car,
+      root: new THREE.Object3D(),
+      rider: null,
+      driven: false,   // a passenger, not a driver: the camera does not chase the train's heading and
+                       // he looks wherever he likes
+      // 9 m of follow camera in a 2.98 m saloon puts the lens through the far wall. The van's roof has
+      // all the room in the world, so it only wants pulling in enough to see the county go past him.
+      camDist: inside ? 2.7 : 5.5,
+      camAdsDist: inside ? 2.1 : 4.0,
+      seat: inside ? bench(-1, PLAYER_BAY, 0) : HOBO,
+      get speed() { return t.speed; },
+      seatWorld(out) {
+        out.set(host.seat.x, host.seat.y, host.seat.z);
+        // localToWorld, and not the rotate-the-offset arithmetic that was here: that one drops the x
+        // term entirely (harmless on the centreline, a metre out on a bench beside a window) and knows
+        // nothing about the car's PITCH, which is real — she leans back going up the bank.
+        return car.root.localToWorld(out);
+      },
+      // WHERE THE LENS MAY GO, in the car's own frame. Called by player.js's follow camera before it
+      // eases, so a camera swung round to look out of the left-hand window ends up pressed against the
+      // right-hand wall instead of a metre outside it, staring at the planking.
+      camConfine: inside ? (x, y, z) => {
+        _cam.set(x, y, z);
+        car.root.worldToLocal(_cam);
+        _cam.x = Math.max(-SALOON.hx, Math.min(SALOON.hx, _cam.x));
+        _cam.y = Math.max(SALOON.y0, Math.min(SALOON.y1, _cam.y));
+        _cam.z = Math.max(SALOON.z0, Math.min(SALOON.z1, _cam.z));
+        return car.root.localToWorld(_cam);
+      } : null,
+      board: (player) => {
+        host.rider = { player, kind: 'inside' };
+        player.aboard = host;
+        // TAKE THE SEAT THAT FACES THE WAY SHE IS GOING. Both benches of bay 5 are kept clear of fares
+        // for you, and they face opposite ways; the car already knows which of its own ends is the
+        // front, because travelYaw is where the route is about to take it. Riding backwards is a thing
+        // that happens to you on a train, not a thing you choose.
+        if (inside) host.seat = bench(-1, PLAYER_BAY, Math.cos(car.root.rotation.y - t.travelYaw) > 0 ? 0 : 1);
+        // A PASSENGER IS NOT A DRIVER. The coach's baked player-seat wears the DRIVER's posture (fists
+        // up on the reins) because on a coach the player is always the man on the box. On a train he
+        // is a fare, so his hands go in his lap. The posture is a plain field and swapping it is
+        // exactly what coach.js's guard does when he takes the reins (coach.js:706). Put back on alight.
+        const pr = t.game.coaches?.playerRider;
+        if (pr) { host._wasPosture = pr.posture; pr.posture = passengerPosture(SEAT); }
+        // AND THE GUN GOES BACK IN THE LEATHER, exactly as it does when he swings into a saddle
+        // (player.js:522). Two reasons, and the second is the one that bites: a fare sits with his
+        // hands in his lap — that is the posture two lines up — and gunInputs does not run at all on
+        // the aboard path (player.js:582 returns above it), so a man who boards with his revolver out
+        // can never put it away, and `drawn` stays up for the whole journey. trainCamera.js reads
+        // `drawn` as "he is reaching for it, give him his camera back", so that man would ride two
+        // kilometres looking at the back of his own hat and never see the film at all.
+        player.holsterGun?.();
+        // PUT THE LENS BEHIND HIS HEAD. camYaw is whatever he happened to be facing when he stepped up,
+        // so without this you sit down and find yourself looking at your own back through a wall. The
+        // camera sits at +(sin, cos) of camYaw from him, so behind him is his heading plus a half turn.
+        // And FLATTEN THE PITCH: the walking camera looks down on him from above, which indoors means
+        // it goes straight into the roof and stays there, clamped, filming the ceiling. A man who has
+        // just sat down in a railway carriage is looking along it.
+        player.camYaw = car.root.rotation.y + host.seat.ry + Math.PI;
+        player.camPitch = 0.06;
+        t.game.ui?.toast?.(inside ? 'Aboard. E to get off when she stops.'
+          : 'On the roof of the van. E to get off when she stops.', 4200);
+      },
+      alight: (player) => {
+        if (!host.rider) return;
+        host.rider = null;
+        player.aboard = null;
+        player._visualY = undefined;   // let the smoother re-latch onto wherever he lands
+        // ...and the CINEMATIC LENS may be sixty metres away on a hillside when he steps down
+        // (trainCamera.js). The follow camera EASES (player.js: lerp on rdt*10), so without this the
+        // man who got off the train watches his own camera fly in at him across the desert for half a
+        // second. It cuts. Free — the follow camera's own wall-clip snap is the same flag.
+        player._camSnap = true;
+        const pr = t.game.coaches?.playerRider;
+        if (pr && host._wasPosture) pr.posture = host._wasPosture;
+        // Step down on the PLATFORM side — the platform stands 6.8 m off the centreline on the town
+        // side, and the town is south of the line. So of the two sides, take the one nearer the town,
+        // and never step down into the six-foot. And step down BESIDE HIS OWN SEAT, not beside the
+        // middle of a seventeen-metre car: a man who was sitting at the back of the coach does not
+        // reappear at the front of it.
+        const ry = car.root.rotation.y;
+        const nx = Math.cos(ry), nz = -Math.sin(ry);
+        _a.set(0, 0, host.seat.z);
+        car.root.localToWorld(_a);
+        const ax = _a.x + nx * 4.8, az = _a.z + nz * 4.8;
+        const bx = _a.x - nx * 4.8, bz = _a.z - nz * 4.8;
+        const [x, z] = az > bz ? [ax, az] : [bx, bz];
+        // ...and step down onto WHATEVER IS THERE, which at a station is the platform: its deck
+        // stands 0.908 m proud of the dirt and it is a COLLIDER, not terrain. groundAt() only knows
+        // the terrain, so alighting onto the platform drops him through the planks and leaves him
+        // standing in the ground with the deck at his waist. probe() settles a capsule onto the real
+        // collision world — the deck if there is one, the dirt if there is not.
+        //
+        // START THE DROP JUST ABOVE HIS BOOTS. probe() defaults to falling from y = 50 and simulates
+        // exactly one second of it (world.js:421), which at this gravity covers about 10 m — so out on
+        // the flat it never reaches the ground at all and hands back 40, and the man who got off the
+        // train appears forty metres over the county and falls. Drop him from a couple of metres above
+        // the dirt instead: that clears the platform deck by 1.6 m and settles well inside the second.
+        const W = t.game.world;
+        player.position.set(x, W.probe(x, z, W.groundAt(x, z) + 2.5).y, z);
+      },
+    };
+    // player.js takes a QUARTER TURN off root.rotation.y to get his heading (player.js:538), and that
+    // turn is not a coach quirk to be cancelled — it is the correction for the SEATED POSE ITSELF,
+    // which is baked facing across the body it is sitting on, because a coachman sits across his box.
+    // Cancelling it (as this line used to, with a +PI/2) sat him on the bench facing the window
+    // instead of the aisle: ninety degrees wrong, which is exactly how it looked. So hand player.js
+    // the plain heading of the seat he is in — the car's, plus the bench's own facing — and let it
+    // take its quarter turn. Refreshed every frame, because the carriage is going round a curve.
+    //
+    // ...and then PUT HIM BACK ON THE BENCH. main.js ticks the player BEFORE the vehicles (main.js:655,
+    // :674), so player.js seated him against the car's matrix from LAST frame — at line speed that is
+    // 0.27 m of lag, and on a pan 0.292 m deep he rides visibly back into the seat behind him. So he is
+    // re-seated here, after the car has moved, on the car where it now IS. (player.position is
+    // player.root.position — entity.js:183 — so this moves the man you can see. The only thing left a
+    // frame behind is the camera, which eases anyway and cannot tell.)
+    host.sync = () => {
+      host.root.rotation.y = car.root.rotation.y + host.seat.ry;
+      const p = host.rider?.player;
+      if (!p) return;
+      // _place has just written the car's position and rotation, but matrixWorld is still LAST FRAME'S
+      // — three only rebuilds it at render. A carriage gets away with that by accident (its fares'
+      // solve() walks updateWorldMatrix up through the car root and refreshes it as a side effect); a
+      // boxcar has no fares and would not. Ask for it, rather than relying on a rider being there.
+      car.root.updateWorldMatrix(false, false);
+      host.seatWorld(p.position);
+      p._visualY = p.position.y;   // the smoother is not running on this path; keep it pinned (player.js:549)
+    };
+    // ...AND THE CAMERA THAT MAKES THE JOURNEY WORTH TAKING. A passenger has nothing to do with his
+    // hands, so the ride is filmed: six shots on a loop, cut on a timer (game/trainCamera.js). It hangs
+    // a `camera` field on the host and player.js calls it if it is there — which is why the stagecoach,
+    // which has no such field, is untouched. Built HERE, on the loading screen, with the train: nothing
+    // is allocated when he steps aboard, and nothing is thrown away when he steps off.
+    attachTrainCamera(t, host);
+    return host;
+  }
+}
+const _cam = new THREE.Vector3();
+
+const _a = new THREE.Vector3(), _b = new THREE.Vector3(), _ws = new THREE.Vector3();
+
+// ── SMOKE ─────────────────────────────────────────────────────────────────────────────────────
+// game.vfx does NOT make this cheap, and I checked before writing a line of it. VFX.spawn() allocates
+// a fresh THREE.Sprite AND a fresh THREE.SpriteMaterial per particle and does a scene.add / a
+// scene.remove per particle (vfx.js:301, 457), and FX_RECIPES has no smoke or steam recipe to play
+// instead (fire_explosion, impact_small, impact_dirt, blood, embers, fireflies, glow_spot, sparkles,
+// stun_stars — that is the lot). A loco chuffing twice a revolution through that would churn the
+// scene graph forever, which is precisely what this codebase's perf law forbids.
+//
+// So the smoke is its own RESIDENT pool: one InstancedMesh of camera-facing quads, built on the
+// loading screen, never added to or removed from the scene, count fixed for life, and every puff is
+// an instance-matrix write. One draw call for the whole fleet. It reuses the smoke_04 texture VFX has
+// already loaded, so it costs no new asset either.
+const PUFFS = 72;
+const PUFF_LIFE = 2.6;
+const SMOKE_R = 260;   // don't chuff a loco nobody can see — the far end of the line is a kilometre out
+
+class Smoke {
+  constructor(game) {
+    this.game = game;
+    this.p = [];
+    for (let i = 0; i < PUFFS; i++) this.p.push({ age: PUFF_LIFE + 1, x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0, s0: 1, rot: 0 });
+    this.next = 0;
+  }
+
+  async build(scene) {
+    const tex = this.game.vfx?.textures?.smoke_04 ?? await loadTexture('/assets/particles/smoke_04.png');
+    const mat = new THREE.MeshBasicMaterial({
+      map: tex, transparent: true, depthWrite: false, side: THREE.DoubleSide,
+      color: 0x39332c, opacity: 0.55,     // coal smoke is dirty. It is not white steam.
+    });
+    this.mesh = new THREE.InstancedMesh(new THREE.PlaneGeometry(1, 1), mat, PUFFS);
+    this.mesh.frustumCulled = false;    // the plume moves; a stale bind sphere pops the whole pool out
+    this.mesh.name = 'trainSmoke';      // NOT scatter:/scatterCol: — world.js must never bake it into the BVH
+    this.mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    this.mesh.renderOrder = 3;
+    const m = new THREE.Matrix4().makeScale(0, 0, 0);
+    for (let i = 0; i < PUFFS; i++) this.mesh.setMatrixAt(i, m);
+    this.mesh.instanceMatrix.needsUpdate = true;
+    scene.add(this.mesh);
+    return this;
+  }
+
+  // A CHUFF IS NOT A TIMER. The exhaust beats with the driving wheels — twice a revolution here (a
+  // real two-cylinder loco gives four; two reads just as well and halves the particle budget) — so a
+  // loco working hard beats fast and a coasting one barely smokes. Because it is driven off the same
+  // `dist / radius` the wheels are, it can never drift out of step with them. A standing loco still
+  // simmers: the fire is lit even when the regulator is shut.
+  chuff(train, dt) {
+    const loco = train.cars[0];
+    if (!loco || !this.mesh) return;
+    const p = this.game.player?.position;
+    if (p && dist2D(p.x, p.z, loco.root.position.x, loco.root.position.z) > SMOKE_R) return;
+    const beats = (train.dist / (2 * Math.PI * 0.931)) * 2;
+    if (train._beat === undefined) train._beat = beats;
+    const standing = train.speed < 0.5;
+    train._sim = standing ? (train._sim ?? 0) + dt : 0;
+    const due = Math.floor(beats) > Math.floor(train._beat) || (standing && train._sim > 1.1);
+    train._beat = beats;
+    if (!due) return;
+    if (standing) train._sim = 0;
+    const ry = train.travelYaw;
+    const lry = loco.root.rotation.y;
+    const q = this.p[this.next = (this.next + 1) % PUFFS];
+    q.age = 0;
+    q.x = loco.root.position.x + STACK.z * Math.sin(lry);
+    q.y = loco.root.position.y + STACK.y;
+    q.z = loco.root.position.z + STACK.z * Math.cos(lry);
+    q.vy = 2.5 + Math.random() * 1.3;
+    // it leaves the chimney straight up and is immediately left behind by the train under it
+    q.vx = -Math.sin(ry) * train.speed * 0.18 + (Math.random() - 0.5) * 0.6;
+    q.vz = -Math.cos(ry) * train.speed * 0.18 + (Math.random() - 0.5) * 0.6;
+    q.s0 = 1.6 + Math.random() * 0.9 + train.speed * 0.05;
+    q.rot = Math.random() * 6.283;
+  }
+
+  update(dt, camera) {
+    if (!this.mesh) return;
+    const cq = camera.quaternion;
+    for (let i = 0; i < PUFFS; i++) {
+      const q = this.p[i];
+      if (q.age > PUFF_LIFE) continue;
+      q.age += dt;
+      if (q.age > PUFF_LIFE) { _m4.makeScale(0, 0, 0); this.mesh.setMatrixAt(i, _m4); continue; }
+      q.x += q.vx * dt; q.y += q.vy * dt; q.z += q.vz * dt;
+      q.vy += 0.5 * dt;                          // hot gas keeps climbing
+      q.vx *= 1 - 0.6 * dt; q.vz *= 1 - 0.6 * dt;
+      const t = q.age / PUFF_LIFE;
+      const s = q.s0 * (1 + t * 3.4);            // it billows out as it cools
+      _q.copy(cq).multiply(_qz.setFromAxisAngle(_zax, q.rot));
+      _m4.compose(_v3b.set(q.x, q.y, q.z), _q, _v3.set(s, s, s));
+      this.mesh.setMatrixAt(i, _m4);
+    }
+    this.mesh.instanceMatrix.needsUpdate = true;
+  }
+}
+const _m4 = new THREE.Matrix4(), _v3 = new THREE.Vector3(), _v3b = new THREE.Vector3();
+const _q = new THREE.Quaternion(), _qz = new THREE.Quaternion(), _zax = new THREE.Vector3(0, 0, 1);
+
+// ── THE LEVEL CROSSING ────────────────────────────────────────────────────────────────────────
+// THE STAGECOACH MUST STOP FOR THE TRAIN, and coach.js is not mine to edit. Its look-ahead already
+// scans game.coaches.coaches and tests each `other.root.position` — and every train car is in that
+// array (Car.proxy), which alone stops the stage driving into iron it can already see. But the
+// coach's reach at a trot is 9.4 m and a train covers that in half a second, so a stage that only
+// reacts to what it can nearly touch is a stage that gets hit ON the crossing.
+//
+// So the crossing gets a GUARD: one more coach-shaped object, parked ON the crossing whenever a train
+// is closing on it or standing across it, and parked a hundred kilometres away the rest of the time.
+// To the stagecoach it is a coach stopped in the road, and it does what it has always done — brakes,
+// and holds, about eight metres short of the rails. That is a level crossing, expressed in the only
+// vocabulary coach.js speaks, with no edit to coach.js.
+//
+// The one thing it must NOT do is trap a coach that is already ON the crossing — and it doesn't:
+// coach.js's inTheWay() ignores anything less than 0.5 m in front of it, so a stage halfway over the
+// rails finds the guard BEHIND it and clears, which is exactly right.
+const CROSS_WARN = 190;   // metres of approach at which the gates come down (12 s at line speed)
+                          // (FOUL_M, declared above the Train class, is how close a car's END may come
+                          // to the road. It was 16 m round the car's CENTRE, which shuts the gates on a
+                          // carriage whose nearest corner is twenty-five metres clear of the dirt.)
+
+class CrossingGuard {
+  constructor(line, at) {
+    this.line = line;
+    this.at = at;
+    this.crew = [];
+    this.riders = [];
+    this.root = new THREE.Object3D();
+    this.root.position.set(1e5, 0, 1e5);   // off the map: it blocks nothing until it has to
+    this.shut = false;
+  }
+  update() { /* CoachLine.update() will call this; the work is in set(), driven by TrainLine */ }
+  _syncRiders() { }
+
+  set() {
+    let shut = false;
+    for (const t of this.line.trains) {
+      if (t.stabled) continue;
+      for (const c of t.cars) {
+        if (dist2D(c.root.position.x, c.root.position.z, this.at.x, this.at.z) < FOUL_M + c.len / 2) { shut = true; break; }
+      }
+      if (shut) break;
+      // ...and CLOSING on it. A train that has just cleared the crossing is the same DISTANCE from it
+      // as one about to reach it, so distance alone would hold the gates shut behind every train for
+      // another mile of road. Ask which side of the loco it is on.
+      const lead = t.reversed ? t.cars[t.cars.length - 1] : t.cars[0];
+      const d = dist2D(lead.root.position.x, lead.root.position.z, this.at.x, this.at.z);
+      if (t.speed > 0.2 && d < CROSS_WARN) {
+        const fx = Math.sin(t.travelYaw), fz = Math.cos(t.travelYaw);
+        const ahead = (this.at.x - lead.root.position.x) * fx + (this.at.z - lead.root.position.z) * fz;
+        if (ahead > -10) { shut = true; break; }
+      }
+    }
+    this.shut = shut;
+    if (shut) this.root.position.set(this.at.x, 0, this.at.z);
+    else this.root.position.set(1e5, 0, 1e5);
+  }
+}
+
+// ── THE FLEET ─────────────────────────────────────────────────────────────────────────────────
+// Four trains, four jobs. The ORE is the one that pays for the line; the rest ride on its back, which
+// is how every real branch line in the west got built.
+export const FLEET = [
+  { id: 'passenger', name: 'The Dustwater Flyer',   consist: ['loco', 'tender', 'carriage', 'carriage'],
+    start: 'west', calls: ['west', 'dustwater', 'east', 'dustwater'] },
+  { id: 'ore',       name: 'The Bonebreak Ore',     consist: ['loco', 'tender', 'freight', 'freight', 'freight'],
+    start: 'east', calls: ['east', 'dustwater', 'bonebreak', 'dustwater'] },   // empties down, ore back
+  { id: 'freight',   name: 'The Copperhead Goods',  consist: ['loco', 'tender', 'freight', 'carriage'],
+    start: 'east', calls: ['east', 'dustwater', 'west', 'dustwater'] },        // a mixed train: a van and a coach on the back
+  { id: 'local',     name: 'The Dustwater Local',   consist: ['loco', 'tender', 'carriage'],
+    start: 'west', calls: ['west', 'dustwater'] },                             // a short working, out and back
+];
+
+export class TrainLine {
+  constructor(game) {
+    this.game = game;
+    this.trains = [];
+    this.places = {};
+    this.guards = [];
+    this.holds = [];    // every time a train was refused the road. The proof that it waited.
+    this.clock = 0;
+  }
+
+  async build(count = FLEET.length) {
+    const world = this.game.world;
+    this.paths = {};
+    // The track author's graded centreline if it has landed; my own cut-and-fill of the sited route
+    // if it has not. Everything downstream sees the same two methods (pos, height) either way.
+    if (LINES_IN?.main?.nodes?.length) {
+      for (const [id, line] of Object.entries(LINES_IN)) this.paths[id] = pathFromNodes(id, line);
+      this.laidBy = 'world/data/railway.js';
+    } else {
+      for (const p of FALLBACK_PATHS) this.paths[p.id] = gradePolyline(p.id, p.pts, world);
+      this.laidBy = 'the fallback survey (data/railway.js has not landed)';
+    }
+    const main = this.paths.main, spur = this.paths.spur;
+    if (!main) throw new Error('[train] no main line');
+
+    const stops = STOPS_IN ?? FALLBACK_STOPS;
+    // A CALL IS AN ARC LENGTH, NOT A PIN. The graded centreline is up to 1.25 m off the surveyed
+    // polyline, so projecting an (x,z) onto it is a guess where the track author has an answer.
+    const sOf = (st, path) => (st?.s !== undefined ? st.s : path.sNear(st?.x ?? 0, st?.z ?? 0));
+    const dw = stops.find((st) => st.id === 'dustwater');
+    const bb = stops.find((st) => st.id === 'bonebreak');
+    this.junctionS = JUNC_IN?.s ?? (spur ? main.sNear(spur.nodes?.[0]?.x ?? -300, spur.nodes?.[0]?.z ?? -230) : main.len / 2);
+    this.crossings = XING_IN ? [{ x: XING_IN.x, z: XING_IN.z, s: XING_IN.s }] : FALLBACK_CROSSINGS.map((c) => ({ ...c, s: main.sNear(c.x, c.z) }));
+    this.crossS = this.crossings.map((c) => c.s);   // the berth clamp works in arc length (berthLead)
+    this.places = {
+      west:      { id: 'west',      name: 'the west end of the line', path: main, s: 0,        sink: true },
+      dustwater: { id: 'dustwater', name: dw?.name ?? 'Dustwater Station', path: main, s: sOf(dw, main), wait: DWELL_STATION },
+      east:      { id: 'east',      name: 'the east end of the line', path: main, s: main.len, sink: true },
+    };
+    if (spur && bb) this.places.bonebreak = { id: 'bonebreak', name: bb.name ?? 'Bonebreak Loading', path: spur, s: sOf(bb, spur), shunt: true, wait: DWELL_LOAD };
+
+    this.signals = new Signalman(this.trains);
+    this.smoke = await new Smoke(this.game).build(this.game.scene);
+
+    for (const spec of FLEET.slice(0, count)) {
+      if (!spec.calls.every((c) => this.places[c])) { console.warn('[train] no such place for', spec.id); continue; }
+      try {
+        const t = new Train(this, spec);
+        await t.load();
+        this.trains.push(t);
+      } catch (e) { console.warn('[train] failed to build', spec.id, e); }
+    }
+
+    // REGISTER WITH THE COACHES — see Car.proxy(). This is the whole of "the stagecoach stops for the
+    // train", and it is also what makes the footplate crew shootable, witnesses and aim targets. If
+    // the coach line failed to build, stand an empty one up: that array is what five other modules
+    // read, and an empty coach line is a perfectly good coach line with no coaches on it.
+    if (!this.game.coaches) this.game.coaches = { coaches: [], playerRider: null, update() {}, syncRiders() {} };
+    this.guards = this.crossings.map((c) => new CrossingGuard(this, c));
+    for (const t of this.trains) for (const c of t.cars) this.game.coaches.coaches.push(c.proxy());
+    for (const g of this.guards) this.game.coaches.coaches.push(g);
+
+    // RIDE THE TRAIN — FROM ANYWHERE ALONGSIDE THE CAR, BOTH SIDES, ITS WHOLE LENGTH.
+    //
+    // There used to be ONE circle, on the middle of the last carriage, written `r: 4.4`. That radius is
+    // a fiction: main.js starts its search at bestD = 3.2 (main.js:733) and never looks further,
+    // whatever number you write. So the only place on a fifty-five metre train where E did anything was
+    // a 3.2 m bubble round the CENTRE of a seventeen-metre coach — and since you must stand outside a
+    // body 1.88 m half-wide, that left a couple of paces of dirt, on whichever side you happened to
+    // approach from. "i cant get on the train", and quite right too.
+    //
+    // So the circles go in TWO ROWS, one down each FLANK of the car, RIDE_OUT clear of the body —
+    // which is where a man wanting to get on a train actually stands. From there a 3.2 m circle reaches
+    // from the planking out to five metres of dirt, and RIDE_STEP apart they overlap the whole length
+    // of the car. Both sides, end to end, and the same E gets you off again.
+    //
+    // EVERY carriage of the train is boardable, not just the last: on the Flyer the front coach is
+    // forty metres from the back one, and a passenger walks to the door he is nearest. Each car has its
+    // own seat host, so you sit down in the coach you got into.
+    //
+    // AND EVERY TRAIN OFFERS A RIDE. Two of the four have no carriage in them at all (the ore is five
+    // cars of loco, tender and vans), and a train standing at a platform with nothing to press E on is
+    // a train the county cannot use — so those are ridden on the roof of the rear van, which is what a
+    // man with no ticket has always done.
+    const RIDE_R = 3.2;      // main.js will not look further than this, however big a number you write
+    const RIDE_OUT = 2.6;    // car-local |x| of the two rows: 0.7 m clear of the widest body (halfW 1.88)
+    const RIDE_STEP = 4.0;   // ...so the worst point between two circles is 2.0 m of z, and 2.5 m of
+                             // dirt still reads: sqrt(3.2^2 - 2.0^2) = 2.5 m out beyond the row itself
+    for (const t of this.trains) {
+      const coaches = t.cars.filter((c) => c.kind === 'carriage');
+      const ride = coaches.length ? coaches : t.cars.filter((c) => c.kind === 'freight').slice(-1);
+      if (!ride.length) continue;   // a loco and a tender and nothing else: nowhere to put a man
+      t.seats = [];
+      t._its = [];
+      for (const car of ride) {
+        const host = t.makeSeat(car);
+        t.seats.push(host);
+        const label = car.kind === 'carriage' ? `E — Ride ${t.name}` : `E — Ride the roof of ${t.name}`;
+        const n = Math.max(1, Math.ceil(car.len / RIDE_STEP));
+        for (let i = 0; i < n; i++) {
+          for (const side of [-1, 1]) {
+            const it = {
+              x: 0, z: 0, r: RIDE_R,
+              car, cx: side * RIDE_OUT, cz: -car.len / 2 + (i + 0.5) * (car.len / n),   // car-local; _place puts them in the world
+              // `when` turns one prompt into the other: you cannot leap onto a moving train, and once
+              // aboard the only thing worth offering is the way off. (The names carry their own "The".)
+              // Once aboard, the prompt is where the camera keys are ADVERTISED — there is no manual,
+              // and a cinematic rig nobody knows how to skip or switch off is a cinematic rig that
+              // traps people (trainCamera.js owns the string).
+              get label() { return host.rider ? (host.camPrompt ?? 'E — Get off the train') : label; },
+              // ...and you get off where she STOPS. Offering it at sixteen metres a second put a man
+              // on the ballast in open desert two kilometres from anywhere, which is not a feature —
+              // so once you are aboard, the prompt comes back only when she is standing at a call.
+              when: () => (host.rider?.player === this.game.player
+                ? (t.speed < 0.6 && t.state === 'standing')
+                : (!this.game.player.aboard && !t.stabled && t.speed < 0.6)),
+              action: () => (host.rider ? host.alight(this.game.player) : host.board(this.game.player)),
+            };
+            t._its.push(it);
+            this.game.interactables.push(it);
+          }
+        }
+      }
+      t.seat = t.seats[0];
+    }
+
+    console.log(`[train] the railroad is working: ${this.trains.length} trains on ${main.len.toFixed(0)}m of main line`
+      + `${spur ? ` + ${spur.len.toFixed(0)}m of ore spur` : ''}, ${Object.keys(this.places).length} places, laid by ${this.laidBy}`);
+    return this;
+  }
+
+  // A ROAD from one place to the next. The only interesting one is the spur: a run between Dustwater
+  // and Bonebreak is two legs — back down the main line to the junction, then out along the spur —
+  // and the junction is a point on BOTH paths, which is what makes it a junction.
+  route(from, to) {
+    const A = this.places[from], B = this.places[to];
+    if (!A || !B || from === to) return null;
+    const main = this.paths.main, spur = this.paths.spur;
+    let legs;
+    if (A.path === main && B.path === main) legs = [{ path: main, s0: A.s, s1: B.s }];
+    else if (A.path === main && B.path === spur) legs = [{ path: main, s0: A.s, s1: this.junctionS }, { path: spur, s0: 0, s1: B.s }];
+    else if (A.path === spur && B.path === main) legs = [{ path: spur, s0: A.s, s1: 0 }, { path: main, s0: this.junctionS, s1: B.s }];
+    else return null;
+    const R = makeRoute(legs, from, to);
+    R.shunt = !!(A.shunt || B.shunt);   // you do not take a loaded ore train down a siding at 36 mph
+    return R;
+  }
+
+  update(dt) {
+    this.clock += dt;
+    // THE ONE WHO HAS WAITED LONGEST ASKS FIRST. The trains used to ask for the road in the order they
+    // were built, and the road always went to whoever asked first — so the Copperhead Goods, third in
+    // the list, sat at the east end for the whole of a twenty-minute run and never turned a wheel
+    // (measured: 0.00 km in 1200 s). A signalman works a queue, not a stack.
+    this._order ??= [...this.trains];
+    this._order.sort((a, b) => b.heldT - a.heldT);
+    for (const t of this._order) { t.update(dt); for (const h of t.seats ?? []) h.sync(); }
+    for (const g of this.guards) g.set();
+    this.smoke.update(dt, this.game.camera);
+  }
+
+  // combat.js calls game.coaches.syncRiders() before it sweeps its bullets and the car proxies answer
+  // it. This is here for anything that would rather ask the trains directly.
+  syncRiders() { for (const t of this.trains) for (const c of t.cars) c.syncRiders(); }
+}