@johnmorrisdotca/jirai 0.2.1 → 0.4.0

package/dist/measure.d.ts

@@ -0,0 +1,28 @@
+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 declare function measureBoard(board: Board): Measure;

package/dist/measure.js

@@ -0,0 +1,21 @@
+import { Solver } from "./solve.js";
+/**
+ * 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) {
+    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/dist/repair.d.ts

@@ -0,0 +1,14 @@
+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;
+};
+/**
+ * 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 declare function repair(solver: Solver, mines: Uint8Array, clues: Int8Array, first: number, pinned: ReadonlySet<number>, random: () => number, budget: number, enumerate: boolean, restart: () => void): RepairOutcome;

package/dist/repair.js

@@ -0,0 +1,112 @@
+/** 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(items, random) {
+    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, mines, clues, from, to) {
+    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, mines, clues, first, pinned, random, budget, enumerate, restart) {
+    const around = (cell, radius) => {
+        const seen = new Set([cell]);
+        let ring = [cell];
+        for (let step = 0; step < radius; step += 1) {
+            const next = [];
+            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 = [], covered = [], cutOff = [];
+        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, to;
+        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/dist/solve.d.ts

@@ -0,0 +1,79 @@
+import type { 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;
+};
+/**
+ * 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 declare class Solver {
+    readonly settings: Settings;
+    readonly adjacent: readonly (readonly number[])[];
+    readonly cells: number;
+    readonly safeTotal: number;
+    readonly mineTotal: number;
+    readonly state: Uint8Array;
+    private readonly start;
+    private readonly need;
+    private readonly unknown;
+    private readonly chain;
+    private readonly dirty;
+    private readonly searched;
+    private readonly marks;
+    private readonly seen;
+    private readonly visit;
+    private readonly queue;
+    private readonly stack;
+    private clues;
+    private stamp;
+    private covered;
+    private left;
+    private opened;
+    private free;
+    private deepestMine;
+    private depth;
+    private broken;
+    private searching;
+    private proved;
+    constructor(settings: Settings, adjacent?: readonly (readonly number[])[]);
+    /** 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): Int8Array;
+    /** Play the opening at `first` and every deduction after it. `clues` is read, never changed. */
+    run(clues: Int8Array, first: number, enumerate?: boolean): SolveReport;
+    private report;
+    private touch;
+    /** Open a cell known to be safe, and flood through every zero. `kind` null is the free opening. */
+    private reveal;
+    private flag;
+    private settle;
+    /** One deduction from the clue at `cell` alone, or from it and an overlapping clue. */
+    private step;
+    /** The mine counter: nothing left to find, everything left a mine, or a clue that accounts for all that remain. */
+    private counter;
+    /**
+     * 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;
+}

package/dist/solve.js

@@ -0,0 +1,336 @@
+import { enumerateForced } from "./enumerate.js";
+import { neighboursOf } from "./grid.js";
+import { activeCell } from "./shape.js";
+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 {
+    settings;
+    adjacent;
+    cells;
+    safeTotal;
+    mineTotal;
+    state;
+    start;
+    need;
+    unknown;
+    chain;
+    dirty;
+    searched;
+    marks;
+    seen;
+    visit;
+    queue = [];
+    stack = [];
+    clues = new Int8Array(0);
+    stamp = 0;
+    covered = 0;
+    left = 0;
+    opened = 0;
+    free = 0;
+    deepestMine = 0;
+    depth = 0;
+    broken = false;
+    searching = true;
+    proved = { count: 0, overlap: 0, total: 0, enumeration: 0 };
+    constructor(settings, adjacent = neighboursOf(settings)) {
+        this.settings = 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, into = new Int8Array(this.cells)) {
+        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, first, enumerate = true) {
+        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();
+    }
+    report() {
+        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 };
+    }
+    touch(cell) {
+        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. */
+    reveal(start, depth, kind) {
+        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);
+        }
+    }
+    flag(cell, depth, kind) {
+        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);
+            }
+    }
+    settle(cells, safe, depth, kind) {
+        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. */
+    step(cell) {
+        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, mines;
+                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. */
+    counter() {
+        const covered = [];
+        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.
+     */
+    enumerate() {
+        const round = ++this.stamp;
+        const found = [];
+        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();
+            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 = 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/jirai",
-  "version": "0.2.1",
-  "description": "Minesweeper on square, hexagonal and wraparound boards: seeded games, a safe opening, verified no-guess boards, explained hints, configurable materials and markers, and a playable board for any page. Zero runtime dependencies.",
+  "version": "0.4.0",
+  "description": "Minesweeper on square, orthogonal, hexagonal and wraparound boards: four levels up to extra-hard, seeded games, a safe opening, verified no-guess boards, explained hints, configurable materials and markers, and a playable board for any page. Zero runtime dependencies.",
   "type": "module",
   "license": "MIT",
   "author": "John Morris",
@@ -30,6 +30,7 @@
     "wraparound-grid",
     "no-guess",
     "no-guess-minesweeper",
+    "difficulty-levels",
     "seeded-puzzle",
     "daily-puzzle",
     "puzzle-generator",

package/src/deduce.ts

@@ -6,8 +6,7 @@ import type { Constraint, Deduction, VisibleGame } from "./jirai.types.ts";
  * What the clues prove, without reading the answer or trusting a player's
  * flags. A flag is a note; treating it as evidence makes a bad note a bad hint.
  */
-export function deduce(game: VisibleGame, knownMines: ReadonlySet<number> = new Set(), enumerate = true): Deduction {
-  const adjacent = neighboursOf(game.settings);
+export function deduce(game: VisibleGame, knownMines: ReadonlySet<number> = new Set(), enumerate = true, adjacent: readonly (readonly number[])[] = neighboursOf(game.settings)): Deduction {
   const constraints: Constraint[] = [];
   const empty: Deduction = { safe: [], mines: [], reason: "none", sources: [], contradiction: false };
   for (let cell = 0; cell < game.clues.length; cell += 1) {
@@ -31,19 +30,26 @@ export function deduce(game: VisibleGame, knownMines: ReadonlySet<number> = new
   if (unknown.length) { const result = forced(total, "total"); if (result !== null) return result; }
   // Compare a smaller clue with a larger one, including the mine counter.
   // Their difference is another exact count. Never subtract mere overlaps.
-  const sets = [...constraints, total].map((c) => new Set(c.cells));
   const all = [...constraints, total];
-  for (let i = 0; i < all.length; i += 1) for (let j = 0; j < all.length; j += 1) {
-    if (i === j || all[i]!.cells.length >= all[j]!.cells.length) continue;
-    if (!all[i]!.cells.every((cell) => sets[j]!.has(cell))) continue;
-    const c: Constraint = {
-      cells: all[j]!.cells.filter((cell) => !sets[i]!.has(cell)),
-      mines: all[j]!.mines - all[i]!.mines,
-      sources: [...new Set([...all[i]!.sources, ...all[j]!.sources])],
-    };
-    if (c.mines < 0 || c.mines > c.cells.length) return { ...empty, contradiction: true };
-    const result = forced(c, j === all.length - 1 ? "total" : "overlap");
-    if (result !== null) return result;
+  const sets = all.map((c) => new Set(c.cells));
+  // A constraint can only be inside another that holds its first cell, so each is compared with those alone, in the same order as
+  // comparing it with every other. On a large field that is a handful of neighbours instead of every clue on the board.
+  const holding = new Map<number, number[]>();
+  all.forEach((c, index) => { for (const cell of c.cells) { const list = holding.get(cell); if (list === undefined) holding.set(cell, [index]); else list.push(index); } });
+  for (let i = 0; i < all.length; i += 1) {
+    const inside = all[i]!.cells.length === 0 ? all.map((_, index) => index) : holding.get(all[i]!.cells[0]!)!;
+    for (const j of inside) {
+      if (i === j || all[i]!.cells.length >= all[j]!.cells.length) continue;
+      if (!all[i]!.cells.every((cell) => sets[j]!.has(cell))) continue;
+      const c: Constraint = {
+        cells: all[j]!.cells.filter((cell) => !sets[i]!.has(cell)),
+        mines: all[j]!.mines - all[i]!.mines,
+        sources: [...new Set([...all[i]!.sources, ...all[j]!.sources])],
+      };
+      if (c.mines < 0 || c.mines > c.cells.length) return { ...empty, contradiction: true };
+      const result = forced(c, j === all.length - 1 ? "total" : "overlap");
+      if (result !== null) return result;
+    }
   }
   // A whole-board constraint would join otherwise independent components.
   // Local enumeration is conservative; the global counter is used above.
@@ -53,9 +59,10 @@ export function deduce(game: VisibleGame, knownMines: ReadonlySet<number> = new
 /** Keep discovering certain mines until there is a safe cell or nothing more is proved. */
 export function hintFor(game: VisibleGame): Deduction {
   const known = new Set<number>();
+  const adjacent = neighboursOf(game.settings);
   let last: Deduction = { safe: [], mines: [], reason: "none", sources: [], contradiction: false };
   while (known.size <= game.settings.mines) {
-    const result = deduce(game, known);
+    const result = deduce(game, known, true, adjacent);
     if (result.contradiction || result.safe.length) return result;
     const fresh = result.mines.filter((cell) => !known.has(cell));
     if (!fresh.length) return last;