v0.4.9h — a leg that is part of the row, the deck the sheet prints, and regions not miles per hour

The 0.4.9 line's port of v0.7.2, minus Gitea#18: the Division map redraw is a multiplayer redesign and does not belong in a build people are mid-playtest on. Gitea#17 — a 45° leg is an end of the west-to-east row, so backing into a cut through a curve's south leg no longer couples it back to front, and a crew pulling out through a leg takes its own cut with it. Gitea#14 — every count is docs/Deck cards5.xlsx, including removing the Q12 office doubling and the Gap 12 industry tripling. Gitea#15 — RAR reversed it: the placement is legal; what must hold is that no train crosses the gap. Gitea#3 — the printed speeds are scenery. One Stage per printed region, and where a train starts is what varies.
2026-08-26 15:21:49 -04:00
parent f684c60f2e
commit e9683cc8c5
22 changed files with 4079 additions and 3055 deletions
@@ -40,3 +40,14 @@ __pycache__/
 # website's replay viewer. It was therefore never committed, and a fresh clone was missing a page
 # the build copies unconditionally. Only the throwaway files this directory collects are ignored.
 /replay*.html
 # Playtest saves — somebody's game, attached to a bug report.
 #
 # ANCHORED, and this is the line those saves actually arrive on. A save is a seed plus the moves
 # made: it belongs to whoever sent it, and it goes stale the moment the rules move. Nothing that
 # lands here is ever committed. `public/replays/` is the place for a game worth publishing.
 #
 # The README exemption mirrors `main`, so a `playtests/README.md` would still be committable if this
 # line ever wants one; today the directory is simply created when the first save arrives.
 /playtests/*
 !/playtests/README.md
@@ -19,6 +19,79 @@ page as `v0.1.0 · <sha> · <date>`, so what is deployed can always be identifie
 ---
 ## 0.4.9h — 2026-08-26
 Four issues off the tracker, the same four that ship as **0.7.2** on `main`. Two are engine bugs a
 player hit at the board and two are the design catching up with rulings from RAR. `main`'s fifth
 change, the Division map redrawn as a single row (Gitea#18), is deliberately NOT here: it is a
 multiplayer redesign, and pushing one of those into the build people are mid-playtest on invalidates
 the feedback.
 ### A 45° leg is part of the row (Gitea#17)
 **REPORTED:** "Cars were West to East Caboose, Loaded boxcar, Loaded boxcar, Loaded boxcar. After
 backing into that square cars were attached to the train Loaded boxcar, Loaded boxcar, Loaded boxcar,
 Caboose, Engine." The caboose came back next to the engine instead of at the far end, which also
 leaves the train badly made up under §8.2.
 The square was a `sw` CURVE and the train backed in through its SOUTH leg. `standing` runs west to
 east, and both places that walk that row asked the PORT which end they were at — but a 45° leg leaves
 through the MIDDLE of its edge, so its end of the run is whichever end the arc does not reach. A `sw`
 curve's south leg is the row's EAST end; an `se` curve's south leg is its WEST end. `rowEndAt` answers
 it from the card, and `cutTowards` is narrowed to `'e' | 'w'` so every caller must resolve.
 **The second half was live too:** a crew standing on a curve and pulling out through the leg drove
 away LEAVING ITS OWN CUT STANDING, against §A.4. That is the "cars left behind when backing up over
 them" report, carried as NOT REPRODUCED since 2026-08-22 — the earlier sweep had tried that case only
 with an east or west exit.
 ### The deck is the sheet (Gitea#14)
 Every count in the catalogue is `docs/Deck cards5.xlsx`'s count. Track halved to 16 straights, 8+8
 curves, 8+8 turnouts. **Both long-standing multipliers come out with it** — the Q12 office doubling
 (14 → 7) and the Gap 12 industry tripling (27 → 9) — because both were measured against a deck with
 96 track cards, and halving the track turns the tripling backwards. Measured over 300 games on
 identical seeds: reefer cars set out by a crew 49 / 0 / 39 across the three configurations, mean
 revenue −0.20 / +0.22 / +0.27. The sheet's own density is the best of the three.
 Everything sheet 5 does not list is dealt ZERO copies rather than deleted, so the rules stay
 implemented: the dispatching ladder, Facing Point Locks, Flying Switch, Section House and Vandalism,
 all confirmed as deliberate removals. 84 rows now agree with the sheet card for card; the only ones
 that do not are the ten Safety, Event and Inspection cards it adds that are not built.
 ### A rail may stop dead against its neighbour (Gitea#15)
 Filed as "track placements must connect" and **reversed by RAR on review**: the placement is fine,
 and a stub like that has a use as a siding to park cars on. What he asked to confirm is that no train
 can traverse the gap — and it cannot: every hop is gated on `joins`, which tests both ports and the
 diagonal. That was already true and simply unpinned; the reported geometry is now a test, including
 the check that the card IS reachable from the side that joins.
 ### Crossing a Mainline card is regions, not miles per hour (Gitea#3)
 **REPORTED:** a train taking two Stages to clear Double Track, which prints 60. RAR: "Ignore speed
 signs, they are just graphics. Regions shown on cards indicate how many stages it takes to cross."
 Q1 and Q2 are superseded together, and Q2 — a Slow train adds a Stage to every card — is what
 produced the report. Cards carry a region count and where a train STARTS is what varies: Plains 1,
 Double Track 1, Trestle 1, Curves 2, Tunnel 2, Heavy Grade 3. Fast/Slow is read on Hilly alone, which
 no longer reads the consist. Grade modifiers move the start: Helpers an uphill train, Brakeman a
 downhill one, Airbrakes another again. The Uncontrolled Siding and Interchange print a back region
 that is not road — a train arriving to find the siding occupied takes it and runs a region behind,
 and an Extra beginning its run at an Interchange starts there.
 Three things were missing rather than wrong: a following train ENTERING a one-region card behind
 another was never tested for a collision, which is what ABS is for; ABS was holding silently on the
 Office and Division Point paths; and `collide` never released the A/D track of a train destroyed as
 it left. The Uncontrolled Siding was marked "trains may pass", which skipped the collision test and
 made the siding do nothing.
 Measured: on a 3-player Division the Mainline cards cost a fast train ~5.6 Stages against ~5.4 before
 and a slow one ~6.0 against ~9.4. Fast traffic is unchanged; **slow traffic is about a third
 quicker**.
 ---
 ## 0.4.9g — 2026-08-25
 Four more off the Gitea tracker, all of them things a player saw at the board: **#8** a per-diem train
@@ -1,6 +1,6 @@
 {
  "name": "station-master",
-  "version": "0.4.9g",
+  "version": "0.4.9h",
  "private": true,
  "type": "module",
  "description": "Station Master — a railroad operations game",
@@ -23,6 +23,7 @@ import {
  enhancementRule,
  crossingStages,
  trainProfile,
  startRegion,
  MOVES_PER_LOCAL_OPS,
  MOVES_PER_LOCAL_OPS_NIGHT,
  STAGES_PER_DAY,
@@ -31,10 +32,9 @@ import {
  houseRules,
  lengthProfile,
  officeProfile,
  REGIONS_PER_MAINLINE_CARD,
  mainlineProfile,
 } from './content.ts';
-import type { Direction } from './content.ts';
+import type { Direction, MainlineEntry, MainlineKind } from './content.ts';
 import type { GameEvent } from './events.ts';
 // `trainNeedingCars` lives in apply.ts beside `check`'s copy of the same question, so the phase and
 // the legality test cannot disagree about which train is being assembled.
@@ -425,6 +425,104 @@ function badlyMadeUp(tray: CrewTray): string | null {
  return caboose === rear ? null : 'not made up — the caboose must be at the rear of the train';
 }
 /**
 * WHICH REGION OF A MAINLINE CARD A TRAIN IS STANDING IN (Gitea#3).
 *
 * A card is `regions` boxes wide and a train advances one per Stage, so what it has LEFT to run says
 * where it is: enter with `regions` still to go and you are at the beginning; enter with one to go
 * and you are in the last box.
 *
 * This used to be derived from a single global `REGIONS_PER_MAINLINE_CARD = 2`, with an entry term
 * that put a one-Stage train in region 1 of a two-region card — a fast train did not traverse a fast
 * card, it appeared at the far half of it. Cards carry their own region count now, so the position
 * is simply the count minus what is left.
 */
 export function regionOfTransit(card: MainlineKind, stagesRemaining: number): number {
  const regions = mainlineProfile(card).regions;
  return Math.min(regions - 1, Math.max(0, regions - stagesRemaining));
 }
 /** The entry a train would make onto this card, before occupancy is taken into account. */
 function entryFor(
  node: Extract<DivisionNode, { kind: 'mainline' }>,
  tray: CrewTray,
  startsAtBack = false,
 ): MainlineEntry {
  const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
  return {
    trainSpeed: profile?.speed ?? 'slow',
    direction: tray.direction,
    gradeUp: node.gradeUp ?? 'east',
    modifiers: node.modifiers ?? [],
    ...(startsAtBack ? { startsAtBack: true } : {}),
  };
 }
 /**
 * THE UNCONTROLLED SIDING RULE (Gitea#3): "if a train already exists when you arrive, you go in the
 * second stage back — you are in the siding and are one behind the other train. This prevents a
 * collision, since you are not in same exact location."
 *
 * So arriving at an occupied siding is not a collision and not a hold; it is a different, slower
 * entry. Anywhere else this returns false and the ordinary start applies.
 */
 function takesTheSiding(node: Extract<DivisionNode, { kind: 'mainline' }>): boolean {
  return node.card === 'uncontrolledSiding' && node.transits.length > 0;
 }
 /**
 * IS MOVING ONTO THIS CARD A COLLISION? (Gitea#3)
 *
 * A card can be ONE region wide — Plains, Double Track and Trestle all are — so a following train
 * granted clearance arrives in the same region as the train ahead the moment it enters. There was no
 * test for that at all: the catch-up check lives inside `stagesRemaining > 1`, which a one-Stage
 * crossing never reaches, so entering behind another train on a Plains was silently free.
 *
 * ABS is the card that answers it, in RAR's words: "This is played on a mainline card to prevent
 * collisions. If a collision would normally occur, the train moving onto the card is instead held
 * back." Held, not waved through — it tries again next Stage.
 *
 * The Uncontrolled Siding never conflicts on entry, because `takesTheSiding` has already moved this
 * train a region back; that is the whole point of the card.
 */
 function entryConflict(
  s: GameState,
  node: Extract<DivisionNode, { kind: 'mainline' }>,
  id: TrayId,
  tray: CrewTray,
  events: GameEvent[],
  startsAtBack = false,
 ): 'collided' | 'held' | null {
  if (mainlineProfile(node.card).trainsMayPass) return null;
  const start = startRegion(node.card, entryFor(node, tray, startsAtBack || takesTheSiding(node)));
  const ahead = node.transits.find(
    (t) =>
      t.tray !== id &&
      t.direction === tray.direction &&
      regionOfTransit(node.card, t.stagesRemaining) === start,
  );
  if (!ahead) return null;
  /**
   * A BACKSTOP, not the main path. `evaluateClearance` already refuses to clear a train onto a card
   * carrying ABS, so in the ordinary run of things nothing reaches here with signals up. It stays
   * because the two rules answer to different questions — clearance looks at the whole Subdivision,
   * this looks at one region — and a card that promises no rear-enders should not depend on the
   * wider check happening to fire first.
   */
  if (node.absSignals) {
    events.push({
      type: 'trainHeld',
      trainNumber: tray.trainNumber ?? 0,
      reason: 'ABS Signals — held short of the train ahead',
    });
    return 'held';
  }
  // §10 — the Superintendent cleared it into an occupied region, so it is the Superintendent's fault.
  collide(s, s.clock.superintendent, [id, ahead.tray], events, 'ran into the train ahead', 'the Mainline');
  return 'collided';
 }
 /** Puts a train onto a Mainline card with its crossing time already computed. */
 function enterMainline(
  s: GameState,
@@ -432,17 +530,9 @@ function enterMainline(
  id: TrayId,
  tray: CrewTray,
  index: number,
  startsAtBack = false,
 ): void {
-  const profile = trainProfile(tray.trainNumber ?? 0, tray.trainIsExtra);
+  const stages = crossingStages(node.card, entryFor(node, tray, startsAtBack || takesTheSiding(node)));
  const carriesPassengers = tray.consist.some((c) => c.type === 'coach');
  const stages = crossingStages(
    node.card,
    profile?.speed ?? 'slow',
    carriesPassengers,
    node.modifiers ?? [],
    tray.direction,
    node.gradeUp ?? 'east',
  );
  node.transits.push({ tray: id, stagesRemaining: stages, stagesTotal: stages, direction: tray.direction });
  tray.position = { at: 'mainline', index };
  // It is running now, so it is no longer being assembled (state.ts). A train at a Division Point
@@ -551,6 +641,10 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
    if (clearance === 'blocked') return 'held';
    if (clearance === 'ask') return 'needsClearance';
    const conflict = entryConflict(s, node, id, tray, events);
    if (conflict === 'held') return 'held';
    if (conflict === 'collided') return 'moved';
    enterMainline(s, node, id, tray, target);
    const dp = s.division.nodes[dpIndex];
    if (dp?.kind === 'divisionPoint') dp.holding = dp.holding.filter((t) => t !== id);
@@ -610,6 +704,11 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
      if (clearance === 'blocked') return 'held';
      if (clearance === 'ask') return 'needsClearance';
      const conflict = entryConflict(s, node, id, tray, events);
      if (conflict === 'held') return 'held';
      // The wreck's A/D track is released by `collide` itself, which is why it has to be.
      if (conflict === 'collided') return 'moved';
      enterMainline(s, node, id, tray, target);
      area.adOccupancy = area.adOccupancy.filter((t) => t !== id);
      events.push({
@@ -670,8 +769,18 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
      }
      if (clearance === 'ask') return 'needsClearance';
      /**
       * AN EXTRA PULLING OUT OF THE INTERCHANGE STARTS IN THE BACK REGION (Gitea#3) — "interchange
       * has new extras show up in second region (like uncontrolled siding)", and earlier, "Plains is
       * 1 stage for ALL trains. So are interlockings, with a second stage for incoming extras to hold
       * at."
       */
      const conflict = entryConflict(s, node, id, tray, events, true);
      if (conflict === 'held') return 'held';
      if (conflict === 'collided') return 'moved';
      node.holding = node.holding.filter((t) => t !== id);
-      enterMainline(s, node, id, tray, index);
+      enterMainline(s, node, id, tray, index, true);
      events.push({
        type: 'trainHighballed',
        trainNumber: tray.trainNumber ?? 0,
@@ -703,21 +812,22 @@ function moveTrain(s: GameState, id: TrayId, tray: CrewTray, events: GameEvent[]
       *
       * ABS Signals does what it says instead: the follower stops SHORT of the collision and holds.
       */
-      const regionOf = (t: { stagesTotal: number; stagesRemaining: number }): number => {
+      // NOT on a card that prints "trains may pass" — Double Track holds two trains because it HAS
-        const entry = REGIONS_PER_MAINLINE_CARD - t.stagesTotal;
+      // two roads, so a train catching another there goes past it. That is what the card is for.
-        const elapsed = t.stagesTotal - t.stagesRemaining;
+      //
-        return Math.min(REGIONS_PER_MAINLINE_CARD - 1, Math.max(0, entry + elapsed));
+      // The Uncontrolled Siding used to be in that set and no longer is: it keeps two trains apart
-      };
+      // by putting the second one in the siding a region back (`takesTheSiding`), not by letting
-      // NOT on a card that prints "trains may pass". Double Track and Uncontrolled Siding hold two
+      // them share a place. Marking it "may pass" skipped this test entirely and made the siding do
-      // trains because they HAVE two roads, so a train catching another there goes past it — that
+      // nothing at all.
      // is what the card is for. Without this the mechanic fired 0.41 times a game while the bot
      // never once granted clearance, which is the tell: those were all passing cards.
      const mayPass = mainlineProfile(node.card).trainsMayPass;
-      const next = regionOf({ stagesTotal: transit.stagesTotal, stagesRemaining: transit.stagesRemaining - 1 });
+      const next = regionOfTransit(node.card, transit.stagesRemaining - 1);
      const ahead = mayPass
        ? undefined
        : node.transits.find(
-            (t) => t.tray !== id && t.direction === transit.direction && regionOf(t) === next,
+            (t) =>
              t.tray !== id &&
              t.direction === transit.direction &&
              regionOfTransit(node.card, t.stagesRemaining) === next,
          );
      if (ahead) {
@@ -859,7 +969,22 @@ function evaluateClearance(
    // ABS Signals — "trains on this card will not rear-end each other; they stop short of a
    // collision". With signals in place a following train simply holds, and the Superintendent has
    // no judgment call to make. This is the amendment to Gap 2's unconditional collisions.
-    if (onNode?.kind === 'mainline' && onNode.absSignals) return 'blocked';
+    if (onNode?.kind === 'mainline' && onNode.absSignals) {
      /**
       * ABS Signals — "if a collision would normally occur, the train moving onto the card is
       * instead held back" (RAR, Gitea#3). Caught here rather than at the entry itself, so the train
       * never gets as far as the card.
       *
       * IT USED TO HOLD SILENTLY: a blocked clearance emits nothing on the Office and Division Point
       * paths, so the one card whose entire purpose is to stop a wreck did its job invisibly.
       */
      events.push({
        type: 'trainHeld',
        trainNumber: tray.trainNumber ?? 0,
        reason: 'ABS Signals — held short of the train ahead',
      });
      return 'blocked';
    }
    // Same direction — the Superintendent must rule (§8.1, fourth condition).
    s.clock.pendingDecision = { train: id, occupiedBy: other };
@@ -1010,6 +1135,18 @@ function collide(
      if (n.holding) n.holding = n.holding.filter((t) => t !== id);
      if (n.redFlagged) n.redFlagged = n.redFlagged.filter((t) => t !== id);
    }
    /**
     * AND OFF THE A/D TRACK, for exactly the same reason as the transit above.
     *
     * It never mattered while every collision happened to a train already out on the road. Gitea#3
     * adds one that can happen as a train LEAVES — a following train entering an occupied region —
     * and that train is still standing at the Office when it dies. Without this its A/D track stays
     * marked forever: the Office reads as permanently full, and every later arrival collides against
     * a train that no longer exists.
     */
    for (const [, area] of s.officeAreas) {
      area.adOccupancy = area.adOccupancy.filter((t) => t !== id);
    }
  }
  if (lost.length > 0) {
@@ -77,6 +77,7 @@ import {
  facilityVariants,
  opposite,
  reachableDestinations,
  rowEndAt,
  variantsFor,
  withinLimits,
 } from './track.ts';
@@ -331,6 +332,15 @@ function checkTurnoutUpgrade(existing: TrackCard, proto: TrackCard): RejectionCo
  if (existing.standing.length > 0) return 'UPGRADE_OCCUPIED';
  if (existing.enhancements.length > 0) return 'UPGRADE_ENHANCED';
  /**
   * NOTHING IS ASKED ABOUT THE NEIGHBOURS, deliberately (Gitea#15).
   *
   * A turnout adds a 45° leg the card underneath did not have, and that leg may well point into an
   * occupied square with nothing to meet it. That is legal: RAR ruled (2026-08-26) that a rail may
   * stop dead against its neighbour, and an upgrade is no different from laying the piece there in
   * the first place. What must hold either way is that no train can cross the gap, which is
   * `exploreMoves`' business and is tested in `track.test.ts`.
   */
  return null;
 }
@@ -963,7 +973,7 @@ export function check(s: GameState, player: PlayerIndex, i: Intent): RejectionCo
      if (!node || node.kind !== 'mainline') return 'NO_PLACEMENT';
      const on = node.modifiers ?? [];
      if (on.includes(rule.key)) return 'OPTION_ALREADY_CHOSEN';
-      if (rule.gradeOnly && mainlineProfile(node.card).speed.kind !== 'grade') return 'NOT_A_GRADE';
+      if (rule.gradeOnly && node.card !== 'heavyGrade') return 'NOT_A_GRADE';
      if (rule.requiresOnCard && !on.includes(rule.requiresOnCard)) return 'NOT_CONNECTED';
      // "Not while a train is on it" — realigning under a moving train is exactly the situation the
      // restriction exists to prevent. A train standing in the Interchange's yard counts: it is on
@@ -1467,7 +1477,7 @@ export function ownCutFor(s: GameState, player: PlayerIndex, trayId: TrayId, rev
  const facing = facingPort(s, trayId);
  const exit: Port = reverse ? reversePort(s, player, here, facing) : facing;
  const card = areaOf(s, player).grid.get(coordKey(here)) ?? emptyCard();
-  return cutTowards(card, carsOn(card), exit);
+  return cutTowards(card, carsOn(card), rowEndAt(card, exit));
 }
 /**
@@ -1585,14 +1595,16 @@ function execute(s: GameState, player: PlayerIndex, i: Intent): GameEvent[] {
         */
        const grid = areaOf(s, player).grid;
        const startCard = grid.get(coordKey(from)) ?? emptyCard();
-        const startCut = cutTowards(startCard, carsOn(startCard), exitPort);
+        const startCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, exitPort));
        const lifted = [
          ...(startCut.length > 0 ? [from] : []),
          ...dest.path.map((step) => step.coord),
          i.to,
        ].filter((c) => carsOn(grid.get(coordKey(c)) ?? emptyCard()).length > 0);
        const sides = standingSides(startCard, carsOn(startCard));
-        const stayed = exitPort === 'e' ? sides.west : exitPort === 'w' ? sides.east : [];
+        // The OTHER end's cut, which stays behind — so it is the other end of the row, not the
        // other port. A 45° leg is an end of the row too (`rowEndAt`, Gitea#17).
        const stayed = rowEndAt(startCard, exitPort) === 'e' ? sides.west : sides.east;
        // §A.3 — "engines also have couplers on the front end, so a train can pick cars up onto
        // its nose". Running forward the engine meets cars head-on and takes them in front; backing
        // up, they couple behind. Which end they land on is the whole point of a run-around: it
@@ -72,6 +72,26 @@ export type TrackProfile = {
 * from `docs/Deck cards2.xlsx`, a fixed document, and stay here as the audit trail for the
 * transcription — they are not claims about what the game deals today.
 *
 * THE COUNTS BELOW NOW COME FROM `docs/Deck cards5.xlsx` (Gitea#14), which HALVES every track row
 * against sheet 2: straight 32 → 16, each curve 16 → 8, each turnout 16 → 8. Track is the only
 * section of that sheet whose numbers moved — every station, industry, modifier and train row is
 * character-for-character what sheet 2 said — so this is the whole of the deck change it asks for.
 *
 * Sheet 5 also deals the sharp curves ZERO, which is where they already were: Jesse took them out
 * for the reason below, and RAR arrived at the same number independently. Nothing to do, but worth
 * recording that the two agree rather than leaving it looking like a coincidence.
 *
 * IT LANDS ON RAR'S OWN TARGETS, which is the check that matters — the top right of sheet 5 states
 * the draw rates he is designing to. Against his denominators (start cards counted for track, only
 * the non-track deck counted for trains): he wants track 48/167 = **28.7%** and trains 22/107 =
 * **20.6%**; this deck gives 48/170 = **28.2%** and 22/110 = **20.0%**.
 *
 * THAT MATCH IS PARTLY A CANCELLATION, and whoever retunes next should know it. The engine holds
 * ~25 more office and industry cards than the sheet (doubled and tripled, below) and is missing the
 * ~33 Safety, Event, Inspection and Space-use cards sheet 5 lists, which Gitea#14 defers. The two
 * errors are opposite and nearly equal today. Build the deferred categories and they stop
 * cancelling, so the ratios have to be re-measured then rather than assumed to have held.
 *
 * It matters well beyond bookkeeping. Track competes for the draw with industry, trains and
 * enhancements, so building a district is paid for in cards you did not draw instead — and the
 * hand-of-three is the real constraint on how fast a railroad grows.
@@ -86,9 +106,9 @@ export type TrackProfile = {
 * published replay still plays. Reordering to look tidy would silently re-deal every saved game.
 */
 export const TRACK_CARDS: readonly TrackProfile[] = [
-  { geometry: 'straight', hand: 'none', name: 'Straight track', copiesInDeck: 32, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'straight', hand: 'none', name: 'Straight track', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
-  { geometry: 'curved', hand: 'right', name: 'Curved track (right)', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'curved', hand: 'right', name: 'Curved track (right)', copiesInDeck: 8, isOperationalRail: true, moveCost: 1 },
-  { geometry: 'curved', hand: 'left', name: 'Curved track (left)', copiesInDeck: 16, isOperationalRail: true, moveCost: 1 },
+  { geometry: 'curved', hand: 'left', name: 'Curved track (left)', copiesInDeck: 8, isOperationalRail: true, moveCost: 1 },
  /**
   * SHARP CURVES ARE DEALT ZERO COPIES — Jesse's call, and the same treatment as Poling.
   *
@@ -103,8 +123,8 @@ export const TRACK_CARDS: readonly TrackProfile[] = [
   */
  { geometry: 'sharpCurved', hand: 'right', name: 'Sharp Curved Track (right)', copiesInDeck: 0, isOperationalRail: true, moveCost: 2 },
  { geometry: 'sharpCurved', hand: 'left', name: 'Sharp Curved Track (left)', copiesInDeck: 0, isOperationalRail: true, moveCost: 2 },
-  { geometry: 'turnout', hand: 'right', name: 'Turnout (right)', copiesInDeck: 16, isOperationalRail: false, moveCost: 1 },
+  { geometry: 'turnout', hand: 'right', name: 'Turnout (right)', copiesInDeck: 8, isOperationalRail: false, moveCost: 1 },
-  { geometry: 'turnout', hand: 'left', name: 'Turnout (left)', copiesInDeck: 16, isOperationalRail: false, moveCost: 1 },
+  { geometry: 'turnout', hand: 'left', name: 'Turnout (left)', copiesInDeck: 8, isOperationalRail: false, moveCost: 1 },
 ];
 /** Summed from `copiesInDeck` above, never written down — it moves whenever the deck is retuned. */
@@ -143,29 +163,39 @@ export type OfficeProfile = {
 * passenger modifier cards (Waiting Area, Restaurant, Hotel).
 */
 /**
- * Office cards. Every tier's `copiesInDeck` was **doubled** against the recovered design — Q12.
+ * Office cards, at `docs/Deck cards5.xlsx`'s counts exactly: Depot 4, Station 2, Terminal 1.
 *
- * Players always start at a Whistle Post, which has ONE A/D track, so a second arrival is an
+ * THE Q12 DOUBLING IS GONE (Gitea#14). Every tier used to be dealt at twice the sheet, to remove a
- * automatic collision (§8.3, Gap 2a). Measured at the original density, 25 of 100 games never drew
+ * 25% chance of an unwinnable opening deal: players always start at a Whistle Post, which has ONE
- * a Depot and never escaped: they averaged **−6.0** revenue against **−0.4** for games that
+ * A/D track, so a second arrival is an automatic collision (§8.3, Gap 2a), and measured at the
- * upgraded at least once, and 25 of 26 collisions happened at Whistle Post.
+ * sheet's density 25 of 100 games never drew a Depot and never escaped — averaging **−6.0** revenue
 * against **−0.4** for games that upgraded at least once, with 25 of 26 collisions at a Whistle
 * Post.
 *
 * That measurement was taken against a deck with 96 track cards in it, and the failure it describes
 * does not survive the halving of track. RE-MEASURED at the sheet's counts, 100 games: **43 of 100**
 * never upgrade off a Whistle Post, up from 25 — but they average **−0.2** revenue against **+1.4**
 * for games that do upgrade, where the gap used to be −6.0 against −0.4. Collisions fell from 26 per
 * 100 games to **6**, and only 3 of those are in games that never upgraded, against 25 of 26 before.
 *
 * So staying at a Whistle Post is now common and survivable rather than rare and fatal, which is the
 * opposite of the shape Q12 was answering: with fewer trains reaching an Office, a single A/D track
 * is seldom contested. The doubling was the blunt instrument its own note called it, and at the
 * sheet's deck size it costs more than it buys — see `TRACK_CARDS` for the whole comparison and
 * `INDUSTRY_PROFILES` for the other half of the same decision.
 *
 * Upgrades are strictly sequential (Gap 3b, no skipping), so Station and Terminal are rarer than
- * their raw counts imply — Terminal needs all three cards in order. Station and Terminal were
+ * their raw counts imply — Terminal needs all three cards in order.
 * doubled with Depot to keep that ladder in proportion rather than making Depot a special case.
 *
- * PROVISIONAL — re-evaluate. This was chosen to remove a 25% chance of an unwinnable opening deal,
+ * IF THE OPENING BITES AGAIN, the fix is not to re-double this. The note it replaces already listed
- * not from the recovered design, and it is a blunt instrument: it lifts the whole office ladder and
+ * the better options: fewer Terminals, a cheaper first upgrade, or more A/D capacity at a Whistle
- * dilutes every other category slightly. Revisit once the victory target is settled and freight is
+ * Post. Any of those answers the collision without diluting every other category to do it.
 * carrying its intended share; the right answer may instead be fewer Terminals, a cheaper first
 * upgrade, or more A/D capacity at Whistle Post. The counts themselves are in the rows below, which
 * is the only place they should be read from.
 */
 export const OFFICE_PROFILES: readonly OfficeProfile[] = [
  { tier: 'whistlePost', name: 'Whistle Post', isControlPoint: false, isPassengerFacility: false, adTracks: 1, porters: 0, passengerOut: 0, passengerIn: 0, copiesInDeck: 0 },
-  { tier: 'depot', name: 'Depot', isControlPoint: true, isPassengerFacility: true, adTracks: 2, porters: 1, passengerOut: 1, passengerIn: 1, copiesInDeck: 8 },
+  { tier: 'depot', name: 'Depot', isControlPoint: true, isPassengerFacility: true, adTracks: 2, porters: 1, passengerOut: 1, passengerIn: 1, copiesInDeck: 4 },
-  { tier: 'station', name: 'Station', isControlPoint: true, isPassengerFacility: true, adTracks: 3, porters: 2, passengerOut: 2, passengerIn: 2, copiesInDeck: 4 },
+  { tier: 'station', name: 'Station', isControlPoint: true, isPassengerFacility: true, adTracks: 3, porters: 2, passengerOut: 2, passengerIn: 2, copiesInDeck: 2 },
-  { tier: 'terminal', name: 'Terminal', isControlPoint: true, isPassengerFacility: true, adTracks: 4, porters: 3, passengerOut: 3, passengerIn: 3, copiesInDeck: 2 },
+  { tier: 'terminal', name: 'Terminal', isControlPoint: true, isPassengerFacility: true, adTracks: 4, porters: 3, passengerOut: 3, passengerIn: 3, copiesInDeck: 1 },
 ];
 export const OFFICE_ORDER: readonly OfficeTier[] = ['whistlePost', 'depot', 'station', 'terminal'];
@@ -202,15 +232,24 @@ export type IndustryProfile = {
 };
 /**
- * Industry density (Gap 12). The recovered sheet lists 9 industries in a 115-card deck; the
+ * Industry density, at `docs/Deck cards5.xlsx`'s counts exactly (Gitea#14).
 * prototype ran 10 in 52. At the sheet's density a game saw 1.6 Freight Facilities, freight was 10%
 * of gross revenue, and `carsCoupled` fired 4 times per 100 games — the freight loop, which is the
 * point of the game, effectively never ran.
 *
- * Each industry's `copies` is TRIPLED against the sheet, which restores roughly the prototype's
+ * THE GAP-12 TRIPLING IS GONE. The recovered sheet listed 9 industries in a 115-card deck and the
- * ratio while preserving the sheet's proportions exactly: the outbound/inbound balance and the
+ * prototype ran 10 in 52; at that density a game saw 1.6 Freight Facilities, freight was 10% of
- * lockout structure are unchanged, because every kind scales by the same factor. The multiplier is
+ * gross revenue, and `carsCoupled` fired 4 times per 100 games, so the freight loop effectively
- * the decision; the resulting totals are in the rows below and move with every retune.
+ * never ran. Tripling every kind restored roughly the prototype's ratio.
 *
 * ALL OF THAT WAS MEASURED AGAINST A DECK WITH 96 TRACK CARDS. Sheet 5 halves the track, and the
 * tripling then works backwards: the deck keeps dealing industries while the district stays too
 * small to reach them. Measured over 300 bot games on identical seeds — 96 track with the multiplier
 * / 48 track with it / 48 track without — reefer cars set out by a crew went **49 / 0 / 39** and
 * mean revenue **−0.20 / +0.22 / +0.27**. The middle column is the tripling meeting the halved
 * deck: it wipes out the reefer chain completely. The sheet's own density is the best of the three
 * on both counts.
 *
 * The sheet's proportions were always preserved by the multiplier, since every kind scaled by the
 * same factor — so removing it changes the density and nothing else. The outbound/inbound balance
 * and the lockout structure below are the sheet's, as they always were.
 */
 /**
 * LOCKOUTS, from the sheet's "Lockouts" column verbatim:
@@ -233,8 +272,8 @@ export type IndustryProfile = {
 * enforced for every kind in `isLockedOut`, not repeated in each row here.
 */
 export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
-  { kind: 'freightHouse', name: 'Freight House', carTypes: ['boxcar'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 6 },
+  { kind: 'freightHouse', name: 'Freight House', carTypes: ['boxcar'], flow: 'both', baseOut: 1, baseIn: 1, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 2 },
-  { kind: 'mineTipple', name: 'Mine Tipple', carTypes: ['hopper'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 6 },
+  { kind: 'mineTipple', name: 'Mine Tipple', carTypes: ['hopper'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 2 },
  /**
   * OUTBOUND ONLY. A Refinery ships oil out and receives nothing; reported from playtesting and
   * confirmed by Jesse (v0.4.9e): "only ships out tanks, does not receive anything".
@@ -252,9 +291,9 @@ export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
   * the game with no way to raise the direction it is supposed to use half its capacity on.
   * `StationMaster-Home-Deck-v0.4.5.md` prints it "Outbound, 1 out / 0 in".
   */
-  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 3 },
+  { kind: 'refinery', name: 'Refinery', carTypes: ['tank'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['powerPlant'], copies: 1 },
-  { kind: 'powerPlant', name: 'Power Plant', carTypes: ['hopper', 'tank'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['mineTipple', 'refinery'], copies: 6 },
+  { kind: 'powerPlant', name: 'Power Plant', carTypes: ['hopper', 'tank'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['mineTipple', 'refinery'], copies: 2 },
-  { kind: 'packingSheds', name: 'Packing Sheds', carTypes: ['reefer'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 3 },
+  { kind: 'packingSheds', name: 'Packing Sheds', carTypes: ['reefer'], flow: 'outbound', baseOut: 1, baseIn: 0, baseLoaders: 1, lockouts: ['grocersWarehouse'], copies: 1 },
  /**
   * INBOUND ONLY — the mirror of the Refinery above, and the same correction. Reported from
   * playtesting and confirmed by Jesse (v0.4.9e): "Grocer's Warehouse should be receive only, does
@@ -267,7 +306,7 @@ export const INDUSTRY_PROFILES: readonly IndustryProfile[] = [
   * other example. The Truck Dock (+1 inbound) and Local Small Groceries (+1 Laborer) are the two
   * that do work here.
   */
-  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 3 },
+  { kind: 'grocersWarehouse', name: "Grocer's Warehouse", carTypes: ['boxcar', 'reefer'], flow: 'inbound', baseOut: 0, baseIn: 1, baseLoaders: 1, lockouts: ['packingSheds', 'freightHouse'], copies: 1 },
 ];
 /** Legacy alias; the engine still reads FREIGHT_PROFILES in places. */
@@ -504,22 +543,35 @@ export type MainlineKind =
  | 'uncontrolledSiding' | 'tunnel' | 'trestle' | 'interchange';
 /**
- * Speed as printed. `60` and `30` appear on the cards; Hilly prints P60/F30, and Heavy Grade
+ * THE PRINTED SPEEDS ARE GRAPHICS. RAR, 2026-08-26 (Gitea#3): "please ignore the speed signs I put
- * prints "G" with the player setting orientation.
+ * on the cards — those are nothing but scene-setting graphics that mimic the speed you are
 * travelling. It's just ambiance, nothing more."
 *
- * WHAT THESE NUMBERS MEAN IS NOT YET SETTLED — see implications.md §10 Q2. Transcribed as data so
+ * They used to decide everything: a `MainlineSpeed` of 60 meant one Stage and a 30 meant two, plus
- * the answer can be applied without re-reading the cards.
+ * one more for a Slow train. Both rules are gone. **What crosses a card is REGIONS** — the boxes
 * printed on it — one per Stage, and where a train STARTS decides how many it has left to run.
 */
 export type MainlineSpeed =
  | { kind: 'uniform'; value: number }
  | { kind: 'byTrainType'; passenger: number; freight: number }
  | { kind: 'grade' };
 export type MainlineProfile = {
  kind: MainlineKind;
  name: string;
-  speed: MainlineSpeed;
+  /** Regions printed on the card. A train advances one per Stage, so a full run costs `regions`. */
-  /** Double Track and Uncontrolled Siding: "Trains may pass". */
+  regions: number;
  /**
   * The region an ordinary train enters at. Zero on nearly everything — but the Uncontrolled Siding
   * and the Interchange print a back region that is a siding or a holding spur rather than part of
   * the road, so a train running straight through starts past it and crosses in one Stage.
   */
  defaultStart: number;
  /**
   * Cards that print a FAST and a SLOW start, and the region each begins at. "Some cards say fast /
   * slow. This is an indication that if on the train card, the train is listed as fast or slow,
   * that's starting position / how many stages it takes to traverse the card. Fast / Slow does not
   * apply to every card — just those that say fast / slow on them. Currently this is only hilly."
   *
   * So the train's rating is read HERE and nowhere else. It used to add a Stage to every card.
   */
  speedStarts?: { fast: number; slow: number };
  /** Double Track: "Trains may pass". */
  trainsMayPass: boolean;
  /** Interchange: "Sort cars in new order". */
  sortsCars: boolean;
@@ -528,22 +580,56 @@ export type MainlineProfile = {
 };
 export const MAINLINE_PROFILES: readonly MainlineProfile[] = [
-  { kind: 'plains', name: 'Plains', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  { kind: 'plains', name: 'Plains', regions: 1, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
-  { kind: 'curves', name: 'Curves', speed: { kind: 'uniform', value: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
+  { kind: 'curves', name: 'Curves', regions: 2, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
  { kind: 'hilly', name: 'Hilly', speed: { kind: 'byTrainType', passenger: 60, freight: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['passenger', 'freight'] },
  { kind: 'heavyGrade', name: 'Heavy Grade', speed: { kind: 'grade' }, trainsMayPass: false, sortsCars: false, entryPoints: ['start', 'brakemen', 'airbrakes', 'helpers'] },
  { kind: 'doubleTrack', name: 'Double Track', speed: { kind: 'uniform', value: 60 }, trainsMayPass: true, sortsCars: false, entryPoints: ['start'] },
  { kind: 'uncontrolledSiding', name: 'Uncontrolled Siding', speed: { kind: 'uniform', value: 60 }, trainsMayPass: true, sortsCars: false, entryPoints: ['noPass', 'passingTrains'] },
  { kind: 'tunnel', name: 'Tunnel', speed: { kind: 'uniform', value: 30 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
  { kind: 'trestle', name: 'Trestle', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
  /**
-   * RENAMED FROM "Yard" after play. The card is unchanged — same 60, same "sort cars in new
+   * THE ONLY CARD THAT READS A TRAIN'S FAST/SLOW RATING. A fast train starts in the second region
-   * order", same entry points, same art — but "Yard" collided with the Division Yard, the
+   * and is across in one Stage; a slow one starts at the beginning and takes two.
-   * Classification Yard, the Salvage Yard, the Yard Office and the Small Yard, none of which are
+   *
-   * this. Its own key is renamed with it, so the two never drift apart. Those OTHER yards are
+   * It used to read the CONSIST instead — any coach aboard made the train "passenger" for this card
-   * deliberately left alone: they are different things that merely shared a word.
+   * — off the printed P60/F30. RAR corrected that directly: "I notice that you are basing stages in
   * mainline cards off coach/non-coach. Actually, all trains are rated as FAST and SLOW."
   */
-  { kind: 'interchange', name: 'Interchange', speed: { kind: 'uniform', value: 60 }, trainsMayPass: false, sortsCars: true, entryPoints: ['start', 'sortCars'] },
+  { kind: 'hilly', name: 'Hilly', regions: 2, defaultStart: 0, speedStarts: { fast: 1, slow: 0 }, trainsMayPass: false, sortsCars: false, entryPoints: ['fast', 'slow'] },
  /**
   * THREE REGIONS, AND THE MODIFIERS MOVE THE START RATHER THAN CUTTING THE TIME — which comes to
   * the same number of Stages and is how the card is actually printed and played. "If you play the
   * home deck card 'helpers' against the mainline card heavy grade, it remains there the rest of the
   * game and helps all trains going up hill by starting 1 region easier — so 2 to traverse, not 3.
   * Other cards help the other direction, similar idea. Airbrakes is an upgrade from brakemen (which
   * must be played first)."
   *
   * So: Helpers moves an UPHILL train up one region; Brakeman moves a DOWNHILL train up one, and
   * Airbrakes another on top of it. A fully-equipped grade is one Stage downhill and two up.
   */
  { kind: 'heavyGrade', name: 'Heavy Grade', regions: 3, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start', 'brakemen', 'airbrakes', 'helpers'] },
  { kind: 'doubleTrack', name: 'Double Track', regions: 1, defaultStart: 0, trainsMayPass: true, sortsCars: false, entryPoints: ['start'] },
  /**
   * TWO REGIONS, AND THE BACK ONE IS THE SIDING. A train with the card to itself starts past it and
   * crosses in one Stage. "Uncontrolled siding: if a train already exists when you arrive, you go in
   * the second stage back (you are in the siding and are one behind the other train). This prevents
   * a collision — since you are not in same exact location."
   *
   * `trainsMayPass` is FALSE here, and used to be true. Two trains fit, but not by passing: the
   * second one takes the siding and sits a region behind, which is what keeps them apart. Leaving it
   * true skipped the collision test altogether and made the siding do nothing at all.
   */
  { kind: 'uncontrolledSiding', name: 'Uncontrolled Siding', regions: 2, defaultStart: 1, trainsMayPass: false, sortsCars: false, entryPoints: ['through', 'siding'] },
  { kind: 'tunnel', name: 'Tunnel', regions: 2, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
  { kind: 'trestle', name: 'Trestle', regions: 1, defaultStart: 0, trainsMayPass: false, sortsCars: false, entryPoints: ['start'] },
  /**
   * RENAMED FROM "Yard" after play. The card is unchanged — same "sort cars in new order", same art
   * — but "Yard" collided with the Division Yard, the Classification Yard, the Salvage Yard, the
   * Yard Office and the Small Yard, none of which are this. Its own key is renamed with it, so the
   * two never drift apart. Those OTHER yards are deliberately left alone: they are different things
   * that merely shared a word.
   *
   * TWO REGIONS, the back one a holding spur, exactly as the Uncontrolled Siding: "interchange has
   * new extras show up in second region (like uncontrolled siding)", and earlier, "Plains is 1 stage
   * for ALL trains. So are interlockings, with a second stage for incoming extras to hold at." A
   * train running through crosses in one Stage; an Extra beginning its run here starts at the back.
   */
  { kind: 'interchange', name: 'Interchange', regions: 2, defaultStart: 1, trainsMayPass: false, sortsCars: true, entryPoints: ['through', 'extraStart'] },
 ];
 /**
@@ -570,44 +656,63 @@ export const MAINLINE_DECK: readonly MainlineKind[] = [
 ];
 /**
- * How many Stages a train needs to cross a Mainline card.
+ * WHERE A TRAIN ENTERS A MAINLINE CARD, and therefore how long it takes to cross (Gitea#3).
 *
- * Q1 — the printed 60/30 are miles per hour expressed as crossing time: a 60 card takes one Stage,
+ * "Regions shown on cards indicate how many stages it takes to cross. Plains is 1. Double track is
- * a 30 card takes two. The cells drawn on the cards are decoration.
+ * 1, tunnel is 2, curves is 2, heavy grade is 3 unless you have help." A train advances one region
- * Q2 — a Slow train adds one Stage to every card.
+ * per Stage, so the whole of crossing time is `regions - startRegion`.
 *
- * Hilly prints P60/F30, so it reads the consist rather than the speed class: a train carrying any
+ * FOUR THINGS MOVE THE START, and nothing else does:
- * coach is "passenger" for this purpose.
+ *
 *   1. the card's own `defaultStart` — the Uncontrolled Siding and the Interchange print a back
 *      region that is not part of the road, so a train running through begins past it;
 *   2. `speedStarts`, on a card that prints a Fast and a Slow start. Only Hilly does;
 *   3. the permanent Heavy Grade modifiers, which move a train one region up the hill each;
 *   4. `takesSiding` / `startsAtBack`, the two occupancy cases below.
 *
 * WHAT NO LONGER MOVES IT: the printed mph, which is now scenery, and a train's Fast/Slow rating on
 * any card but Hilly. That rating used to add a Stage to EVERY card, which is what made a Slow train
 * cross Double Track in two Stages and produced the report this issue opened with.
 */
-export function crossingStages(
+export type MainlineEntry = {
-  kind: MainlineKind,
+  trainSpeed: TrainSpeed;
-  trainSpeed: TrainSpeed,
+  direction: Direction;
-  carriesPassengers: boolean,
+  gradeUp: Direction;
-  modifiers: readonly string[] = [],
+  modifiers: readonly string[];
-  direction: Direction = 'east',
+  /**
-  gradeUp: Direction = 'east',
+   * The Uncontrolled Siding with a train already on it: this one takes the siding and sits a region
-): number {
+   * behind, which is what keeps them out of the same place. Also the Interchange, where an Extra
-  const profile = MAINLINE_PROFILES.find((m) => m.kind === kind);
+   * beginning its run starts in the holding region rather than on the road.
-  if (!profile) throw new Error(`unknown mainline card: ${kind}`);
+   */
  startsAtBack?: boolean;
 };
-  let mph: number;
+export function startRegion(kind: MainlineKind, entry: MainlineEntry): number {
-  switch (profile.speed.kind) {
+  const profile = mainlineProfile(kind);
-    case 'uniform':
+  if (entry.startsAtBack) return 0;
-      mph = profile.speed.value;
+
-      break;
+  const base = profile.speedStarts
-    case 'byTrainType':
+    ? profile.speedStarts[entry.trainSpeed]
-      mph = carriesPassengers ? profile.speed.passenger : profile.speed.freight;
+    : profile.defaultStart;
-      break;
+
-    case 'grade':
+  const climbing = entry.direction === entry.gradeUp;
-      // Heavy Grade has no printed number; the modifier cards are what improve it, so it is a 30
+  let help = 0;
-      // until one is placed.
+  if (kind === 'heavyGrade') {
-      mph = 30;
+    if (climbing) {
-      break;
+      if (entry.modifiers.includes('helpers')) help++;
    } else {
      // Airbrakes is an upgrade on Brakeman and cannot be played without it, so this counts both.
      if (entry.modifiers.includes('brakeman')) help++;
      if (entry.modifiers.includes('airbrakes')) help++;
    }
  }
  // Never past the last region: a card always costs at least one Stage to cross.
  return Math.min(profile.regions - 1, base + help);
 }
-  const base = mph >= 60 ? 1 : 2;
+/** How many Stages a train needs to cross a Mainline card — the regions it has left to run. */
-  const stages = base + (trainSpeed === 'slow' ? 1 : 0);
+export function crossingStages(kind: MainlineKind, entry: MainlineEntry): number {
-  return Math.max(1, stages - gradeReduction(profile, modifiers, direction, gradeUp));
+  return mainlineProfile(kind).regions - startRegion(kind, entry);
 }
 /**
@@ -625,35 +730,50 @@ export function crossingStages(
 export function mainlineDescription(kind: MainlineKind, gradeUp: Direction = 'east'): string {
  const p = mainlineProfile(kind);
  const stages = (n: number): string => `${n} Stage${n === 1 ? '' : 's'}`;
  const run = (entry: Partial<MainlineEntry>): number =>
    crossingStages(kind, { trainSpeed: 'fast', direction: 'east', gradeUp, modifiers: [], ...entry });
  const parts: string[] = [];
-  if (p.speed.kind === 'byTrainType') {
+  parts.push(`${p.regions} region${p.regions === 1 ? '' : 's'} — one Stage each.`);
-    // Hilly. The split is by CONSIST, not by the train's speed class: anything with a coach on it
+
-    // takes the passenger figure.
+  if (p.speedStarts) {
    parts.push(
-      `P${p.speed.passenger} / F${p.speed.freight} — a train carrying ANY coach crosses as a ` +
+      `This card reads the train's FAST/SLOW rating: a fast train starts further along and crosses ` +
-        `${p.speed.passenger} (${stages(crossingStages(kind, 'fast', true))} for a fast train), and a ` +
+        `in ${stages(run({ trainSpeed: 'fast' }))}, a slow one in ${stages(run({ trainSpeed: 'slow' }))}. ` +
-        `freight-only train as a ${p.speed.freight} (${stages(crossingStages(kind, 'fast', false))}). ` +
+        `No other card cares which it is.`,
        `A slow train adds one Stage either way.`,
    );
-  } else if (p.speed.kind === 'grade') {
+  } else if (kind === 'heavyGrade') {
    parts.push(
-      `A grade, climbing ${gradeUp === 'east' ? 'eastward' : 'westward'}. It crosses as a 30 — ` +
+      `A grade, climbing ${gradeUp === 'east' ? 'eastward' : 'westward'}. ` +
-        `${stages(crossingStages(kind, 'fast', false, [], gradeUp, gradeUp))} for a fast train, and one ` +
+        `${stages(run({ direction: gradeUp }))} to climb it and ${stages(run({ direction: gradeUp === 'east' ? 'west' : 'east' }))} to run down, ` +
-        `more for a slow one. Brakeman and Airbrakes each take a Stage off a train running DOWNHILL; ` +
+        `before help. Helpers start an UPHILL train a region further on; Brakeman does the same ` +
-        `Helpers takes one off a train running UPHILL. Never below one Stage.`,
+        `DOWNHILL and Airbrakes another again, and Airbrakes cannot be played without Brakeman. ` +
        `Never less than one Stage.`,
    );
  } else if (p.defaultStart > 0) {
    parts.push(
      `A train with the card to itself starts past the back region and is across in ` +
        `${stages(run({}))}.`,
    );
  } else {
    parts.push(`${stages(run({}))} for every train — the printed speed is scenery.`);
  }
  if (kind === 'uncontrolledSiding') {
    parts.push(
-      `${p.speed.value} — ${stages(crossingStages(kind, 'fast', false))} for a fast train, ` +
+      'UNCONTROLLED SIDING — arrive to find a train already here and you take the siding, a region ' +
-        `${stages(crossingStages(kind, 'slow', false))} for a slow one.`,
+        'behind it. You are not in the same place, so you do not run into it; it costs you the ' +
        'extra Stage instead.',
    );
  }
  if (kind === 'interchange') {
    parts.push('An Extra beginning its run here starts in the back region and takes the extra Stage.');
  }
  if (p.trainsMayPass) {
    parts.push(
      'TRAINS MAY PASS — two trains may stand on this card at once, so a following train is not held ' +
-        'behind a slower one. Only this and the Double Track allow it.',
+        'behind a slower one.',
    );
  } else {
    parts.push('One train at a time — anything following has to wait for it to clear.');
@@ -663,31 +783,7 @@ export function mainlineDescription(kind: MainlineKind, gradeUp: Direction = 'ea
  return parts.join(' · ');
 }
-/**
+
 * Q11, answered: the Heavy Grade card prints "(Up)" and "Player sets orientation", so which way it
 * climbs is a property of the placed card, not a constant. `gradeUp` is the direction a train is
 * travelling when it goes UPHILL; a train heading the other way is descending.
 *
 * Each applicable card takes a Stage off, never below one: a train cannot cross in no time.
 * Airbrakes only counts when Brakeman is already there, which the placement rule enforces.
 */
 function gradeReduction(
  profile: MainlineProfile,
  modifiers: readonly string[],
  direction: Direction,
  gradeUp: Direction,
 ): number {
  if (profile.speed.kind !== 'grade') return 0;
  const downhill = direction !== gradeUp;
  let n = 0;
  if (downhill) {
    if (modifiers.includes('brakeman')) n++;
    if (modifiers.includes('airbrakes')) n++;
  } else if (modifiers.includes('helpers')) {
    n++;
  }
  return n;
 }
 export function mainlineProfile(kind: MainlineKind): MainlineProfile {
  const p = MAINLINE_PROFILES.find((m) => m.kind === kind);
@@ -748,7 +844,8 @@ export const SPACE_USE_CARDS: readonly SimpleCard[] = [
  { key: 'flopHouse', name: 'Flop house', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
  { key: 'watertower', name: 'Watertower', copies: 1, placement: 'adjacent to any straight, turnout on Running Track', effect: 'Burns tablespace.' },
  { key: 'hoboJungle', name: 'Hobo Jungle', copies: 1, placement: 'adjacent to any straight, turnout, Limit on Running Track', effect: 'Burns tablespace. Vandalism can loot a boxcar passing it.' },
-  { key: 'sectionHouse', name: 'Section House', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26), the same treatment as the ladder.
  { key: 'sectionHouse', name: 'Section House', copies: 0, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
  { key: 'cityBlocks', name: 'City blocks', copies: 4, placement: 'adjacent to any straight, curve, turnout, Limit', effect: 'Burns tablespace.' },
  { key: 'engineShops', name: 'Engine Shops', copies: 1, placement: 'adjacent to any straight, curve, turnout', effect: 'Burns tablespace.' },
  { key: 'tenderloin', name: 'Tenderloin District', copies: 1, placement: 'adjacent to any straight, curve, turnout, Limit', effect: 'Burns tablespace.' },
@@ -855,16 +952,32 @@ export function enhancementRule(key: string): EnhancementRule | null {
 }
 export const ENHANCEMENT_CARDS: readonly SimpleCard[] = [
-  { key: 'interlocking', name: 'Interlocking', copies: 2, placement: 'any Running Track Straight', effect: 'May stop an inbound train on the Limit Track.' },
+  { key: 'interlocking', name: 'Interlocking', copies: 1, placement: 'any Running Track Straight', effect: 'May stop an inbound train on the Limit Track.' },
-  { key: 'facingPointLocks', name: 'Facing Point Locks', copies: 2, placement: 'adjacent to Interlocking', effect: 'Must have Interlocking. Prevents Derail being played on you.', answers: 'Derail' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26). It answers Derail, which is itself an
  // Event held out until built, so at zero it defends against nothing that can be dealt anyway.
  { key: 'facingPointLocks', name: 'Facing Point Locks', copies: 0, placement: 'adjacent to Interlocking', effect: 'Must have Interlocking. Prevents Derail being played on you.', answers: 'Derail' },
  { key: 'yardOffice', name: 'Yard office', copies: 1, placement: 'any Secondary Track Straight', effect: 'An inbound train with no coaches that can reach the yard office in one move may arrive there instead of the Train Order Office.' },
  { key: 'smallYard', name: 'Small yard', copies: 1, placement: 'any Secondary Track Straight', effect: 'A train that spends one move in the yard may sort itself into ANY order, including cars ahead of the engine.' },
-  { key: 'waterColumn', name: 'Water column', copies: 2, placement: 'any Running Track Straight', effect: 'Lets you remove any Watertower in your district.', answers: 'Watertower' },
+  { key: 'waterColumn', name: 'Water column', copies: 1, placement: 'any Running Track Straight', effect: 'Lets you remove any Watertower in your district.', answers: 'Watertower' },
  { key: 'overpass', name: 'Overpass', copies: 1, placement: 'any Railroad Crossing', effect: 'Removes the restrictions of a played Railroad Crossing.', answers: 'Railroad crossing' },
-  { key: 'telegraph', name: 'Telegraph', copies: 3, placement: 'any Running Track Straight', effect: 'Once a day, when dispatching facing trains, add +4 to the other train’s number.' },
+  /**
-  { key: 'telephone', name: 'Telephone', copies: 2, placement: 'on Telegraph', effect: 'Once a day, add +8 to the other train’s number.' },
+   * THE DISPATCHING LADDER IS OUT OF THE DECK, at 0 copies rather than deleted — the treatment
-  { key: 'radio', name: 'Radio', copies: 2, placement: 'on Telephone', effect: 'Once a day, add +12 to the other train’s number.' },
+   * Poling and the sharp curves already get, and for the same reason.
-  { key: 'absSignals', name: 'ABS Signals', copies: 2, placement: 'any Mainline card', effect: 'Trains on this card will not rear-end each other; they stop short of a collision.' },
+   *
   * `docs/Deck cards5.xlsx` does not list Telegraph, Telephone or Radio at any count, and **Jesse
   * confirmed (2026-08-26) that the removal is deliberate, not a row that failed to carry across**
   * from sheet 2. So no copy is dealt, which is what the sheet asks for.
   *
   * The rows and `ENHANCEMENT_RULES`' `dispatchBonus` chain stay exactly where they are. The rule
   * is implemented and tested — `advance.ts` reads the ladder when the Superintendent dispatches
   * facing trains, best device first — and deleting working machinery to express a count of zero
   * would throw away the only record of how it worked. At zero copies the code is unreachable: no
   * card is ever dealt, so nothing ever places one, so the bonus never applies.
   */
  { key: 'telegraph', name: 'Telegraph', copies: 0, placement: 'any Running Track Straight', effect: 'Once a day, when dispatching facing trains, add +4 to the other train’s number.' },
  { key: 'telephone', name: 'Telephone', copies: 0, placement: 'on Telegraph', effect: 'Once a day, add +8 to the other train’s number.' },
  { key: 'radio', name: 'Radio', copies: 0, placement: 'on Telephone', effect: 'Once a day, add +12 to the other train’s number.' },
  { key: 'absSignals', name: 'ABS Signals', copies: 1, placement: 'any Mainline card', effect: 'Trains on this card will not rear-end each other; they stop short of a collision.' },
 ];
 export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
@@ -872,7 +985,8 @@ export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
  { key: 'airbrakes', name: 'Airbrakes', copies: 1, placement: 'a GRADE Mainline card', effect: 'Faster passage downhill. Brakeman must be in effect.' },
  { key: 'helpers', name: 'Helpers', copies: 1, placement: 'a GRADE Mainline card', effect: 'Faster passage uphill.' },
  { key: 'realignment', name: 'Realignment', copies: 2, placement: 'a Mainline card', effect: 'Convert one Mainline type to another. Not while a train is on it.' },
-  { key: 'facingPointLocksMainline', name: 'Facing Point Locks', copies: 2, placement: 'adjacent to Interlocking', effect: 'Prevents Derail being played on you.', answers: 'Derail' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26); see the Enhancement of the same name.
  { key: 'facingPointLocksMainline', name: 'Facing Point Locks', copies: 0, placement: 'adjacent to Interlocking', effect: 'Prevents Derail being played on you.', answers: 'Derail' },
 ];
 /**
@@ -883,8 +997,9 @@ export const MAINLINE_MODIFIER_CARDS: readonly SimpleCard[] = [
 export const SECOND_SECTION = { key: 'secondSection', name: 'Second Section', copies: 1 };
 export const MANEUVER_CARDS: readonly SimpleCard[] = [
-  { key: 'redFlags', name: 'Red Flags', copies: 5, placement: 'any time', effect: 'A stopped train is prevented from being hit; the approaching train is prevented from moving.' },
+  { key: 'redFlags', name: 'Red Flags', copies: 3, placement: 'any time', effect: 'A stopped train is prevented from being hit; the approaching train is prevented from moving.' },
-  { key: 'flyingSwitch', name: 'Flying Switch', copies: 1, placement: 'any time', effect: 'Break a cut of cars away from behind the engine and roll them into an industry.' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26). The reducer stays; nothing can reach it.
  { key: 'flyingSwitch', name: 'Flying Switch', copies: 0, placement: 'any time', effect: 'Break a cut of cars away from behind the engine and roll them into an industry.' },
  // POLING IS OUT OF THE DECK, at 0 copies rather than deleted.
  //
  // It is the one card whose effect the source records as "TBD", so there is nothing to implement
@@ -901,7 +1016,8 @@ export const ACTION_CARDS: readonly SimpleCard[] = [
  { key: 'perDiemInventory', name: 'Per Diem inventory', copies: 1, placement: 'another player', effect: 'Lose one point per 2 empty cars on Secondary Tracks.' },
  { key: 'demurrageCharge', name: 'Demurrage charge', copies: 1, placement: 'another player', effect: 'Lose one point per 2 loaded freight cars on Secondary Tracks.' },
  { key: 'customerComplaints', name: 'Customer complaints', copies: 1, placement: 'another player', effect: 'Lose one point per 2 coaches in loading boxes.' },
-  { key: 'vandalism', name: 'Vandalism', copies: 1, placement: 'another player', effect: 'A train passing a Hobo Jungle has a boxcar looted (converted to empty).' },
+  // Not in sheet 5 — dealt 0 copies (Jesse, 2026-08-26).
  { key: 'vandalism', name: 'Vandalism', copies: 0, placement: 'another player', effect: 'A train passing a Hobo Jungle has a boxcar looted (converted to empty).' },
  { key: 'hotbox', name: 'Hotbox', copies: 1, placement: 'another player', effect: 'A train just arrived must set one car (chooser’s pick) onto Secondary Track until it departs.' },
  { key: 'outlawed', name: 'Outlawed', copies: 1, placement: 'another player', effect: 'A train just arrived may not depart for one turn — the crew’s hours have expired.' },
 ];
@@ -945,7 +1061,6 @@ export function crewTrayCount(players: number): number {
  return players + 3;
 }
 export const REGIONS_PER_MAINLINE_CARD = 2; // provisional, pending §10 Q2
 export const STAGES_PER_DAY = 12;
 export const STAGES_PER_SHIFT = 3;
 export const HAND_LIMIT = 3;
@@ -246,7 +246,7 @@ function buildDivision(players: number, rng: Rng): DivisionNode[] {
    // createGame is synchronous and returns a ready state. Rolled for now so the orientation is at
    // least deterministic and varies between games; it should become a real player choice when
    // setup gains an interactive phase. See implications.md §10 Q11.
-    if (mainlineProfile(card).speed.kind === 'grade') {
+    if (card === 'heavyGrade') {
      /**
       * TEMPORARY, and flagged in TODO. The card prints "(Up)" and "Player sets orientation", so
       * which way a Heavy Grade climbs is the player's decision — but it is dealt during setup, and
@@ -732,22 +732,25 @@ export function standingSides(
 }
 /**
- * The cut a train would run into if it left this card through `exit` — the cars between it and that
+ * The cut a train would run into if it left this card by the `exit` END OF THE ROW — the cars
- * end of the card.
+ * between it and that end. Returned in the order the train MEETS them, nearest first, which is what
 * `carsCoupled` wants.
 *
- * Only 'e' and 'w' can hold a cut: the array is a west-to-east row, so a train leaving north or
+ * `exit` IS AN END OF THE ROW, NOT A PORT. It used to be a raw `Port`, and answered "you meet
- * south off a curve or a spur is not running along it and meets nothing. Returned in the order the
+ * nothing" for north and south on the reasoning that a leg leaving through an edge is not running
- * train MEETS them, nearest first, which is what `carsCoupled` wants.
+ * along the west-to-east row. It is: a `sw` curve's south leg IS the east end of that row, so a
 * crew standing on the curve pulled out through the leg and drove away leaving the cars beside it
 * standing, against §A.4's mandatory coupling (Gitea#17). Callers resolve the leg with `rowEndAt`
 * (`track.ts`), which lives there because only the card's arc can say which end a leg is — and the
 * narrowed type is what makes every caller do it.
 */
 export function cutTowards(
  tray: { standingWest?: number | undefined },
  cars: readonly RollingStock[],
-  exit: 'n' | 's' | 'e' | 'w',
+  exit: 'e' | 'w',
 ): RollingStock[] {
  const { west, east } = standingSides(tray, cars);
-  if (exit === 'e') return east;
+  return exit === 'e' ? east : [...west].reverse();
  if (exit === 'w') return [...west].reverse();
  return [];
 }
 export function turnOf(s: GameState, player: PlayerIndex): TurnState {
@@ -188,6 +188,40 @@ export function joins(a: TrackCard, p: Port, b: TrackCard): boolean {
  return slopeAt(a, p) === slopeAt(b, opposite(p));
 }
 /**
 * WHICH END OF THE WEST-TO-EAST ROW A PORT SITS AT.
 *
 * `TrackCard.standing` is ordered west to east (§A.3), so whether a train meets the row front to
 * back or back to front depends on which end it enters by — and a port is not always at one of
 * those two extremes. Every 45° leg leaves through the MIDDLE of its north or south edge, so its
 * end of the run is whichever end the arc does NOT reach: a `sw` curve's south leg is the EAST end
 * of the row, and an `se` curve's south leg is the WEST end. Same port, opposite answers, which is
 * why this has to ask the card rather than read the port.
 *
 * Gitea#17 is what both callers looked like without it. `exploreMoves` reversed the row for an 'e'
 * entry and for nothing else, so backing into a cut through a `sw` curve's south leg coupled it up
 * back to front — the caboose came out next to the engine, which §8.2 then calls badly made up.
 * `cutTowards` answered "you meet nothing" for a north or south exit, so a crew standing on a curve
 * pulled out through the leg and left the cars beside it standing, which §A.4 forbids.
 *
 * There is no north-south straight anywhere on the printed sheet (see the module comment), so a run
 * touching a 45° leg always has an east or west port at its other end and the answer is never
 * undefined. A TURNOUT is the one card whose row has three ends rather than two — and it is also
 * the one card no cut can ever stand on, since a train may not stop there (§A.1) and so never sets
 * anything out there. Its stem answers for it.
 */
 export function rowEndAt(card: TrackCard, p: Port): 'e' | 'w' {
  if (p === 'e' || p === 'w') return p;
  for (const [a, b] of connectionsFor(card)) {
    const other = a === p ? b : b === p ? a : null;
    if (other === 'e') return 'w';
    if (other === 'w') return 'e';
  }
  // Not a card the printed sheet can produce. Reading the leg as the west end leaves the row in the
  // order it is stored rather than inventing a reversal on a card nothing knows the shape of.
  return 'w';
 }
 // ---------------------------------------------------------------------------
 // Orientation (Gap 11)
 // ---------------------------------------------------------------------------
@@ -450,7 +484,7 @@ export function exploreMoves(
   *
   * Ordered nearest-first like every other card's, so it simply seeds the accumulator.
   */
-  const ownCut = cutTowards(startCard, carsOn(startCard), initialExit);
+  const ownCut = cutTowards(startCard, carsOn(startCard), rowEndAt(startCard, initialExit));
  const startKey = coordKey(start);
  const queue: Frontier[] = [
    {
@@ -502,12 +536,15 @@ export function exploreMoves(
     * overfill the tray is illegal, not a move that picks up fewer cars.
     *
     * NEAREST FIRST ALONG THE DIRECTION OF TRAVEL. `carsOn` runs west to east, so a train entering
-     * through the card's EAST port meets them back to front and the row has to be reversed. Without
+     * at the row's EAST end meets them back to front and the row has to be reversed. Without this
-     * this the same parked cut produced an identical consist whichever way it was approached, when
+     * the same parked cut produced an identical consist whichever way it was approached, when the
-     * the two must mirror — which is the difference between a run-around being worth a Move and
+     * two must mirror — which is the difference between a run-around being worth a Move and being
-     * being pointless.
+     * pointless.
     *
     * `rowEndAt` rather than `node.entry === 'e'`: a 45° leg is an end of the row too, and which
     * end it is depends on the card's arc (Gitea#17).
     */
-    const met = node.entry === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
+    const met = rowEndAt(card, node.entry) === 'e' ? [...carsOn(card)].reverse() : carsOn(card);
    const couples = [...node.couples, ...met];
    const nodeKey = coordKey(node.coord);
    const origins = [...node.origins, ...met.map(() => nodeKey)];
@@ -658,6 +695,26 @@ export function canPlaceAt(area: OfficeArea, coord: GridCoord, card: TrackCard):
  // into a stub and cutting the Office off from the Limits.
  if (coord.row === area.runningRow && !carriesThroughTrack(card)) return false;
  /**
   * ONE NEIGHBOUR MUST JOIN. THE OTHERS NEED NOT — AND THIS RULE HAS BEEN BOTH WAYS (Gitea#15).
   *
   * A card may be laid with an exit facing a card that has nothing to meet it. The rail stops dead
   * at that edge, and that is legal.
   *
   * The issue was filed the other way round — "if a card is placed in that space, it MUST connect" —
   * against a right-hand curve laid with its north leg against an Ice House and the turnout below it
   * pointing at its portless south edge. **RAR reversed it on review (2026-08-26): placing it is
   * fine, and a stub like that is useful — a siding to park cars on.**
   *
   * WHAT MATTERS INSTEAD IS THAT NOTHING CAN DRIVE ACROSS THE GAP, so the real requirement is on
   * MOVEMENT rather than on placement: two cards touching are not connected, and `exploreMoves` must
   * refuse the hop. It does — every step is gated on `joins`, never on a bare pair of `hasPort`
   * calls — and `track.test.ts` pins the reported geometry against exactly that.
   *
   * SO DO NOT ADD A PER-EDGE CHECK HERE. One was written and taken out again when the ruling
   * arrived. What survives is the weaker rule that was always here: the piece must touch the network
   * SOMEWHERE, which is what stops orphaned track being laid in an empty corner of the board.
   */
  const ports: Port[] = ['n', 's', 'e', 'w'];
  for (const p of ports) {
    const neighbourCard = cardAt(area, neighbour(coord, p));
@@ -10,6 +10,7 @@
 * drift into two different pictures of the same board.
 */
 import { regionOfTransit } from '../engine/advance.ts';
 import {
  areaAtSeat,
  areaOf,
@@ -31,7 +32,6 @@ import {
  MANEUVER_CARDS,
  MODIFIER_PROFILES,
  REALIGNMENTS,
  REGIONS_PER_MAINLINE_CARD,
  OFFICE_ORDER,
  SPACE_USE_CARDS,
  enhancementRule,
@@ -1112,36 +1112,27 @@ export function snapshot(
      // Crossing time is in Stages now, so a Mainline card shows its terrain and the trains on it
      // with how long each still has to run.
      const name = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.name ?? n.card;
-      const isGrade = MAINLINE_PROFILES.find((m) => m.kind === n.card)?.speed.kind === 'grade';
+      const isGrade = n.card === 'heavyGrade';
      /**
-       * WHERE ON THE CARD, from what the crossing already cost.
+       * WHERE ON THE CARD — now simply what the card says.
       *
-       * §2.1 divides a Mainline card into two regions and §8.2 moves a train one region per Stage.
+       * This used to recover a printed two-region model from a crossing time computed out of the
-       * The engine crosses in `crossingStages` Stages instead, which varies by card speed, train
+       * card's mph, the train's Fast/Slow class, its consist and any modifiers, by treating the
-       * speed, passengers and modifiers — so the printed model is recovered by treating the entry
+       * ENTRY point as the thing that varied: `entry = 2 - stagesTotal`. It even had to cope with a
-       * point as the thing that varies, exactly as the cards do:
+       * negative entry, for a slow train needing three Stages to cross a card with two regions.
       *
-       *     entry = REGIONS - stagesTotal        position = entry + elapsed
+       * Gitea#3 turned that the right way up. Regions are the primary thing — printed on the card,
-       *
+       * one per Stage — and the entry point is what the rules actually move. There is nothing left
-       * A 60 card is one Stage, so the train enters at the second region and is gone — which is
+       * to reconstruct.
       * what "Start positions further along the card" means on the printed art. A 30 card is two
       * Stages, giving one region per Stage, which is §8.2 exactly. A slow train needing three
       * Stages cannot fit three steps into two regions, so it holds in the first for a Stage: the
       * card's distance is fixed and the train is simply slow across it.
       */
-      const place = (t: { stagesRemaining: number; stagesTotal: number }): number => {
+      // One region per Stage, straight off the card's own count: what a train has LEFT to run says
-        // `entry` may be NEGATIVE — a slow train needing three Stages cannot fit three steps into
+      // where it is standing. `regionOfTransit` is the engine's own answer, so the picture and the
-        // two regions, so it notionally starts before the card and spends the extra Stage getting
+      // collision rule cannot disagree about who is where.
-        // to the first region. Clamping only the final position keeps that Stage at the START,
+      const place = (t: { stagesRemaining: number }): number => regionOfTransit(n.card, t.stagesRemaining);
        // where being slow shows; clamping `entry` first would have parked it at the exit instead.
        const entry = REGIONS_PER_MAINLINE_CARD - t.stagesTotal;
        const elapsed = t.stagesTotal - t.stagesRemaining;
        return Math.min(REGIONS_PER_MAINLINE_CARD - 1, Math.max(0, entry + elapsed));
      };
      return {
        kind: 'ml',
        label: name,
-        regions: REGIONS_PER_MAINLINE_CARD,
+        regions: mainlineProfile(n.card).regions,
        trains: [n.transits.map((t) => {
          const chip = trainChip(s, t.tray);
          return {
@@ -13,7 +13,7 @@ import assert from 'node:assert/strict';
 import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
 import { createGame } from '../src/engine/setup.ts';
-import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackCard } from '../src/engine/state.ts';
+import type { CrewTray, GameConfig, GameState, GridCoord, RollingStock, TrackArc, TrackCard } from '../src/engine/state.ts';
 import { carsOn, coordKey, turnOf } from '../src/engine/state.ts';
 const config: GameConfig = {
@@ -51,12 +51,18 @@ function row(s: GameState, n: number): void {
  for (let c = 0; c < n; c++) addCard(s, at(1, c), straight());
 }
 /**
 * `facing` is the PORT the engine points out through, which is not always an east-west one: a train
 * standing on a curve points along its 45° leg. `railFacing` carries the east-west sense the train
 * arrived with, so it keeps a straight answer whatever port the nose is on (`railFacingOf`).
 */
 function placeTray(
  s: GameState,
  coord: GridCoord,
  consist: RollingStock[],
-  facing: 'e' | 'w',
+  facing: 'n' | 's' | 'e' | 'w',
  engineAt = 0,
  railFacing: 'e' | 'w' = facing === 'w' ? 'w' : 'e',
 ): string {
  const id = s.freeTrays.pop()!;
  s.trays.set(id, {
@@ -65,9 +71,9 @@ function placeTray(
    trainIsExtra: false,
    engineAt,
    consist,
-    direction: facing === 'w' ? 'west' : 'east',
+    direction: railFacing === 'w' ? 'west' : 'east',
    facing,
-    railFacing: facing,
+    railFacing,
    position: { at: 'grid', seat: 0, coord },
    movesUsed: 0,
  } as CrewTray);
@@ -371,3 +377,85 @@ describe('taking your own cut back is undoing the drop, not a fresh pick-up', ()
    );
  });
 });
 // ---------------------------------------------------------------------------
 describe('a 45° leg is part of the west-to-east row, not outside it (Gitea#17)', () => {
  /**
   * Reported: "Cars were West to East Caboose, Loaded boxcar, Loaded boxcar, Loaded boxcar. After
   * backing into that square cars were attached to the train Loaded boxcar, Loaded boxcar, Loaded
   * boxcar, Caboose, Engine." The caboose came back next to the engine instead of at the far end,
   * which also leaves the train badly made up under §8.2.
   *
   * The square was a `sw` CURVE and the train backed in through its SOUTH leg. `standing` runs west
   * to east, and the two places that walk it both asked the PORT which end of the row they were at:
   * `exploreMoves` reversed the row for an 'e' entry and for nothing else, and `cutTowards` answered
   * "you meet nothing" for a north or south exit. Neither is a property of the port.
   *
   * A 45° leg leaves through the MIDDLE of its edge, so its end of the run is whichever end the arc
   * does not reach: the south leg of a `sw` curve is the row's EAST end, and the south leg of an
   * `se` curve is its WEST end. Same port, opposite answers — which is why `rowEndAt` has to ask the
   * card.
   */
  const curve = (arc: TrackArc, standing: RollingStock[] = [], standingWest = 0): TrackCard => ({
    geometry: { kind: 'track', geometry: 'curved', arc, hand: 'right' },
    baseOperationalRail: true,
    standing,
    standingWest,
    facility: null,
    modifiers: [],
    enhancements: [],
  });
  /**
   * The reported board, minimally: a `sw` curve holding the cut, and an `ne` curve below it for the
   * train to run from. Both legs lie on the `ne_sw` diagonal, so the two cards actually join.
   */
  function board(standing: RollingStock[], standingWest = standing.length): GameState {
    const s = game();
    addCard(s, at(1, 0), curve('sw', standing, standingWest));
    addCard(s, at(0, 0), curve('ne'));
    switching(s);
    return s;
  }
  it('backs into a cut through the south leg and meets the EAST end of the row first', () => {
    const s = board([car('caboose', true), car('boxcar', true), car('boxcar', true), car('boxcar', true)]);
    // Facing east on the `ne` curve, so reversing pulls out through its north leg and into the
    // curve above through that card's south leg — the move in the reported save.
    const id = placeTray(s, at(0, 0), [], 'e');
    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
    assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
    // Coupled behind the engine nearest-car-first, and the nearest car is the one at the south end
    // — the LAST of a west-to-east row on a `sw` curve. The caboose was westmost, so it ends up
    // furthest from the engine, which is where §8.2 needs it.
    assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar', 'boxcar', 'boxcar', 'caboose']);
  });
  it('meets the WEST end of the row first where the same leg belongs to an `se` curve', () => {
    // The mirror, and the reason the port alone cannot answer: an `se` curve's south leg is the
    // west end of its row, so the same reverse move meets the caboose first.
    const s = game();
    addCard(s, at(1, 0), curve('se', [car('caboose', true), car('boxcar', true)], 2));
    addCard(s, at(0, 0), curve('nw'));
    switching(s);
    const id = placeTray(s, at(0, 0), [], 'w');
    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(1, 0), reverse: true });
    assert.ok(r.ok, `the reverse move was refused: ${r.ok ? '' : r.code}`);
    assert.deepEqual(types(s.trays.get(id)!.consist), ['caboose', 'boxcar']);
  });
  it('takes its own cut back with it when it pulls out through the south leg (§A.4)', () => {
    // The other half of the same assumption: `cutTowards` said a train leaving north or south meets
    // nothing, so a crew standing on a curve drove away and left the cars beside it standing —
    // exactly what mandatory coupling forbids.
    const s = board([car('boxcar', true)], 0);
    // `standingWest` 0 puts the boxcar EAST of the train, which on a `sw` curve is between it and
    // the south leg it is about to leave by.
    const id = placeTray(s, at(1, 0), [], 's');
    const r = applyIntent(s, 0, { type: 'switch.move', trayId: id, to: at(0, 0), reverse: false });
    assert.ok(r.ok, `the move off the curve was refused: ${r.ok ? '' : r.code}`);
    assert.deepEqual(types(s.trays.get(id)!.consist), ['boxcar'], 'the cut beside the train was left standing');
    assert.deepEqual(standingAt(s, at(1, 0)), [], 'the cars should have come off the card');
  });
 });
@@ -226,14 +226,28 @@ describe('the game conserves Rolling Stock', () => {
      for (let t = 0; t < 50_000; t++) {
        const before = census(s);
        const pumped = pump(s);
-        // §10 — a collision destroys both trains and everything they were carrying. That is the one
+        /**
-        // legitimate way the count falls, so the expectation follows it down.
+         * A COLLISION DESTROYS NO CAR, and this used to assume it destroyed all of them.
-        for (const e of pumped) {
+         *
-          if (e.type === 'trainsDestroyed') for (const tr of e.trains) expected -= tr.consist.length;
+         * The subtraction that stood here — `expected -= tr.consist.length` for every train in a
-        }
+         * `trainsDestroyed` event — describes a rule the engine does not have. Gap 2c (`advance.ts`,
-        assert.ok(
+         * "TAKE THE WRECK OFF THE CARD") sends the wreck's cabooses back to the Division Yard and
-          census(s) === before || pumped.some((e) => e.type === 'trainsDestroyed'),
+         * everything else to Classification, so the stock is conserved through a collision like any
-          `seed ${seed}: the engine changed the census by ${census(s) - before} outside a collision`,
+         * other move. The train is destroyed; its cars are not.
         *
         * It passed for as long as it did because none of the six seeds below ever collided, so the
         * branch never ran. Changing the deck to the sheet's counts (Gitea#14) moved the deals, seed
         * 24757 collided, and the test failed claiming the engine had CONJURED three cars — the
         * exact opposite of what had happened.
         *
         * So the census is now held flat, unconditionally, which is both the real invariant and a
         * stronger test than the one it replaces: there is no longer any event that excuses a
         * change, and `expected` cannot drift away from the supply it was dealt.
         */
        assert.equal(
          census(s),
          before,
          `seed ${seed}: the engine changed the census by ${census(s) - before} while pumping`,
        );
        if (s.status === 'finished') break;
        const actor = s.clock.pendingDecision !== null ? s.clock.superintendent : s.clock.currentActor;
@@ -12,6 +12,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import type { MainlineKind } from '../src/engine/content.ts';
 import { advance } from '../src/engine/advance.ts';
 import { applyIntent, areaOf, check } from '../src/engine/apply.ts';
 import { legalActions } from '../src/engine/legal.ts';
@@ -40,6 +41,20 @@ const game = (seed = 5): GameState => createGame({ id: 'g', seed, config, player
 const at = (row: number, col: number): GridCoord => ({ row, col });
 /** Puts a card of `kind`/`key` in hand and returns its id. */
 /**
 * Puts a specific rules card in hand and returns its id, MINTING ONE IF THE DECK NO LONGER DEALS IT.
 *
 * A card at `copies: 0` is still a card: the catalogue keeps its row and the engine keeps its rule,
 * so the design stays visible and the mechanic works the moment it is dealt again. Poling and the
 * sharp curves have been treated that way for a while, and Gitea#14 put the dispatching ladder,
 * Facing Point Locks, Flying Switch, Section House and Vandalism there too — none of them are in
 * `docs/Deck cards5.xlsx`.
 *
 * This used to throw when it could not find one, which made "dealt zero copies" and "deleted"
 * indistinguishable from a test's point of view: zeroing Flying Switch took five passing tests of a
 * rule that had not changed at all down with it. Minting keeps the rule under test independently of
 * whether the deck currently deals the card, which is the whole reason for keeping the row.
 */
 function hand(s: GameState, kind: string, key: string): string {
  for (const [id, card] of s.cards) {
    const k = card.kind as { kind: string; key?: string };
@@ -48,7 +63,10 @@ function hand(s: GameState, kind: string, key: string): string {
      return id;
    }
  }
-  throw new Error(`no ${kind} card: ${key}`);
+  const id = `zero-copy-${kind}-${key}`;
  s.cards.set(id, { id, kind: { kind, key } } as never);
  s.decks.hands.set(0, [id]);
  return id;
 }
 /**
@@ -87,53 +105,124 @@ function drawTurn(s: GameState): void {
 // ---------------------------------------------------------------------------
-describe('grade modifiers change crossing time', () => {
+/**
-  it('a Heavy Grade takes two Stages bare', () => {
+ * Crossing time on the region model (Gitea#3). `cross` fills in the parts each test does not care
-    assert.equal(crossingStages('heavyGrade', 'fast', false), 2);
+ * about, so the numbers below read as the table RAR gave rather than as argument lists.
 */
 const cross = (
  kind: Parameters<typeof crossingStages>[0],
  over: Partial<Parameters<typeof crossingStages>[1]> = {},
 ): number =>
  crossingStages(kind, {
    trainSpeed: 'fast',
    direction: 'east',
    gradeUp: 'east',
    modifiers: [],
    ...over,
  });
 describe('a card costs one Stage per printed region (Gitea#3)', () => {
  /**
   * RAR, 2026-08-26, and this REPLACES the two rules that were here before — Q1, "the printed 60/30
   * are mph expressed as crossing time", and Q2, "a Slow train adds one Stage to every card".
   *
   * "Ignore speed signs, they are just graphics. Regions shown on cards indicate how many stages it
   * takes to cross. Plains is 1. Double track is 1, tunnel is 2, curves is 2, heavy grade is 3
   * unless you have help."
   *
   * The report that opened the issue was a Slow train taking two Stages to clear Double Track. Q2 is
   * what did that, and it is gone.
   */
  it('crosses in the number of regions the card prints, whatever the train', () => {
    for (const speed of ['fast', 'slow'] as const) {
      assert.equal(cross('plains', { trainSpeed: speed }), 1, `plains, ${speed}`);
      assert.equal(cross('doubleTrack', { trainSpeed: speed }), 1, `double track, ${speed}`);
      assert.equal(cross('trestle', { trainSpeed: speed }), 1, `trestle, ${speed}`);
      assert.equal(cross('curves', { trainSpeed: speed }), 2, `curves, ${speed}`);
      assert.equal(cross('tunnel', { trainSpeed: speed }), 2, `tunnel, ${speed}`);
      assert.equal(cross('heavyGrade', { trainSpeed: speed }), 3, `heavy grade, ${speed}`);
    }
  });
  it('reads Fast/Slow on Hilly and on nothing else', () => {
    // "Some cards say fast / slow… Fast / Slow does not apply to every card — just those that say
    // fast / slow on them. Currently this is only hilly." A fast train starts in the second region.
    assert.equal(cross('hilly', { trainSpeed: 'fast' }), 1);
    assert.equal(cross('hilly', { trainSpeed: 'slow' }), 2);
  });
  it('does not read the consist any more', () => {
    // Hilly used to take its split off the printed P60/F30 and decide by whether the train carried a
    // coach, so a fast freight crossed slower than a slow passenger train. RAR: "I notice that you
    // are basing stages in mainline cards off coach/non-coach. Actually, all trains are rated as
    // FAST and SLOW." `crossingStages` no longer takes a consist at all — this test is here so the
    // deletion is deliberate rather than incidental.
    assert.equal(cross('hilly', { trainSpeed: 'fast' }), cross('hilly', { trainSpeed: 'fast' }));
  });
  it('runs a train through a siding or an Interchange in one Stage', () => {
    // Both print a back region that is not part of the road, so a train passing through starts past
    // it. What that region is FOR is tested below and in the collision tests.
    assert.equal(cross('uncontrolledSiding'), 1);
    assert.equal(cross('interchange'), 1);
  });
  it('costs the extra Stage to anything starting in that back region', () => {
    // The Uncontrolled Siding with a train already on it, and an Extra beginning its run at an
    // Interchange. Both start at the back and have the whole card to run.
    assert.equal(cross('uncontrolledSiding', { startsAtBack: true }), 2);
    assert.equal(cross('interchange', { startsAtBack: true }), 2);
  });
 });
 describe('grade modifiers move the start, not the clock', () => {
  it('a Heavy Grade takes three Stages bare', () => {
    // Three regions, up from the two the old 30mph reading gave it.
    assert.equal(cross('heavyGrade'), 3);
  });
  it('Brakeman speeds the descent but not the climb', () => {
-    // Q11 — the card prints "(Up)" and "Player sets orientation", so the last argument is which
+    // Q11 — the card prints "(Up)" and "Player sets orientation", so `gradeUp` is which way is
-    // way is UPHILL. With up = east, a westbound train is descending.
+    // UPHILL. With up = east, a westbound train is descending.
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'east'), 1);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'east'), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east' }), 3);
  });
-  it('follows the orientation the player chose, not a fixed compass direction', () => {
+  it('follows the orientation the card was dealt, not a fixed compass direction', () => {
-    // The same train on the same card, with the card turned around: Brakeman helps a westbound
+    // The same train on the same card, with the card turned around.
-    // train on an east-climbing grade, and an eastbound one when the grade climbs west.
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'east', gradeUp: 'west' }), 2);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'east', 'west'), 1);
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west', gradeUp: 'west' }), 3);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['brakeman'], 'west', 'west'), 2);
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west', gradeUp: 'west' }), 2);
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'west'), 1);
+    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east', gradeUp: 'west' }), 3);
    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'west'), 2);
  });
  it('Helpers speed the climb but not the descent', () => {
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'east', 'east'), 1);
+    // RAR: "helpers… helps all trains going up hill by starting 1 region easier — so 2 to traverse,
-    assert.equal(crossingStages('heavyGrade', 'fast', false, ['helpers'], 'west', 'east'), 2);
+    // not 3."
    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'east' }), 2);
    assert.equal(cross('heavyGrade', { modifiers: ['helpers'], direction: 'west' }), 3);
  });
-  it('Airbrakes stack with Brakeman on a slow train', () => {
+  it('Airbrakes stack on top of Brakeman', () => {
-    // A slow train pays 3 on a grade; Brakeman and Airbrakes take one Stage each.
+    // "Airbrakes is an upgrade from brakemen (which must be played first)", so a fully-equipped
-    assert.equal(crossingStages('heavyGrade', 'slow', false, [], 'west', 'east'), 3);
+    // grade is one Stage downhill — and `check` refuses Airbrakes without Brakeman already there.
-    assert.equal(crossingStages('heavyGrade', 'slow', false, ['brakeman'], 'west', 'east'), 2);
+    assert.equal(cross('heavyGrade', { direction: 'west' }), 3);
-    assert.equal(
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman'], direction: 'west' }), 2);
-      crossingStages('heavyGrade', 'slow', false, ['brakeman', 'airbrakes'], 'west', 'east'),
+    assert.equal(cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes'], direction: 'west' }), 1);
      1,
    );
  });
  it('never lets a train cross in no time', () => {
    // Three modifiers on a three-region card would otherwise put the start past the far edge.
    assert.equal(
-      crossingStages('heavyGrade', 'fast', false, ['brakeman', 'airbrakes'], 'west', 'east'),
+      cross('heavyGrade', { modifiers: ['brakeman', 'airbrakes', 'helpers'], direction: 'west' }),
      1,
    );
  });
  it('leaves non-grade cards alone', () => {
    // Brakeman on Plains would be an illegal placement anyway; the maths must not move regardless.
-    assert.equal(crossingStages('plains', 'fast', false, ['brakeman'], 'west', 'east'), 1);
+    assert.equal(cross('plains', { modifiers: ['brakeman'], direction: 'west' }), 1);
-    assert.equal(crossingStages('curves', 'fast', false, ['helpers'], 'east', 'east'), 2);
+    assert.equal(cross('curves', { modifiers: ['helpers'] }), 2);
  });
 });
@@ -206,8 +295,8 @@ describe('Realignment converts one Mainline type to another', () => {
    assert.ok(r.ok);
    assert.equal(node.card, 'plains', 'Curves realigns to Plains');
-    // The point of the card: Curves is a 30 (two Stages), Plains a 60 (one).
+    // The point of the card: Curves prints two regions, Plains one, so realigning halves the time.
-    assert.equal(crossingStages(node.card, 'fast', false), 1);
+    assert.equal(cross(node.card), 1);
  });
  it('refuses a card with no conversion listed', () => {
@@ -793,18 +882,35 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
   * then region 1 — so it catches up whichever order the phase happens to process them in.
   */
  const twoTrains = (opts: { absSignals?: boolean } = {}): { s: GameState; events: GameEvent[] } => {
-    const s = createGame({
+    /**
-      id: 'rear', seed: 3,
+     * THE SEED IS SEARCHED FOR, NOT WRITTEN DOWN.
-      config: {
+     *
-        mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
+     * This asked for seed 3 and asserted that its Division held a single-track Mainline card. It
-        optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
+     * does not any more: the Division is laid out from the same RNG stream the card deck is
-      },
+     * shuffled from, so changing the SIZE of that deck re-deals the Division too. Gitea#14's deck
-      playerNames: ['bot'],
+     * counts moved it, and the test failed on its own precondition — "no single-track Mainline card
-    });
+     * in this Division" — which says nothing about the rule under test.
-    const index = s.division.nodes.findIndex(
+     *
-      (n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
+     * The fixture needs A Division with a card trains may not pass on, not one particular one, so
-    );
+     * it now takes the first seed that provides one. That is stable across any future retune, and
-    assert.ok(index >= 0, 'no single-track Mainline card in this Division');
+     * it fails loudly if such a Division stops being reachable at all.
     */
    let s!: GameState;
    let index = -1;
    for (let seed = 3; seed < 200 && index < 0; seed++) {
      s = createGame({
        id: 'rear', seed,
        config: {
          mode: 'solitaire', victory: 'highestAfterDays', length: 'standard',
          optionalRules: { reducedVisibility: false, sisterTrains: false, employeeRotation: false, emergencyToolbox: false },
        },
        playerNames: ['bot'],
      });
      index = s.division.nodes.findIndex(
        (n) => n.kind === 'mainline' && !mainlineProfile(n.card).trainsMayPass,
      );
    }
    assert.ok(index >= 0, 'no seed under 200 deals a Division holding a single-track Mainline card');
    const node = s.division.nodes[index]!;
    assert.ok(node.kind === 'mainline');
    if (node.kind !== 'mainline') throw new Error('unreachable');
@@ -860,12 +966,116 @@ describe('Q13 — a train that catches the one ahead runs into it', () => {
    );
  });
-  it('leaves trains alone on a card that prints "trains may pass"', () => {
+  /**
-    // Double Track and Uncontrolled Siding hold two trains because they HAVE two roads. Catching up
+   * ENTERING an occupied region, as opposed to catching up inside the card (Gitea#3).
-    // there means going past, which is what the card is for. Without this the mechanic fired 0.41
+   *
-    // times a game while the bot never once granted clearance — the tell that they were all
+   * A card can be ONE region wide — Plains, Double Track and Trestle all are — so a following train
-    // passing cards.
+   * granted clearance is in the same place as the train ahead the moment it arrives. Nothing tested
   * that: the catch-up check lives inside `stagesRemaining > 1`, which a one-Stage crossing never
   * reaches, so entering behind another train on a Plains was silently free.
   */
  const enteringBehind = (card: MainlineKind, opts: { absSignals?: boolean } = {}) => {
    const s = game();
    const index = s.division.nodes.findIndex((n) => n.kind === 'mainline');
    const node = s.division.nodes[index]!;
    assert.ok(node.kind === 'mainline');
    if (node.kind !== 'mainline') throw new Error('unreachable');
    node.card = card;
    node.transits = [];
    if (opts.absSignals) node.absSignals = true;
    /**
     * THE TRAIN ALREADY THERE IS THE JUNIOR ONE, and that is what makes the situation reachable.
     *
     * Trains move lowest number first, so a card's occupant normally clears before anything behind
     * it is even considered — put train 9 on the card and train 11 at the Division Point and 9 has
     * gone by the time 11 enters. The conflict is a SUPERIOR train catching an inferior one that has
     * not got out of the way yet, so the numbers run the other way round here.
     */
    const leader = s.freeTrays.pop()!;
    s.trays.set(leader, {
      id: leader, trainNumber: 11, trainIsExtra: false, engineAt: 0,
      consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
      position: { at: 'mainline', index },
    } as never);
    const total = crossingStages(card, { trainSpeed: 'fast', direction: 'east', gradeUp: 'east', modifiers: [] });
    node.transits.push({ tray: leader, stagesRemaining: total, stagesTotal: total, direction: 'east' });
    // And the one arriving, held at the Division Point west of it.
    const dp = s.division.nodes[index - 1];
    assert.ok(dp && dp.kind === 'divisionPoint', 'expected a Division Point west of the first card');
    if (!dp || dp.kind !== 'divisionPoint') throw new Error('unreachable');
    const follower = s.freeTrays.pop()!;
    s.trays.set(follower, {
      id: follower, trainNumber: 9, trainIsExtra: false, engineAt: 0,
      consist: [{ type: 'boxcar', loaded: false }], direction: 'east',
      position: { at: 'divisionPoint', side: dp.side },
    } as never);
    dp.holding.push(follower);
    /**
     * THE SUPERINTENDENT LETS IT IN, which is the whole point.
     *
     * A same-direction train in the Subdivision is not an absolute bar — §8.1 makes it a judgment
     * call, and `advance` stops and asks. Granting it is what puts one train in behind another, and
     * §10 is then explicit that the wreck is the Superintendent's fault. So the fixture answers
     * `allow: true` whenever it is asked, and the collision below is the consequence of that
     * ruling rather than of a rule firing on its own.
     */
    s.clock.phase = 'mainline';
    const events: GameEvent[] = [];
    for (let i = 0; i < 6; i++) {
      events.push(...advance(s).events);
      if (s.clock.pendingDecision !== null) {
        const who = s.clock.superintendent;
        const r = applyIntent(s, who, { type: 'mainline.clearance', allow: true });
        assert.ok(r.ok, `clearance refused: ${r.ok ? '' : r.code}`);
        events.push(...r.events);
      }
    }
    return { s, node, events, follower };
  };
  it('runs a train into the one ahead when it ENTERS an occupied region', () => {
    const { events } = enteringBehind('plains');
    const smash = events.find((e) => e.type === 'trainsDestroyed');
    assert.ok(smash, 'a train entered a one-region card behind another and nothing happened');
  });
  it('holds it short instead when the card carries ABS Signals', () => {
    // RAR: "ABS. This is played on a mainline card to prevent collisions. If a collision would
    // normally occur, the train moving onto the card is instead held back."
    const { events } = enteringBehind('plains', { absSignals: true });
    assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'ABS Signals did not prevent it');
    assert.ok(
      events.some((e) => e.type === 'trainHeld' && /ABS Signals/.test(e.reason)),
      'nothing was held short of the train ahead',
    );
  });
  it('takes the siding instead of colliding on an Uncontrolled Siding', () => {
    // "If a train already exists when you arrive, you go in the second stage back — you are in the
    // siding and are one behind the other train. This prevents a collision, since you are not in
    // same exact location." So: no wreck, both trains on the card, and the newcomer paying the
    // extra Stage for the detour.
    const { node, events, follower } = enteringBehind('uncontrolledSiding');
    assert.ok(!events.some((e) => e.type === 'trainsDestroyed'), 'the siding did not prevent a collision');
    const mine = node.transits.find((t) => t.tray === follower);
    assert.ok(mine, 'the arriving train never made it onto the card');
    assert.equal(mine.stagesTotal, 2, 'it should have entered at the back of the card, not the front');
  });
  it('leaves trains alone on the one card that prints "trains may pass"', () => {
    // Double Track holds two trains because it HAS two roads. Catching up there means going past,
    // which is what the card is for.
    //
    // THE UNCONTROLLED SIDING USED TO BE IN THIS LIST AND IS NOT ANY MORE (Gitea#3). It holds two
    // trains as well, but not by letting them share a place: the second one takes the siding and
    // sits a region behind, which is what keeps them apart — "you are in the siding and are one
    // behind the other train. This prevents a collision, since you are not in same exact location."
    // Marked "may pass" it skipped the collision test entirely, so the siding did nothing at all and
    // two trains could occupy the same region of it unchallenged.
    const passing = MAINLINE_PROFILES.filter((m) => m.trainsMayPass).map((m) => m.kind);
-    assert.deepEqual(passing, ['doubleTrack', 'uncontrolledSiding']);
+    assert.deepEqual(passing, ['doubleTrack']);
  });
 });
@@ -115,19 +115,34 @@ describe('the Fedora goes round the table', () => {
   * decides who sits where, the sequence of player indices is a permutation while the sequence of
   * seats is the plain 0, 1, 2, … that the rule describes.
   */
  /**
   * THE SEED IS SEARCHED FOR, because a game that ends on Day 1 cannot show a rotation.
   *
   * This took seed 4242 flat. Gitea#14's deck counts re-dealt it, and the three-player game now
   * loses on `collisionFloor` at Day 1 Stage 10 — so the Fedora legitimately moves twice and the
   * test failed reporting a rotation bug that is not there. Whether a particular deal ends early on
   * collisions has nothing to do with whether the Fedora passes to the next seat.
   *
   * So the fixture asks for what it actually needs: a game that runs far enough to watch. It takes
   * the first seed whose game reaches Day 3, which is four shift changes at minimum, and reports
   * honestly if no seed in range does.
   */
  const superintendentsSeen = (players: number): number[] => {
-    const s = game(players);
+    for (let seed = 4242; seed < 4342; seed++) {
-    const seen: number[] = [];
+      const s = game(players, seed);
-    const spy = {
+      const seen: number[] = [];
-      name: 'spy',
+      const spy = {
-      choose(st: GameState, p: PlayerIndex, opts: Parameters<typeof developerBot.choose>[2]) {
+        name: 'spy',
-        const who = seatOf(st, st.clock.superintendent);
+        choose(st: GameState, p: PlayerIndex, opts: Parameters<typeof developerBot.choose>[2]) {
-        if (seen[seen.length - 1] !== who) seen.push(who);
+          const who = seatOf(st, st.clock.superintendent);
-        return developerBot.choose(st, p, opts);
+          if (seen[seen.length - 1] !== who) seen.push(who);
-      },
+          return developerBot.choose(st, p, opts);
-    };
+        },
-    playGame(s, spy as never, pump);
+      };
-    return seen;
+      playGame(s, spy as never, pump);
      if (s.clock.day >= 3) return seen;
    }
    assert.fail(`${players}p: no seed in range produced a game that reached Day 3`);
  };
  it('passes the Superintendent to the next seat, wrapping round the table', () => {
@@ -61,56 +61,73 @@ const gameDealtWith = (startingHand: StartingHand, seed = 1234) =>
 describe('card catalogue (component 1)', () => {
  it('composes the deck from the design', () => {
-    // Transcribed from docs/Deck cards2.xlsx. The sheet's own totals are "Sum other 115" and
+    // THE WHOLE CATALOGUE IS docs/Deck cards5.xlsx NOW (Gitea#14). Sheet 5's own totals are
-    // "Total track 104", i.e. 219, plus 12 start cards for its grand total of 231.
+    // "Total track 48" and "Total other (in play) 107", i.e. 155 shuffled, plus 12 start cards for
    // its grand total of 167. Card for card, 84 rows agree with it exactly and the only ones that
    // do not are listed below — every one of them a deliberate hold, in one direction or the other.
    //
-    // We are at 235 rather than 219 because of three deliberate departures, all flagged in
+    // EVERY COUNT IN THE CATALOGUE IS NOW THE SHEET'S. The two deliberate departures that used to
-    // content.ts: 18 extra industry cards (Gap 12, industries 9 → 27), 7 extra office cards (Q12,
+    // sit here are gone with Gitea#14 — the Q12 office doubling (offices 14 → 7) and the Gap 12
-    // offices 7 → 14), and the 8 sharp curves taken back OUT. The first two were tuned against a deck
+    // industry tripling (27 → 9) — because both were measured against a deck holding 96 track
-    // that had NO track in it, so both are due a re-measurement now that 96 track cards share the
+    // cards, and sheet 5 halves that. content.ts carries the measurements that decided it.
    // draw.
    //
-    // Two entries are dealt ZERO copies and kept in the catalogue so the design stays visible:
+    // We are at 143 rather than the sheet's 155 for ONE reason: the ten Safety, Event, Inspection
-    // Poling, whose effect is "TBD in the source", and the sharp curves, whose only difference from
+    // and Space-use cards sheet 5 adds are not built, and stay out until they are (Jesse,
-    // an ordinary curve was a Move cost nothing ever charged.
+    // 2026-08-26) — Cargo Theft, Civic Improvement, Civilian angel, Delayed Clearance, Flares 2,
-    // DECK_SIZE is the CATALOGUE, 235. The deck actually dealt is smaller: the 22 opponent-directed
+    // Robbery, Service Delays, Shipper complaints, Strike, Union Hall 2. Twelve copies in all.
-    // cards are held back in every mode until they are implemented, so `buildDeck` returns 213.
+    //
-    assert.equal(DECK_SIZE, 235);
+    // NOTHING RUNS THE OTHER WAY ANY MORE. Every card sheet 5 does not list is dealt ZERO copies
    // rather than deleted, so the design stays visible and the rules stay implemented: the
    // Telegraph/Telephone/Radio ladder, Facing Point Locks (both), Flying Switch, Section House and
    // Vandalism, all removed from the design on purpose; Poling, whose effect the source records as
    // "TBD"; and the sharp curves, whose only difference from an ordinary curve was a Move cost
    // nothing ever charged — sheet 5 deals those zero too, so the catalogue and the design agree.
    //
    // DECK_SIZE is the CATALOGUE, 143. The deck actually dealt is smaller: the 20 opponent-directed
    // cards are held back in every mode until they are implemented, so `buildDeck` returns 123.
    assert.equal(DECK_SIZE, 143);
    assert.equal(buildDeck().length, SOLITAIRE_DECK_SIZE);
  });
  it('matches the design deck composition exactly', () => {
    const byCategory = Object.fromEntries(deckComposition().map((c) => [c.category, c.count]));
    assert.deepEqual(byCategory, {
-      // 96, not the sheet's 104: the 8 SHARP CURVES are dealt zero copies. The only thing that made
+      // Sheet 5's track counts exactly (Gitea#14): 16 straights, 8+8 curves, 8+8 turnouts, and the
-      // one different from an ordinary curve was a Move cost that nothing ever charged, so they were
+      // sharp curves dealt none — which is where the catalogue already had them, and where sheet 5
-      // geometric duplicates taking 8 draws. Kept in the catalogue at zero, as Poling is.
+      // now puts them too.
-      track: 96,
+      track: 48,
-      // 14, not the sheet's 7 — Q12 office density; see OFFICE_PROFILES.
+      // The sheet's 7 — the Q12 doubling came out in Gitea#14; see OFFICE_PROFILES.
-      office: 14,
+      office: 7,
-      // 27, not the sheet's 9 — Gap 12 industry density; see INDUSTRY_PROFILES.
+      // The sheet's 9 — the Gap 12 tripling came out in Gitea#14; see INDUSTRY_PROFILES.
-      industry: 27,
+      industry: 9,
      modifier: 23,
      train: 22,
-      spaceUse: 12,
+      spaceUse: 11,
-      enhancement: 18,
+      // 6 — the dispatching ladder and Facing Point Locks are dealt 0 copies (see
-      mainlineModifier: 7,
+      // ENHANCEMENT_CARDS), and Interlocking, Water column and ABS Signals came down to the sheet's
-      // 6, not 7 — Poling is dealt no copies until its rule is known.
+      // single copies. What is left is the sheet's Enhancements exactly, bar Railroad crossing,
-      maneuver: 6,
+      // which sheet 5 moved here from the Action cards and which is still counted there below.
-      action: 10,
+      enhancement: 6,
      // 5 — Facing Point Locks came out of the Mainline modifiers too.
      mainlineModifier: 5,
      // 3 — Red Flags is the sheet's 3; Flying Switch and Poling are both dealt none.
      maneuver: 3,
      // 9 — Vandalism is dealt none. The rest are opponent-directed and held out of every deck.
      action: 9,
    });
  });
  it('removes opponent-directed cards from a solitaire deck', () => {
    // Q6 took Space-use and Action cards out of solitaire, where they have no legal target. They are
    // now out of the COMPETITIVE deck too, until they are implemented: `checkPlay` answers both
-    // categories NOT_IMPLEMENTED, so dealing them would make 22 of 235 draws (9%) reject outright.
+    // categories NOT_IMPLEMENTED, so dealing them would be a dead draw.
-    // 206, not 213: the 22 opponent-directed cards come out, and so do the SEVEN that exist only to
+    // 121, not 123: the 20 opponent-directed cards come out, and so do the TWO that exist only to
-    // answer them — Facing Point Locks (both the Enhancement and the Mainline modifier, 2 each), two
+    // answer them — one Water Column and one Overpass. A defence with nothing to defend against is
-    // Water Columns and one Overpass. A defence with nothing to defend against is the same dead draw
+    // the same dead draw as the attack would be. `SimpleCard.answers` names the pairing, so they
-    // as the attack would be. `SimpleCard.answers` names the pairing, so they return together.
+    // return together. It was seven until Gitea#14 dealt Facing Point Locks zero copies: a card at
-    assert.equal(SOLITAIRE_DECK_SIZE, 206);
+    // zero is already out, so it no longer needs holding back.
-    assert.equal(DEFENCE_ONLY_COPIES, 7);
+    assert.equal(SOLITAIRE_DECK_SIZE, 121);
    assert.equal(DEFENCE_ONLY_COPIES, 2);
    for (const c of DEFENCE_ONLY_CARDS) {
      assert.ok(c.answers, `${c.name} is held back without saying what it answers`);
      assert.ok(
@@ -129,11 +146,12 @@ describe('card catalogue (component 1)', () => {
  });
  it('deals track FROM the deck, at the sheet\'s counts', () => {
-    // Column B of Deck cards2.xlsx, "Number in Deck": 32 straights, 16+16 curves, 16+16 turnouts —
+    // Column B of Deck cards5.xlsx, "Number in Deck": 16 straights, 8+8 curves, 8+8 turnouts, and
-    // and 4+4 sharp curves, which are dealt none. An earlier reading took the sheet's LAST column,
+    // 0+0 sharp curves. Sheet 2 had each of those at double, which is what the deck dealt until
-    // "Track Per Player" (26), as a separate stack outside the deck; it is the sheet's 104 shared out
+    // Gitea#14. An earlier reading took the sheet's LAST column, "Track Per Player" (26), as a
-    // among four players, not a second pile.
+    // separate stack outside the deck; it is the sheet's total shared out among four players, not a
-    assert.equal(TRACK_IN_DECK, 96);
+    // second pile.
    assert.equal(TRACK_IN_DECK, 48);
    const deck = buildDeck();
    for (const t of TRACK_CARDS) {
      const n = deck.filter(
@@ -144,11 +162,26 @@ describe('card catalogue (component 1)', () => {
  });
  it('makes track the largest category in the deck', () => {
-    // 96 of 235. Building a district is paid for in the industry or train you did not draw, which
+    // 48 of 121. Building a district is paid for in the industry or train you did not draw, which
    // is the whole reason it matters that track is a card rather than a private supply.
    //
    // This asked for a THIRD of the deck until Gitea#14, which was only ever a rule of thumb. It
    // asks its own question now — is track still the biggest single thing you can draw — plus a
    // loose band, because the exact share is not settled yet and should not be pinned as though it
    // were. Sheet 5 puts track at 48 of the 155 cards it would have you shuffle, i.e. 31%; we read
    // 40% because the Space-use, Safety, Event and Inspection cards are held out, which concentrates
    // everything that is left. The share falls TOWARDS the sheet as those land, so the band is set
    // to hold across that whole journey rather than to be re-edited at each step.
    const deck = buildDeck();
-    const track = deck.filter((c) => c.kind.kind === 'track').length;
+    const counts = new Map<string, number>();
-    assert.ok(track > deck.length / 3, `track is only ${track} of ${deck.length} cards`);
+    for (const c of deck) counts.set(c.kind.kind, (counts.get(c.kind.kind) ?? 0) + 1);
    const track = counts.get('track') ?? 0;
    for (const [kind, n] of counts) {
      if (kind === 'track') continue;
      assert.ok(track > n, `${kind} has ${n} cards against track's ${track}`);
    }
    const share = track / deck.length;
    assert.ok(share > 0.28 && share < 0.45, `track is ${(share * 100).toFixed(1)}% of the deck`);
  });
  it('has 12 timetabled trains, odd westbound and even eastbound', () => {
@@ -189,15 +189,26 @@ describe('the revenue chain works end to end (regression)', () => {
    // only because unloads were mis-scored as completed loads after one Laborer action instead of
    // four. Correcting that dropped mean revenue from 24.8 to ~4.6 and the win rate to zero, so
    // "did anyone win" is no longer a safe proxy for "does freight work".
    /**
     * TWO HUNDRED GAMES, up from forty (Gitea#3). Completed freight loads got scarcer when the
     * Mainline went onto the region model, and measurably so — on these seeds: 40 games yield 0
     * loads, 80 yield 3 (1 game), 120 yield 10 (4 games), 200 yield 21 (9 games). Forty could no
     * longer reach the precondition it exists to establish.
     *
     * WHY it got scarcer is not settled and is worth someone's attention rather than a guess — the
     * change speeds crossings up, which ought to put MORE trains through a district, not fewer.
     * Freight share of gross fell from 8% to 5% over 100 games across the same change. Recorded in
     * TODO.md under Play Balance; the assertion itself is untouched.
     */
    const report = simulate({
-      games: 40,
+      games: 200,
      length: 'standard',
      mode: 'solitaire',
      players: ['bot'],
      policy: developerBot,
    });
    const freight = report.perGame.reduce((n, g) => n + g.revenue.freightLoad, 0);
-    assert.ok(freight > 0, 'no freight load completed across 40 games');
+    assert.ok(freight > 0, 'no freight load completed across 200 games');
  });
  it('grows the Office Area off the Running Track, on either side', () => {
@@ -349,7 +360,24 @@ describe('end-of-game statistics', () => {
     * rule that has become unreachable. Exempted by name so the other forty-odd event checks stay live,
     * and so removing this line is what proves the bot has been fixed.
     */
-    const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch'];
+    /**
     * RED FLAGS JOINS IT (Gitea#3), and for the same reason — the rule is reachable and the bot will
     * not take it.
     *
     * MEASURED over 600 games: `maneuver.redFlags` is OFFERED 4,212 times, first in game 5 — so the
     * rule is live and constantly available. The bot PLAYS it 4 times, first in game 252. At 200
     * games this canary sees nothing and calls it unreachable, which is the opposite of the truth.
     *
     * It got rarer for two compounding reasons, neither of them a broken rule: Gitea#14 took Red
     * Flags from 5 copies to the sheet's 3, and Gitea#3 shortened most crossings to a single Stage,
     * so the window in which a train is STANDING on a Mainline card — the only place the card may be
     * played — is now usually one Stage wide.
     *
     * The bot's unwillingness is the thing worth fixing, and it is in TODO.md under Bot Performance.
     * Exempted BY NAME so the other forty-odd checks stay live, and so deleting this line is what
     * proves the bot has learned to use it.
     */
    const KNOWN_UNREACHABLE_BY_THE_BOT = ['event flyingSwitch', 'event redFlagsSet'];
    const found = anomalies(report.perGame);
    const never = found
      .filter((a) => a.severity === 'never')
@@ -641,12 +669,17 @@ describe('the bot builds sidings that are actually sidings (regression)', () =>
    // Measured across 100 games: tank cars boarded a train 0.07 times a game and were dropped by a
    // crew ZERO times, while boxcars were 67% of every drop — and 23 of 79 waiting loads were
    // sitting at an industry that wanted a tank.
-    // A HUNDRED GAMES, not thirty — the comment above says the original measurement used 100, and
+    // THREE HUNDRED GAMES, up from a hundred, because the sheet's industry density (Gitea#14) makes
-    // the sample has to be that big to mean anything: measured now, a tank is set out in 3% of games
+    // the rare commodities much rarer. Measured on these exact seeds, the game at which each type is
-    // and a reefer in 5%. Thirty games passed on luck and stopped the moment the opening deal moved
+    // first set out by a crew: caboose 5, boxcar 12, hopper 37, reefer 44, coach 64, **tank 216**.
-    // which cards a seed puts in reach. Deterministic seeds, so this either holds or it does not.
+    //
    // A Refinery is one card in a hundred and fifty now, so a tank moving at all needs that card
    // drawn, placed, reached and worked. The old sample of 100 stopped covering it — not because the
    // rule broke, but because the deck did what the sheet asks. The sample follows the measurement
    // rather than the assertion being softened: tank is still the strict test, for the reason below.
    // Deterministic seeds, so this either holds or it does not.
    const dropped = new Set<string>();
-    for (let i = 0; i < 100; i++) {
+    for (let i = 0; i < 300; i++) {
      const s = createGame({
        id: `cs-${i}`,
        seed: 1000 + i * 7919,
@@ -996,6 +1029,12 @@ describe('the bot does not lay track that cannot work (regression)', () => {
    // A TIE-BREAKER rather than a veto, so this is a rate and not a zero: forbidding it outright
    // measured WORSE (-0.62 revenue a game), while preferring the cleaner of two equally good
    // placements measured better and cut these from 28% of pieces to 7%.
    //
    // AND IT STAYS A TIE-BREAKER. Gitea#15 was filed as "track placements must connect" and briefly
    // became a rule here; RAR reversed it on review (2026-08-26) — a rail may stop dead against its
    // neighbour, and such a stub is useful as a siding to park cars on. What the engine must refuse
    // is a TRAIN crossing the gap, which is `exploreMoves`' job and is tested in `track.test.ts`.
    // So laying one of these is a preference, exactly as it was, and the rate below is the bar.
    let laid = 0;
    let dead = 0;
    /**
@@ -1092,8 +1131,14 @@ describe('the freight figures count both halves (regression)', () => {
     * The subject here is the INSTRUMENT — does `freightUnload` count Revenue earned rather than
     * unloads started — and `unloads > 0` is only the precondition that makes the comparison mean
     * anything. Widening the sample restores the precondition without weakening the assertion.
     *
     * A HUNDRED AND FIFTY DEALS, up from forty, for the same reason as the commodity test above:
     * Gitea#14 put the deck on the sheet's industry density and completed unloads went with it.
     * Measured on these seeds, the first deal to EARN unload Revenue is number **46**, and 19 deals
     * in 400 earn any — so forty could not reach the precondition it exists to establish. 150 clears
     * it with room, and the assertion itself is untouched.
     */
-    for (let i = 0; i < 40; i++) {
+    for (let i = 0; i < 150; i++) {
      const seed = 1000 + i * 7919;
      const s = createGame({
        id: `fu-${seed}`, seed,
@@ -540,6 +540,100 @@ describe('placement and drop-off', () => {
    assert.ok(!canPlaceAt(area, at(-1, 1), straight()), 'an east-west straight cannot meet a 45° leg');
  });
  describe('a rail that stops dead against its neighbour (Gitea#15)', () => {
    /**
     * REPORTED, THEN REVERSED. The issue first read "if a card is placed in that space, it MUST
     * connect", against a right-hand curve laid at (1,-1) with an Ice House above it and a turnout
     * with a north-facing leg below. **RAR reviewed it and ruled the other way (2026-08-26): the
     * placement is fine, and a stub like that has a use — a siding to park cars on.**
     *
     * "We need to confirm, however, that trains are not allowed to traverse from the turnout below
     * to that right-hand curve since the tracks do not connect." That is what these tests are: the
     * rule lives in MOVEMENT, not in placement.
     *
     * The save cannot carry this any more — Gitea#14 took the deck from 206 cards to 121, so its
     * card ids no longer exist and the history stops at the first `card.play`. The geometry is what
     * mattered, and it is rebuilt here directly.
     */
    /** A Modifier card — an Ice House. Not track: no ports on any edge. */
    const modifierCard = (): TrackCard => ({
      geometry: { kind: 'modifier', modifier: 'iceHouse' },
      baseOperationalRail: false,
      standing: [],
      standingWest: 0,
      facility: null,
      modifiers: [],
      enhancements: [],
    });
    /** A Grocer's Warehouse — a Facility, so a plain east-west through track. */
    const warehouse = (): TrackCard => ({
      geometry: { kind: 'facility', facility: 'grocersWarehouse' },
      baseOperationalRail: true,
      standing: [],
      standingWest: 0,
      facility: null,
      modifiers: [],
      enhancements: [],
    });
    /**
     * The reported district. `withCurve` puts the disputed right-hand curve on the square; without
     * it, the square is empty and the placement itself is under test.
     *
     * The turnout's leg goes NORTH on the `nw_se` diagonal; the curve is `ne`, which is `ne_sw` and
     * has no south port at all. Two reasons the two do not join, either of which is enough.
     */
    const board = (withCurve: boolean): OfficeArea =>
      areaFrom(
        {
          [coordKey(at(0, -1))]: turnout({ stem: 'w', through: 'e', diverge: 'n' }),
          [coordKey(at(0, 0))]: officeCard(),
          [coordKey(at(1, 0))]: warehouse(),
          [coordKey(at(2, -1))]: modifierCard(),
          ...(withCurve ? { [coordKey(at(1, -1))]: curve('ne') } : {}),
        },
        at(0, 0),
      );
    it('allows the reported placement, which connects on one side and nothing else', () => {
      // RAR's ruling. The curve joins the warehouse to its east; its north leg faces an Ice House
      // that carries no rail, and the turnout below faces its portless south edge. All legal.
      assert.ok(canPlaceAt(board(false), at(1, -1), curve('ne')), 'the reported play was refused');
    });
    it('will not let a train cross from the turnout below onto that curve', () => {
      // The confirmation the issue actually asks for. Running west out of the Office and into the
      // turnout, the 45° leg goes north — and stops at the curve's blank south edge.
      const dests = reachableDestinations(ctxFor(board(true)), at(0, 0), 'w');
      assert.ok(!has(dests, 1, -1), 'a train drove across rails that do not meet');
    });
    it('still reaches the curve from the side that DOES join', () => {
      // Otherwise the test above would pass on a card that is simply unreachable, which proves
      // nothing. East of the curve is the warehouse, and east-west edges always meet.
      const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
      assert.ok(has(dests, 1, -1), 'the curve was unreachable from the side that joins');
    });
    it('will not let a train cross a north edge onto a card with no rail at all', () => {
      // The Ice House above. A Modifier is scenery beside the rails — Jesse confirmed a rail may
      // point at a building — so what stops a train is the same `joins` test, not a placement rule.
      const dests = reachableDestinations(ctxFor(board(true)), at(1, 0), 'w');
      assert.ok(!has(dests, 2, -1), 'a train drove into an Ice House');
    });
    it('still allows an exit that faces a BLANK square', () => {
      // Unchanged by the reversal, and the reason a district can grow at all: a turnout laid on the
      // Running Track with nothing yet beside its diverging leg is a perfectly good play.
      const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
      assert.ok(
        canPlaceAt(area, at(0, 1), turnout({ stem: 'w', through: 'e', diverge: 'n' })),
        'a turnout whose leg faces open space was refused',
      );
    });
  });
  it('refuses a card that connects to nothing', () => {
    const area = areaFrom({ [coordKey(at(0, 0))]: officeCard() }, at(0, 0));
    assert.ok(!canPlaceAt(area, at(3, 3), straight()), 'orphaned track is never legal');
@@ -907,17 +907,29 @@ describe('the page explains itself', () => {
    // A played card becomes a cell with a name on it — "turnout", "Freight House", "waiting area" —
    // and the explanation that was visible while it sat in hand disappears exactly when it starts
    // mattering. Play a long way in so every card kind reaches the grid.
-    const game = newGame(111);
+    /**
-    for (let i = 0; i < 400; i++) {
+     * THE SEED IS SEARCHED FOR, not written down. This took seed 111 flat and asserted its board
-      if (currentActor(game) === null) break;
+     * ended up with more than four cards on it. Gitea#3 changed how fast trains cross, which changes
-      const { options } = actionGroups(game);
+     * how a game unfolds, and 111 stopped building enough of a district — so the test failed on its
-      if (options.length === 0) break;
+     * own precondition rather than on anything about tooltips.
-      const pick = options.find((o) => o.type === 'card.play' && o.placement) ?? options[0]!;
+     *
-      if (!submit(game, pick)) break;
+     * It needs A well-built board, not one particular one, so it takes the first seed that gives it.
     */
    let game = newGame(111);
    for (let seed = 111; seed < 211; seed++) {
      game = newGame(seed);
      for (let i = 0; i < 400; i++) {
        if (currentActor(game) === null) break;
        const { options } = actionGroups(game);
        if (options.length === 0) break;
        const pick = options.find((o) => o.type === 'card.play' && o.placement) ?? options[0]!;
        if (!submit(game, pick)) break;
      }
      if (view(game).cells.length > 4) break;
    }
    const cells = view(game).cells;
-    assert.ok(cells.length > 4, 'not enough of the board was built to be a real check');
+    assert.ok(cells.length > 4, 'no seed under 211 built enough of a board to be a real check');
    for (const c of cells) {
      assert.ok(c.what.length > 0, `(${c.row},${c.col}) ${c.label} has no explanation`);
      // camelCase on the board is the failure that keeps recurring — labels AND descriptions.
@@ -1534,7 +1546,40 @@ describe('the static build', () => {
      (target['onclick'] as (() => void) | null)?.();
      return true;
    };
-    assert.ok(clickVerb(hand, 'play'), 'no card in hand offers a play verb');
+    /**
     * TRY EVERY PLAY BUTTON, NOT JUST THE FIRST — a card offering "play" does not necessarily play
     * ONTO THE BOARD.
     *
     * This clicked the first play verb it found and then asserted the board had lit up. A train card
     * plays to the timetable and a Department discard to the piles, so neither lights a square, and
     * whether the first playable card in this deal happens to be a track or facility card is luck.
     * Gitea#14's deck counts re-dealt seed 555, the first play verb landed on Train 2, and the test
     * failed claiming the page highlighted nothing — when the page was right and the card simply had
     * no square to point at.
     *
     * So it clicks each play button in turn until the board lights, which is the property the test
     * is named for. It still fails loudly if NO card in hand can light a square.
     *
     * EACH BUTTON IS CLICKED EXACTLY ONCE. Picking a card is a toggle, so clicking one to check it
     * and then clicking it again inside the loop would UNPICK it — which is how the first draft of
     * this managed to fail on a deal whose very first play card was a good one.
     */
    const playButtons = (el: Record<string, unknown>): Record<string, unknown>[] => {
      const fn = el['querySelectorAll'] as (s: string) => Record<string, unknown>[];
      return fn
        .call(el, 'button.cardact')
        .filter((n) => (n['dataset'] as Record<string, string>)['verb'] === 'play');
    };
    assert.ok(playButtons(hand).length > 0, 'no card in hand offers a play verb');
    let litTheBoard = false;
    for (const target of playButtons(hand)) {
      (target['onclick'] as (() => void) | null)?.();
      const drawn = String(grid['innerHTML']);
      if ((grid['highlighted'] as () => unknown[])().length > 0 || /data-ghost="/.test(drawn)) {
        litTheBoard = true;
        break;
      }
    }
    // Without the board stylesheet every shape is drawn black on a near-black background: the page
    // looks empty even though the markup is perfect.
@@ -1547,7 +1592,10 @@ describe('the static build', () => {
    assert.match(html, /data-cell="/, 'the board drew no addressable cards');
    const lit = (grid['highlighted'] as () => unknown[])();
    const ghosts = /data-ghost="/.test(html);
-    assert.ok(lit.length > 0 || ghosts, 'picking a card highlighted nothing on the board');
+    assert.ok(
      litTheBoard || lit.length > 0 || ghosts,
      'no card in hand, picked in turn, ever highlighted a square on the board',
    );
    /**
     * POINTING AT THE SQUARE A BUTTON MEANS — wired on the emitted bundle, not asserted off the menu.