@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/akariGenerate.js

@@ -1,78 +1,114 @@
-import { AKARI_MOST_SIDE } from "./akari.constants.js";
-import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { AKARI_DENSER_ATTEMPTS, AKARI_DENSER_CROWDS, AKARI_LEVELS, AKARI_MOST_ATTEMPTS, AKARI_MOST_SIDE } from "./akari.constants.js";
+import { akariNeighbours, akariVisible, checkAkari, isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
 import { solveAkari } from "./akariSolve.js";
-import { isKazuSeed, seededRandom } from "./random.js";
+import { templateAkari } from "./akariTemplate.js";
+import { logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
 /**
- * Makes a seeded board from two original room-grid families: horizontal or vertical paired
- * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
- * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ * Makes a seeded board and proves it has one answer. A random wall of black squares is lit by randomly placed
+ * bulbs, every black square that touches a white one is numbered, and then numbers are taken away for as long as
+ * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most
+ * of its numbers), hard by supposing one square at a time, extra-hard for as long as the answer stays single,
+ * which leaves a board that needs more supposing than that. If no board of the level is found within the
+ * attempts, the next one down is tried; if none of the levels finds one, the same is tried again with more
+ * black squares, which a large board needs to be solvable at all (see `AKARI_DENSER_CROWDS`). The fixed lattice
+ * of the first generator is only what is left if even that fails, which no seed does at any size offered.
  */
-export function generateAkari(width = 7, height = width, seed = 1) {
+export function generateAkari(width = 7, height = width, seed = 1, level = "medium") {
     if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
-        || !isKazuSeed(seed))
+        || !isKazuSeed(seed) || !AKARI_LEVELS.includes(level))
         throw new RangeError("Invalid Akari settings");
     const random = seededRandom(seed);
-    const cells = Array(width * height).fill(false);
-    const bulbs = [];
-    const horizontal = random() < .5;
-    if (horizontal) {
-        const firstRow = height > 2 ? 1 : 0;
-        for (let y = firstRow; y < height; y += 3) {
-            const clueY = y > 0 ? y - 1 : y + 1;
-            for (let x = 0; x < width; x += 3) {
-                const room = y * width + x;
-                if (x + 1 < width) {
-                    const bulbX = random() < .5 ? x : x + 1;
-                    cells[room] = null;
-                    cells[room + 1] = null;
-                    cells[clueY * width + bulbX] = 1;
-                    bulbs.push(y * width + bulbX);
-                }
-                else {
-                    cells[room] = null;
-                    cells[clueY * width + x] = 1;
-                    bulbs.push(room);
-                }
-            }
+    // The plain attempts come first, as they always have, so every seed that made a board before makes the same one.
+    for (let aim = AKARI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const found = bestAkari(width, height, AKARI_LEVELS[aim], random, 1, AKARI_MOST_ATTEMPTS);
+        if (found)
+            return { ...found.board, seed, level, solution: found.solution };
+    }
+    for (const crowd of AKARI_DENSER_CROWDS)
+        for (let aim = AKARI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+            const found = bestAkari(width, height, AKARI_LEVELS[aim], random, crowd, AKARI_DENSER_ATTEMPTS);
+            if (found)
+                return { ...found.board, seed, level, solution: found.solution };
         }
+    const fallback = templateAkari(width, height, seed);
+    return { ...fallback, level };
+}
+/** The best board of the level found within `attempts` tries at this share of black squares, with its answer, or null. */
+function bestAkari(width, height, level, random, crowd, attempts) {
+    // Extra-hard is the hardest of several boards that need supposing: the most suppositions wins.
+    const wanted = level === "extra-hard" ? 8 : 1;
+    let best = null, found = 0;
+    for (let attempt = 0; attempt < attempts && found < wanted; attempt += 1) {
+        const made = attemptAkari(width, height, level, random, crowd);
+        if (!made)
+            continue;
+        const proof = solveAkari(made.board, { limit: 2 });
+        if (!proof.complete || proof.count !== 1 || !proof.solution || !checkAkari(made.board, proof.solution).ok)
+            continue;
+        found += 1;
+        if (!best || made.probes > best.probes)
+            best = { board: made.board, probes: made.probes, solution: proof.solution };
     }
-    else {
-        const firstColumn = width > 2 ? 1 : 0;
-        for (let x = firstColumn; x < width; x += 3) {
-            const clueX = x > 0 ? x - 1 : x + 1;
-            for (let y = 0; y < height; y += 3) {
-                const room = y * width + x;
-                if (y + 1 < height) {
-                    const bulbY = random() < .5 ? y : y + 1;
-                    cells[room] = null;
-                    cells[room + width] = null;
-                    cells[bulbY * width + clueX] = 1;
-                    bulbs.push(bulbY * width + x);
-                }
-                else {
-                    cells[room] = null;
-                    cells[y * width + clueX] = 1;
-                    bulbs.push(room);
-                }
+    return best;
+}
+function attemptAkari(width, height, level, random, crowd) {
+    const size = width * height;
+    const density = { easy: .2, medium: .22, hard: .24, "extra-hard": .26 }[level] * (.85 + random() * .3) * crowd;
+    const cells = Array.from({ length: size }, () => random() < density ? false : null);
+    if (random() < .5)
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const mirror = (height - 1 - y) * width + width - 1 - x;
+                if (y * width + x < mirror)
+                    cells[mirror] = cells[y * width + x];
             }
-        }
+    if (!cells.includes(null))
+        return null;
+    const base = { width, height, cells };
+    // Light every white square with randomly chosen bulbs that never see one another.
+    const lit = new Set(), bulbs = new Set();
+    for (const cell of shuffled(cells.flatMap((value, at) => value === null ? [at] : []), random)) {
+        if (lit.has(cell))
+            continue;
+        bulbs.add(cell);
+        for (const seen of akariVisible(base, cell))
+            lit.add(seen);
     }
-    // Reflections are applied to the board and the construction answer together.
-    const reflectX = random() < .5, reflectY = random() < .5;
-    const original = [...cells];
-    const map = (cell) => {
-        const x = cell % width, y = Math.floor(cell / width);
-        return (reflectY ? height - 1 - y : y) * width + (reflectX ? width - 1 - x : x);
+    const numbered = cells.flatMap((value, at) => value === false && akariNeighbours(base, at).some(n => cells[n] === null) ? [at] : []);
+    for (const at of numbered)
+        cells[at] = akariNeighbours(base, at).filter(n => bulbs.has(n)).length;
+    if (!numbered.length)
+        return null;
+    const accepts = () => {
+        const { csp } = akariModel({ width, height, cells });
+        return logicCsp(csp, openSlots(csp), level === "easy" || level === "medium" ? 0 : 1).solved;
     };
-    for (let cell = 0; cell < original.length; cell += 1)
-        cells[map(cell)] = original[cell];
-    const answer = bulbs.map(map);
-    const board = { width, height, cells };
-    if (!isAkariBoard(board) || !checkAkari(board, answer).ok)
-        throw new Error("Unable to construct Akari puzzle");
-    const proof = solveAkari(board, { limit: 2 });
-    if (!proof.complete || proof.count !== 1 || !proof.solution) {
-        throw new Error("No uniquely solvable Akari found within the generation budget");
+    if (!accepts())
+        return null;
+    const keepAtLeast = level === "easy" ? Math.ceil(numbered.length * .7) : 0;
+    let left = numbered.length;
+    for (const at of shuffled(numbered, random)) {
+        if (left <= keepAtLeast)
+            break;
+        const was = cells[at];
+        cells[at] = false;
+        if (accepts())
+            left -= 1;
+        else
+            cells[at] = was;
     }
-    return { ...board, seed, solution: proof.solution };
+    const board = { width, height, cells };
+    if (!isAkariBoard(board))
+        return null;
+    const { csp } = akariModel(board);
+    if (level === "easy" || level === "medium")
+        return { board, probes: 0 };
+    if (logicCsp(csp, openSlots(csp), 0).solved)
+        return null;
+    const probing = logicCsp(csp, openSlots(csp), 1);
+    if (!probing.solved)
+        return level === "extra-hard" ? { board, probes: 1000 } : null;
+    return probing.probes >= Math.max(2, Math.round(size * .02)) ? { board, probes: probing.probes } : null;
 }

package/dist/akariLogic.d.ts

@@ -0,0 +1,10 @@
+import type { Csp } from "./csp.ts";
+import type { AkariBoard } from "./akari.types.ts";
+/** An Akari board as variables: one per white square, slot 0 for no bulb and slot 1 for a bulb. */
+export type AkariModel = {
+    csp: Csp;
+    whites: readonly number[];
+    index: Int32Array;
+};
+/** Builds the pruning rules of Akari: a bulb shades its lines, a number counts its neighbours, every white square needs a lamp. */
+export declare function akariModel(board: AkariBoard): AkariModel;

package/dist/akariLogic.js

@@ -0,0 +1,84 @@
+import { akariNeighbours, akariVisible } from "./akariBoard.js";
+/** Builds the pruning rules of Akari: a bulb shades its lines, a number counts its neighbours, every white square needs a lamp. */
+export function akariModel(board) {
+    const whites = board.cells.flatMap((value, cell) => value === null ? [cell] : []);
+    const index = new Int32Array(board.cells.length).fill(-1);
+    whites.forEach((cell, i) => { index[cell] = i; });
+    const sees = whites.map(cell => Int32Array.from(akariVisible(board, cell).filter(other => other !== cell).map(other => index[other])));
+    const clues = board.cells.flatMap((value, cell) => typeof value === "number"
+        ? [{ need: value, near: Int32Array.from(akariNeighbours(board, cell).filter(other => index[other] >= 0).map(other => index[other])) }]
+        : []);
+    const starts = Int32Array.from({ length: whites.length + 1 }, (_, i) => i * 2);
+    const propagate = (alive) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let i = 0; i < whites.length; i += 1) {
+                if (!alive[2 * i] && !alive[2 * i + 1])
+                    return false;
+                if (alive[2 * i] || !alive[2 * i + 1])
+                    continue;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        alive[2 * j + 1] = 0;
+                        changed = true;
+                        if (!alive[2 * j])
+                            return false;
+                    }
+                }
+            }
+            for (const clue of clues) {
+                let on = 0, maybe = 0;
+                for (let k = 0; k < clue.near.length; k += 1) {
+                    const j = clue.near[k];
+                    if (alive[2 * j + 1]) {
+                        maybe += 1;
+                        if (!alive[2 * j])
+                            on += 1;
+                    }
+                }
+                if (on > clue.need || maybe < clue.need)
+                    return false;
+                if (on === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j + 1] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+                else if (maybe === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < whites.length; i += 1) {
+                let lamps = alive[2 * i + 1] ? 1 : 0, only = alive[2 * i + 1] ? i : -1;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length && lamps < 2; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        lamps += 1;
+                        only = j;
+                    }
+                }
+                if (lamps === 0)
+                    return false;
+                if (lamps === 1 && alive[2 * only]) {
+                    alive[2 * only] = 0;
+                    changed = true;
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts, propagate }, whites, index };
+}

package/dist/akariRate.d.ts

@@ -0,0 +1,6 @@
+import type { AkariBoard, AkariRating } from "./akari.types.ts";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export declare function rateAkari(board: AkariBoard): AkariRating;

package/dist/akariRate.js

@@ -0,0 +1,34 @@
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export function rateAkari(board) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const { csp, whites } = akariModel(board);
+    const proof = solveCsp(csp, openSlots(csp), 2, 250000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Akari rating needs a board with one answer");
+    const plain = logicCsp(csp, openSlots(csp), 0);
+    const probing = plain.solved ? plain : logicCsp(csp, openSlots(csp), 1);
+    const blacks = board.cells.length - whites.length;
+    const clues = board.cells.filter(cell => typeof cell === "number").length;
+    const lit = board.cells.map((cell, at) => cell === false || typeof cell === "number" ? at : -1).filter(at => at >= 0);
+    const touching = lit.filter(at => {
+        const x = at % board.width, y = Math.floor(at / board.width);
+        return [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]].some(([nx, ny]) => nx >= 0 && ny >= 0 && nx < board.width && ny < board.height && board.cells[ny * board.width + nx] === null);
+    }).length;
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        whites: whites.length,
+        blacks,
+        clues,
+        bulbs: proof.solution ? whites.filter((_, i) => proof.solution[2 * i + 1] === 1).length : 0,
+        clueShare: touching ? clues / touching : 0,
+        openShare: whites.length / board.cells.length,
+    };
+}

