v0.7.2 — a leg that is part of the row, the deck the sheet prints, regions not miles per hour, and a Division you read left to right

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. The same
assumption left a crew's own cut standing when it pulled out through a leg,
which is the "cars left behind" report we had failed to reproduce.

Gitea#14 — every count is docs/Deck cards5.xlsx. Track halved, and the Q12
office doubling and Gap 12 industry tripling both come out with it: they were
measured against a deck with twice the track, and keeping them at the sheet's
track count wipes out the reefer chain entirely. 84 rows now match card for
card; the ten Safety, Event and Inspection cards it adds are not built and are
held out. Cards the sheet no longer lists are dealt zero copies rather than
deleted, so their rules stay implemented.

Gitea#15 — RAR reversed it: a rail may stop dead against its neighbour and the
placement is legal. What must hold is that no train crosses the gap, which was
already true and is now pinned against the reported board.

Gitea#3 — the printed speeds are scenery. A card costs one Stage per printed
region and where a train STARTS is what varies; Fast/Slow is read on Hilly
alone. Entering a one-region card behind another is a collision now, which is
what ABS exists to prevent, and ABS no longer holds trains silently.

Gitea#18 — the Division draws as one row, west to east, with no office-area
detail. East is finally always to the right.

Closes #3
Closes #14
Closes #15
Closes #17
Closes #18

src/sim/view.ts

@@ -10,6 +10,7 @@
  * drift into two different pictures of the same board.
  */
 
+import { regionOfTransit } from '../engine/advance.ts';
 import {
   areaAtSeat,
   areaOf,
@@ -32,7 +33,6 @@ import {
   MANEUVER_CARDS,
   MODIFIER_PROFILES,
   REALIGNMENTS,
-  REGIONS_PER_MAINLINE_CARD,
   OFFICE_ORDER,
   SPACE_USE_CARDS,
   enhancementRule,
@@ -1165,36 +1165,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.
-       * The engine crosses in `crossingStages` Stages instead, which varies by card speed, train
-       * speed, passengers and modifiers — so the printed model is recovered by treating the entry
-       * point as the thing that varies, exactly as the cards do:
+       * This used to recover a printed two-region model from a crossing time computed out of the
+       * card's mph, the train's Fast/Slow class, its consist and any modifiers, by treating the
+       * ENTRY point as the thing that varied: `entry = 2 - stagesTotal`. It even had to cope with a
+       * negative entry, for a slow train needing three Stages to cross a card with two regions.
        *
-       *     entry = REGIONS - stagesTotal        position = entry + elapsed
-       *
-       * A 60 card is one Stage, so the train enters at the second region and is gone — which is
-       * 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.
+       * 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
+       * to reconstruct.
        */
-      const place = (t: { stagesRemaining: number; stagesTotal: number }): number => {
-        // `entry` may be NEGATIVE — a slow train needing three Stages cannot fit three steps into
-        // two regions, so it notionally starts before the card and spends the extra Stage getting
-        // to the first region. Clamping only the final position keeps that Stage at the START,
-        // 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));
-      };
+      // One region per Stage, straight off the card's own count: what a train has LEFT to run says
+      // where it is standing. `regionOfTransit` is the engine's own answer, so the picture and the
+      // collision rule cannot disagree about who is where.
+      const place = (t: { stagesRemaining: number }): number => regionOfTransit(n.card, t.stagesRemaining);
       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 {