v0.7.0 — four game types, a lobby you can read and leave, and a multiplayer game that makes a sound

The multiplayer set-up, the lobby, the start of a game, and four signals a remote client had never
been sent. Reasoning, the preset table and what was verified how: CHANGELOG.md.

- Co-op, Competitive, Cutthroat, Solitaire and Custom, on both screens, from one shared block —
  they had drifted, and each was missing a question the other asked.
- A player reads the whole rule set before taking a seat, may leave a lobby or a running game, and
  keeps a seat across a reload. The host may clear a chair. The browser remembers every game it is
  in, not just the last one.
- The start of a game is drawn: a handoff beat, an announcement, the code and type in the header.
- Sound, the timetable flash, announcements and the just-drawn badge now reach a remote client;
  justDrawn goes to the seat that drew it and nobody else.
- Played on StartOS, which found the rest: an Extra belongs to the player who played it, the board
  never named the Superintendent, bot seats were reported as absent players, and rule section
  numbers are out of every string a player reads.

Also carries the previous session's Heavy Grade documentation work — asked again, answer unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016JczK5i33ZNSf2PtzZqdhS

test/multiplayer.test.ts

@@ -11,9 +11,10 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { advance, pump } from '../src/engine/advance.ts';
-import { applyIntent, areaAtSeat, areaOf } from '../src/engine/apply.ts';
+import { applyIntent, areaAtSeat, areaOf, check } from '../src/engine/apply.ts';
 import { STAGES_PER_DAY, STAGES_PER_SHIFT, crewTrayCount } from '../src/engine/content.ts';
 import { createGame } from '../src/engine/setup.ts';
+import { legalActions } from '../src/engine/legal.ts';
 import type { GameConfig, GameState, PlayerIndex } from '../src/engine/state.ts';
 import { coordKey, playerAtSeat, playerLeftOf, seatOf, subdivisions } from '../src/engine/state.ts';
 import { developerBot, playGame } from '../src/sim/bot.ts';
@@ -675,6 +676,105 @@ describe('the New Train phase car-placement round rotates (§7, Gap 9)', () => {
   });
 });
 
+describe('an Extra belongs to the player who played it (§7)', () => {
+  /**
+   * REPORTED BY JESSE 2026-08-23, from a two-player game on StartOS: one seat played a train card
+   * and the OTHER was asked to build the train. For a Timetabled train that is correct — the round
+   * above starts at the Superintendent — but §7 states the Extra rule a paragraph later and it is
+   * the opposite one: "the player who played the card may place the Crew Tray at either Division
+   * Point ... and may load the consist as he chooses."
+   *
+   * The engine could not honour it: `pendingExtras` was a bare `number[]`, so nothing recorded whose
+   * Extra it was and the phase asked whoever the acting order happened to be on. Invisible in
+   * solitaire, where that is always the same person.
+   */
+  const withPendingExtra = (players: number, owner: PlayerIndex) => {
+    const s = game(players);
+    s.clock.phase = 'newTrain';
+    s.timetable = s.timetable.map(() => null);
+    // X22 "Pee-Dee" — a caboose-only Extra, so the consist is short and the round would be visible.
+    s.pendingExtras = [{ trainNumber: 22, player: owner }];
+    return s;
+  };
+
+  it('asks the player who played it where it starts — not whoever the round is on', () => {
+    // The owner is deliberately NOT the Superintendent, which is the case that used to go wrong.
+    const s = withPendingExtra(2, 1 as PlayerIndex);
+    const notSuper = playerLeftOf(s, s.clock.superintendent, 1);
+    s.pendingExtras = [{ trainNumber: 22, player: notSuper }];
+
+    const r = advance(s);
+    assert.equal(r.needsInput, true, 'the phase did not stop to place the Extra');
+    assert.equal(s.clock.currentActor, notSuper, 'the wrong player was asked where the Extra starts');
+  });
+
+  it('refuses another seat placing it, and offers it to nobody else', () => {
+    const s = withPendingExtra(2, 0 as PlayerIndex);
+    const intent = {
+      type: 'newTrain.startExtra' as const,
+      trainNumber: 22,
+      start: { kind: 'divisionPoint' as const, side: 'west' as const },
+    };
+    const theirs = applyIntent(s, 0 as PlayerIndex, intent);
+    assert.ok(theirs.ok, `the owner could not place their own Extra — ${theirs.ok ? '' : theirs.code}`);
+
+    /**
+     * TWO EXTRAS, TWO OWNERS — the case where the guard is actually reachable. The phase stops on
+     * the first pending Extra's owner, so seat 0 is legitimately the current actor; nothing but this
+     * rule stops them placing seat 1's train while they are there.
+     */
+    const both = withPendingExtra(2, 0 as PlayerIndex);
+    both.pendingExtras = [
+      { trainNumber: 22, player: 0 as PlayerIndex },
+      { trainNumber: 24, player: 1 as PlayerIndex },
+    ];
+    advance(both);
+    assert.equal(both.clock.currentActor, 0, 'the first pending Extra should have stopped on its owner');
+    assert.equal(check(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 }), 'NOT_YOUR_EXTRA');
+    const notTheirs = applyIntent(both, 0 as PlayerIndex, { ...intent, trainNumber: 24 });
+    assert.equal(notTheirs.ok, false, 'a seat placed somebody else’s Extra while it was their turn');
+    // And it is not even offered: a menu that lists an action `check` will refuse is a menu lying.
+    assert.equal(
+      legalActions(both, 0 as PlayerIndex).some(
+        (i) => i.type === 'newTrain.startExtra' && i.trainNumber === 24,
+      ),
+      false,
+      'somebody else’s Extra was offered a start point',
+    );
+  });
+
+  it('lets its player load the whole consist, rather than passing the round', () => {
+    // §7: "may load the consist as he chooses" — no going round the table for an Extra.
+    const s = withPendingExtra(2, 0 as PlayerIndex);
+    const owner = 0 as PlayerIndex;
+    const placed = applyIntent(s, owner, {
+      type: 'newTrain.startExtra',
+      trainNumber: 22,
+      start: { kind: 'divisionPoint', side: 'west' },
+    });
+    assert.ok(placed.ok, 'the Extra could not be placed');
+    s.yards.divisionYard.push({ type: 'caboose', loaded: false }, { type: 'caboose', loaded: false });
+
+    const asked: PlayerIndex[] = [];
+    for (let guard = 0; guard < 4; guard++) {
+      const r = advance(s);
+      if (!r.needsInput) break;
+      const actor = s.clock.currentActor!;
+      asked.push(actor);
+      const tray = [...s.trays.values()].find((t) => t.trainIsExtra);
+      assert.ok(tray, 'the Extra has no tray');
+      const result = applyIntent(s, actor, { type: 'newTrain.passCar', trayId: tray.id });
+      if (!result.ok) break;
+    }
+    assert.ok(asked.length > 0, 'nobody was asked to load the Extra');
+    assert.deepEqual(
+      [...new Set(asked)],
+      [owner],
+      `the Extra's consist went round the table (asked ${asked.join(', ')}) instead of staying with its player`,
+    );
+  });
+});
+
 describe('actionMenu is seat-safe (Phase 2 prep)', () => {
   /**
    * REGRESSION. `actionMenu(game, seat)` used `seat` only for the `hand` field — `options`/`direct`/