@dreadwood-types/types 0.1.190 → 0.1.192

package/dist/westernTrain.js

@@ -24,8 +24,13 @@
  * client draws the same train from the clock sent with the chunks (`trainClock`). The trains run the same timetable
  * WESTERN_TRAIN_COUNT apart. Stops other than the platform are data (WESTERN_TRAIN_STOPS, `enabled: false`) until their
  * places are built; switching one on adds its dwell to the cycle.
+ *
+ * THE CIRCUIT VERSION (slice 2-0, plan .cursor/task-plans/2026-10-11-western-phase2-circuit-plan.md): the legs, stops and
+ * train count are one WesternTrainCircuit with a version and a key. The game deploys on a push while the backend waits
+ * for a release, so the server sends its circuit's key (`trainCircuit`, with the clock) and the client draws and times
+ * THAT circuit (westernCircuitForKey); every train sum takes the circuit as its last argument (the server's by default).
  */
-import { CAPITAL_BUILDING_MODELS, HEIGHT_STEP, UNDERGROUND_END_X } from './constants.js';
+import { CAPITAL_BUILDING_MODELS, CHUNK_SIZE, CHUNK_VIEW_RADIUS, HEIGHT_STEP, UNDERGROUND_END_X, worldRegionAt } from './constants.js';
 import { WESTERN_CARS, WESTERN_CAUSEWAY, WESTERN_GANGWAYS, WESTERN_GAP_ROW, WESTERN_JOINTS, WESTERN_KIT_DECK_METRES, WESTERN_KNOLL, WESTERN_PLATFORM, WESTERN_PLATFORM_PIECES, WESTERN_PRECINCT_HEIGHT, WESTERN_RAKE_SLOTS, WESTERN_SEA_END, WESTERN_SEA_KERB, WESTERN_STEPS, WESTERN_TRACK, WESTERN_TRACK_Z, WESTERN_TUNNEL_MOUTH, westernCausewayHeight, } from './westernEntrance.js';
 /* ------------------------------------------------------------------ *
  * The docked rake (the cart-local frame).
@@ -198,20 +203,50 @@ export function inWesternIsleStub(x, z) {
     return (x >= b.minX && x <= b.maxX && z >= b.minZ && z <= b.maxZ) ||
         (x >= WESTERN_ISLE_CAUSEWAY.minX && x <= WESTERN_ISLE_CAUSEWAY.maxX && z >= WESTERN_ISLE_CAUSEWAY.minZ && z <= WESTERN_ISLE_CAUSEWAY.maxZ);
 }
+/* ------------------------------------------------------------------ *
+ * The timetable's constants.
+ * ------------------------------------------------------------------ */
+/** Every train counts from this instant (a fixed date, so a restart never moves a train). */
+export const WESTERN_TRAIN_EPOCH_MS = Date.UTC(2026, 9, 10, 0, 0, 0);
+/** Cruising speed (tiles a second) and the rate it gets up to it and slows from it. */
+export const WESTERN_TRAIN_TOP_SPEED = 6;
+export const WESTERN_TRAIN_ACCEL = 0.5;
+/** The bell rings this long before a departure; the step plates shut this long before it. */
+export const WESTERN_TRAIN_BELL_BEFORE_MS = 15_000;
+export const WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS = 5_000;
+/** The whistle and the bell are heard this far (tiles) from the loco. */
+export const WESTERN_TRAIN_SOUND_RANGE = 40;
+export const WESTERN_TRAIN_MOVING_TEXT = 'The train is moving.';
+export const WESTERN_TRAIN_DOORS_SHUT_TEXT = 'The doors are shut: the train is about to leave.';
+export const WESTERN_TRAIN_ABOARD_COMBAT_TEXT = 'There is no fighting aboard the train.';
+export const WESTERN_TRAIN_ALIGHT_MOVING_TEXT = 'The train is moving. Wait until it stops at the platform.';
+/** A stop's arriving announcement goes to its riders this long before the train stands there. */
+export const WESTERN_TRAIN_ANNOUNCE_BEFORE_MS = 10_000;
+export const WESTERN_TRAIN_MEMBERS_ONLY_TEXT = 'Only members may step off here. Stay aboard: the train runs on to the next stop.';
+export const WESTERN_BORE_A = {
+    id: 'bore-a',
+    x: WESTERN_TUNNEL_X,
+    z0: WESTERN_TUNNEL_START_Z,
+    length: WESTERN_TUNNEL_LENGTH,
+    halfWidth: WESTERN_TUNNEL_HALF_WIDTH,
+    floorHeight: WESTERN_TUNNEL_FLOOR_HEIGHT,
+    sconceEvery: WESTERN_TUNNEL_SCONCE_EVERY,
+    idPrefix: 'western-tunnel',
+};
+/** A bore's floor tiles, walls excluded (bore A's is WESTERN_TUNNEL_BOX). */
+export function westernBoreBox(bore) {
+    return { minX: bore.x - bore.halfWidth, maxX: bore.x + bore.halfWidth, minZ: bore.z0, maxZ: bore.z0 + bore.length - 1 };
+}
 const SURFACE_LENGTH = WESTERN_SEA_END.x - (WESTERN_TRACK.minX - 1) + 1; // x 199 to x 26 (the mouth tile): 174
 /** The spike's third leg: the isle causeway's sea end west to the tile in front of the stub's portal (102 tiles). */
 const ISLE_LENGTH = WESTERN_ISLE_SEA_END_X - (WESTERN_ISLE_MOUTH.x + 1) + 1;
 const ISLE_C0 = SURFACE_LENGTH + WESTERN_TUNNEL_LENGTH;
-export const WESTERN_TRAIN_SEGMENTS = [
-    { id: 'surface', c0: 0, length: SURFACE_LENGTH, x0: WESTERN_SEA_END.x, z0: WESTERN_TRACK_Z, dx: -1, dz: 0 },
-    { id: 'tunnel', c0: SURFACE_LENGTH, length: WESTERN_TUNNEL_LENGTH, x0: WESTERN_TUNNEL_X, z0: WESTERN_TUNNEL_START_Z, dx: 0, dz: 1 },
-    { id: 'isle', c0: ISLE_C0, length: ISLE_LENGTH, x0: WESTERN_ISLE_SEA_END_X, z0: WESTERN_ISLE_TRACK_Z, dx: -1, dz: 0 },
-];
 /** c of the nose when the train stands at the isle stub (the nose on the platform's west end, as at home). */
 export const WESTERN_ISLE_STOP_C = ISLE_C0 + (WESTERN_ISLE_SEA_END_X - WESTERN_ISLE_PLATFORM.minX);
-export const WESTERN_TRAIN_CIRCUIT_LENGTH = WESTERN_TRAIN_SEGMENTS.reduce((n, s) => n + s.length, 0);
 /** c of the nose when the train stands at the platform (loco's nose at x 30). */
 export const WESTERN_TRAIN_PLATFORM_C = WESTERN_SEA_END.x - WESTERN_TRAIN_NOSE_X;
+/** The surface leg's x range the rake is drawn on (the mouth hides it to the west, the sea to the east). */
+export const WESTERN_TRAIN_SURFACE_DRAW = { minX: 18, maxX: WESTERN_SEA_END.x + 8 };
 /** The lateral unit: the docked frame's +z (the sea side) for a leg heading (dx, dz). */
 function lateralOf(seg) {
     return { lx: seg.dz, lz: -seg.dx };
@@ -221,16 +256,256 @@ export function westernTrainSegmentYaw(seg) {
     // A model facing +z yawed by t faces (sin t, cos t); the docked heading (-1, 0) is t = -pi/2.
     return Math.atan2(seg.dx, seg.dz) + Math.PI / 2;
 }
-export function wrapWesternC(c) {
-    const n = WESTERN_TRAIN_CIRCUIT_LENGTH;
-    return ((c % n) + n) % n;
+/** Duration (ms) of a run of D tiles from a stop to a stop: up to speed, cruise, slow to a stand. */
+export function westernTrainRunMs(distance) {
+    const v = WESTERN_TRAIN_TOP_SPEED, a = WESTERN_TRAIN_ACCEL;
+    const ramp = (v * v) / a; // tiles spent getting up to speed and slowing again
+    const s = distance >= ramp ? distance / v + v / a : 2 * Math.sqrt(distance / a);
+    return s * 1000;
+}
+/** Tiles covered after t ms of a run of D tiles. */
+export function westernTrainRunTiles(distance, tMs) {
+    const v = WESTERN_TRAIN_TOP_SPEED, a = WESTERN_TRAIN_ACCEL;
+    const total = westernTrainRunMs(distance) / 1000;
+    const t = Math.max(0, Math.min(total, tMs / 1000));
+    const peak = Math.min(v, Math.sqrt(distance * a));
+    const ta = peak / a;
+    if (t <= ta)
+        return 0.5 * a * t * t;
+    if (t >= total - ta)
+        return distance - 0.5 * a * (total - t) ** 2;
+    return 0.5 * a * ta * ta + peak * (t - ta);
+}
+const wrapOn = (c, n) => ((c % n) + n) % n;
+function runningStops(stops) {
+    return stops.filter((s) => s.enabled).sort((a, b) => a.c - b.c);
+}
+function timetableOf(stops, length) {
+    const running = runningStops(stops);
+    const legs = [];
+    let t = 0;
+    running.forEach((stop, i) => {
+        const next = running[(i + 1) % running.length];
+        const runTiles = wrapOn(next.c - stop.c, length) || length;
+        const startMs = t;
+        const departMs = startMs + stop.dwellMs;
+        const endMs = departMs + westernTrainRunMs(runTiles);
+        legs.push({ stop, startMs, departMs, runTiles, endMs });
+        t = endMs;
+    });
+    return { cycleMs: t, legs };
+}
+/** 32-bit FNV-1a, hex: the circuit key's hash (stable across engines, no crypto needed). */
+function fnv1a(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
 }
-export function westernTrainSegmentAt(c) {
-    const w = wrapWesternC(c);
-    for (const seg of WESTERN_TRAIN_SEGMENTS)
+/**
+ * Build and check a circuit. Throws on a circuit the line cannot run: legs that are not unit steps along x or z, a
+ * surface leg not heading west (the causeway profile is the home line's), stops off the track or on the same c, no home
+ * stop or more than one, a home stop whose rake is not the docked frame itself, a train count outside 1-8.
+ */
+export function defineWesternCircuit(def) {
+    if (!Number.isInteger(def.version) || def.version < 1)
+        throw new Error(`circuit version ${def.version}: a whole number from 1`);
+    if (!Number.isInteger(def.trainCount) || def.trainCount < 1 || def.trainCount > 8)
+        throw new Error(`circuit v${def.version}: ${def.trainCount} trains (1-8)`);
+    if (def.segments.length === 0)
+        throw new Error(`circuit v${def.version}: no legs`);
+    let c0 = 0;
+    const segments = def.segments.map((s) => {
+        if (Math.abs(s.dx) + Math.abs(s.dz) !== 1 || !Number.isInteger(s.dx) || !Number.isInteger(s.dz))
+            throw new Error(`leg ${s.id}: not a unit step along x or z`);
+        if (!Number.isInteger(s.length) || s.length < 1)
+            throw new Error(`leg ${s.id}: length ${s.length}`);
+        if (s.kind === 'surface' && s.dx !== -1)
+            throw new Error(`leg ${s.id}: a surface leg heads west (the causeway profile)`);
+        if (s.kind === 'bore' && (!s.bore || s.dx !== 0 || s.x0 !== s.bore.x))
+            throw new Error(`leg ${s.id}: a bore leg runs down its bore's line`);
+        const seg = { ...s, c0, drawBefore: s.drawBefore ?? 4, drawAfter: s.drawAfter ?? 4 };
+        c0 += s.length;
+        return seg;
+    });
+    if (new Set(segments.map((s) => s.id)).size !== segments.length)
+        throw new Error(`circuit v${def.version}: two legs share an id`);
+    const length = c0;
+    const track = { segments, length };
+    const stops = def.stops.map((s) => ({ ...s }));
+    if (new Set(stops.map((s) => s.id)).size !== stops.length)
+        throw new Error(`circuit v${def.version}: two stops share an id`);
+    for (const s of stops)
+        if (!(s.c >= 0 && s.c < length))
+            throw new Error(`stop ${s.id}: c ${s.c} is off the track (0-${length - 1})`);
+    const running = runningStops(stops);
+    if (new Set(running.map((s) => s.c)).size !== running.length)
+        throw new Error(`circuit v${def.version}: two running stops on one c`);
+    const homes = stops.filter((s) => s.home);
+    if (homes.length !== 1 || !homes[0].enabled)
+        throw new Error(`circuit v${def.version}: exactly one home stop, running`);
+    const home = homes[0];
+    // The home stop's rake is the docked frame: standing there, every docked tile is its own world tile.
+    for (const [x, z] of [[WESTERN_TRAIN_RIDE_BOX.minX, WESTERN_TRAIN_RIDE_BOX.minZ], [WESTERN_TRAIN_RIDE_BOX.maxX, WESTERN_TRAIN_RIDE_BOX.maxZ]]) {
+        const w = riderTileOn(track, home.c, x, z);
+        if (w.x !== x || w.y !== z)
+            throw new Error(`circuit v${def.version}: the home stop's rake is not the docked frame`);
+    }
+    const homeLeg = segmentOn(track, home.c);
+    const timetable = timetableOf(stops, length);
+    const stopSteps = running.filter((s) => s.steps).flatMap((s) => stepsOn(track, s));
+    const bores = [];
+    for (const s of segments)
+        if (s.bore && !bores.includes(s.bore))
+            bores.push(s.bore);
+    const canon = JSON.stringify({
+        v: def.version,
+        n: def.trainCount,
+        clock: [WESTERN_TRAIN_EPOCH_MS, WESTERN_TRAIN_TOP_SPEED, WESTERN_TRAIN_ACCEL, WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS, WESTERN_TRAIN_NOSE_X, WESTERN_TRAIN_RAKE_LENGTH],
+        legs: segments.map((s) => [s.id, s.kind, s.c0, s.length, s.x0, s.z0, s.dx, s.dz, s.drawBefore, s.drawAfter,
+            s.bore ? [s.bore.id, s.bore.x, s.bore.z0, s.bore.length, s.bore.halfWidth, s.bore.floorHeight] : null]),
+        stops: stops.map((s) => [s.id, s.c, s.dwellMs, s.enabled, !!s.home, !!s.steps, s.stepPrefix ?? null, !!s.membersOnly]),
+    });
+    return {
+        version: def.version,
+        key: `v${def.version}-${fnv1a(canon)}`,
+        segments,
+        length,
+        stops,
+        trainCount: def.trainCount,
+        timetable,
+        home,
+        homeLeg,
+        stopSteps,
+        bores,
+    };
+}
+/* The position sums on a track (exported below with the server's circuit as their default). */
+function segmentOn(track, c) {
+    const w = wrapOn(c, track.length);
+    for (const seg of track.segments)
         if (w >= seg.c0 && w < seg.c0 + seg.length)
             return seg;
-    return WESTERN_TRAIN_SEGMENTS[0];
+    return track.segments[0];
+}
+function riderTileOn(track, noseC, dockedX, dockedZ) {
+    const c = westernDockedC(noseC, dockedX);
+    const p = westernTrainPointOn(segmentOn(track, c), wrapOn(c, track.length), dockedZ - WESTERN_TRACK_Z);
+    return { x: Math.round(p.x), y: Math.round(p.z) };
+}
+function stepsOn(track, stop) {
+    return WESTERN_STEPS.map((s) => {
+        const plate = riderTileOn(track, stop.c, s.x, s.z);
+        return {
+            stopId: stop.id,
+            car: s.car,
+            id: `${stop.stepPrefix ?? `${stop.id}-step`}-${s.car}`,
+            x: plate.x,
+            z: plate.y,
+            platform: riderTileOn(track, stop.c, s.platform[0], s.platform[1]),
+            doorway: { x: s.doorway[0], y: s.doorway[1] },
+        };
+    });
+}
+/**
+ * VERSION 1: the line as it ran from 2026-10-10 (the moving train) and 2026-10-10 (Lantern Wake): the home platform's
+ * surface leg, bore A south under the sea, Lantern Wake's leg west into its rock cap, two trains. Frozen: never edit.
+ */
+export const WESTERN_TRAIN_CIRCUIT_V1 = defineWesternCircuit({
+    version: 1,
+    trainCount: 2,
+    segments: [
+        {
+            id: 'surface', kind: 'surface', length: SURFACE_LENGTH, x0: WESTERN_SEA_END.x, z0: WESTERN_TRACK_Z, dx: -1, dz: 0,
+            cover: { area: 'western-line', title: 'The Western Entrance' },
+            // The mouth hides the rake to the west, the sea to the east (WESTERN_TRAIN_SURFACE_DRAW, in tiles along the leg).
+            drawBefore: WESTERN_TRAIN_SURFACE_DRAW.maxX - WESTERN_SEA_END.x,
+            drawAfter: WESTERN_SEA_END.x - WESTERN_TRAIN_SURFACE_DRAW.minX - SURFACE_LENGTH,
+        },
+        {
+            id: 'tunnel', kind: 'bore', bore: WESTERN_BORE_A, length: WESTERN_TUNNEL_LENGTH, x0: WESTERN_TUNNEL_X, z0: WESTERN_TUNNEL_START_Z, dx: 0, dz: 1,
+            cover: { area: 'western-line', title: 'Under the sea' },
+        },
+        {
+            id: 'isle', kind: 'surface', length: ISLE_LENGTH, x0: WESTERN_ISLE_SEA_END_X, z0: WESTERN_ISLE_TRACK_Z, dx: -1, dz: 0,
+            // Coming up into the Western Kingdoms: the land's own title card (a small train over its name, phase 1b).
+            cover: { area: 'western-kingdoms-train' },
+        },
+    ],
+    stops: [
+        { id: 'platform', name: 'The Western Entrance', c: WESTERN_TRAIN_PLATFORM_C, dwellMs: 60_000, enabled: true, home: true, note: 'The platform on the headland: boarding by the step plates.' },
+        // Lantern Wake, the Western Kingdoms' first stop (phase 0c's stub, made the real station in phase 1c-1; types
+        // lanternWake.ts). The id stays 'western-isle' so nothing keyed on it moves.
+        { id: 'western-isle', name: 'Lantern Wake', c: WESTERN_ISLE_STOP_C, dwellMs: 30_000, enabled: true, steps: true, stepPrefix: 'lw-station-step', note: "Lantern Wake: the Western Kingdoms' first stop, the station on the south-east bay where the train climbs out of the sea." },
+    ],
+});
+/** Every circuit this build knows, oldest first: a client follows whichever of them its server runs. */
+export const WESTERN_TRAIN_CIRCUITS = [WESTERN_TRAIN_CIRCUIT_V1];
+/** The circuit this build's SERVER runs (the client's default before the server has said). */
+export const WESTERN_TRAIN_CIRCUIT = WESTERN_TRAIN_CIRCUIT_V1;
+/** Every bore of every known circuit (lighting and sounds: a bore the server has not cut is never reached). */
+export const WESTERN_BORES = (() => {
+    const out = [];
+    for (const c of WESTERN_TRAIN_CIRCUITS)
+        for (const b of c.bores)
+            if (!out.some((o) => o.id === b.id))
+                out.push(b);
+    return out;
+})();
+/** In a bore (its floor or its wall tiles), of every known circuit or the bores given. */
+export function inWesternBore(x, z, bores = WESTERN_BORES) {
+    for (const b of bores) {
+        const B = westernBoreBox(b);
+        if (x >= B.minX - 1 && x <= B.maxX + 1 && z >= B.minZ - 1 && z <= B.maxZ + 1)
+            return true;
+    }
+    return false;
+}
+/** The version a key names (`v3-...` is 3), or null for a key that is not one. */
+export function westernCircuitVersionOf(key) {
+    const m = typeof key === 'string' ? /^v(\d+)-[0-9a-f]{8}$/.exec(key) : null;
+    return m ? Number(m[1]) : null;
+}
+/**
+ * The circuit a server runs, from the key it sent: no key is a server from before the version (slice 2-0), which runs
+ * version 1; a key this build knows is that circuit; anything else is null (a newer server than this page, or a circuit
+ * changed without a new version): the client then draws no moving train and asks for a reload.
+ */
+export function westernCircuitForKey(key, known = WESTERN_TRAIN_CIRCUITS) {
+    if (key === undefined || key === null || key === '')
+        return known.find((c) => c.version === 1) ?? null;
+    return known.find((c) => c.key === key) ?? null;
+}
+/**
+ * How this build stands with the server's circuit: `same` (the one it would run), `older` (the server runs an older
+ * circuit this build still knows: follow it), `newer` (the server runs a later version than any this build knows: reload),
+ * `unknown` (a version this build knows with different numbers: someone changed a circuit without a new version).
+ */
+export function westernCircuitAgreement(key, own = WESTERN_TRAIN_CIRCUIT, known = WESTERN_TRAIN_CIRCUITS) {
+    const circuit = westernCircuitForKey(key, known);
+    if (circuit)
+        return { status: circuit.key === own.key ? 'same' : circuit.version < own.version ? 'older' : 'newer', circuit };
+    const v = westernCircuitVersionOf(key);
+    const top = Math.max(0, ...known.map((c) => c.version));
+    return { status: v !== null && v > top ? 'newer' : 'unknown', circuit: null };
+}
+/** What a client tells its player when it cannot follow the server's circuit. */
+export const WESTERN_TRAIN_RELOAD_TEXT = 'The Western Line has changed since this page loaded. Reload the page to see the trains.';
+/* The server's circuit, as the constants the line has always had (code that must follow the SERVER's circuit on the
+ * client passes the circuit it was sent instead of reading these). */
+export const WESTERN_TRAIN_SEGMENTS = WESTERN_TRAIN_CIRCUIT.segments;
+export const WESTERN_TRAIN_CIRCUIT_LENGTH = WESTERN_TRAIN_CIRCUIT.length;
+/** How many trains run the circuit, evenly spaced in time (James: "1-3 trains running constantly"). */
+export const WESTERN_TRAIN_COUNT = WESTERN_TRAIN_CIRCUIT.trainCount;
+export const WESTERN_TRAIN_STOPS = WESTERN_TRAIN_CIRCUIT.stops;
+export const WESTERN_TRAIN_CYCLE_MS = WESTERN_TRAIN_CIRCUIT.timetable.cycleMs;
+export function wrapWesternC(c, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return wrapOn(c, circuit.length);
+}
+export function westernTrainSegmentAt(c, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return segmentOn(circuit, c);
 }
 /** A point on a leg (c may run past its ends: the client extrapolates a piece into the sea or the rock). */
 export function westernTrainPointOn(seg, c, lateral) {
@@ -239,24 +514,23 @@ export function westernTrainPointOn(seg, c, lateral) {
     return { x: seg.x0 + seg.dx * along + lx * lateral, z: seg.z0 + seg.dz * along + lz * lateral };
 }
 /** The world point of track coordinate c (wrapped) and a lateral offset (docked z - track z). */
-export function westernTrainWorldPoint(c, lateral) {
-    const segment = westernTrainSegmentAt(c);
-    return { ...westernTrainPointOn(segment, wrapWesternC(c), lateral), segment };
+export function westernTrainWorldPoint(c, lateral, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const segment = segmentOn(circuit, c);
+    return { ...westernTrainPointOn(segment, wrapOn(c, circuit.length), lateral), segment };
 }
-/** The ground under the track at c on a leg (terrain steps; the causeway steps down to the waterline, then the sea). */
+/** The ground under the track at c on a leg: a bore's floor, or the causeway stepping down to the waterline, then the sea. */
 export function westernTrainGroundHeight(seg, c) {
-    if (seg.id === 'tunnel')
-        return WESTERN_TUNNEL_FLOOR_HEIGHT;
+    if (seg.kind === 'bore')
+        return seg.bore?.floorHeight ?? WESTERN_TUNNEL_FLOOR_HEIGHT;
+    // A surface leg comes up out of the sea at its x0 (heading west) and climbs the home line's causeway, moved along x.
     const x = seg.x0 + seg.dx * (c - seg.c0);
-    // Both open-air legs come up out of the sea at their x0 and climb a causeway to the station's ground.
-    const isle = seg.id === 'isle';
-    const seaEnd = isle ? WESTERN_ISLE_SEA_END_X : WESTERN_SEA_END.x;
-    const causewayFrom = isle ? WESTERN_ISLE_CAUSEWAY.minX : WESTERN_CAUSEWAY.minX;
-    const causeway = isle ? westernIsleCausewayHeight : westernCausewayHeight;
+    const seaEnd = seg.x0;
+    const shift = seaEnd - WESTERN_SEA_END.x;
+    const causewayFrom = WESTERN_CAUSEWAY.minX + shift;
     if (x > seaEnd)
         return -(x - seaEnd) * 1.4; // under the sea past the line's end
     const lo = Math.floor(x), t = x - lo;
-    const h = (xi) => (xi >= causewayFrom ? causeway(Math.min(xi, seaEnd)) : WESTERN_PRECINCT_HEIGHT);
+    const h = (xi) => (xi >= causewayFrom ? westernCausewayHeight(Math.min(xi, seaEnd) - shift) : WESTERN_PRECINCT_HEIGHT);
     return h(lo) * (1 - t) + h(lo + 1) * t;
 }
 /** Metres: the deck a rider stands on at c (the ground plus the kit's deck height). */
@@ -268,195 +542,208 @@ export function westernDockedC(noseC, dockedX) {
     return noseC - (dockedX - WESTERN_TRAIN_NOSE_X);
 }
 /** The world tile of a docked tile when the nose stands at integer c (the server's step). */
-export function westernRiderWorldTile(noseC, dockedX, dockedZ) {
-    const p = westernTrainWorldPoint(westernDockedC(noseC, dockedX), dockedZ - WESTERN_TRACK_Z);
-    return { x: Math.round(p.x), y: Math.round(p.z) };
+export function westernRiderWorldTile(noseC, dockedX, dockedZ, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return riderTileOn(circuit, noseC, dockedX, dockedZ);
 }
 /**
  * A world tile back to the docked frame of a train whose nose is at c (a rider's click on the moving deck), or null when
  * the tile is not on the rake.
  */
-export function westernWorldToDocked(noseC, x, z) {
-    for (const seg of WESTERN_TRAIN_SEGMENTS) {
+export function westernWorldToDocked(noseC, x, z, circuit = WESTERN_TRAIN_CIRCUIT) {
+    for (const seg of circuit.segments) {
         const { lx, lz } = lateralOf(seg);
         const along = (x - seg.x0) * seg.dx + (z - seg.z0) * seg.dz;
         const lateral = (x - seg.x0) * lx + (z - seg.z0) * lz;
         if (along < 0 || along >= seg.length || Math.abs(lateral) > WESTERN_TRAIN_HALF_ACROSS)
             continue;
-        const behind = wrapWesternC(noseC - (seg.c0 + along));
+        const behind = wrapOn(noseC - (seg.c0 + along), circuit.length);
         if (behind > WESTERN_TRAIN_RAKE_LENGTH - 1)
             continue;
         return { x: WESTERN_TRAIN_NOSE_X + behind, y: WESTERN_TRACK_Z + lateral };
     }
     return null;
 }
+/** The compass side of the track a stop's platform is on (the docked platform side, turned with the leg). */
+export function westernStopPlatformSide(stop, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const { lx, lz } = lateralOf(segmentOn(circuit, stop.c));
+    // The platform is lateral -1.
+    if (-lz < 0)
+        return 'north';
+    if (-lz > 0)
+        return 'south';
+    return -lx > 0 ? 'east' : 'west';
+}
+/** How far (tiles, Chebyshev) a rider may be carried in one step before it counts as a jump needing the cover: the view ring. */
+export const WESTERN_TRAIN_JUMP_TILES = CHUNK_VIEW_RADIUS * CHUNK_SIZE;
+/**
+ * A rider's tile carried from one server step to the next: a JUMP (the loading cover first) when it lands in another
+ * region of the grid OR farther than the view ring (two bores in the same region, slice 2-0), with the cover of the leg
+ * it lands on; null for an ordinary step.
+ */
+export function westernRiderJump(prevNoseStep, noseStep, dockedX, dockedZ, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const from = riderTileOn(circuit, prevNoseStep, dockedX, dockedZ);
+    const to = riderTileOn(circuit, noseStep, dockedX, dockedZ);
+    const far = Math.max(Math.abs(to.x - from.x), Math.abs(to.y - from.y)) > WESTERN_TRAIN_JUMP_TILES;
+    if (!far && worldRegionAt(from.x) === worldRegionAt(to.x))
+        return null;
+    const segment = segmentOn(circuit, westernDockedC(noseStep, dockedX));
+    return { from, to, segment, cover: segment.cover };
+}
 /* ------------------------------------------------------------------ *
  * The timetable.
  * ------------------------------------------------------------------ */
-/** Every train counts from this instant (a fixed date, so a restart never moves a train). */
-export const WESTERN_TRAIN_EPOCH_MS = Date.UTC(2026, 9, 10, 0, 0, 0);
-/** How many trains run the circuit, evenly spaced in time (James: "1-3 trains running constantly"). */
-export const WESTERN_TRAIN_COUNT = 2;
-/** Cruising speed (tiles a second) and the rate it gets up to it and slows from it. */
-export const WESTERN_TRAIN_TOP_SPEED = 6;
-export const WESTERN_TRAIN_ACCEL = 0.5;
-/** The bell rings this long before a departure; the step plates shut this long before it. */
-export const WESTERN_TRAIN_BELL_BEFORE_MS = 15_000;
-export const WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS = 5_000;
-/** The whistle and the bell are heard this far (tiles) from the loco. */
-export const WESTERN_TRAIN_SOUND_RANGE = 40;
-export const WESTERN_TRAIN_MOVING_TEXT = 'The train is moving.';
-export const WESTERN_TRAIN_DOORS_SHUT_TEXT = 'The doors are shut: the train is about to leave.';
-export const WESTERN_TRAIN_ABOARD_COMBAT_TEXT = 'There is no fighting aboard the train.';
-export const WESTERN_TRAIN_ALIGHT_MOVING_TEXT = 'The train is moving. Wait until it stops at the platform.';
-export const WESTERN_TRAIN_STOPS = [
-    { id: 'platform', name: 'The Western Entrance', c: WESTERN_TRAIN_PLATFORM_C, dwellMs: 60_000, enabled: true, note: 'The platform on the headland: boarding by the step plates.' },
-    // Lantern Wake, the Western Kingdoms' first stop (phase 0c's stub, made the real station in phase 1c-1; types
-    // lanternWake.ts). The id stays 'western-isle' so nothing keyed on it moves.
-    { id: 'western-isle', name: 'Lantern Wake', c: WESTERN_ISLE_STOP_C, dwellMs: 30_000, enabled: true, steps: true, stepPrefix: 'lw-station-step', note: "Lantern Wake: the Western Kingdoms' first stop, the station on the south-east bay where the train climbs out of the sea." },
-    { id: 'dwarf-hold', name: 'The Dwarf Hold', c: SURFACE_LENGTH + 300, dwellMs: 45_000, enabled: false, note: 'An underground dwarf dungeon beside the bore; its exit is blocked for now.' },
-    { id: 'capital', name: 'The Capital', c: SURFACE_LENGTH + 450, dwellMs: 60_000, enabled: false, note: 'Not reachable by a surface line (the city is ~900 rows north); needs an underground halt on this bore and a stair or lift from the city.' },
-];
-/** Duration (ms) of a run of D tiles from a stop to a stop: up to speed, cruise, slow to a stand. */
-export function westernTrainRunMs(distance) {
-    const v = WESTERN_TRAIN_TOP_SPEED, a = WESTERN_TRAIN_ACCEL;
-    const ramp = (v * v) / a; // tiles spent getting up to speed and slowing again
-    const s = distance >= ramp ? distance / v + v / a : 2 * Math.sqrt(distance / a);
-    return s * 1000;
-}
-/** Tiles covered after t ms of a run of D tiles. */
-export function westernTrainRunTiles(distance, tMs) {
-    const v = WESTERN_TRAIN_TOP_SPEED, a = WESTERN_TRAIN_ACCEL;
-    const total = westernTrainRunMs(distance) / 1000;
-    const t = Math.max(0, Math.min(total, tMs / 1000));
-    const peak = Math.min(v, Math.sqrt(distance * a));
-    const ta = peak / a;
-    if (t <= ta)
-        return 0.5 * a * t * t;
-    if (t >= total - ta)
-        return distance - 0.5 * a * (total - t) ** 2;
-    return 0.5 * a * ta * ta + peak * (t - ta);
-}
 /** The cycle: for each running stop in order, its dwell then the run to the next running stop (wrapping). */
-export function westernTrainTimetable(stops = WESTERN_TRAIN_STOPS) {
-    const running = stops.filter((s) => s.enabled).sort((a, b) => a.c - b.c);
-    const legs = [];
-    let t = 0;
-    running.forEach((stop, i) => {
-        const next = running[(i + 1) % running.length];
-        const runTiles = wrapWesternC(next.c - stop.c) || WESTERN_TRAIN_CIRCUIT_LENGTH;
-        const startMs = t;
-        const departMs = startMs + stop.dwellMs;
-        const endMs = departMs + westernTrainRunMs(runTiles);
-        legs.push({ stop, startMs, departMs, runTiles, endMs });
-        t = endMs;
-    });
-    return { cycleMs: t, legs };
+export function westernTrainTimetable(stops = WESTERN_TRAIN_CIRCUIT.stops, length = WESTERN_TRAIN_CIRCUIT.length) {
+    return timetableOf(stops, length);
 }
-const TIMETABLE = westernTrainTimetable();
-export const WESTERN_TRAIN_CYCLE_MS = TIMETABLE.cycleMs;
-/** Is any piece of the rake on the surface leg with the nose at c? */
-function rakeOnSurface(noseC) {
-    const surface = WESTERN_TRAIN_SEGMENTS[0];
+/** Is any piece of the rake on the leg with the nose at c? */
+function rakeOnLeg(noseC, leg) {
     const tail = noseC - (WESTERN_TRAIN_RAKE_LENGTH - 1);
-    return noseC >= surface.c0 && tail < surface.c0 + surface.length;
+    return noseC >= leg.c0 && tail < leg.c0 + leg.length;
 }
-/** Where train `train` (0-based) is at server time `nowMs`. */
-export function westernTrainAt(nowMs, train = 0, timetable = TIMETABLE) {
+/** Where train `train` (0-based) is at server time `nowMs`, on a circuit (the server's by default). */
+export function westernTrainAt(nowMs, train = 0, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const timetable = circuit.timetable;
+    const home = circuit.home;
     const cycle = timetable.cycleMs;
-    const offset = (train * cycle) / WESTERN_TRAIN_COUNT;
+    const offset = (train * cycle) / circuit.trainCount;
     const t = (((nowMs - WESTERN_TRAIN_EPOCH_MS + offset) % cycle) + cycle) % cycle;
-    const platform = timetable.legs.find((l) => l.stop.id === 'platform');
-    const msToPlatform = platform ? ((platform.startMs - t) % cycle + cycle) % cycle : 0;
-    for (const leg of timetable.legs) {
+    const homeLeg = timetable.legs.find((l) => l.stop.id === home.id);
+    const msToPlatform = homeLeg ? ((homeLeg.startMs - t) % cycle + cycle) % cycle : 0;
+    const legs = timetable.legs;
+    for (let i = 0; i < legs.length; i++) {
+        const leg = legs[i];
         if (t < leg.startMs || t >= leg.endMs)
             continue;
         if (t < leg.departMs) {
-            const noseC = wrapWesternC(leg.stop.c);
+            const noseC = wrapOn(leg.stop.c, circuit.length);
+            const atHome = leg.stop.id === home.id;
             return {
                 train, noseC, noseStep: Math.floor(noseC), moving: false,
-                phase: leg.stop.id === 'platform' ? 'boarding' : 'away',
+                phase: atHome ? 'boarding' : 'away',
                 stopId: leg.stop.id, msToDepart: leg.departMs - t,
-                msToPlatform: leg.stop.id === 'platform' ? 0 : msToPlatform, cycleMs: t,
+                msToPlatform: atHome ? 0 : msToPlatform, cycleMs: t,
+                nextStopId: leg.stop.id, msToNextStop: 0,
             };
         }
         const ran = westernTrainRunTiles(leg.runTiles, t - leg.departMs);
-        const noseC = wrapWesternC(leg.stop.c + ran);
-        const onSurface = rakeOnSurface(noseC);
+        const noseC = wrapOn(leg.stop.c + ran, circuit.length);
+        const onHomeLeg = rakeOnLeg(noseC, circuit.homeLeg);
         // The last instant of a run into the platform is still the approach (its noseC lands exactly on the platform's c).
         const arriving = leg.runTiles - ran < 0.5;
-        const phase = !onSurface ? 'away' : noseC < WESTERN_TRAIN_PLATFORM_C || arriving ? 'approaching' : 'departing';
-        return { train, noseC, noseStep: Math.floor(noseC), moving: true, phase, stopId: null, msToDepart: null, msToPlatform, cycleMs: t };
+        const phase = !onHomeLeg ? 'away' : noseC < home.c || arriving ? 'approaching' : 'departing';
+        const next = legs[(i + 1) % legs.length];
+        return {
+            train, noseC, noseStep: Math.floor(noseC), moving: true, phase, stopId: null, msToDepart: null, msToPlatform, cycleMs: t,
+            nextStopId: next.stop.id, msToNextStop: leg.endMs - t,
+        };
     }
     // Rounding at the cycle's very end: treat as the first leg's start.
     const first = timetable.legs[0];
+    const atHome = first.stop.id === home.id;
     return {
-        train, noseC: wrapWesternC(first.stop.c), noseStep: Math.floor(wrapWesternC(first.stop.c)), moving: false,
-        phase: first.stop.id === 'platform' ? 'boarding' : 'away', stopId: first.stop.id, msToDepart: first.stop.dwellMs,
-        msToPlatform: 0, cycleMs: 0,
+        train, noseC: wrapOn(first.stop.c, circuit.length), noseStep: Math.floor(wrapOn(first.stop.c, circuit.length)), moving: false,
+        phase: atHome ? 'boarding' : 'away', stopId: first.stop.id, msToDepart: first.stop.dwellMs,
+        msToPlatform: 0, cycleMs: 0, nextStopId: first.stop.id, msToNextStop: 0,
     };
 }
-/** The train standing at the platform at `nowMs`, or null. */
-export function westernTrainAtPlatform(nowMs) {
-    for (let i = 0; i < WESTERN_TRAIN_COUNT; i++) {
-        const s = westernTrainAt(nowMs, i);
+/** Every train of a circuit at `nowMs`. */
+export function westernTrainsAt(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return Array.from({ length: circuit.trainCount }, (_, i) => westernTrainAt(nowMs, i, circuit));
+}
+/** The stop a train stands at, or the next running stop it reaches. */
+export function westernNextStop(state, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return circuit.stops.find((s) => s.id === state.nextStopId) ?? null;
+}
+/** The running stop after this one (wrapping). */
+export function westernStopAfter(stopId, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const running = runningStops(circuit.stops);
+    const i = running.findIndex((s) => s.id === stopId);
+    return i < 0 ? null : running[(i + 1) % running.length];
+}
+/** A stop's name as said mid-sentence ("for the Western Entrance"). */
+export function westernStopNamePhrase(stop) {
+    return stop.name.startsWith('The ') ? `the ${stop.name.slice(4)}` : stop.name;
+}
+/**
+ * The closest two trains come on a circuit (tiles from one's nose to the tail ahead of it, along the line), sampled over
+ * a cycle; Infinity with one train. The line's own test wants at least 20.
+ */
+export function westernTrainMinGap(circuit = WESTERN_TRAIN_CIRCUIT, stepMs = 100) {
+    let minGap = Infinity;
+    const L = circuit.length;
+    for (let t = 0; t < circuit.timetable.cycleMs; t += stepMs) {
+        const states = westernTrainsAt(WESTERN_TRAIN_EPOCH_MS + t, circuit);
+        for (const a of states)
+            for (const b of states) {
+                if (a === b)
+                    continue;
+                const gap = wrapOn(a.noseC - (WESTERN_TRAIN_RAKE_LENGTH - 1) - b.noseC, L);
+                if (gap < L / 2)
+                    minGap = Math.min(minGap, gap);
+            }
+    }
+    return minGap;
+}
+/** The train standing at the home platform at `nowMs`, or null. */
+export function westernTrainAtPlatform(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    for (let i = 0; i < circuit.trainCount; i++) {
+        const s = westernTrainAt(nowMs, i, circuit);
         if (s.phase === 'boarding')
             return s;
     }
     return null;
 }
 /** Ms until the next train stands at the platform (0 if one is there). */
-export function westernTrainNextArrivalMs(nowMs) {
+export function westernTrainNextArrivalMs(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
     let best = Infinity;
-    for (let i = 0; i < WESTERN_TRAIN_COUNT; i++)
-        best = Math.min(best, westernTrainAt(nowMs, i).msToPlatform);
+    for (let i = 0; i < circuit.trainCount; i++)
+        best = Math.min(best, westernTrainAt(nowMs, i, circuit).msToPlatform);
     return best;
 }
 /** The refusal text for the step plates while no train can be boarded. */
-export function westernTrainNoBoardingText(nowMs) {
-    const here = westernTrainAtPlatform(nowMs);
+export function westernTrainNoBoardingText(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const here = westernTrainAtPlatform(nowMs, circuit);
     if (here)
         return WESTERN_TRAIN_DOORS_SHUT_TEXT;
-    for (let i = 0; i < WESTERN_TRAIN_COUNT; i++) {
-        const s = westernTrainAt(nowMs, i);
+    for (let i = 0; i < circuit.trainCount; i++) {
+        const s = westernTrainAt(nowMs, i, circuit);
         if (s.phase === 'approaching' || s.phase === 'departing')
             return WESTERN_TRAIN_MOVING_TEXT;
     }
-    const secs = Math.max(1, Math.round(westernTrainNextArrivalMs(nowMs) / 1000));
+    const secs = Math.max(1, Math.round(westernTrainNextArrivalMs(nowMs, circuit) / 1000));
     return `No train stands at the platform. The next one is due in about ${secs} seconds.`;
 }
 /**
  * The station's word on the next train (the station hub, 2026-10-10: the All Aboard board's click and the station
  * master's "Next train?"): a train standing with its doors open, shut, or the next one due.
  */
-export function westernStationNextTrainText(nowMs) {
-    const here = westernTrainAtPlatform(nowMs);
+export function westernStationNextTrainText(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const here = westernTrainAtPlatform(nowMs, circuit);
     if (here) {
         const secs = Math.round(((here.msToDepart ?? 0) - WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS) / 1000);
         return secs >= 1
             ? `A train is standing at the platform: its doors shut in about ${secs} seconds.`
             : 'A train is standing at the platform, but its doors are shut: it is about to leave.';
     }
-    const secs = Math.max(1, Math.round(westernTrainNextArrivalMs(nowMs) / 1000));
+    const secs = Math.max(1, Math.round(westernTrainNextArrivalMs(nowMs, circuit) / 1000));
     return `The next train is due at the platform in about ${secs} seconds.`;
 }
 const COUNT_WORDS = ['No', 'One', 'Two', 'Three', 'Four'];
 /** What the All Aboard board says: the line's rules from the timetable, then the next train. */
-export function westernStationNoticeText(nowMs) {
-    const dwell = Math.round((WESTERN_TRAIN_STOPS.find((s) => s.id === 'platform')?.dwellMs ?? 0) / 1000);
-    const every = Math.round(WESTERN_TRAIN_CYCLE_MS / WESTERN_TRAIN_COUNT / 1000);
-    const trains = COUNT_WORDS[WESTERN_TRAIN_COUNT] ?? String(WESTERN_TRAIN_COUNT);
+export function westernStationNoticeText(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const dwell = Math.round(circuit.home.dwellMs / 1000);
+    const every = Math.round(circuit.timetable.cycleMs / circuit.trainCount / 1000);
+    const trains = COUNT_WORDS[circuit.trainCount] ?? String(circuit.trainCount);
     return `ALL ABOARD the Western Line. ${trains} trains run the loop under the sea, one about every ${every} seconds, and each stands ${dwell} seconds at the platform. ` +
         `Board by the brass step plates while a train stands; the doors shut ${WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS / 1000} seconds before it leaves. No fighting aboard. No fares while the line is new. ` +
-        westernStationNextTrainText(nowMs);
+        westernStationNextTrainText(nowMs, circuit);
 }
 /** Can the step plates be used at `nowMs` (a train standing, more than the shut time to go)? */
-export function westernTrainDoorsOpen(nowMs) {
-    const here = westernTrainAtPlatform(nowMs);
+export function westernTrainDoorsOpen(nowMs, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const here = westernTrainAtPlatform(nowMs, circuit);
     return !!here && (here.msToDepart ?? 0) > WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS;
 }
-/** The surface leg's x range the rake is drawn on (the mouth hides it to the west, the sea to the east). */
-export const WESTERN_TRAIN_SURFACE_DRAW = { minX: 18, maxX: WESTERN_SEA_END.x + 8 };
 /** The platform tile in front of the nearest step plate to a docked x (where someone left on the docked rake is put). */
 export function westernPlatformTileNear(x) {
     let best = WESTERN_STEPS[0];
@@ -465,54 +752,44 @@ export function westernPlatformTileNear(x) {
             best = s;
     return { x: best.platform[0], y: best.platform[1] };
 }
-export function westernStopSteps(stop) {
-    return WESTERN_STEPS.map((s) => {
-        const plate = westernRiderWorldTile(stop.c, s.x, s.z);
-        return {
-            stopId: stop.id,
-            car: s.car,
-            id: `${stop.stepPrefix ?? `${stop.id}-step`}-${s.car}`,
-            x: plate.x,
-            z: plate.y,
-            platform: westernRiderWorldTile(stop.c, s.platform[0], s.platform[1]),
-            doorway: { x: s.doorway[0], y: s.doorway[1] },
-        };
-    });
+export function westernStopSteps(stop, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return stepsOn(circuit, stop);
 }
-/** Every running stop's own plates (not the home platform's). */
-export const WESTERN_STOP_STEPS = WESTERN_TRAIN_STOPS.filter((s) => s.enabled && s.steps).flatMap(westernStopSteps);
-export function westernStopStepAt(x, z) {
-    return WESTERN_STOP_STEPS.find((s) => s.x === x && s.z === z) ?? null;
+/** Every running stop's own plates (not the home platform's), on the server's circuit. */
+export const WESTERN_STOP_STEPS = WESTERN_TRAIN_CIRCUIT.stopSteps;
+export function westernStopStepAt(x, z, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return circuit.stopSteps.find((s) => s.x === x && s.z === z) ?? null;
 }
-export function westernStopStepById(id) {
-    return WESTERN_STOP_STEPS.find((s) => s.id === id) ?? null;
+export function westernStopStepById(id, circuit = WESTERN_TRAIN_CIRCUIT) {
+    return circuit.stopSteps.find((s) => s.id === id) ?? null;
 }
 /** The train standing at a stop (not the home platform) at `nowMs`, or null. */
-export function westernTrainAtStop(nowMs, stopId) {
-    for (let i = 0; i < WESTERN_TRAIN_COUNT; i++) {
-        const s = westernTrainAt(nowMs, i);
+export function westernTrainAtStop(nowMs, stopId, circuit = WESTERN_TRAIN_CIRCUIT) {
+    for (let i = 0; i < circuit.trainCount; i++) {
+        const s = westernTrainAt(nowMs, i, circuit);
         if (!s.moving && s.stopId === stopId)
             return s;
     }
     return null;
 }
 /** The train at a stop with its doors open (more than the shut time to go), or null. */
-export function westernStopDoorsOpen(nowMs, stopId) {
-    const s = westernTrainAtStop(nowMs, stopId);
+export function westernStopDoorsOpen(nowMs, stopId, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const s = westernTrainAtStop(nowMs, stopId, circuit);
     return s && (s.msToDepart ?? 0) > WESTERN_TRAIN_DOORS_SHUT_BEFORE_MS ? s : null;
 }
 /**
  * Ms until the next train stands at a stop (0 while one stands there), from the timetable; Infinity for a stop that is
  * not running. The station master's sum for the home platform is westernTrainNextArrivalMs.
  */
-export function westernStopNextArrivalMs(nowMs, stopId, timetable = TIMETABLE) {
+export function westernStopNextArrivalMs(nowMs, stopId, circuit = WESTERN_TRAIN_CIRCUIT) {
+    const timetable = circuit.timetable;
     const leg = timetable.legs.find((l) => l.stop.id === stopId);
     if (!leg)
         return Infinity;
     const cycle = timetable.cycleMs;
     let best = Infinity;
-    for (let i = 0; i < WESTERN_TRAIN_COUNT; i++) {
-        const offset = (i * cycle) / WESTERN_TRAIN_COUNT;
+    for (let i = 0; i < circuit.trainCount; i++) {
+        const offset = (i * cycle) / circuit.trainCount;
         const t = (((nowMs - WESTERN_TRAIN_EPOCH_MS + offset) % cycle) + cycle) % cycle;
         if (t >= leg.startMs && t < leg.departMs)
             return 0;
@@ -521,10 +798,27 @@ export function westernStopNextArrivalMs(nowMs, stopId, timetable = TIMETABLE) {
     return best;
 }
 /** Why a stop's plates refuse at `nowMs`. */
-export function westernStopNoBoardingText(nowMs, stopId) {
-    if (westernTrainAtStop(nowMs, stopId))
+export function westernStopNoBoardingText(nowMs, stopId, circuit = WESTERN_TRAIN_CIRCUIT) {
+    if (westernTrainAtStop(nowMs, stopId, circuit))
         return WESTERN_TRAIN_DOORS_SHUT_TEXT;
-    const stop = WESTERN_TRAIN_STOPS.find((s) => s.id === stopId);
+    const stop = circuit.stops.find((s) => s.id === stopId);
     return `No train stands at ${stop?.name ?? 'this platform'}.`;
 }
+/**
+ * A stop of any known circuit whose closed pocket (a hall reached only by its train) holds this tile and which the given
+ * circuit does not run: someone saved there wakes at home (the stop was switched off, or the server runs an older circuit).
+ */
+export function westernClosedPocketAt(x, z, circuit = WESTERN_TRAIN_CIRCUIT, known = WESTERN_TRAIN_CIRCUITS) {
+    for (const c of [circuit, ...known]) {
+        for (const s of c.stops) {
+            const p = s.pocket;
+            if (!p || x < p.minX || x > p.maxX || z < p.minZ || z > p.maxZ)
+                continue;
+            if (circuit.stops.some((r) => r.id === s.id && r.enabled))
+                continue;
+            return s;
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=westernTrain.js.map