package/dist/akariSolve.d.ts

@@ -1,5 +1,5 @@
 import type { AkariBoard, AkariSolve } from "./akari.types.ts";
-/** Bounded binary constraint search; a stopped proof is always marked incomplete. */
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
 export declare function solveAkari(board: AkariBoard, options?: {
     limit?: number;
     nodes?: number;

package/dist/akariSolve.js

@@ -1,6 +1,8 @@
 import { AKARI_MOST_NODES } from "./akari.constants.js";
-import { akariNeighbours, akariVisible, checkAkari, isAkariBoard } from "./akariBoard.js";
-/** Bounded binary constraint search; a stopped proof is always marked incomplete. */
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
 export function solveAkari(board, options = {}) {
     if (!isAkariBoard(board))
         throw new RangeError("Invalid Akari board");
@@ -9,98 +11,8 @@ export function solveAkari(board, options = {}) {
     if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
         throw new RangeError("Invalid search bounds");
     }
-    const whites = board.cells.flatMap((value, cell) => value === null ? [cell] : []);
-    const visible = whites.map(cell => akariVisible(board, cell));
-    let nodes = 0;
-    let count = 0;
-    let complete = true;
-    let solution = null;
-    const search = (start) => {
-        if (!complete)
-            return;
-        nodes += 1;
-        if (nodes > budget) {
-            complete = false;
-            return;
-        }
-        const assigned = start.slice();
-        let changed = true;
-        while (changed) {
-            changed = false;
-            // A placed bulb rules out every other white square in its four rays.
-            for (let i = 0; i < whites.length; i += 1) {
-                if (assigned[i] !== 1)
-                    continue;
-                for (const cell of visible[i]) {
-                    if (cell === whites[i])
-                        continue;
-                    const other = whites.indexOf(cell);
-                    if (assigned[other] === 1)
-                        return;
-                    if (assigned[other] < 0) {
-                        assigned[other] = 0;
-                        changed = true;
-                    }
-                }
-            }
-            // Numbered black squares provide lower and upper bounds on adjacent bulbs.
-            for (let cell = 0; cell < board.cells.length; cell += 1) {
-                const clue = board.cells[cell];
-                if (typeof clue !== "number")
-                    continue;
-                const nearby = akariNeighbours(board, cell)
-                    .map(neighbour => whites.indexOf(neighbour))
-                    .filter(index => index >= 0);
-                const on = nearby.filter(index => assigned[index] === 1).length;
-                const unknown = nearby.filter(index => assigned[index] < 0);
-                if (on > clue || on + unknown.length < clue)
-                    return;
-                if (on === clue) {
-                    for (const index of unknown) {
-                        assigned[index] = 0;
-                        changed = true;
-                    }
-                }
-                if (on + unknown.length === clue) {
-                    for (const index of unknown) {
-                        assigned[index] = 1;
-                        changed = true;
-                    }
-                }
-            }
-            // Every white cell still needs a possible source of light.
-            for (let i = 0; i < whites.length; i += 1) {
-                const ray = visible[i].map(cell => whites.indexOf(cell));
-                if (ray.some(index => assigned[index] === 1))
-                    continue;
-                const unknown = ray.filter(index => assigned[index] < 0);
-                if (!unknown.length)
-                    return;
-                if (unknown.length === 1) {
-                    assigned[unknown[0]] = 1;
-                    changed = true;
-                }
-            }
-        }
-        const branch = assigned.findIndex(value => value < 0);
-        if (branch < 0) {
-            const bulbs = whites.filter((_, index) => assigned[index] === 1);
-            if (!checkAkari(board, bulbs).ok)
-                return;
-            count += 1;
-            solution ?? (solution = bulbs);
-            if (count >= limit)
-                complete = false;
-            return;
-        }
-        for (const value of [1, 0]) {
-            const next = assigned.slice();
-            next[branch] = value;
-            search(next);
-            if (!complete)
-                return;
-        }
-    };
-    search(new Int8Array(whites.length).fill(-1));
-    return { count, solution, complete, nodes };
+    const { csp, whites } = akariModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const solution = found.solution ? whites.filter((_, i) => found.solution[2 * i + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/akariTemplate.d.ts

@@ -0,0 +1,7 @@
+import type { AkariPuzzle } from "./akari.types.ts";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export declare function templateAkari(width?: number, height?: number, seed?: number): Omit<AkariPuzzle, "level">;

package/dist/akariTemplate.js

@@ -0,0 +1,78 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export function templateAkari(width = 7, height = width, seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Akari settings");
+    const random = seededRandom(seed);
+    const cells = Array(width * height).fill(false);
+    const bulbs = [];
+    const horizontal = random() < .5;
+    if (horizontal) {
+        const firstRow = height > 2 ? 1 : 0;
+        for (let y = firstRow; y < height; y += 3) {
+            const clueY = y > 0 ? y - 1 : y + 1;
+            for (let x = 0; x < width; x += 3) {
+                const room = y * width + x;
+                if (x + 1 < width) {
+                    const bulbX = random() < .5 ? x : x + 1;
+                    cells[room] = null;
+                    cells[room + 1] = null;
+                    cells[clueY * width + bulbX] = 1;
+                    bulbs.push(y * width + bulbX);
+                }
+                else {
+                    cells[room] = null;
+                    cells[clueY * width + x] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    else {
+        const firstColumn = width > 2 ? 1 : 0;
+        for (let x = firstColumn; x < width; x += 3) {
+            const clueX = x > 0 ? x - 1 : x + 1;
+            for (let y = 0; y < height; y += 3) {
+                const room = y * width + x;
+                if (y + 1 < height) {
+                    const bulbY = random() < .5 ? y : y + 1;
+                    cells[room] = null;
+                    cells[room + width] = null;
+                    cells[bulbY * width + clueX] = 1;
+                    bulbs.push(bulbY * width + x);
+                }
+                else {
+                    cells[room] = null;
+                    cells[y * width + clueX] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    // Reflections are applied to the board and the construction answer together.
+    const reflectX = random() < .5, reflectY = random() < .5;
+    const original = [...cells];
+    const map = (cell) => {
+        const x = cell % width, y = Math.floor(cell / width);
+        return (reflectY ? height - 1 - y : y) * width + (reflectX ? width - 1 - x : x);
+    };
+    for (let cell = 0; cell < original.length; cell += 1)
+        cells[map(cell)] = original[cell];
+    const answer = bulbs.map(map);
+    const board = { width, height, cells };
+    if (!isAkariBoard(board) || !checkAkari(board, answer).ok)
+        throw new Error("Unable to construct Akari puzzle");
+    const proof = solveAkari(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Akari found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/cells.d.ts

@@ -2,14 +2,14 @@
  * A GRID OF NUMBERS AS A STRING: for an address, a POST body, and a kept run.
  *
  * Row-major, one character per cell: a digit for a value, `.` for an empty cell. Past nine the
- * values are letters, A for 10 up to G for 16, as a 16×16 Sudoku is printed (`symbolOf`), so one
- * character is still one cell. Upper case only in a code, so one grid has one spelling. These are
+ * values are letters, A for 10 up to G for 16 as a 16×16 Sudoku is printed, and on to P for 25 on a
+ * 25×25 (`symbolOf`), so one character is still one cell. Upper case only in a code, so one grid has one spelling. These are
  * the spellings itsutsu.com has always stored, and they decode here unchanged.
  */
 export declare const EMPTY_CELL = ".";
-/** How a value is written, in a code and on a cell: 1–9, then A–G. */
+/** How a value is written, in a code and on a cell: 1–9, then A–P. */
 export declare function symbolOf(value: number): string;
-/** The value a symbol names, or 0 for one that is not 1–9 or A–G (either case). */
+/** The value a symbol names, or 0 for one that is not 1–9 or A–P (either case). */
 export declare function valueOfSymbol(symbol: string): number;
 /** `[0, 3, 0, 1]` → `".3.1"`. */
 export declare function encodeCells(cells: readonly number[]): string;

package/dist/cells.js

@@ -2,18 +2,18 @@
  * A GRID OF NUMBERS AS A STRING: for an address, a POST body, and a kept run.
  *
  * Row-major, one character per cell: a digit for a value, `.` for an empty cell. Past nine the
- * values are letters, A for 10 up to G for 16, as a 16×16 Sudoku is printed (`symbolOf`), so one
- * character is still one cell. Upper case only in a code, so one grid has one spelling. These are
+ * values are letters, A for 10 up to G for 16 as a 16×16 Sudoku is printed, and on to P for 25 on a
+ * 25×25 (`symbolOf`), so one character is still one cell. Upper case only in a code, so one grid has one spelling. These are
  * the spellings itsutsu.com has always stored, and they decode here unchanged.
  */
 export const EMPTY_CELL = ".";
-/** The letters after 9, in order: A is 10, G is 16. */
-const PAST_NINE = "ABCDEFG";
-/** How a value is written, in a code and on a cell: 1–9, then A–G. */
+/** The letters after 9, in order: A is 10, G is 16, P is 25. */
+const PAST_NINE = "ABCDEFGHIJKLMNOP";
+/** How a value is written, in a code and on a cell: 1–9, then A–P. */
 export function symbolOf(value) {
     return value <= 9 ? String(value) : PAST_NINE[value - 10];
 }
-/** The value a symbol names, or 0 for one that is not 1–9 or A–G (either case). */
+/** The value a symbol names, or 0 for one that is not 1–9 or A–P (either case). */
 export function valueOfSymbol(symbol) {
     if (symbol.length !== 1)
         return 0;

package/dist/csp.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ONE SMALL ENGINE for the puzzles that are solved by narrowing down what each square, edge or rectangle can
+ * still be. A puzzle supplies its variables and one function that prunes; this file does the two things
+ * every one of them needs: counting answers (a search that stops at a limit) and rating how hard a puzzle
+ * is (how deep the reasoning must go before the grid is decided).
+ *
+ * A variable has a few slots (its possible values). `alive[slot]` is 1 while that value is still possible.
+ * A variable is decided when exactly one of its slots is alive and impossible when none is.
+ */
+export type Csp = {
+    /** The slots of variable `v` are `starts[v]` up to, not including, `starts[v + 1]`. */
+    starts: Int32Array;
+    /**
+     * Prunes `alive` as far as the rules force and says `false` when they cannot all be kept. Never guesses.
+     * `decided` names a variable that was just narrowed from a state that was already pruned, so a rule may
+     * look only at what that can change; leaving it out means look at everything.
+     */
+    propagate: (alive: Uint8Array, decided?: number) => boolean;
+    /** Which variable to branch on in a search; the default is the one with the fewest values left. */
+    choose?: (alive: Uint8Array) => number;
+};
+/** How many values a variable still has. */
+export declare function slotsLeft(csp: Csp, alive: Uint8Array, variable: number): number;
+/** Every value of every variable still possible. */
+export declare function openSlots(csp: Csp): Uint8Array;
+/** Leaves `variable` with only `slot` (a slot number, not an offset). */
+export declare function decide(csp: Csp, alive: Uint8Array, variable: number, slot: number): void;
+/** The slot a decided variable has left, or -1 when it has more than one or none. */
+export declare function decidedSlot(csp: Csp, alive: Uint8Array, variable: number): number;
+export type CspCount = {
+    count: number;
+    solution: Uint8Array | null;
+    solutions: Uint8Array[];
+    stopped: boolean;
+    exhausted: boolean;
+    nodes: number;
+};
+/**
+ * Counts the ways to decide every variable, up to `limit`. `exhausted` says the node budget ran out;
+ * `stopped` says the limit was reached. Either way the count must not be read as proof of anything
+ * beyond what was seen.
+ */
+export declare function countCsp(csp: Csp, start: Uint8Array, limit: number, budget: number): CspCount;
+export type CspLogic = {
+    solved: boolean;
+    contradiction: boolean;
+    probes: number;
+    alive: Uint8Array;
+};
+/**
+ * Solves by reasoning alone, never by guessing a value and keeping it. `depth` 0 is the rules' own
+ * pruning. Depth 1 adds probing: suppose one value, prune, and when that breaks a rule the value is
+ * ruled out. Depth 2 lets a probe probe. `probes` counts the values ruled out by supposing, which is how
+ * much supposing the puzzle asks of a person.
+ */
+export declare function logicCsp(csp: Csp, start: Uint8Array, depth: number): CspLogic;
+/**
+ * Counts answers like `countCsp`, but first tries to settle the puzzle by reasoning (rules, then one level of
+ * supposing): reasoning that leaves every variable decided proves exactly one answer, and reasoning that breaks a
+ * rule proves none, in far fewer steps than a search. Only a puzzle that reasoning leaves open is searched, from the
+ * state reasoning reached.
+ */
+export declare function solveCsp(csp: Csp, start: Uint8Array, limit: number, budget: number, depth?: number): CspCount;