feat: add Bejeweled Blitz and Mini Motorways games

- Implement Phaser scenes and pure JS logic modules for both games
- Register games in server registry and scene routing
- Add headless verification scripts for Bejeweled and Mini Motorways logic
- Update game-icons sprite sheet

public/src/games/bejeweled/BejeweledLogic.js

@@ -0,0 +1,424 @@
+// Bejeweled Blitz — pure game logic (no Phaser).
+//
+// Board is ROWS×COLS of gems { color, special }. Swapping two adjacent gems is
+// legal when it creates a run of 3+ (or involves a Hypercube). Matches resolve
+// in cascading phases; each phase reports exactly what happened so the scene
+// can animate it: cleared gems, special-gem spawns, detonation events, falls
+// and refills, plus the points earned.
+//
+// Specials:
+//   FLAME  — from a 4-in-a-row; detonates a 3×3 blast when cleared.
+//   STAR   — from an L/T intersection; clears its full row and column.
+//   HYPER  — from 5+ in a row; swap with any gem to clear that colour
+//            (detonated by a blast, it zaps a random colour instead).
+//   MULT   — multiplier gem dropped during deep cascades; clearing it raises
+//            the global score multiplier (×2 … ×8).
+
+export const COLS = 8;
+export const ROWS = 8;
+export const BLITZ_SECONDS = 60;
+export const MAX_MULTIPLIER = 8;
+
+export const GEM_COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'white'];
+
+export const SPECIAL = {
+  NONE:  'none',
+  FLAME: 'flame',
+  STAR:  'star',
+  HYPER: 'hyper',
+  MULT:  'mult',
+};
+
+const key = (c, r) => r * COLS + c;
+const unkey = (k) => ({ c: k % COLS, r: (k / COLS) | 0 });
+const inBounds = (c, r) => c >= 0 && c < COLS && r >= 0 && r < ROWS;
+
+function randomGem(rng) {
+  return { color: GEM_COLORS[(rng() * GEM_COLORS.length) | 0], special: SPECIAL.NONE };
+}
+
+// ── Board construction ──────────────────────────────────────────────────────
+
+export function randomBoard(rng = Math.random) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const board = [];
+    for (let r = 0; r < ROWS; r++) {
+      board[r] = [];
+      for (let c = 0; c < COLS; c++) {
+        let gem;
+        do { gem = randomGem(rng); } while (
+          (c >= 2 && board[r][c - 1].color === gem.color && board[r][c - 2].color === gem.color) ||
+          (r >= 2 && board[r - 1][c].color === gem.color && board[r - 2][c].color === gem.color)
+        );
+        board[r][c] = gem;
+      }
+    }
+    if (findMove(board)) return board;
+  }
+  throw new Error('Could not generate a board with a legal move.');
+}
+
+export function newGame(rng = Math.random) {
+  return { board: randomBoard(rng), multiplier: 1, noMoves: false };
+}
+
+// ── Runs & match groups ─────────────────────────────────────────────────────
+
+export function findRuns(board) {
+  const runs = [];
+  for (let r = 0; r < ROWS; r++) {
+    let c = 0;
+    while (c < COLS) {
+      const color = board[r][c]?.color;
+      if (!color) { c++; continue; }
+      let end = c + 1;
+      while (end < COLS && board[r][end]?.color === color) end++;
+      if (end - c >= 3) {
+        const cells = [];
+        for (let i = c; i < end; i++) cells.push([i, r]);
+        runs.push({ color, horizontal: true, cells });
+      }
+      c = end;
+    }
+  }
+  for (let c = 0; c < COLS; c++) {
+    let r = 0;
+    while (r < ROWS) {
+      const color = board[r][c]?.color;
+      if (!color) { r++; continue; }
+      let end = r + 1;
+      while (end < ROWS && board[end][c]?.color === color) end++;
+      if (end - r >= 3) {
+        const cells = [];
+        for (let i = r; i < end; i++) cells.push([c, i]);
+        runs.push({ color, horizontal: false, cells });
+      }
+      r = end;
+    }
+  }
+  return runs;
+}
+
+// Union runs that share a cell into match groups (an L/T counts as one group).
+function groupRuns(runs) {
+  const parent = runs.map((_, i) => i);
+  const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i])));
+  const union = (a, b) => { parent[find(a)] = find(b); };
+
+  const byCell = new Map();
+  runs.forEach((run, i) => run.cells.forEach(([c, r]) => {
+    const k = key(c, r);
+    if (byCell.has(k)) union(i, byCell.get(k));
+    else byCell.set(k, i);
+  }));
+
+  const groups = new Map();
+  runs.forEach((run, i) => {
+    const root = find(i);
+    if (!groups.has(root)) groups.set(root, { color: run.color, runs: [], cells: new Set() });
+    const g = groups.get(root);
+    g.runs.push(run);
+    run.cells.forEach(([c, r]) => g.cells.add(key(c, r)));
+  });
+  return [...groups.values()];
+}
+
+// Where a freshly-earned special gem materialises: the swapped cell if it is
+// part of the group, else the runs' shared cell, else the longest run's middle.
+function pickSpawnKey(group, swapKeys) {
+  for (const k of swapKeys) if (group.cells.has(k)) return k;
+  if (group.runs.length >= 2) {
+    const seen = new Set();
+    for (const run of group.runs) {
+      for (const [c, r] of run.cells) {
+        const k = key(c, r);
+        if (seen.has(k)) return k;
+        seen.add(k);
+      }
+    }
+  }
+  const longest = group.runs.reduce((a, b) => (b.cells.length > a.cells.length ? b : a));
+  const [c, r] = longest.cells[(longest.cells.length / 2) | 0];
+  return key(c, r);
+}
+
+// ── Detonation chains ───────────────────────────────────────────────────────
+
+// Expand a seed set of cleared cells through special-gem chain reactions.
+// hyperOverrides maps a hyper gem's key to the colour it must zap (set by a
+// hyper swap); hypers consumed by blasts zap a random colour on the board.
+function expandClears(board, seedKeys, rng, hyperOverrides = new Map()) {
+  const keys = new Set();
+  const events = [];
+  const queue = [];
+
+  const add = (c, r) => {
+    if (!inBounds(c, r)) return;
+    const k = key(c, r);
+    if (keys.has(k) || !board[r][c]) return;
+    keys.add(k);
+    const sp = board[r][c].special;
+    if (sp === SPECIAL.FLAME || sp === SPECIAL.STAR || sp === SPECIAL.HYPER) queue.push(k);
+  };
+
+  for (const k of seedKeys) { const { c, r } = unkey(k); add(c, r); }
+
+  while (queue.length) {
+    const k = queue.shift();
+    const { c, r } = unkey(k);
+    const sp = board[r][c].special;
+    if (sp === SPECIAL.FLAME) {
+      events.push({ type: 'flame', c, r });
+      for (let dr = -1; dr <= 1; dr++) for (let dc = -1; dc <= 1; dc++) add(c + dc, r + dr);
+    } else if (sp === SPECIAL.STAR) {
+      events.push({ type: 'star', c, r });
+      for (let i = 0; i < COLS; i++) add(i, r);
+      for (let i = 0; i < ROWS; i++) add(c, i);
+    } else if (sp === SPECIAL.HYPER) {
+      let color = hyperOverrides.get(k) ?? null;
+      if (!color) {
+        const present = new Set();
+        for (let rr = 0; rr < ROWS; rr++) for (let cc = 0; cc < COLS; cc++) {
+          if (board[rr][cc]?.color && !keys.has(key(cc, rr))) present.add(board[rr][cc].color);
+        }
+        const pool = [...present];
+        color = pool.length ? pool[(rng() * pool.length) | 0] : null;
+      }
+      const cells = [];
+      if (color) {
+        for (let rr = 0; rr < ROWS; rr++) for (let cc = 0; cc < COLS; cc++) {
+          if (board[rr][cc]?.color === color) { cells.push([cc, rr]); add(cc, rr); }
+        }
+      }
+      events.push({ type: 'hyper', c, r, color, cells });
+    }
+  }
+  return { keys, events };
+}
+
+// ── Gravity & refill ────────────────────────────────────────────────────────
+
+function collapse(board, rng) {
+  const falls = [];
+  const refills = [];
+  for (let c = 0; c < COLS; c++) {
+    let write = ROWS - 1;
+    for (let r = ROWS - 1; r >= 0; r--) {
+      if (!board[r][c]) continue;
+      if (write !== r) {
+        board[write][c] = board[r][c];
+        board[r][c] = null;
+        falls.push({ c, fromR: r, toR: write });
+      }
+      write--;
+    }
+    const newCount = write + 1;
+    for (let r = write; r >= 0; r--) {
+      const gem = randomGem(rng);
+      board[r][c] = gem;
+      refills.push({ c, r, color: gem.color, special: gem.special, fromR: r - newCount });
+    }
+  }
+  return { falls, refills };
+}
+
+// ── Cascade driver ──────────────────────────────────────────────────────────
+
+const GEM_POINTS = 30;
+const EVENT_BONUS = { flame: 100, star: 200, hyper: 400 };
+
+// Resolve one or more cascade phases. opts.preClear seeds phase 1 directly
+// (hyper swaps, Last Hurrah); afterwards phases come from runs on the board.
+function runCascades(state, rng, opts = {}) {
+  const board = state.board;
+  const phases = [];
+  let swapKeys = opts.swapKeys ?? [];
+  let preClear = opts.preClear ?? null;
+  let multDropped = false;
+  let cascade = 0;
+
+  while (cascade < 30) {
+    cascade++;
+    let seedKeys;
+    let spawns = [];
+    let runBonus = 0;
+    let hyperOverrides = new Map();
+
+    if (preClear) {
+      seedKeys = preClear.keys;
+      runBonus = preClear.bonus ?? 0;
+      hyperOverrides = preClear.hyperOverrides ?? new Map();
+      preClear = null;
+    } else {
+      const runs = findRuns(board);
+      if (!runs.length) break;
+      seedKeys = new Set();
+      for (const group of groupRuns(runs)) {
+        group.cells.forEach((k) => seedKeys.add(k));
+        const maxLen = Math.max(...group.runs.map((r) => r.cells.length));
+        let special = null;
+        if (maxLen >= 5) special = SPECIAL.HYPER;
+        else if (group.runs.length >= 2) special = SPECIAL.STAR;
+        else if (maxLen === 4) special = SPECIAL.FLAME;
+        if (special) {
+          const k = pickSpawnKey(group, swapKeys);
+          spawns.push({ k, color: special === SPECIAL.HYPER ? null : group.color, special });
+        }
+        runBonus += (maxLen - 3) * 100 + (group.runs.length >= 2 ? 150 : 0);
+      }
+    }
+
+    const { keys, events } = expandClears(board, seedKeys, rng, hyperOverrides);
+    const spawnKeys = new Set(spawns.map((s) => s.k));
+
+    // Multiplier gems consumed this phase raise the global multiplier.
+    let eventBonus = 0;
+    const cleared = [];
+    for (const k of keys) {
+      const { c, r } = unkey(k);
+      const gem = board[r][c];
+      if (gem.special === SPECIAL.MULT && state.multiplier < MAX_MULTIPLIER) {
+        state.multiplier++;
+        events.push({ type: 'mult', c, r, multiplier: state.multiplier });
+      }
+      if (!spawnKeys.has(k)) cleared.push({ c, r, color: gem.color, special: gem.special });
+    }
+    for (const e of events) eventBonus += EVENT_BONUS[e.type] ?? 0;
+
+    const points = Math.round((keys.size * GEM_POINTS + runBonus + eventBonus) * cascade * state.multiplier);
+
+    for (const k of keys) { const { c, r } = unkey(k); board[r][c] = null; }
+    const placedSpawns = [];
+    for (const s of spawns) {
+      const { c, r } = unkey(s.k);
+      board[r][c] = { color: s.color, special: s.special };
+      placedSpawns.push({ c, r, color: s.color, special: s.special });
+    }
+
+    const { falls, refills } = collapse(board, rng);
+
+    // Deep cascades can drop a multiplier gem into the refill.
+    if (opts.allowMult !== false && !multDropped && cascade >= 2
+        && state.multiplier < MAX_MULTIPLIER && refills.length && rng() < 0.6) {
+      const pick = refills[(rng() * refills.length) | 0];
+      pick.special = SPECIAL.MULT;
+      board[pick.r][pick.c].special = SPECIAL.MULT;
+      multDropped = true;
+    }
+
+    phases.push({
+      cascade, points, multiplier: state.multiplier,
+      cleared, spawns: placedSpawns, events, falls, refills,
+    });
+    swapKeys = [];
+  }
+
+  state.noMoves = !findMove(board);
+  return phases;
+}
+
+// ── Moves ───────────────────────────────────────────────────────────────────
+
+// Attempt a swap of adjacent cells a/b ({c, r}). Returns an array of phases,
+// or null if the swap is illegal (board left untouched).
+export function applyMove(state, a, b, rng = Math.random) {
+  const board = state.board;
+  if (!inBounds(a.c, a.r) || !inBounds(b.c, b.r)) return null;
+  if (Math.abs(a.c - b.c) + Math.abs(a.r - b.r) !== 1) return null;
+  const A = board[a.r][a.c];
+  const B = board[b.r][b.c];
+  if (!A || !B) return null;
+
+  if (A.special === SPECIAL.HYPER || B.special === SPECIAL.HYPER) {
+    const keys = new Set();
+    const hyperOverrides = new Map();
+    let bonus;
+    if (A.special === SPECIAL.HYPER && B.special === SPECIAL.HYPER) {
+      // Double hypercube: the whole board goes up.
+      for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) keys.add(key(c, r));
+      hyperOverrides.set(key(a.c, a.r), null);
+      hyperOverrides.set(key(b.c, b.r), null);
+      bonus = 2000;
+    } else {
+      const hyper = A.special === SPECIAL.HYPER ? a : b;
+      const other = A.special === SPECIAL.HYPER ? B : A;
+      keys.add(key(hyper.c, hyper.r));
+      hyperOverrides.set(key(hyper.c, hyper.r), other.color);
+      bonus = 500;
+    }
+    return runCascades(state, rng, { preClear: { keys, bonus, hyperOverrides } });
+  }
+
+  board[a.r][a.c] = B;
+  board[b.r][b.c] = A;
+  if (!findRuns(board).length) {
+    board[a.r][a.c] = A;
+    board[b.r][b.c] = B;
+    return null;
+  }
+  return runCascades(state, rng, { swapKeys: [key(b.c, b.r), key(a.c, a.r)] });
+}
+
+// When the clock runs out every special left on the board detonates,
+// repeatedly, until none remain.
+export function lastHurrah(state, rng = Math.random) {
+  const board = state.board;
+  const phases = [];
+  for (let round = 0; round < 12; round++) {
+    const keys = new Set();
+    for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+      if (board[r][c] && board[r][c].special !== SPECIAL.NONE) keys.add(key(c, r));
+    }
+    if (!keys.size) break;
+    phases.push(...runCascades(state, rng, { preClear: { keys }, allowMult: false }));
+  }
+  return phases;
+}
+
+// ── Move search / shuffle ───────────────────────────────────────────────────
+
+export function findMove(board) {
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+    if (board[r][c]?.special === SPECIAL.HYPER) {
+      const b = c + 1 < COLS ? { c: c + 1, r } : { c: c - 1, r };
+      return { a: { c, r }, b };
+    }
+  }
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+    for (const [dc, dr] of [[1, 0], [0, 1]]) {
+      const c2 = c + dc, r2 = r + dr;
+      if (!inBounds(c2, r2)) continue;
+      const A = board[r][c], B = board[r2][c2];
+      if (!A || !B || A.color === B.color) continue;
+      board[r][c] = B; board[r2][c2] = A;
+      const hit = findRuns(board).length > 0;
+      board[r][c] = A; board[r2][c2] = B;
+      if (hit) return { a: { c, r }, b: { c: c2, r: r2 } };
+    }
+  }
+  return null;
+}
+
+// Rearrange the existing gems into a fresh layout with no instant matches and
+// at least one legal move. Falls back to a brand-new board if that fails.
+export function shuffleBoard(state, rng = Math.random) {
+  const gems = [];
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) gems.push(state.board[r][c]);
+
+  for (let attempt = 0; attempt < 300; attempt++) {
+    for (let i = gems.length - 1; i > 0; i--) {
+      const j = (rng() * (i + 1)) | 0;
+      [gems[i], gems[j]] = [gems[j], gems[i]];
+    }
+    const board = [];
+    for (let r = 0; r < ROWS; r++) board[r] = gems.slice(r * COLS, (r + 1) * COLS);
+    if (!findRuns(board).length && findMove(board)) {
+      state.board = board;
+      state.noMoves = false;
+      return board;
+    }
+  }
+  state.board = randomBoard(rng);
+  state.noMoves = false;
+  return state.board;
+}

