@johnmorrisdotca/jirai 0.2.1 → 0.3.0

package/src/jirai.constants.ts

@@ -15,21 +15,33 @@ export const GRID_SPECS: Record<Grid, { offsets: readonly (readonly [number, num
   hex: { offsets: [[-1,0],[1,0],[0,-1],[1,-1],[-1,1],[0,1]], wrap: false },
   wrap: { offsets: [[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]], wrap: true },
 };
-/** Common minefield dimensions and mine counts. */
+/** The four difficulty levels, easiest first. Each is a larger and denser field than the one before. */
+export const LEVELS = ["easy", "medium", "hard", "extra-hard"] as const;
+/** The 0.1 and 0.2 names for the first three levels. They are still accepted wherever a level is. */
+export const LEVEL_ALIASES = { beginner: "easy", intermediate: "medium", expert: "hard" } as const;
+/** Size and mine count of each level on a rectangular board. Shaped boards keep the size and the density. */
+export const LEVEL_SIZES: Record<(typeof LEVELS)[number], { width: number; height: number; mines: number }> = {
+  easy: { width: 9, height: 9, mines: 10 },
+  medium: { width: 16, height: 16, mines: 40 },
+  hard: { width: 30, height: 16, mines: 99 },
+  "extra-hard": { width: 40, height: 24, mines: 240 },
+};
+/** Common minefield dimensions and mine counts. The levels, their older names, and two shapes of field. */
 export const PRESETS = {
-  beginner: { width: 9, height: 9, mines: 10 },
-  intermediate: { width: 16, height: 16, mines: 40 },
-  expert: { width: 30, height: 16, mines: 99 },
+  ...LEVEL_SIZES,
+  beginner: LEVEL_SIZES.easy,
+  intermediate: LEVEL_SIZES.medium,
+  expert: LEVEL_SIZES.hard,
   wide: { width: 21, height: 9, mines: 24 },
   tall: { width: 9, height: 21, mines: 24 },
 } as const;
-/** Default beginner game, with a verified no-guess board and clear opening. */
-export const DEFAULT_SETTINGS: Settings = { ...PRESETS.beginner, grid: GRIDS.square, noGuess: true, opening: "clear", seed: 1 };
+/** Default easy game, with a verified no-guess board and clear opening. */
+export const DEFAULT_SETTINGS: Settings = { ...LEVEL_SIZES.easy, grid: GRIDS.square, noGuess: true, opening: "clear", seed: 1 };
 /** Largest width or height accepted by settings validation. */
 export const MAX_SIDE = 60;
 /** Largest total cell count accepted by settings validation. */
 export const MAX_CELLS = 2400;
-/** Default candidate-board budget for verified generation. */
+/** Default number of random layouts tried before a no-guess deal falls back to repairing the closest one. */
 export const GENERATION_ATTEMPTS = 128;
 /** Largest frontier enumerated for exact deductions. */
 export const ENUMERATION_CELLS = 18;

package/src/jirai.types.ts

@@ -1,5 +1,9 @@
 /** Neighbour topology used to count the clues around each cell. */
 export type Grid = "square" | "orthogonal" | "hex" | "wrap";
+/** A difficulty level: easy, medium, hard or extra-hard. */
+export type Level = "easy" | "medium" | "hard" | "extra-hard";
+/** The 0.1 and 0.2 names for easy, medium and hard, still accepted wherever a level is. */
+export type LevelAlias = "beginner" | "intermediate" | "expert";
 /** Current game state, including whether a mine has been hit. */
 export type Status = "ready" | "playing" | "won" | "lost";
 /** Player-facing state of one cell; the answer is never a mark. */
@@ -26,6 +30,7 @@ export type Board = {
   mines: readonly boolean[];
   clues: readonly number[];
   first: number;
+  /** Which candidate this deal was: below the `attempts` limit it is a random layout, at or above it a repaired one. */
   attempt: number;
 };
 /** Rules data includes the answer; never send it to a competitive client. Use visibleGame for hints and drawing. */
@@ -58,8 +63,12 @@ export type Deduction = {
   /** A conflicting clue, or a board with no consistent mine placement. */
   contradiction: boolean;
 };
-/** Work limits for seeded board generation and its no-guess check. */
-export type GenerationOptions = { attempts?: number; enumerate?: boolean };
+/**
+ * Work limits for seeded board generation and its no-guess check. `attempts` is the number of random layouts tried
+ * first; `repairs` is how many single-mine moves the repair stage may try on the closest of them (0, or `repair:
+ * false`, keeps the 0.2 behaviour of giving up after the attempts); `enumerate` switches the exact small-frontier check.
+ */
+export type GenerationOptions = { attempts?: number; repairs?: number; repair?: boolean; enumerate?: boolean };
 /** Supported interface copy locales. */
 export type Language = "en" | "ja";
 /** Board colours for drawing and mounted play. */

package/src/levels.ts

@@ -0,0 +1,31 @@
+import { LEVEL_ALIASES, LEVEL_SIZES, LEVELS } from "./jirai.constants.ts";
+import { activeCells } from "./shape.ts";
+import type { Grid, Level, LevelAlias, Settings } from "./jirai.types.ts";
+
+/** Board size and mine count a level asks for. */
+export type LevelSize = Pick<Settings, "width" | "height" | "mines">;
+
+/**
+ * The level a name means, or null. Accepts `easy`, `medium`, `hard` and `extra-hard` (also written `extra hard`,
+ * `extra_hard` or `extraHard`, in any case), and the older `beginner`, `intermediate` and `expert`.
+ */
+export function levelNamed(name: unknown): Level | null {
+  if (typeof name !== "string") return null;
+  const key = name.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/^extrahard$/, "extra-hard");
+  if (Object.hasOwn(LEVEL_ALIASES, key)) return LEVEL_ALIASES[key as LevelAlias];
+  return (LEVELS as readonly string[]).includes(key) ? key as Level : null;
+}
+
+/**
+ * The size and mine count of a level. A rectangle gets the level's own numbers; a shaped board keeps the level's
+ * width and height and its density of mines over the cells that are left. Throws `RangeError` for a name that is no level.
+ */
+export function levelSettings(level: Level | LevelAlias, board: { grid?: Grid; shape?: Settings["shape"] } = {}): LevelSize {
+  const named = levelNamed(level);
+  if (named === null) throw new RangeError(`Unknown level: ${String(level)}`);
+  const size = LEVEL_SIZES[named];
+  if ((board.shape ?? "rectangle") === "rectangle") return { ...size };
+  const probe = { ...size, grid: board.grid ?? "square", shape: board.shape, noGuess: true, opening: "clear", seed: 1 } as const;
+  const cells = activeCells(probe).length;
+  return { width: size.width, height: size.height, mines: Math.max(1, Math.min(cells - 10, Math.round(size.mines / (size.width * size.height) * cells))) };
+}

package/src/measure.ts

@@ -0,0 +1,44 @@
+import { Solver } from "./solve.ts";
+import type { ProofTally } from "./solve.ts";
+import type { Board } from "./jirai.types.ts";
+
+/** How demanding a dealt board is to solve by deduction, measured by solving it. */
+export type Measure = {
+  /** Mines per playable cell. */
+  density: number;
+  /** Playable cells. */
+  cells: number;
+  /** Share of the safe cells the first reveal opens before any reasoning. */
+  opening: number;
+  /** Cells proved by each kind of reasoning: one clue, two clues together, the mine counter, or every arrangement of a small frontier. */
+  proofs: ProofTally;
+  /** Share of the playable cells proved by anything beyond one clue's count: the part of the board that needs multi-step reasoning. */
+  multiStep: number;
+  /** The longest chain of deductions, each resting on the one before. */
+  depth: number;
+  /** One number for ranking boards: higher is harder. Not a calibrated rating, but monotone in each part above. */
+  score: number;
+  /** The board can be finished by deduction alone. */
+  solvable: boolean;
+};
+
+/**
+ * Solve a dealt board from its opening and report what it took. The score is
+ * `100 × density + 100 × multiStep + depth ÷ 4`, so it rises with the crowding of the mines, with the share of the
+ * field that needs more than a single clue, and with how long the longest chain of reasoning runs. It is a way to
+ * put boards in order, not a rating of how long a person will take.
+ */
+export function measureBoard(board: Board): Measure {
+  const solver = new Solver(board.settings);
+  const report = solver.run(Int8Array.from(board.clues), board.first, true);
+  const cells = solver.safeTotal + solver.mineTotal;
+  const density = solver.mineTotal / cells;
+  const { count, overlap, total, enumeration } = report.proved;
+  const multiStep = (overlap + total + enumeration) / cells;
+  const opening = solver.safeTotal === 0 ? 0 : report.free / solver.safeTotal;
+  const score = 100 * density + 100 * multiStep + report.depth / 4;
+  return {
+    density, cells, opening, proofs: { count, overlap, total, enumeration }, multiStep, depth: report.depth,
+    score: Math.round(score * 10) / 10, solvable: report.solved,
+  };
+}

package/src/repair.ts

@@ -0,0 +1,88 @@
+import type { Solver } from "./solve.ts";
+
+/** What a repair run did: whether it reached a board the solver finishes, how many layouts it tried, and how many safe cells it left covered. */
+export type RepairOutcome = { solved: boolean; tries: number; remaining: number };
+
+/** How readily a move that leaves more safe cells covered is kept, to climb out of a dead end. Small: nearly all such moves are refused. */
+const WARMTH = 0.3;
+/** Tries without getting closer after which the search begins again from a new layout, at least. */
+const PATIENCE = 1500;
+/** How far from the stuck cell a mine may be moved from and to. */
+const REACH = 2;
+
+function pick<T>(items: readonly T[], random: () => number): T | undefined {
+  return items.length === 0 ? undefined : items[Math.floor(random() * items.length)];
+}
+
+/** Move a mine from `from` to `to`, keeping every clue in step. Calling it again with the arguments swapped undoes it. */
+function move(solver: Solver, mines: Uint8Array, clues: Int8Array, from: number, to: number): void {
+  mines[from] = 0; mines[to] = 1;
+  for (const cell of [from, to]) {
+    const delta = cell === to ? 1 : -1;
+    for (const n of solver.adjacent[cell]!) if (!mines[n]) clues[n]! += delta;
+  }
+  clues[to] = -1;
+  let count = 0;
+  for (const n of solver.adjacent[from]!) if (mines[n]) count += 1;
+  clues[from] = count;
+}
+
+/**
+ * Make an unsolvable layout solvable by moving single mines next to the place the solver got stuck, never touching a
+ * pinned cell, and keeping a move when it leaves the solver no worse off (and now and then when it does, so that a
+ * dead end can be left). The search is counted in layouts tried, never in time, so a seed always gives the same board.
+ * `mines` and `clues` are changed in place and hold the answer when the outcome is solved.
+ */
+export function repair(solver: Solver, mines: Uint8Array, clues: Int8Array, first: number, pinned: ReadonlySet<number>, random: () => number, budget: number, enumerate: boolean, restart: () => void): RepairOutcome {
+  const around = (cell: number, radius: number): number[] => {
+    const seen = new Set([cell]);
+    let ring = [cell];
+    for (let step = 0; step < radius; step += 1) {
+      const next: number[] = [];
+      for (const c of ring) for (const n of solver.adjacent[c]!) if (!seen.has(n)) { seen.add(n); next.push(n); }
+      ring = next;
+    }
+    return [...seen].filter((c) => !pinned.has(c));
+  };
+  let report = solver.run(clues, first, enumerate);
+  let tries = 0, closest = report.remaining, idle = 0;
+  const patience = Math.max(PATIENCE, 2 * solver.cells);
+  while (!report.solved && tries < budget) {
+    tries += 1;
+    const frontier: number[] = [], covered: number[] = [], cutOff: number[] = [];
+    for (let cell = 0; cell < solver.cells; cell += 1) {
+      if (solver.state[cell] !== 0) continue;
+      covered.push(cell);
+      if (solver.adjacent[cell]!.some((n) => solver.state[n] === 1)) frontier.push(cell);
+      else if (!mines[cell] && !pinned.has(cell)) cutOff.push(cell);
+    }
+    let from: number | undefined, to: number | undefined;
+    const lost = cutOff.length > 0 && random() < 0.5 ? pick(cutOff, random) : undefined;
+    if (lost !== undefined) {
+      // A safe cell no opened clue touches is walled in by mines. Either wall one in more, or take a wall mine away.
+      const walls = solver.adjacent[lost]!.filter((n) => mines[n] && !pinned.has(n));
+      if (walls.length > 0 && random() < 0.5) { from = pick(walls, random); to = pick(around(from!, REACH).filter((c) => !mines[c]), random); }
+      else { to = lost; from = pick(around(lost, REACH + 1).filter((c) => mines[c]), random); }
+    } else {
+      const focus = pick(frontier.length > 0 ? frontier : covered, random);
+      if (focus === undefined) break;
+      let near = around(focus, REACH);
+      from = pick(near.filter((c) => mines[c]), random);
+      if (from === undefined) { near = around(focus, REACH + 2); from = pick(near.filter((c) => mines[c]), random); }
+      to = pick(near.filter((c) => !mines[c]), random);
+    }
+    if (from === undefined || to === undefined) continue;
+    move(solver, mines, clues, from, to);
+    const next = solver.run(clues, first, enumerate);
+    const worse = next.remaining - report.remaining;
+    if (worse < 0 || (worse === 0 && next.unresolved <= report.unresolved) || (worse > 0 && random() < Math.exp(-worse / WARMTH))) report = next;
+    else move(solver, mines, clues, to, from);
+    if (report.remaining < closest) { closest = report.remaining; idle = 0; }
+    else if (++idle > patience) {
+      // Stuck for a long while in one corner of the search: begin again from a new layout.
+      restart();
+      report = solver.run(clues, first, enumerate); closest = report.remaining; idle = 0;
+    }
+  }
+  return { solved: report.solved, tries, remaining: report.remaining };
+}

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/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"));
+});