@johnmorrisdotca/jirai 0.2.0 → 0.3.0

package/src/solve.ts

@@ -0,0 +1,253 @@
+import { enumerateForced } from "./enumerate.ts";
+import { neighboursOf } from "./grid.ts";
+import { activeCell } from "./shape.ts";
+import type { Constraint, Settings } from "./jirai.types.ts";
+
+/** Why a cell was proved: one clue, two overlapping clues, the mine counter, or every arrangement of a small frontier. */
+export type ProofKind = "count" | "overlap" | "total" | "enumeration";
+/** Cells proved by each kind of reasoning. */
+export type ProofTally = Record<ProofKind, number>;
+/** What a run of the deduction solver found. */
+export type SolveReport = {
+  /** Every safe cell was opened using only proved deductions. */
+  solved: boolean;
+  /** Safe cells still covered when the solver stopped; zero when solved. */
+  remaining: number;
+  /** Safe cells opened, including the free opening. */
+  opened: number;
+  /** Covered cells, safe or mine, nothing has been proved about. */
+  unresolved: number;
+  /** Cells opened by the first reveal and its flood, before any deduction. */
+  free: number;
+  /** Cells proved (safe or mine) by each kind of reasoning. */
+  proved: ProofTally;
+  /** The longest chain of deductions, each resting on the one before. */
+  depth: number;
+};
+
+const COVERED = 0, OPEN = 1, MINE = 2, OUTSIDE = 3;
+
+/**
+ * The same deductions as `deduce` (one clue, two overlapping clues, the mine counter, exact enumeration of a
+ * small frontier), run to a fixed point over one board in a single pass instead of one deduction per scan of the
+ * whole field. A deduction found here is a deduction `deduce` would find; the order differs, the closure does not.
+ * Built once for a set of settings, then `run` as often as needed on different mine layouts.
+ */
+export class Solver {
+  readonly adjacent: readonly (readonly number[])[];
+  readonly cells: number;
+  readonly safeTotal: number;
+  readonly mineTotal: number;
+  readonly state: Uint8Array;
+  private readonly start: Uint8Array;
+  private readonly need: Int8Array;
+  private readonly unknown: Int8Array;
+  private readonly chain: Int16Array;
+  private readonly dirty: Uint8Array;
+  private readonly searched: Uint8Array;
+  private readonly marks: Int32Array;
+  private readonly seen: Int32Array;
+  private readonly visit: Int32Array;
+  private readonly queue: number[] = [];
+  private readonly stack: number[] = [];
+  private clues: Int8Array = new Int8Array(0);
+  private stamp = 0;
+  private covered = 0;
+  private left = 0;
+  private opened = 0;
+  private free = 0;
+  private deepestMine = 0;
+  private depth = 0;
+  private broken = false;
+  private searching = true;
+  private proved: ProofTally = { count: 0, overlap: 0, total: 0, enumeration: 0 };
+
+  constructor(readonly settings: Settings, adjacent: readonly (readonly number[])[] = neighboursOf(settings)) {
+    this.adjacent = adjacent;
+    this.cells = settings.width * settings.height;
+    this.start = Uint8Array.from({ length: this.cells }, (_, cell) => activeCell(settings, cell) ? COVERED : OUTSIDE);
+    this.safeTotal = this.start.reduce((sum, state) => sum + (state === COVERED ? 1 : 0), 0) - settings.mines;
+    this.mineTotal = settings.mines;
+    this.state = new Uint8Array(this.cells);
+    this.need = new Int8Array(this.cells);
+    this.unknown = new Int8Array(this.cells);
+    this.chain = new Int16Array(this.cells);
+    this.dirty = new Uint8Array(this.cells);
+    this.searched = new Uint8Array(this.cells);
+    this.marks = new Int32Array(this.cells);
+    this.seen = new Int32Array(this.cells);
+    this.visit = new Int32Array(this.cells);
+  }
+
+  /** Clues of a layout: -1 for a mine, -2 outside the shape, otherwise the count of neighbouring mines. */
+  clueFor(mines: ArrayLike<number | boolean>, into: Int8Array = new Int8Array(this.cells)): Int8Array {
+    for (let cell = 0; cell < this.cells; cell += 1) {
+      if (this.start[cell] === OUTSIDE) { into[cell] = -2; continue; }
+      if (mines[cell]) { into[cell] = -1; continue; }
+      let count = 0;
+      for (const n of this.adjacent[cell]!) if (mines[n]) count += 1;
+      into[cell] = count;
+    }
+    return into;
+  }
+
+  /** Play the opening at `first` and every deduction after it. `clues` is read, never changed. */
+  run(clues: Int8Array, first: number, enumerate = true): SolveReport {
+    this.clues = clues;
+    this.state.set(this.start); this.need.fill(0); this.unknown.fill(0); this.chain.fill(0);
+    this.dirty.fill(0); this.searched.fill(0); this.queue.length = 0;
+    this.covered = this.safeTotal + this.mineTotal; this.left = this.mineTotal;
+    this.opened = 0; this.free = 0; this.deepestMine = 0; this.depth = 0; this.broken = false;
+    this.proved = { count: 0, overlap: 0, total: 0, enumeration: 0 };
+    if ((clues[first] ?? -1) < 0) return this.report();
+    this.reveal(first, 0, null);
+    this.free = this.opened;
+    for (;;) {
+      while (this.queue.length > 0 && !this.broken) {
+        const cell = this.queue.pop()!;
+        this.dirty[cell] = 0;
+        while (this.step(cell)) { /* a clue may settle more than once */ }
+      }
+      if (this.broken || this.opened === this.safeTotal || this.covered === 0) break;
+      if (this.counter()) continue;
+      if (enumerate && this.enumerate()) continue;
+      break;
+    }
+    return this.report();
+  }
+
+  private report(): SolveReport {
+    const solved = !this.broken && this.opened === this.safeTotal;
+    return { solved, remaining: this.safeTotal - this.opened, unresolved: this.covered, opened: this.opened, free: this.free, proved: { ...this.proved }, depth: this.depth };
+  }
+
+  private touch(cell: number): void {
+    this.searched[cell] = 0;
+    if (!this.dirty[cell]) { this.dirty[cell] = 1; this.queue.push(cell); }
+  }
+
+  /** Open a cell known to be safe, and flood through every zero. `kind` null is the free opening. */
+  private reveal(start: number, depth: number, kind: ProofKind | null): void {
+    const stack = this.stack;
+    stack.length = 0; stack.push(start);
+    let first = true;
+    while (stack.length > 0) {
+      const cell = stack.pop()!;
+      if (this.state[cell] !== COVERED) continue;
+      if (this.clues[cell]! < 0) { this.broken = true; return; }
+      if (first && kind !== null) { this.proved[kind] += 1; if (depth > this.depth) this.depth = depth; }
+      first = false;
+      this.state[cell] = OPEN; this.covered -= 1; this.opened += 1;
+      let mines = 0, unknown = 0;
+      for (const n of this.adjacent[cell]!) {
+        const s = this.state[n];
+        if (s === MINE) mines += 1; else if (s === COVERED) unknown += 1;
+        else if (s === OPEN) { this.unknown[n]! -= 1; if (depth > this.chain[n]!) this.chain[n] = depth; this.touch(n); }
+      }
+      this.need[cell] = this.clues[cell]! - mines; this.unknown[cell] = unknown; this.chain[cell] = depth;
+      if (this.clues[cell] === 0) { for (const n of this.adjacent[cell]!) if (this.state[n] === COVERED) stack.push(n); }
+      else if (unknown > 0) this.touch(cell);
+    }
+  }
+
+  private flag(cell: number, depth: number, kind: ProofKind): void {
+    if (this.state[cell] !== COVERED) return;
+    if (this.clues[cell]! >= 0) { this.broken = true; return; }
+    this.state[cell] = MINE; this.covered -= 1; this.left -= 1;
+    this.proved[kind] += 1; if (depth > this.depth) this.depth = depth;
+    if (depth > this.deepestMine) this.deepestMine = depth;
+    for (const n of this.adjacent[cell]!) if (this.state[n] === OPEN) {
+      this.unknown[n]! -= 1; this.need[n]! -= 1; if (depth > this.chain[n]!) this.chain[n] = depth; this.touch(n);
+    }
+  }
+
+  private settle(cells: readonly number[], safe: boolean, depth: number, kind: ProofKind): void {
+    for (const cell of cells) { if (safe) this.reveal(cell, depth, kind); else this.flag(cell, depth, kind); }
+  }
+
+  /** One deduction from the clue at `cell` alone, or from it and an overlapping clue. */
+  private step(cell: number): boolean {
+    if (this.broken || this.state[cell] !== OPEN || this.unknown[cell] === 0) return false;
+    const around = this.adjacent[cell]!;
+    const unknown = this.unknown[cell]!, need = this.need[cell]!;
+    if (need < 0 || need > unknown) { this.broken = true; return false; }
+    const depth = this.chain[cell]! + 1;
+    if (need === 0 || need === unknown) {
+      this.settle(around.filter((n) => this.state[n] === COVERED), need === 0, depth, "count");
+      return true;
+    }
+    const mine = ++this.stamp;
+    for (const n of around) if (this.state[n] === COVERED) this.marks[n] = mine;
+    const compared = ++this.stamp;
+    for (const x of around) {
+      if (this.state[x] !== COVERED) continue;
+      for (const other of this.adjacent[x]!) {
+        if (other === cell || this.state[other] !== OPEN || this.unknown[other] === 0 || this.seen[other] === compared) continue;
+        this.seen[other] = compared;
+        let common = 0;
+        for (const y of this.adjacent[other]!) if (this.state[y] === COVERED && this.marks[y] === mine) common += 1;
+        const there = this.unknown[other]!;
+        let rest: number[], mines: number;
+        if (common === there && there < unknown) {
+          rest = around.filter((n) => this.state[n] === COVERED && !this.adjacent[other]!.includes(n)); mines = need - this.need[other]!;
+        } else if (common === unknown && unknown < there) {
+          rest = this.adjacent[other]!.filter((n) => this.state[n] === COVERED && this.marks[n] !== mine); mines = this.need[other]! - need;
+        } else continue;
+        if (mines < 0 || mines > rest.length) { this.broken = true; return false; }
+        if (mines !== 0 && mines !== rest.length) continue;
+        this.settle(rest, mines === 0, 1 + Math.max(depth - 1, this.chain[other]!), "overlap");
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** The mine counter: nothing left to find, everything left a mine, or a clue that accounts for all that remain. */
+  private counter(): boolean {
+    const covered: number[] = [];
+    for (let cell = 0; cell < this.cells; cell += 1) if (this.state[cell] === COVERED) covered.push(cell);
+    if (covered.length === 0) return false;
+    const depth = this.deepestMine + 1;
+    if (this.left === 0 || this.left === covered.length) { this.settle(covered, this.left === 0, depth, "total"); return true; }
+    for (let cell = 0; cell < this.cells; cell += 1) {
+      if (this.state[cell] !== OPEN || this.unknown[cell] === 0) continue;
+      const outside = covered.length - this.unknown[cell]!, mines = this.left - this.need[cell]!;
+      if (outside === 0 || (mines !== 0 && mines !== outside)) continue;
+      const mark = ++this.stamp;
+      for (const n of this.adjacent[cell]!) if (this.state[n] === COVERED) this.marks[n] = mark;
+      this.settle(covered.filter((n) => this.marks[n] !== mark), mines === 0, 1 + Math.max(depth - 1, this.chain[cell]!), "total");
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Exact enumeration of every frontier small enough, as `enumerateForced` does. Every component is read from the
+   * same position and the answers are applied together, exactly as one `deduce` call does, so that this solver and
+   * the hint engine finish the same boards: with a cap on the size of a frontier, the order of enumerating matters.
+   */
+  private enumerate(): boolean {
+    const round = ++this.stamp;
+    const found: { mines: number[]; safe: number[]; depth: number }[] = [];
+    for (let start = 0; start < this.cells; start += 1) {
+      if (this.state[start] !== OPEN || this.unknown[start] === 0 || this.visit[start] === round) continue;
+      const clues = [start]; this.visit[start] = round;
+      const cells = new Set<number>();
+      for (let at = 0; at < clues.length; at += 1) for (const x of this.adjacent[clues[at]!]!) {
+        if (this.state[x] !== COVERED || cells.has(x)) continue;
+        cells.add(x);
+        for (const other of this.adjacent[x]!) if (this.state[other] === OPEN && this.visit[other] !== round) { this.visit[other] = round; clues.push(other); }
+      }
+      if (cells.size > 18 || clues.every((c) => this.searched[c])) continue;
+      clues.sort((a, b) => a - b);
+      const constraints: Constraint[] = clues.map((c) => ({ cells: this.adjacent[c]!.filter((n) => this.state[n] === COVERED), mines: this.need[c]!, sources: [c] }));
+      const result = enumerateForced(constraints);
+      if (result.contradiction) { this.broken = true; return false; }
+      if (result.safe.length === 0 && result.mines.length === 0) { for (const c of clues) this.searched[c] = 1; continue; }
+      found.push({ mines: [...result.mines], safe: [...result.safe], depth: 1 + clues.reduce((most, c) => Math.max(most, this.chain[c]!), 0) });
+    }
+    for (const one of found) this.settle(one.mines, false, one.depth, "enumeration");
+    for (const one of found) this.settle(one.safe, true, one.depth, "enumeration");
+    return found.length > 0;
+  }
+}

package/src/strings.ts

@@ -1,4 +1,5 @@
 import type { Language } from "./jirai.types.ts";
+/** Built-in English and Japanese strings used by the player and renderer. */
 export const STRINGS = {
   en: {
     board: "Minesweeper board", covered: "covered", flag: "flagged", question: "uncertain", empty: "empty", mine: "mine", wrong: "incorrect flag",
@@ -15,4 +16,5 @@ export const STRINGS = {
     error: "推測なしで解ける盤が見つかりませんでした。別のシード、別の開始マス、または少ない地雷で試してください。",
   },
 } as const;
+/** Returns the built-in interface strings for a locale. */
 export function words(language: Language = "en"): typeof STRINGS["en"] | typeof STRINGS["ja"] { return STRINGS[language]; }

package/src/ui.types.ts

@@ -1,7 +1,11 @@
 import type { Game, Language, Material, Pieces, Settings } from "./jirai.types.ts";
+/** Appearance and optional hint marker used by drawing and play. */
 export type DrawOptions = { material?: Material; pieces?: Pieces; language?: Language; hint?: number | null };
+/** Accessible presentation data for one active board cell. */
 export type CellModel = { cell: number; x: number; y: number; width: number; height: number; label: string; text: string; kind: string; hint: boolean };
+/** Layout and cell presentation returned by `boardModel`. */
 export type BoardModel = { width: number; height: number; cells: CellModel[] };
+/** Initial game, appearance, control, and lifecycle callbacks for a mounted board. */
 export type MountOptions = DrawOptions & {
   settings?: Settings;
   progress?: string;
@@ -10,6 +14,7 @@ export type MountOptions = DrawOptions & {
   onFinish?: (game: Game) => void;
   onError?: (error: Error) => void;
 };
+/** Controls for reading and operating a mounted board. */
 export type JiraiMount = {
   game: () => Game;
   progress: () => string;

package/src/version.test.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "node:fs";
+import { expect, it } from "vitest";
+import { VERSION } from "./index.ts";
+
+it("names one version in the package, the library and the changelog", () => {
+  const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+  expect(VERSION).toBe(pkg.version);
+  expect(readFileSync("CHANGELOG.md", "utf8")).toMatch(new RegExp(`^## \\[${pkg.version.replaceAll(".", "\\.")}\\] - \\d{4}-\\d{2}-\\d{2}$`, "m"));
+});

package/src/deduce.test.ts

@@ -1,47 +0,0 @@
-import { expect, it } from "vitest";
-import { deduce, hintFor } from "./deduce.ts";
-import { enumerateForced } from "./enumerate.ts";
-import { DEFAULT_SETTINGS, MARKS, STATUSES } from "./jirai.constants.ts";
-import { neighbours } from "./grid.ts";
-import type { VisibleGame, Grid } from "./jirai.types.ts";
-
-it("extracts the 1–2–1 wall pattern without trusting flags", () => {
-  const game: VisibleGame = {
-    settings: { ...DEFAULT_SETTINGS, width: 3, height: 3, mines: 2 }, status: STATUSES.playing,
-    clues: [null,null,null,1,2,1,0,0,0], marks: [MARKS.flag,MARKS.flag,MARKS.covered,...Array(6).fill(MARKS.open)],
-  };
-  const hint = hintFor(game);
-  expect(hint.safe).toContain(1); // A wrongly flagged square is still provably safe.
-});
-
-it("enumeration proves only cells forced in every consistent assignment", () => {
-  const proof = enumerateForced([
-    { cells: [0,1], mines: 1, sources: [3] },
-    { cells: [1,2], mines: 1, sources: [4] },
-    { cells: [0,2], mines: 0, sources: [5] },
-  ]);
-  expect([...proof.safe].sort()).toEqual([0,2]); expect(proof.mines).toEqual([1]);
-  expect(enumerateForced([{ cells: [0,1], mines: 1, sources: [] }]).safe).toEqual([]);
-  expect(enumerateForced([{ cells: [0], mines: 2, sources: [] }]).contradiction).toBe(true);
-});
-
-it("agrees with an independent exhaustive oracle on square, orthogonal, hex and wrapped 3×3 positions", () => {
-  for (const grid of ["square", "orthogonal", "hex", "wrap"] as Grid[]) {
-    const settings = { ...DEFAULT_SETTINGS, width: 3, height: 3, mines: 2, grid };
-    for (let firstMine = 0; firstMine < 9; firstMine += 1) for (let secondMine = firstMine + 1; secondMine < 9; secondMine += 1) {
-      const actual = [firstMine, secondMine];
-      const clues = Array.from({ length: 9 }, (_, cell) => !actual.includes(cell) && cell % 2 === 0 ? neighbours(settings, cell).filter((n) => actual.includes(n)).length : null);
-      const possible: number[][] = [];
-      for (let a = 0; a < 9; a += 1) for (let b = a + 1; b < 9; b += 1) {
-        const mines = [a,b];
-        if (mines.some((cell) => clues[cell] !== null)) continue;
-        if (clues.every((clue, cell) => clue === null || neighbours(settings, cell).filter((n) => mines.includes(n)).length === clue)) possible.push(mines);
-      }
-      const game: VisibleGame = { settings, clues, status: STATUSES.playing, marks: clues.map((n) => n === null ? MARKS.flag : MARKS.open) };
-      const result = deduce(game);
-      expect(result.contradiction).toBe(false); expect(possible.length).toBeGreaterThan(0);
-      for (const cell of result.safe) expect(possible.every((mines) => !mines.includes(cell))).toBe(true);
-      for (const cell of result.mines) expect(possible.every((mines) => mines.includes(cell))).toBe(true);
-    }
-  }
-});

package/src/game.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { newGame, play, visibleGame } from "./game.ts";
-import { makeBoard, isSolvable, GenerationError } from "./generate.ts";
-import { DEFAULT_SETTINGS, GRIDS, MARKS, MOVES, STATUSES } from "./jirai.constants.ts";
-import { neighbours, neighboursOf, validCell, validSettings } from "./grid.ts";
-import { gameFromProgress, gameProgress, dailySeed } from "./keep.ts";
-import { boardModel } from "./draw.ts";
-import { hintFor } from "./deduce.ts";
-import type { Board, Game, Settings } from "./jirai.types.ts";
-import { decodeOrthogonalGame, encodeOrthogonalGame, makeOrthogonalBoard, newOrthogonalGame, orthogonalHint, orthogonalNeighbours } from "./orthogonal.ts";
-
-function fixedGame(minesAt: number[]): Game {
-  const settings: Settings = { ...DEFAULT_SETTINGS, width: 5, height: 5, mines: minesAt.length, noGuess: false, opening: "safe" };
-  const mines = Array.from({ length: 25 }, (_, cell) => minesAt.includes(cell));
-  const clues = mines.map((mine, cell) => mine ? -1 : neighbours(settings, cell).filter((n) => mines[n]).length);
-  const board: Board = { settings, mines, clues, first: 12, attempt: 0 };
-  return { ...newGame(settings), board };
-}
-
-describe("the grid topologies", () => {
-  for (const grid of Object.values(GRIDS)) it(`${grid} has reciprocal, unique neighbours and no self-neighbours`, () => {
-    const settings = { ...DEFAULT_SETTINGS, width: 7, height: 5, grid };
-    const all = neighboursOf(settings);
-    for (let cell = 0; cell < all.length; cell += 1) {
-      expect(new Set(all[cell]).size).toBe(all[cell]!.length);
-      expect(all[cell]).not.toContain(cell);
-      for (const n of all[cell]!) expect(all[n]).toContain(cell);
-    }
-  });
-  it("uses four orthogonal neighbours, six hex neighbours, eight square neighbours, and joins both wrap seams", () => {
-    expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.orthogonal }, 40)).toHaveLength(4);
-    expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.hex }, 40)).toHaveLength(6);
-    expect(neighbours(DEFAULT_SETTINGS, 40)).toHaveLength(8);
-    expect(neighbours({ ...DEFAULT_SETTINGS, grid: GRIDS.wrap }, 0)).toEqual([1,8,9,10,17,72,73,80]);
-  });
-  it("uses only orthogonal clues, preserves playable voids, and verifies a no-guess deal", () => {
-    const settings = { ...DEFAULT_SETTINGS, width: 9, height: 9, mines: 10, grid: GRIDS.orthogonal, seed: 19 };
-    const board = makeBoard(settings, 40);
-    expect(board.clues[40]).toBe(0);
-    for (let cell = 0; cell < 81; cell += 1) {
-      expect(board.clues[cell]).toBe(board.mines[cell] ? -1 : neighbours(settings, cell).filter(next => board.mines[next]).length);
-    }
-    expect(isSolvable(board)).toBe(true);
-    const shaped = { ...settings, shape: "heart" as const };
-    const shapedBoard = makeBoard(shaped, 40);
-    for (let cell = 0; cell < 81; cell += 1) if (!validCell(shaped, cell)) {
-      expect(shapedBoard.mines[cell]).toBe(false);
-      expect(shapedBoard.clues[cell]).toBe(-2);
-      expect(neighbours(shaped, cell)).toEqual([]);
-    }
-    const playing = play(newGame(settings), { kind: MOVES.reveal, cell: 40 });
-    const proof = hintFor(visibleGame(playing));
-    expect(proof.safe.every(cell => !playing.board!.mines[cell])).toBe(true);
-    expect(proof.mines.every(cell => playing.board!.mines[cell])).toBe(true);
-  });
-  it("rejects malformed or excessive settings before making a board", () => {
-    for (const change of [{ width: 1 }, { width: 61 }, { width: 60, height: 60 }, { mines: 81 }, { seed: NaN }, { grid: "__proto__" }, { mines: 1.5 }, { noGuess: "yes" }]) expect(validSettings({ ...DEFAULT_SETTINGS, ...change })).toBe(false);
-  });
-});
-
-describe("dealing and verified boards", () => {
-  for (const grid of Object.values(GRIDS)) it(`${grid} deals exact counts and a clear first opening for many seeds`, () => {
-    for (let seed = 0; seed < 40; seed += 1) {
-      const settings = { ...DEFAULT_SETTINGS, grid, seed, noGuess: false };
-      const board = makeBoard(settings, 40);
-      expect(board.mines.filter(Boolean)).toHaveLength(10);
-      expect(board.clues[40]).toBe(0);
-      for (let cell = 0; cell < 81; cell += 1) {
-        expect(board.clues[cell]).toBe(board.mines[cell] ? -1 : neighbours(settings, cell).filter((n) => board.mines[n]).length);
-      }
-      expect(makeBoard(settings, 40)).toEqual(board);
-    }
-  });
-  for (const grid of Object.values(GRIDS)) it(`${grid} only advertises boards its visible-clue solver actually finishes`, () => {
-    for (let seed = 0; seed < 15; seed += 1) expect(isSolvable(makeBoard({ ...DEFAULT_SETTINGS, grid, seed }, 40))).toBe(true);
-  });
-  it("reports a failed proof budget rather than returning an unverified board", () => {
-    let failures = 0;
-    for (let seed = 0; seed < 50; seed += 1) {
-      try { makeBoard({ ...DEFAULT_SETTINGS, width: 5, height: 5, mines: 10, opening: "safe", seed }, 12, { attempts: 1 }); }
-      catch (error) { expect(error).toBeInstanceOf(GenerationError); expect((error as GenerationError).code).toBe("exhausted"); failures += 1; }
-    }
-    expect(failures).toBeGreaterThan(0);
-  });
-  it("rejects a dense board that cannot protect the chosen opening", () => {
-    expect(() => makeBoard({ ...DEFAULT_SETTINGS, width: 3, height: 3, mines: 1 }, 4)).toThrow(GenerationError);
-  });
-});
-
-describe("moves", () => {
-  it("floods empty ground and wins without requiring any flags", () => {
-    const game = fixedGame([0]);
-    const before = structuredClone(game);
-    const next = play(game, { kind: MOVES.reveal, cell: 24 });
-    expect(next.status).toBe(STATUSES.won);
-    expect(next.marks.filter((mark) => mark === MARKS.open)).toHaveLength(24);
-    expect(game).toEqual(before);
-  });
-  it("does not open a flagged cell, including inside a flood", () => {
-    let game = fixedGame([0]);
-    game = play(game, { kind: MOVES.mark, cell: 24 });
-    expect(play(game, { kind: MOVES.reveal, cell: 24 })).toBe(game);
-    game = play(game, { kind: MOVES.reveal, cell: 20 });
-    expect(game.marks[24]).toBe(MARKS.flag);
-    expect(game.status).toBe(STATUSES.playing);
-  });
-  it("cycles notes through flag, question and covered", () => {
-    let game = newGame();
-    for (const mark of [MARKS.flag, MARKS.question, MARKS.covered]) { game = play(game, { kind: MOVES.mark, cell: 0 }); expect(game.marks[0]).toBe(mark); }
-    expect(game.board).toBeNull();
-  });
-  it("chords a matched number and loses if the flags were wrong", () => {
-    let game = fixedGame([0,24]);
-    game = play(game, { kind: MOVES.reveal, cell: 6 });
-    expect(play(game, { kind: MOVES.chord, cell: 6 })).toBe(game);
-    game = play(game, { kind: MOVES.mark, cell: 1 });
-    game = play(game, { kind: MOVES.chord, cell: 6 });
-    expect(game.status).toBe(STATUSES.lost); expect(game.exploded).toBe(0);
-    expect(play(game, { kind: MOVES.mark, cell: 3 })).toBe(game);
-  });
-  it("chords correctly flagged mines without revealing them", () => {
-    let game = fixedGame([0,24]);
-    game = play(game, { kind: MOVES.reveal, cell: 6 });
-    game = play(game, { kind: MOVES.mark, cell: 0 });
-    game = play(game, { kind: MOVES.chord, cell: 6 });
-    expect(game.status).not.toBe(STATUSES.lost); expect(game.marks[0]).toBe(MARKS.flag);
-  });
-  it("keeps hidden answers out of both the clue view and drawing", () => {
-    const game = fixedGame([0,24]);
-    expect(visibleGame(game).clues.every((clue) => clue === null)).toBe(true);
-    expect(boardModel(game).cells.every((cell) => cell.text === "" && cell.kind === MARKS.covered)).toBe(true);
-  });
-  it("replays a saved game from its seed and moves; malformed records are refused", () => {
-    let game = newGame({ ...DEFAULT_SETTINGS, noGuess: false });
-    game = play(game, { kind: MOVES.mark, cell: 0 }); game = play(game, { kind: MOVES.reveal, cell: 40 });
-    expect(gameFromProgress(gameProgress(game))).toEqual(game);
-    for (const data of ["garbage", "null", '{"version":2}', JSON.stringify({ version: 1, settings: DEFAULT_SETTINGS, moves: [{ kind: "reveal", cell: -1 }] })]) expect(gameFromProgress(data)).toBeNull();
-  });
-  it("keeps orthogonal save records distinct and preserves legacy square codes", () => {
-    const legacy = JSON.stringify({ version: 1, settings: DEFAULT_SETTINGS, moves: [], helped: false });
-    expect(gameFromProgress(legacy)).toEqual(newGame());
-    const orthogonal = newGame({ ...DEFAULT_SETTINGS, grid: GRIDS.orthogonal });
-    const code = gameProgress(orthogonal);
-    expect(JSON.parse(code)).toMatchObject({ version: 2, variant: "orthogonal", settings: { grid: "orthogonal" } });
-    expect(gameFromProgress(code)).toEqual(orthogonal);
-    expect(gameFromProgress(JSON.stringify({ ...JSON.parse(code), variant: "square" }))).toBeNull();
-  });
-  it("exposes focused orthogonal helpers and variant-only progress codes", () => {
-    const settings = { ...DEFAULT_SETTINGS, width: 9, height: 9, mines: 10, seed: 4 };
-    const game = newOrthogonalGame(settings);
-    expect(game.settings.grid).toBe("orthogonal");
-    expect(orthogonalNeighbours(settings, 40)).toHaveLength(4);
-    expect(makeOrthogonalBoard(settings, 40).settings.grid).toBe("orthogonal");
-    expect(orthogonalHint(play(game, { kind: MOVES.reveal, cell: 40 })).contradiction).toBe(false);
-    expect(decodeOrthogonalGame(encodeOrthogonalGame(game))).toEqual(game);
-    expect(decodeOrthogonalGame(gameProgress(newGame()))).toBeNull();
-  });
-  it("has stable daily seeds and rejects impossible calendar dates", () => {
-    expect(dailySeed("2026-10-04")).toBe(dailySeed("2026-10-04"));
-    expect(dailySeed("2026-10-04", "orthogonal")).not.toBe(dailySeed("2026-10-04"));
-    expect(dailySeed("2026-10-04", "hex")).not.toBe(dailySeed("2026-10-04"));
-    expect(() => dailySeed("2026-02-30")).toThrow();
-  });
-});
-
-export { fixedGame };
-
-it("keeps assisted status through public progress and rejects invalid assisted data", () => {
-  const game = { ...newGame(), helped: true };
-  expect(gameFromProgress(gameProgress(game))?.helped).toBe(true);
-  expect(gameFromProgress(JSON.stringify({ version: 1, settings: game.settings, moves: [], helped: "yes" }))).toBeNull();
-});

package/src/shape.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { activeCell, activeCells } from "./shape.ts";
-import { DEFAULT_SETTINGS, GRIDS } from "./jirai.constants.ts";
-import { neighboursOf, validSettings } from "./grid.ts";
-import { makeBoard, isSolvable } from "./generate.ts";
-import { newGame, play, visibleGame } from "./game.ts";
-import { boardModel } from "./draw.ts";
-import { gameFromProgress, gameProgress } from "./keep.ts";
-import type { Settings } from "./jirai.types.ts";
-
-describe("shaped minefields", () => {
-  for (const shape of ["heart", "star", "hexagon"] as const) for (const grid of [GRIDS.square, GRIDS.orthogonal, GRIDS.hex]) {
-    it(`${shape}/${grid} omits cells and retains reciprocal neighbours and proved deals`, () => {
-      const settings: Settings = { ...DEFAULT_SETTINGS, width: 17, height: 17, mines: 12, shape, grid };
-      for (const outside of [-1, 289, 1.5, NaN]) expect(activeCell(settings, outside)).toBe(false);
-      const cells = activeCells(settings), adjacent = neighboursOf(settings);
-      expect(cells.length).toBeGreaterThan(40); expect(cells.length).toBeLessThan(289);
-      for (const c of cells) for (const n of adjacent[c]!) {
-        expect(activeCell(settings, n)).toBe(true); expect(adjacent[n]).toContain(c);
-      }
-      const first = cells[Math.floor(cells.length / 2)]!;
-      for (let seed = 1; seed <= 12; seed += 1) {
-        const board = makeBoard({ ...settings, seed }, first);
-        expect(board.mines.filter(Boolean)).toHaveLength(12); expect(isSolvable(board)).toBe(true);
-        for (let c = 0; c < 289; c += 1) if (!activeCell(settings, c)) {
-          expect(board.mines[c]).toBe(false); expect(board.clues[c]).toBe(-2); expect(adjacent[c]).toEqual([]);
-        }
-      }
-    });
-  }
-  it("never draws or lets the player act on cut-out cells, and restores the shape", () => {
-    const settings: Settings = { ...DEFAULT_SETTINGS, width: 17, height: 17, shape: "heart", mines: 12 };
-    let game = newGame(settings);
-    const absent = Array.from({ length: 289 }, (_, c) => c).find(c => !activeCell(settings, c))!;
-    expect(play(game, { kind: "reveal", cell: absent })).toBe(game);
-    expect(play(game, { kind: "mark", cell: absent })).toBe(game);
-    expect(visibleGame(game).clues[absent]).toBe(-2);
-    expect(boardModel(game).cells.some(c => c.cell === absent)).toBe(false);
-    game = play(game, { kind: "reveal", cell: activeCells(settings)[50]! });
-    expect(gameFromProgress(gameProgress(game))?.settings.shape).toBe("heart");
-  });
-  it("wins when every active safe cell opens, without requiring absent cells", () => {
-    const settings: Settings = { ...DEFAULT_SETTINGS, width: 9, height: 9, shape: "star", mines: 1, noGuess: false };
-    let game = newGame(settings);
-    const first = activeCells(settings)[10]!;
-    game = play(game, { kind: "reveal", cell: first });
-    for (const c of activeCells(settings)) if (!game.board!.mines[c]) game = play(game, { kind: "reveal", cell: c });
-    expect(game.status).toBe("won");
-  });
-  it("rejects unknown outlines, tiny silhouettes, wrap cut-outs and excess mines", () => {
-    expect(validSettings({ ...DEFAULT_SETTINGS, shape: "toString" })).toBe(false);
-    expect(validSettings({ ...DEFAULT_SETTINGS, width: 5, height: 5, shape: "heart" })).toBe(false);
-    expect(validSettings({ ...DEFAULT_SETTINGS, shape: "heart", grid: "wrap" })).toBe(false);
-    expect(validSettings({ ...DEFAULT_SETTINGS, width: 9, height: 9, shape: "star", mines: 70 })).toBe(false);
-  });
-});