public/src/main.js

@@ -70,6 +70,8 @@ import MahjongMatchGame from './games/mahjongmatch/MahjongMatchGame.js';
 import MahjongGame from './games/mahjong/MahjongGame.js';
 import JewelQuestGame from './games/jewelquest/JewelQuestGame.js';
 import ZumaGame from './games/zuma/ZumaGame.js';
+import BejeweledGame from './games/bejeweled/BejeweledGame.js';
+import MiniMotorwaysGame from './games/minimotorways/MiniMotorwaysGame.js';
 
 const config = {
   type: Phaser.AUTO,
@@ -153,6 +155,8 @@ const config = {
     MahjongGame,
     JewelQuestGame,
     ZumaGame,
+    BejeweledGame,
+    MiniMotorwaysGame,
   ],
 };
 

public/src/scenes/GameRoomScene.js

@@ -22,7 +22,7 @@ export default class GameRoomScene extends Phaser.Scene {
   }
 
   create() {
-    const slugDispatch = { backgammon: 'Backgammon', holdem: 'HoldemGame', blackjack: 'BlackjackGame', parchisi: 'ParchisiGame', yatzi: 'YatziGame', skipbo: 'SkipBoGame', phase10: 'Phase10Game', chinesecheckers: 'ChineseCheckersGame', gofish: 'GoFishGame', uno: 'UnoGame', craps: 'CrapsGame', roulette: 'RouletteGame', mexicantrain: 'MexicanTrainGame', hearts: 'HeartsGame', catan: 'CatanGame', tickettoride: 'TicketToRideGame', nerts: 'NertsGame', bingo: 'BingoGame', baccarat: 'BaccaratGame', dominion: 'DominionGame', checkers: 'CheckersGame', chess: 'ChessGame', wordle: 'WordleGame', scrabble: 'ScrabbleGame', ghost: 'GhostGame', wordladder: 'WordLadderGame', wordsearch: 'WordSearchGame', hangman: 'HangmanGame', sudoku: 'SudokuGame', othello: 'OthelloGame', go: 'GoGame', battleship: 'BattleshipGame', mastermind: 'MastermindGame', connect4: 'Connect4Game', boggle: 'BoggleGame', oldmaid: 'OldMaidGame', blokus: 'BlokusGame', spellingbee: 'SpellingBeeGame', minicrossword: 'MiniCrosswordGame', forbiddenisland: 'ForbiddenIslandGame', solitairetour: 'SolitaireTourGame', splendor: 'SplendorGame', tectonic: 'TectonicGame', labyrinth: 'LabyrinthGame', videopoker: 'VideoPokerGame', farkel: 'FarkelGame', stratego: 'StrategoGame', kiitos: 'KiitosGame', monopoly: 'MonopolyGame', triominoes: 'TriominoesGame', freecell: 'FreecellGame', rushhour: 'RushHourGame', hexsweeper: 'HexsweeperGame', puddingmonsters: 'PuddingMonstersGame', shift: 'ShiftGame', blockfighter: 'BlockFighterGame', mahjongmatch: 'MahjongMatchGame', mahjong: 'MahjongGame', jewelquest: 'JewelQuestGame', zuma: 'ZumaGame' };
+    const slugDispatch = { backgammon: 'Backgammon', holdem: 'HoldemGame', blackjack: 'BlackjackGame', parchisi: 'ParchisiGame', yatzi: 'YatziGame', skipbo: 'SkipBoGame', phase10: 'Phase10Game', chinesecheckers: 'ChineseCheckersGame', gofish: 'GoFishGame', uno: 'UnoGame', craps: 'CrapsGame', roulette: 'RouletteGame', mexicantrain: 'MexicanTrainGame', hearts: 'HeartsGame', catan: 'CatanGame', tickettoride: 'TicketToRideGame', nerts: 'NertsGame', bingo: 'BingoGame', baccarat: 'BaccaratGame', dominion: 'DominionGame', checkers: 'CheckersGame', chess: 'ChessGame', wordle: 'WordleGame', scrabble: 'ScrabbleGame', ghost: 'GhostGame', wordladder: 'WordLadderGame', wordsearch: 'WordSearchGame', hangman: 'HangmanGame', sudoku: 'SudokuGame', othello: 'OthelloGame', go: 'GoGame', battleship: 'BattleshipGame', mastermind: 'MastermindGame', connect4: 'Connect4Game', boggle: 'BoggleGame', oldmaid: 'OldMaidGame', blokus: 'BlokusGame', spellingbee: 'SpellingBeeGame', minicrossword: 'MiniCrosswordGame', forbiddenisland: 'ForbiddenIslandGame', solitairetour: 'SolitaireTourGame', splendor: 'SplendorGame', tectonic: 'TectonicGame', labyrinth: 'LabyrinthGame', videopoker: 'VideoPokerGame', farkel: 'FarkelGame', stratego: 'StrategoGame', kiitos: 'KiitosGame', monopoly: 'MonopolyGame', triominoes: 'TriominoesGame', freecell: 'FreecellGame', rushhour: 'RushHourGame', hexsweeper: 'HexsweeperGame', puddingmonsters: 'PuddingMonstersGame', shift: 'ShiftGame', blockfighter: 'BlockFighterGame', mahjongmatch: 'MahjongMatchGame', mahjong: 'MahjongGame', jewelquest: 'JewelQuestGame', zuma: 'ZumaGame', bejeweled: 'BejeweledGame', minimotorways: 'MiniMotorwaysGame' };
     if (slugDispatch[this.game.slug]) {
       this.scene.start(slugDispatch[this.game.slug], {
         game:          this.game,

server/games/registry.js

@@ -85,3 +85,5 @@ registerGame({ slug: 'mahjongmatch',      name: 'Mahjong Match',     category: '
 registerGame({ slug: 'mahjong',           name: 'Mahjong',           category: 'tabletop', minPlayers: 4, maxPlayers: 4, minOpponents: 3, maxOpponents: 3, hasTutorial: true, iconFrame: 58 });
 registerGame({ slug: 'jewelquest',        name: 'Jewel Quest',       category: 'logic',    minPlayers: 1, maxPlayers: 1, minOpponents: 0, maxOpponents: 0, hasTutorial: true, iconFrame: 59 });
 registerGame({ slug: 'zuma',              name: 'Zuma',              category: 'logic',    minPlayers: 1, maxPlayers: 1, minOpponents: 0, maxOpponents: 0, iconFrame: 60 });
+registerGame({ slug: 'bejeweled',         name: 'Bejeweled Blitz',   category: 'logic',    minPlayers: 1, maxPlayers: 1, minOpponents: 0, maxOpponents: 0, iconFrame: 61 });
+registerGame({ slug: 'minimotorways',     name: 'Mini Motorways',    category: 'logic',    minPlayers: 1, maxPlayers: 1, minOpponents: 0, maxOpponents: 0, iconFrame: 62 });

server/scripts/verifyBejeweled.js

@@ -0,0 +1,281 @@
+// Headless verification for Bejeweled Blitz.
+//   node server/scripts/verifyBejeweled.js
+// Exits non-zero on any failure.
+//
+// 1. Fixture tests: special-gem creation and detonation on hand-built boards.
+// 2. Monte-carlo self-play: thousands of random moves with invariants checked
+//    after every resolution (board full, no resting matches, phases coherent).
+// 3. Last Hurrah and shuffle sanity.
+
+import {
+  COLS, ROWS, SPECIAL, GEM_COLORS,
+  newGame, applyMove, lastHurrah, findMove, findRuns, shuffleBoard, randomBoard,
+} from '../../public/src/games/bejeweled/BejeweledLogic.js';
+
+let failures = 0;
+function check(name, cond, detail = '') {
+  if (cond) { console.log(`  ok   ${name}`); return; }
+  failures++;
+  console.error(`  FAIL ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0; a = (a + 0x6D2B79F5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// Build a board from 8 strings of 8 colour initials (r/o/y/g/b/p/w).
+// Uppercase suffix markers are handled by the caller via overrides.
+const INITIAL = { r: 'red', o: 'orange', y: 'yellow', g: 'green', b: 'blue', p: 'purple', w: 'white' };
+function boardFromStrings(rows, overrides = {}) {
+  const board = [];
+  for (let r = 0; r < ROWS; r++) {
+    board[r] = [];
+    for (let c = 0; c < COLS; c++) {
+      const color = INITIAL[rows[r][c]];
+      board[r][c] = { color, special: SPECIAL.NONE };
+    }
+  }
+  for (const [k, v] of Object.entries(overrides)) {
+    const [c, r] = k.split(',').map(Number);
+    board[r][c] = { ...board[r][c], ...v };
+  }
+  return board;
+}
+
+function boardFull(board) {
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+    const cell = board[r][c];
+    if (!cell) return false;
+    if (cell.special !== SPECIAL.HYPER && !GEM_COLORS.includes(cell.color)) return false;
+  }
+  return true;
+}
+
+console.log('Fixture: 3-match clears, board refills');
+{
+  // Swapping (0,1)↔(0,0)? Build a guaranteed vertical 3-match: column 0 has
+  // red at rows 1,2 and a red arrives at row 0 via swap from (1,0).
+  const rows = [
+    'rgybgypg',
+    'grybyopw',
+    'gboprwyb',
+    'ywgwobry',
+    'obrygwpo',
+    'wpogrbwy',
+    'rygbpoyr',
+    'bowyrgbw',
+  ];
+  const board = boardFromStrings(rows);
+  const state = { board, multiplier: 1, noMoves: false };
+  // (1,0) is 'g'; swap with (0,0)='r'? col0 rows1,2 are g,g → moving g to (0,0) makes col0 g,g,g.
+  const phases = applyMove(state, { c: 1, r: 0 }, { c: 0, r: 0 }, mulberry32(7));
+  check('legal swap returns phases', Array.isArray(phases) && phases.length >= 1);
+  check('phase 1 cleared 3+ gems', phases && phases[0].cleared.length >= 3);
+  check('phase points positive', phases && phases[0].points > 0);
+  check('board still full after resolution', boardFull(state.board));
+  check('no resting matches', findRuns(state.board).length === 0);
+}
+
+console.log('Fixture: illegal swap rejected, board untouched');
+{
+  const state = newGame(mulberry32(3));
+  const snapshot = JSON.stringify(state.board);
+  // Find a swap that yields no match.
+  let rejected = false;
+  outer:
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS - 1; c++) {
+    const res = applyMove(state, { c, r }, { c: c + 1, r }, mulberry32(4));
+    if (res === null) { rejected = true; break outer; }
+    // applyMove mutated the board — restore for the next probe.
+    state.board = JSON.parse(snapshot);
+  }
+  check('some non-matching swap was rejected', rejected);
+  check('rejected swap left board unchanged', JSON.stringify(state.board) === snapshot);
+  check('non-adjacent swap rejected', applyMove(state, { c: 0, r: 0 }, { c: 2, r: 0 }) === null);
+}
+
+console.log('Fixture: match 4 spawns a Flame gem');
+{
+  const rows = [
+    'gybgypgo',
+    'rrwryopw',
+    'gboprwyb',
+    'ywgwobry',
+    'obrygwpo',
+    'wpogrbwy',
+    'rygbpoyr',
+    'bowyrgbw',
+  ];
+  // Row 1: r r w r — swapping (2,1)'w' with (2,0)'b'? need the 'w' replaced by r.
+  // Instead swap (2,1)↔(2,2): (2,2)='o'… simpler: put r at (2,0) and swap down.
+  const board = boardFromStrings(rows, { '2,0': { color: 'red' } });
+  const state = { board, multiplier: 1, noMoves: false };
+  const phases = applyMove(state, { c: 2, r: 0 }, { c: 2, r: 1 }, mulberry32(9));
+  check('4-match resolved', phases !== null);
+  const spawns = phases ? phases.flatMap((p) => p.spawns) : [];
+  check('flame gem spawned', spawns.some((s) => s.special === SPECIAL.FLAME && s.color === 'red'),
+    JSON.stringify(spawns));
+}
+
+console.log('Fixture: match 5 spawns a Hypercube; hyper swap zaps a colour');
+{
+  const rows = [
+    'gybgypgo',
+    'rrwrropw',
+    'gboprwyb',
+    'ywgwobry',
+    'obrygwpo',
+    'wpogrbwy',
+    'rygbpoyr',
+    'bowyrgbw',
+  ];
+  // Row 1 becomes r r r r r after dropping a red into (2,1) from (2,0).
+  const board = boardFromStrings(rows, { '2,0': { color: 'red' } });
+  const state = { board, multiplier: 1, noMoves: false };
+  const phases = applyMove(state, { c: 2, r: 0 }, { c: 2, r: 1 }, mulberry32(11));
+  const spawns = phases ? phases.flatMap((p) => p.spawns) : [];
+  const hyperSpawn = spawns.find((s) => s.special === SPECIAL.HYPER);
+  check('hypercube spawned from 5-match', !!hyperSpawn, JSON.stringify(spawns));
+
+  // Now swap the hypercube with a neighbour and confirm a colour sweep.
+  if (hyperSpawn) {
+    // The hyper may have fallen; find it.
+    let pos = null;
+    for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+      if (state.board[r][c]?.special === SPECIAL.HYPER) pos = { c, r };
+    }
+    check('hypercube present on board', !!pos);
+    if (pos) {
+      const nb = pos.c > 0 ? { c: pos.c - 1, r: pos.r } : { c: pos.c + 1, r: pos.r };
+      const target = state.board[nb.r][nb.c].color;
+      const before = JSON.stringify(state.board);
+      const hp = applyMove(state, pos, nb, mulberry32(13));
+      check('hyper swap always legal', hp !== null);
+      if (hp) {
+        const ev = hp.flatMap((p) => p.events).find((e) => e.type === 'hyper');
+        check('hyper event fired with swapped colour', !!ev && ev.color === target,
+          `event=${JSON.stringify(ev)} target=${target}`);
+        check('board full after hyper sweep', boardFull(state.board));
+      } else {
+        state.board = JSON.parse(before);
+      }
+    }
+  }
+}
+
+console.log('Fixture: L-match spawns a Star; star detonation clears row+col');
+{
+  const rows = [
+    'rwbgypgo',
+    'rgwbropw',
+    'gboprwyb',
+    'ywgwobry',
+    'obrygwpo',
+    'wpogrbwy',
+    'rygbpoyr',
+    'bowyrgbw',
+  ];
+  // Column 0: r r g … and row 0: r w b — swap (1,0)'g' row0? Build L:
+  // put red at (1,1) wait — simpler: col0 rows0,1 red; row2 'g b o' — make
+  // row 2 start r ? Use overrides: row2 col1,col2 red → swapping (0,2)'g'
+  // with (1,2)? Instead: cells (0,0),(0,1) red vertical; (1,2),(2,2) red
+  // horizontal… Build explicitly:
+  const board = boardFromStrings(rows, {
+    '0,0': { color: 'red' }, '0,1': { color: 'red' },          // col 0, rows 0,1
+    '1,2': { color: 'red' }, '2,2': { color: 'red' },          // row 2, cols 1,2
+    '0,3': { color: 'green' },                                  // below the L corner
+    '0,2': { color: 'blue' }, '1,3': { color: 'yellow' },
+  });
+  // Swap (1,3)? The corner (0,2) needs red: swap (0,2)'blue' with… place red at (1,2)? taken.
+  // Give (0,3) red and swap it up into (0,2): col0 r,r,[r] + row2 [r],r,r → L of 5.
+  board[3][0] = { color: 'red', special: SPECIAL.NONE };
+  board[2][0] = { color: 'blue', special: SPECIAL.NONE };
+  const state = { board, multiplier: 1, noMoves: false };
+  const phases = applyMove(state, { c: 0, r: 3 }, { c: 0, r: 2 }, mulberry32(17));
+  check('L-swap resolved', phases !== null);
+  const spawns = phases ? phases.flatMap((p) => p.spawns) : [];
+  check('star gem spawned from L', spawns.some((s) => s.special === SPECIAL.STAR),
+    JSON.stringify(spawns));
+}
+
+console.log('Monte-carlo self-play');
+{
+  const rng = mulberry32(42);
+  let totalMoves = 0;
+  let totalPhases = 0;
+  let specialsSeen = 0;
+  let multsSeen = 0;
+  let maxCascade = 0;
+  let invariantsOk = true;
+  let pointsOk = true;
+
+  for (let game = 0; game < 60; game++) {
+    const state = newGame(rng);
+    for (let move = 0; move < 80; move++) {
+      const mv = findMove(state.board);
+      if (!mv) { shuffleBoard(state, rng); continue; }
+      const phases = applyMove(state, mv.a, mv.b, rng);
+      if (!phases) { invariantsOk = false; console.error('    findMove suggested an illegal move', mv); break; }
+      totalMoves++;
+      totalPhases += phases.length;
+      for (const p of phases) {
+        maxCascade = Math.max(maxCascade, p.cascade);
+        if (p.points <= 0) pointsOk = false;
+        specialsSeen += p.spawns.length;
+        multsSeen += p.events.filter((e) => e.type === 'mult').length;
+        // falls/refills coherence: every refill lands on a distinct cell.
+        const seen = new Set();
+        for (const f of p.refills) {
+          const k = `${f.c},${f.r}`;
+          if (seen.has(k)) { invariantsOk = false; console.error('    duplicate refill cell', k); }
+          seen.add(k);
+        }
+      }
+      if (!boardFull(state.board)) { invariantsOk = false; console.error('    board has holes after move'); break; }
+      if (findRuns(state.board).length) { invariantsOk = false; console.error('    resting matches after move'); break; }
+      if (state.multiplier < 1 || state.multiplier > 8) { invariantsOk = false; console.error('    multiplier out of range'); break; }
+    }
+    if (!invariantsOk) break;
+  }
+  check('played 4000+ moves', totalMoves >= 4000, `moves=${totalMoves}`);
+  check('all invariants held', invariantsOk);
+  check('all phases scored points', pointsOk);
+  check('cascades occurred', totalPhases > totalMoves, `phases=${totalPhases}`);
+  check('special gems spawned', specialsSeen > 0, `specials=${specialsSeen}`);
+  check('multiplier gems appeared', multsSeen > 0, `mults=${multsSeen}`);
+  console.log(`  info moves=${totalMoves} phases=${totalPhases} specials=${specialsSeen} mults=${multsSeen} maxCascade=${maxCascade}`);
+}
+
+console.log('Last Hurrah & shuffle');
+{
+  const rng = mulberry32(99);
+  const state = newGame(rng);
+  // Seed some specials by hand.
+  state.board[7][0].special = SPECIAL.FLAME;
+  state.board[7][3].special = SPECIAL.STAR;
+  state.board[7][6] = { color: null, special: SPECIAL.HYPER };
+  state.board[6][2].special = SPECIAL.MULT;
+  const phases = lastHurrah(state, rng);
+  check('last hurrah produced phases', phases.length >= 1);
+  check('last hurrah detonated events', phases.flatMap((p) => p.events).length >= 3);
+  let specialsLeft = 0;
+  for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
+    if (state.board[r][c].special !== SPECIAL.NONE) specialsLeft++;
+  }
+  check('no specials remain after last hurrah', specialsLeft === 0, `left=${specialsLeft}`);
+  check('board full after last hurrah', boardFull(state.board));
+
+  const s2 = { board: randomBoard(rng), multiplier: 1, noMoves: false };
+  shuffleBoard(s2, rng);
+  check('shuffle leaves no resting matches', findRuns(s2.board).length === 0);
+  check('shuffle leaves a legal move', !!findMove(s2.board));
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nAll checks passed.');
+process.exit(failures ? 1 : 0);

server/scripts/verifyMiniMotorways.js

@@ -0,0 +1,380 @@
+// Headless verification for Mini Motorways.
+//   node server/scripts/verifyMiniMotorways.js
+// Exits non-zero on any failure.
+//
+// 1. City generation invariants for all six cities.
+// 2. Road adjacency fixtures (diagonal crossing rule, costs).
+// 3. Pathfinder fixtures (straight runs, bridges, motorway shortcuts).
+// 4. Overflow with no roads ends the game.
+// 5. Monte-carlo bot: 15 simulated weeks per city with invariant checks.
+
+import {
+  WORLD_W, WORLD_H, TERRAIN, TUNE, CITIES, COLOR_NAMES,
+  Sim, generateCity, keyOf, xOf, yOf, octile,
+} from '../../public/src/games/minimotorways/MiniMotorwaysLogic.js';
+
+let failures = 0;
+function check(name, cond, detail = '') {
+  if (cond) { console.log(`  ok   ${name}`); return; }
+  failures++;
+  console.error(`  FAIL ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+// A sim stripped to bare terrain for hand-built network fixtures.
+function fixtureSim() {
+  const sim = new Sim(0, 12345);
+  sim.terrain.fill(TERRAIN.LAND);
+  sim.houses = [];
+  sim.buildings = [];
+  sim.cars = [];
+  sim.roads.clear();
+  sim.bridgeCells.clear();
+  sim.bridges = [];
+  sim.items.clear();
+  sim.motorways = [];
+  sim.portals.clear();
+  sim.cellOcc.clear();
+  sim.touchNetwork();
+  return sim;
+}
+
+// ── 1. City generation ─────────────────────────────────────────────────────────
+
+console.log('City generation');
+{
+  const r = { x0: (WORLD_W - 20) / 2, y0: (WORLD_H - 12) / 2, w: 20, h: 12 };
+  for (let ci = 0; ci < CITIES.length; ci++) {
+    for (const seed of [1, 777, 424242]) {
+      const { terrain } = generateCity(ci, seed);
+      let bad = terrain.length !== WORLD_W * WORLD_H;
+      let water = 0; let startWater = 0;
+      for (let i = 0; i < terrain.length; i++) {
+        if (terrain[i] > 2) bad = true;
+        if (terrain[i] === TERRAIN.WATER) {
+          water++;
+          const x = xOf(i); const y = yOf(i);
+          if (x >= r.x0 && x < r.x0 + r.w && y >= r.y0 && y < r.y0 + r.h) startWater++;
+        }
+      }
+      check(`${CITIES[ci].name} seed ${seed}: terrain valid`, !bad);
+      check(`${CITIES[ci].name} seed ${seed}: start rect ≥80% land`,
+        startWater <= r.w * r.h * 0.2, `water=${startWater}`);
+      const expectsWater = CITIES[ci].gen.rivers > 0 || CITIES[ci].gen.lakes > 0;
+      if (expectsWater) check(`${CITIES[ci].name} seed ${seed}: has water`, water > 0);
+    }
+  }
+}
+
+// ── 2. Adjacency ───────────────────────────────────────────────────────────────
+
+console.log('Adjacency / crossing rule');
+{
+  const sim = fixtureSim();
+  // 2x2 all-road square: diagonals must be suppressed, orthogonals intact.
+  const square = [keyOf(5, 5), keyOf(6, 5), keyOf(5, 6), keyOf(6, 6)];
+  for (const k of square) sim.roads.add(k);
+  sim.touchNetwork();
+  let diagonals = 0; let orthogonals = 0;
+  for (const k of square) {
+    for (const nb of sim.roadNeighbors(k)) {
+      if (Math.abs(nb.cost - Math.SQRT2) < 0.001) diagonals++;
+      else orthogonals++;
+    }
+  }
+  check('2x2 square has zero diagonal edges', diagonals === 0, `diag=${diagonals}`);
+  check('2x2 square fully orthogonally connected', orthogonals === 8, `orth=${orthogonals}`);
+
+  // Diagonal staircase keeps its diagonal edges at cost √2.
+  const sim2 = fixtureSim();
+  const stairs = [keyOf(10, 10), keyOf(11, 11), keyOf(12, 12)];
+  for (const k of stairs) sim2.roads.add(k);
+  sim2.touchNetwork();
+  const mid = sim2.roadNeighbors(keyOf(11, 11));
+  check('staircase middle has two diagonal edges', mid.length === 2);
+  check('diagonal edge costs √2', mid.every((nb) => Math.abs(nb.cost - Math.SQRT2) < 0.001));
+
+  // Symmetry: every edge runs both ways.
+  const sim3 = fixtureSim();
+  for (let i = 0; i < 60; i++) {
+    sim3.roads.add(keyOf(2 + Math.floor(Math.random() * 20), 2 + Math.floor(Math.random() * 15)));
+  }
+  sim3.touchNetwork();
+  let asym = 0;
+  for (const k of sim3.roads) {
+    for (const nb of sim3.roadNeighbors(k)) {
+      if (!sim3.roadNeighbors(nb.k).some((b) => b.k === k)) asym++;
+    }
+  }
+  check('random network adjacency is symmetric', asym === 0, `asym=${asym}`);
+}
+
+// ── 3. Pathfinding ─────────────────────────────────────────────────────────────
+
+console.log('Pathfinding');
+{
+  const sim = fixtureSim();
+  for (let x = 1; x <= 10; x++) sim.roads.add(keyOf(x, 1));
+  sim.touchNetwork();
+  const path = sim.findPath([keyOf(1, 1)], [keyOf(10, 1)]);
+  check('straight 10-cell road: path found', !!path);
+  check('straight path has 10 cells', path && path.length === 10, `len=${path?.length}`);
+
+  // Bridge across a 2-wide channel.
+  const sim2 = fixtureSim();
+  for (let y = 0; y < WORLD_H; y++) {
+    sim2.terrain[keyOf(12, y)] = TERRAIN.WATER;
+    sim2.terrain[keyOf(13, y)] = TERRAIN.WATER;
+  }
+  for (let x = 8; x <= 11; x++) sim2.roads.add(keyOf(x, 5));
+  for (let x = 14; x <= 17; x++) sim2.roads.add(keyOf(x, 5));
+  sim2.touchNetwork();
+  check('channel blocks path', sim2.findPath([keyOf(8, 5)], [keyOf(17, 5)]) === null);
+  sim2.stock.bridges = 1;
+  const span = [keyOf(12, 5), keyOf(13, 5)];
+  check('bridge placement allowed', sim2.canPlaceBridge(span));
+  sim2.placeBridge(span);
+  const over = sim2.findPath([keyOf(8, 5)], [keyOf(17, 5)]);
+  check('bridge connects the banks', !!over && over.length === 10, `len=${over?.length}`);
+  check('bridge cells marked', sim2.bridgeCells.has(span[0]) && sim2.bridgeCells.has(span[1]));
+  sim2.eraseBridgeAt(span[0]);
+  check('erasing bridge disconnects again', sim2.findPath([keyOf(8, 5)], [keyOf(17, 5)]) === null);
+  check('bridge stock refunded', sim2.stock.bridges === 1);
+
+  // Motorway shortcut.
+  const sim3 = fixtureSim();
+  for (let x = 1; x <= 30; x++) sim3.roads.add(keyOf(x, 1));
+  sim3.touchNetwork();
+  sim3.stock.motorways = 1;
+  const a = keyOf(1, 2); const b = keyOf(30, 2);
+  check('motorway placement allowed', sim3.canPlaceMotorway(a, b));
+  sim3.placeMotorway(a, b);
+  const quick = sim3.findPath([keyOf(1, 1)], [keyOf(30, 1)]);
+  check('motorway path found', !!quick);
+  check('path takes the portal', quick && quick.includes(a) && quick.includes(b));
+  check('portal route is short', quick && quick.length <= 6, `len=${quick?.length}`);
+  sim3.eraseMotorwayAt(a);
+  const slow = sim3.findPath([keyOf(1, 1)], [keyOf(30, 1)]);
+  check('after erase, path is the long way', !!slow && slow.length === 30, `len=${slow?.length}`);
+  check('motorway stock refunded', sim3.stock.motorways === 1);
+
+  // Intersection items need ≥3 connections.
+  const sim4 = fixtureSim();
+  sim4.roads.add(keyOf(5, 5)); sim4.roads.add(keyOf(4, 5)); sim4.roads.add(keyOf(6, 5));
+  sim4.touchNetwork();
+  sim4.stock.lights = 1;
+  check('light rejected on straight road', !sim4.canPlaceItem(keyOf(5, 5), 'light'));
+  sim4.roads.add(keyOf(5, 4));
+  sim4.touchNetwork();
+  check('light allowed on T-junction', sim4.canPlaceItem(keyOf(5, 5), 'light'));
+}
+
+// ── 4. Overflow ends the game ──────────────────────────────────────────────────
+
+console.log('Overflow → game over');
+{
+  const sim = new Sim(0, 99);
+  let gameOverEvent = null;
+  let guard = 0;
+  while (!sim.gameOver && guard++ < 10000) {
+    const events = sim.step(100);
+    for (const e of events) {
+      if (e.type === 'weekEnd') sim.chooseUpgrade(0);
+      if (e.type === 'gameOver') gameOverEvent = e;
+    }
+  }
+  check('roadless city overflows to game over', sim.gameOver);
+  check('game over event emitted with culprit', !!gameOverEvent && gameOverEvent.buildingId > 0);
+  check('overflow timing plausible', sim.time > 60000 && sim.time < 400000, `t=${sim.time}`);
+  check('score stayed at zero', sim.score === 0);
+}
+
+// ── 5. Monte-carlo bot ─────────────────────────────────────────────────────────
+
+console.log('Monte-carlo bot, 15 weeks per city');
+
+// Weighted search over buildable cells (4-connected) between two structures,
+// then pave the path. Water is allowed at a steep cost; runs of water ≤3 cells
+// become bridges, longer runs abort the connection.
+function botConnect(sim, fromCells, toCells) {
+  const from = Array.isArray(fromCells) ? fromCells : [fromCells];
+  const to = new Set(Array.isArray(toCells) ? toCells : [toCells]);
+  const structs = new Set([...from, ...to]);
+  const occ = sim.buildOccupiedSet();
+  const cellCost = (k) => {
+    if (structs.has(k)) return 1;
+    if (sim.terrain[k] === TERRAIN.WATER) return sim.roads.has(k) ? 1 : 6;
+    if (sim.terrain[k] === TERRAIN.LAND && !occ.has(k)) return 1;
+    return Infinity;
+  };
+
+  const dist = new Map();
+  const prev = new Map();
+  const open = [...from.map((k) => [0, k])];
+  for (const k of from) dist.set(k, 0);
+  let hit = null;
+  while (open.length && hit === null) {
+    open.sort((a, b) => a[0] - b[0]);
+    const [d, k] = open.shift();
+    if (d > (dist.get(k) ?? Infinity)) continue;
+    if (to.has(k)) { hit = k; break; }
+    const x = xOf(k); const y = yOf(k);
+    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+      const nx = x + dx; const ny = y + dy;
+      if (nx < 0 || nx >= WORLD_W || ny < 0 || ny >= WORLD_H) continue;
+      const nk = keyOf(nx, ny);
+      const c = cellCost(nk);
+      if (c === Infinity) continue;
+      const nd = d + c;
+      if (nd < (dist.get(nk) ?? Infinity)) {
+        dist.set(nk, nd);
+        prev.set(nk, k);
+        open.push([nd, nk]);
+      }
+    }
+  }
+  if (hit === null) return false;
+
+  const path = [];
+  for (let k = hit; k !== undefined; k = prev.get(k)) path.push(k);
+  path.reverse();
+
+  // Validate water runs first: each must be ≤3 cells and straight.
+  const runs = [];
+  let run = [];
+  for (const k of path) {
+    if (sim.terrain[k] === TERRAIN.WATER && !sim.roads.has(k)) { run.push(k); continue; }
+    if (run.length) { runs.push(run); run = []; }
+  }
+  if (run.length) runs.push(run);
+  for (const r of runs) {
+    if (r.length > 3) return false;
+    const straight = r.every((k) => xOf(k) === xOf(r[0])) || r.every((k) => yOf(k) === yOf(r[0]));
+    if (!straight) return false;
+  }
+
+  for (const r of runs) {
+    if (sim.stock.bridges < 1 || !sim.placeBridge(r)) return false;
+  }
+  for (const k of path) {
+    if (!structs.has(k) && !sim.roads.has(k) && sim.terrain[k] !== TERRAIN.WATER) sim.placeRoad(k);
+  }
+  return true;
+}
+
+function botHandleSpawn(sim, e) {
+  if (e.type === 'houseSpawn') {
+    const targets = sim.buildings.filter((b) => b.color === e.color);
+    targets.sort((p, q) => octile(xOf(p.k), yOf(p.k), xOf(e.k), yOf(e.k))
+      - octile(xOf(q.k), yOf(q.k), xOf(e.k), yOf(e.k)));
+    for (const t of targets.slice(0, 4)) {
+      if (botConnect(sim, e.k, t.cells)) return;
+    }
+  } else if (e.type === 'buildingSpawn') {
+    const building = sim.buildings.find((b) => b.id === e.id);
+    const homes = sim.houses.filter((h) => h.color === e.color && h.k !== e.k);
+    homes.sort((p, q) => octile(xOf(p.k), yOf(p.k), xOf(e.k), yOf(e.k))
+      - octile(xOf(q.k), yOf(q.k), xOf(e.k), yOf(e.k)));
+    for (const h of homes.slice(0, 4)) {
+      if (botConnect(sim, h.k, building.cells)) return;
+    }
+  }
+}
+
+// Late repairs: any building accumulating pins with nothing en route gets a
+// fresh connection attempt to its nearest same-colour houses.
+function botRescue(sim) {
+  for (const b of sim.buildings) {
+    if (b.pins < 3 || (b.reserved > 0 && b.pins < 5)) continue;
+    const homes = sim.houses.filter((h) => h.color === b.color);
+    homes.sort((p, q) => octile(xOf(p.k), yOf(p.k), xOf(b.k), yOf(b.k))
+      - octile(xOf(q.k), yOf(q.k), xOf(b.k), yOf(b.k)));
+    for (const h of homes.slice(0, 3)) {
+      if (botConnect(sim, h.k, b.cells)) break;
+    }
+  }
+}
+
+function checkInvariants(sim, label) {
+  for (const car of sim.cars) {
+    if (Number.isNaN(car.x) || Number.isNaN(car.y) || Number.isNaN(car.pos)) {
+      return `${label}: NaN in car ${car.id} (${car.state})`;
+    }
+  }
+  if (sim.cars.length > TUNE.CAR_CAP) return `${label}: car cap exceeded (${sim.cars.length})`;
+  for (const b of sim.buildings) {
+    if (b.reserved > b.pins) return `${label}: reserved ${b.reserved} > pins ${b.pins} at building ${b.id}`;
+    if (b.ring < 0 || b.ring > 1.2) return `${label}: ring out of range ${b.ring}`;
+  }
+  for (const k of sim.roads) {
+    for (const nb of sim.roadNeighbors(k)) {
+      if (!sim.roadNeighbors(nb.k).some((x) => x.k === k)) {
+        return `${label}: asymmetric edge ${k}→${nb.k}`;
+      }
+    }
+  }
+  return null;
+}
+
+{
+  const targetWeeks = 15;
+  for (let ci = 0; ci < CITIES.length; ci++) {
+    const sim = new Sim(ci, 1000 + ci);
+    sim.stock.roads = 99999;
+    sim.stock.bridges += 50;
+
+    // Wire up the structures spawned during construction.
+    for (const h of sim.houses) {
+      const targets = sim.buildings.filter((b) => b.color === h.color);
+      if (targets.length) botConnect(sim, h.k, targets[0].cells);
+    }
+
+    let lastScore = 0;
+    let scoreRegressed = false;
+    let invariantError = null;
+    let steps = 0;
+    let stranded = 0;
+
+    while (sim.week < targetWeeks && !sim.gameOver && steps < 30000) {
+      const events = sim.step(100);
+      steps++;
+      for (const e of events) {
+        if (e.type === 'weekEnd') sim.chooseUpgrade(0);
+        else if (e.type === 'houseSpawn' || e.type === 'buildingSpawn' || e.type === 'colorUnlock') {
+          if (e.type !== 'colorUnlock') botHandleSpawn(sim, e);
+        } else if (e.type === 'stranded') stranded++;
+      }
+      if (sim.score < lastScore) scoreRegressed = true;
+      lastScore = sim.score;
+
+      // Exercise erase + reroute: pull a road cell out from under traffic,
+      // then put it back two ticks later.
+      if (steps % 600 === 300 && sim.roads.size > 10) {
+        const plain = [...sim.roads].filter((k) => !sim.bridgeCells.has(k) && !sim.portals.has(k));
+        if (plain.length) {
+          const victim = plain[Math.floor(Math.random() * plain.length)];
+          sim.eraseRoad(victim);
+          sim.step(100); steps++;
+          sim.placeRoad(victim);
+        }
+      }
+
+      if (steps % 100 === 0) botRescue(sim);
+      if (steps % 50 === 0 && !invariantError) {
+        invariantError = checkInvariants(sim, `${CITIES[ci].name} step ${steps}`);
+      }
+    }
+
+    const name = CITIES[ci].name;
+    check(`${name}: no invariant violations`, !invariantError, invariantError ?? '');
+    check(`${name}: score is positive`, sim.score > 0, `score=${sim.score}`);
+    check(`${name}: score never regressed`, !scoreRegressed);
+    check(`${name}: survived or died legitimately`,
+      sim.week >= targetWeeks || sim.gameOver, `week=${sim.week} steps=${steps}`);
+    console.log(`       ${name}: weeks=${sim.week} score=${sim.score} cars=${sim.cars.length} `
+      + `houses=${sim.houses.length} buildings=${sim.buildings.length} roads=${sim.roads.size} `
+      + `stranded=${stranded} gameOver=${sim.gameOver}`);
+  }
+}
+
+console.log(failures ? `\n${failures} FAILURE(S)` : '\nAll checks passed.');
+process.exit(failures ? 1 : 0);