@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/kakuroGenerate.js

@@ -1,130 +1,62 @@
-import { KAKURO_GENERATION_ATTEMPTS, KAKURO_GENERATION_NODES, KAKURO_MAX_ATTEMPTS, KAKURO_MAX_NODES } from "./kakuro.constants.js";
-import { isKakuroBoard } from "./kakuroBoard.js";
+import { KAKURO_LEAST_GENERATED_SIDE, KAKURO_LEVELS, KAKURO_MAX_SIDE } from "./kakuro.constants.js";
+import { checkKakuro } from "./kakuroBoard.js";
+import { candidateKakuro } from "./kakuroBuild.js";
+import { kakuroModel } from "./kakuroLogic.js";
 import { solveKakuro } from "./kakuroSolve.js";
+import { templateKakuro } from "./kakuroTemplate.js";
+import { logicCsp, openSlots } from "./csp.js";
 import { isKazuSeed, seededRandom } from "./random.js";
-/** Makes a seeded 10×10 family of crossing runs and returns only a uniquely proved puzzle. */
-export function generateKakuro(seed = 1) {
-    if (!isKazuSeed(seed))
-        throw new RangeError("Invalid Kakuro seed.");
+const MOST_ATTEMPTS = 400;
+/**
+ * Makes a seeded board of `size` squares a side (counting the row and column of totals) and proves it has one
+ * answer. A random pattern of black squares sets the runs, random digits fill them, and digits are changed until
+ * the answer is single. The board is then rated by solving it: easy by the single-run rules, medium once a digit
+ * that must appear has to be traced, hard by supposing, and extra-hard the most-supposing of several boards.
+ * If no board of the level is found within the attempts the next level down is tried, and the first generator
+ * (a 10×10 only) is the last resort, so a seed never throws.
+ */
+export function generateKakuro(seed = 1, level = "medium", size = 10) {
+    if (!isKazuSeed(seed) || !KAKURO_LEVELS.includes(level) || !Number.isInteger(size)
+        || size < KAKURO_LEAST_GENERATED_SIDE || size > KAKURO_MAX_SIDE)
+        throw new RangeError("Invalid Kakuro settings");
     const random = seededRandom(seed);
-    const budget = { attempts: KAKURO_GENERATION_ATTEMPTS, nodes: KAKURO_GENERATION_NODES };
-    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
-        budget.attempts -= 1;
-        const rowGroups = random() < .5 ? [2, 2, 2] : random() < .5 ? [2, 3] : [3, 2];
-        const columnGroups = rowGroups.length === 3 ? [2, 2, 2] : [2, 3];
-        if (random() < .5)
-            columnGroups.reverse();
-        const rowStarts = groupStarts(rowGroups, random);
-        const columnStarts = groupStarts(columnGroups, random);
-        const cells = Array.from({ length: 100 }, () => ({ kind: "black", across: null, down: null }));
-        const solution = Array(100).fill(0);
-        const board = { width: 10, height: 10, cells };
-        let failed = false;
-        for (const [rowIndex, rowStart] of rowStarts.entries()) {
-            for (const [columnIndex, columnStart] of columnStarts.entries()) {
-                const shape = { height: rowGroups[rowIndex], width: columnGroups[columnIndex] };
-                const local = chooseUniqueTile(shape.width, shape.height, random, budget);
-                if (!local) {
-                    failed = true;
-                    break;
-                }
-                placeTile(board, solution, rowStart, columnStart, local);
-            }
-            if (failed)
-                break;
-        }
-        if (failed)
-            continue;
-        if (!isKakuroBoard(board))
-            throw new Error(JSON.stringify(board));
-        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(KAKURO_MAX_NODES, budget.nodes) });
-        budget.nodes -= Math.min(budget.nodes, proof.nodes);
-        if (proof.complete && proof.count === 1 && proof.solution) {
-            return { ...board, seed, solution: proof.solution };
+    for (let aim = KAKURO_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = KAKURO_LEVELS[aim];
+        const wanted = aimed === "extra-hard" ? 3 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const built = candidateKakuro(size, aimed, random);
+            if (!built)
+                continue;
+            const score = scored(built.board, aimed);
+            if (score === null)
+                continue;
+            found += 1;
+            if (!best || score > best.score)
+                best = { board: built.board, score };
         }
-    }
-    throw new Error("No uniquely solvable Kakuro board was proved within the generation budget.");
-}
-function groupStarts(groups, random) {
-    const used = groups.reduce((sum, size) => sum + size, 0) + groups.length - 1;
-    let at = 1 + (8 - used > 0 && random() < .5 ? 8 - used : 0);
-    return groups.map(size => { const start = at; at += size + 1; return start; });
-}
-function chooseUniqueTile(width, height, random, budget) {
-    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
-        budget.attempts -= 1;
-        const candidate = randomRectangle(width, height, random);
-        if (!candidate)
-            continue;
-        const board = tileBoard(candidate);
-        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(25000, budget.nodes) });
-        budget.nodes -= Math.min(budget.nodes, proof.nodes);
-        if (!budget.nodes)
-            return null;
-        if (proof.complete && proof.count === 1)
-            return proof.solution ? splitSolution(proof.solution, width, height) : candidate;
-    }
-    return null;
-}
-function randomRectangle(width, height, random) {
-    const rows = [];
-    for (let y = 0; y < height; y += 1) {
-        let row = null;
-        for (let attempt = 0; attempt < 100; attempt += 1) {
-            const available = shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9], random);
-            const candidate = available.slice(0, width);
-            if (candidate.every((digit, x) => rows.every(previous => previous[x] !== digit))) {
-                row = candidate;
-                break;
+        if (best) {
+            const proof = solveKakuro(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkKakuro(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
             }
         }
-        if (!row)
-            return null;
-        rows.push(row);
-    }
-    return rows;
-}
-function tileBoard(solution) {
-    const height = solution.length + 1, width = solution[0].length + 1;
-    const cells = Array.from({ length: width * height }, () => ({ kind: "black", across: null, down: null }));
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            cells[(y + 1) * width + x + 1] = { kind: "white" };
-    for (let y = 0; y < solution.length; y += 1)
-        cells[(y + 1) * width].across = solution[y].reduce((sum, value) => sum + value, 0);
-    for (let x = 0; x < solution[0].length; x += 1)
-        cells[x + 1].down = solution.reduce((sum, row) => sum + row[x], 0);
-    return { width, height, cells };
-}
-function placeTile(board, full, top, left, solution) {
-    const width = board.width;
-    const cells = board.cells;
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            full[(top + y) * width + left + x] = solution[y][x];
-    for (let y = 0; y < solution.length; y += 1) {
-        const clue = (top + y) * width + left - 1;
-        cells[clue].across = solution[y].reduce((sum, value) => sum + value, 0);
-    }
-    for (let x = 0; x < solution[0].length; x += 1) {
-        const clue = (top - 1) * width + left + x;
-        cells[clue].down = solution.reduce((sum, row) => sum + row[x], 0);
-    }
-    for (let y = 0; y < solution.length; y += 1)
-        for (let x = 0; x < solution[y].length; x += 1)
-            cells[(top + y) * width + left + x] = { kind: "white" };
-}
-function splitSolution(values, width, height) {
-    const result = [];
-    for (let y = 1; y <= height; y += 1)
-        result.push(values.slice(y * (width + 1) + 1, y * (width + 1) + width + 1));
-    return result;
-}
-function shuffled(items, random) {
-    const result = [...items];
-    for (let i = result.length - 1; i > 0; i -= 1) {
-        const j = Math.floor(random() * (i + 1));
-        [result[i], result[j]] = [result[j], result[i]];
     }
-    return result;
+    if (size === 10)
+        return { ...templateKakuro(seed), level };
+    throw new Error("No uniquely solvable Kakuro board was found within the generation budget; try another seed");
+}
+/** Whether a board suits a level, and how well: higher is harder. */
+function scored(board, level) {
+    const weak = kakuroModel(board, 0), strong = kakuroModel(board, 1);
+    if (logicCsp(weak.csp, openSlots(weak.csp), 0).solved)
+        return level === "easy" ? 0 : null;
+    if (level === "easy")
+        return null;
+    if (logicCsp(strong.csp, openSlots(strong.csp), 0).solved)
+        return level === "medium" ? 0 : null;
+    if (level === "medium")
+        return null;
+    const probing = logicCsp(strong.csp, openSlots(strong.csp), 1);
+    return probing.solved ? probing.probes : level === "extra-hard" ? 1000 : null;
 }

package/dist/kakuroLogic.d.ts

@@ -0,0 +1,13 @@
+import type { Csp } from "./csp.ts";
+import type { KakuroBoard } from "./kakuro.types.ts";
+/**
+ * Kakuro as variables: one per white square, nine slots for the digits 1 to 9. A run's pruning keeps only the digit
+ * sets that add up to its total and fit what its squares can still be, so a square keeps only digits some such
+ * set uses; a digit that every such set uses must appear somewhere (`strength` 1), and a digit that only one square
+ * can take is that square's.
+ */
+export declare function kakuroModel(board: KakuroBoard, strength?: 0 | 1, random?: () => number): {
+    csp: Csp;
+    whites: readonly number[];
+    index: Int32Array;
+};

package/dist/kakuroLogic.js

@@ -0,0 +1,153 @@
+import { kakuroRuns } from "./kakuroBoard.js";
+/** Every way to choose `length` different digits that add to `sum`, as 9-bit masks (bit d - 1 for digit d), by length then sum. */
+const COMBINATIONS = (() => {
+    const table = Array.from({ length: 10 }, () => Array.from({ length: 46 }, () => []));
+    for (let mask = 1; mask < 512; mask += 1) {
+        let length = 0, sum = 0;
+        for (let d = 1; d <= 9; d += 1)
+            if (mask & 1 << d - 1) {
+                length += 1;
+                sum += d;
+            }
+        table[length][sum].push(mask);
+    }
+    return table;
+})();
+/**
+ * Kakuro as variables: one per white square, nine slots for the digits 1 to 9. A run's pruning keeps only the digit
+ * sets that add up to its total and fit what its squares can still be, so a square keeps only digits some such
+ * set uses; a digit that every such set uses must appear somewhere (`strength` 1), and a digit that only one square
+ * can take is that square's.
+ */
+export function kakuroModel(board, strength = 1, random) {
+    const whites = board.cells.flatMap((tile, cell) => tile.kind === "white" ? [cell] : []);
+    const index = new Int32Array(board.cells.length).fill(-1);
+    whites.forEach((cell, i) => { index[cell] = i; });
+    const runs = kakuroRuns(board).map(run => ({ cells: Int32Array.from(run.cells.map(cell => index[cell])), sum: run.sum, combos: COMBINATIONS[run.cells.length][run.sum] }));
+    const runsOf = whites.map(() => []);
+    runs.forEach((run, r) => run.cells.forEach(cell => runsOf[cell].push(r)));
+    const starts = Int32Array.from({ length: whites.length + 1 }, (_, i) => i * 9);
+    const domain = new Int16Array(whites.length), loaded = new Int32Array(whites.length), touched = new Int32Array(whites.length), changedCells = new Int32Array(whites.length);
+    const queue = new Int32Array(runs.length * 4 + 4), queued = new Uint8Array(runs.length);
+    let stamp = 0;
+    const propagate = (alive, decided) => {
+        stamp += 1;
+        let changes = 0;
+        // A square's digits are read from `alive` the first time a run asks, so a call after one decision touches only what that reaches.
+        const read = (i) => {
+            if (loaded[i] !== stamp) {
+                let mask = 0;
+                for (let d = 0; d < 9; d += 1)
+                    if (alive[9 * i + d])
+                        mask |= 1 << d;
+                domain[i] = mask;
+                loaded[i] = stamp;
+            }
+            return domain[i];
+        };
+        let head = 0, tail = 0;
+        const push = (r) => { if (!queued[r]) {
+            queued[r] = 1;
+            queue[tail++ % queue.length] = r;
+        } };
+        if (decided === undefined)
+            for (let r = 0; r < runs.length; r += 1)
+                push(r);
+        else
+            for (const r of runsOf[decided])
+                push(r);
+        while (head < tail) {
+            const r = queue[head++ % queue.length], run = runs[r], cells = run.cells;
+            queued[r] = 0;
+            let known = 0, union = 0;
+            for (let k = 0; k < cells.length; k += 1) {
+                const mask = read(cells[k]);
+                if (!mask)
+                    return fail();
+                union |= mask;
+                if (!(mask & mask - 1)) {
+                    if (known & mask)
+                        return fail();
+                    known |= mask;
+                }
+            }
+            let usable = 0, always = 511, viable = 0;
+            for (let c = 0; c < run.combos.length; c += 1) {
+                const combo = run.combos[c];
+                if (combo & ~union || known & ~combo)
+                    continue;
+                let fits = true;
+                for (let k = 0; k < cells.length && fits; k += 1)
+                    if (!(domain[cells[k]] & combo))
+                        fits = false;
+                if (!fits)
+                    continue;
+                viable += 1;
+                usable |= combo;
+                always &= combo;
+            }
+            if (!viable)
+                return fail();
+            for (let k = 0; k < cells.length; k += 1) {
+                const cell = cells[k], was = domain[cell];
+                let mask = was & usable;
+                // Squares not yet decided cannot take the digits the decided ones of the run hold.
+                if (was & was - 1)
+                    mask &= ~known;
+                if (strength > 0 && always && mask & mask - 1) {
+                    // A digit every viable set uses must go somewhere: if only this square can hold it, it does.
+                    for (let d = 0; d < 9; d += 1) {
+                        if (!(always & 1 << d) || !(mask & 1 << d))
+                            continue;
+                        let holders = 0;
+                        for (let j = 0; j < cells.length; j += 1)
+                            if (domain[cells[j]] & 1 << d)
+                                holders += 1;
+                        if (holders === 1) {
+                            mask = 1 << d;
+                            break;
+                        }
+                    }
+                }
+                if (!mask)
+                    return fail();
+                if (mask !== was) {
+                    if (touched[cell] !== stamp) {
+                        touched[cell] = stamp;
+                        changedCells[changes++] = cell;
+                    }
+                    domain[cell] = mask;
+                    for (const other of runsOf[cell])
+                        push(other);
+                }
+            }
+        }
+        for (let c = 0; c < changes; c += 1) {
+            const i = changedCells[c];
+            for (let d = 0; d < 9; d += 1)
+                alive[9 * i + d] = domain[i] & 1 << d ? 1 : 0;
+        }
+        return true;
+    };
+    const fail = () => { queued.fill(0); return false; };
+    // A search that picks at random among the squares with fewest digits left can be restarted when it gets lost.
+    const choose = random ? (alive) => {
+        let best = 10, count = 0, pick = -1;
+        for (let i = 0; i < whites.length; i += 1) {
+            let left = 0;
+            for (let d = 0; d < 9; d += 1)
+                left += alive[9 * i + d];
+            if (left < 2 || left > best)
+                continue;
+            if (left < best) {
+                best = left;
+                count = 0;
+            }
+            count += 1;
+            if (random() * count < 1)
+                pick = i;
+        }
+        return pick;
+    } : undefined;
+    return { csp: { starts, propagate, choose }, whites, index };
+}

package/dist/kakuroRate.d.ts

@@ -0,0 +1,3 @@
+import type { KakuroBoard, KakuroRating } from "./kakuro.types.ts";
+/** Rates a board with one answer by solving it: with the single-run rules, with the digit-that-must-appear rule, then by supposing. */
+export declare function rateKakuro(board: KakuroBoard): KakuroRating;

package/dist/kakuroRate.js

@@ -0,0 +1,40 @@
+import { isKakuroBoard, kakuroRuns } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+const COMBOS = (length, sum) => {
+    let count = 0;
+    for (let mask = 1; mask < 512; mask += 1) {
+        let n = 0, total = 0;
+        for (let d = 1; d <= 9; d += 1)
+            if (mask & 1 << d - 1) {
+                n += 1;
+                total += d;
+            }
+        if (n === length && total === sum)
+            count += 1;
+    }
+    return count;
+};
+/** Rates a board with one answer by solving it: with the single-run rules, with the digit-that-must-appear rule, then by supposing. */
+export function rateKakuro(board) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    const weak = kakuroModel(board, 0), strong = kakuroModel(board, 1);
+    const proof = solveCsp(strong.csp, openSlots(strong.csp), 2, 250000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Kakuro rating needs a board with one answer");
+    const plain = logicCsp(weak.csp, openSlots(weak.csp), 0);
+    const rules = plain.solved ? plain : logicCsp(strong.csp, openSlots(strong.csp), 0);
+    const probing = rules.solved ? rules : logicCsp(strong.csp, openSlots(strong.csp), 1);
+    const runs = kakuroRuns(board);
+    return {
+        depth: rules.solved ? 0 : probing.solved ? 1 : 2,
+        plain: plain.solved,
+        probes: rules.solved ? 0 : probing.probes,
+        whites: strong.whites.length,
+        runs: runs.length,
+        longest: Math.max(...runs.map(run => run.cells.length)),
+        meanRun: runs.reduce((total, run) => total + run.cells.length, 0) / runs.length,
+        fixedShare: runs.filter(run => COMBOS(run.cells.length, run.sum) === 1).length / runs.length,
+    };
+}

package/dist/kakuroSolve.js

@@ -1,5 +1,7 @@
 import { KAKURO_MAX_NODES } from "./kakuro.constants.js";
-import { canReach, isKakuroBoard, kakuroRuns } from "./kakuroBoard.js";
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
 /** Bounded exact counter over across and down runs; an interrupted search never proves uniqueness. */
 export function solveKakuro(board, entries = [], options = {}) {
     if (!isKakuroBoard(board))
@@ -9,77 +11,23 @@ export function solveKakuro(board, entries = [], options = {}) {
         throw new RangeError("Invalid search bounds");
     if (entries.length && entries.length !== board.cells.length)
         throw new RangeError("Invalid Kakuro entries");
-    const runs = kakuroRuns(board), values = entries.length ? [...entries] : Array(board.cells.length).fill(0);
-    const memberships = board.cells.map(() => []);
-    runs.forEach((run, index) => run.cells.forEach(cell => memberships[cell].push(index)));
-    for (let cell = 0; cell < values.length; cell += 1) {
-        const value = values[cell];
+    const { csp, whites } = kakuroModel(board);
+    const start = openSlots(csp);
+    for (let cell = 0; cell < entries.length; cell += 1) {
+        const value = entries[cell];
         if (board.cells[cell].kind === "black" ? value !== 0 : !Number.isInteger(value) || value < 0 || value > 9) {
             return { count: 0, solution: null, complete: true, nodes: 0 };
         }
     }
-    let count = 0, nodes = 0, complete = true, solution = null;
-    const domains = (cell) => {
-        const possible = [];
-        for (let digit = 1; digit <= 9; digit += 1) {
-            if (memberships[cell].every(index => runAllows(runs[index], values, cell, digit)))
-                possible.push(digit);
-        }
-        return possible;
-    };
-    const visit = () => {
-        if (++nodes > budget) {
-            complete = false;
-            return;
-        }
-        let chosen = -1, optionsForCell = [];
-        for (let cell = 0; cell < values.length; cell += 1) {
-            if (board.cells[cell].kind === "black" || values[cell])
-                continue;
-            const possible = domains(cell);
-            if (!possible.length)
-                return;
-            if (chosen < 0 || possible.length < optionsForCell.length) {
-                chosen = cell;
-                optionsForCell = possible;
-                if (possible.length === 1)
-                    break;
-            }
-        }
-        if (chosen < 0) {
-            count += 1;
-            solution ?? (solution = [...values]);
-            return;
-        }
-        for (const digit of optionsForCell) {
-            values[chosen] = digit;
-            visit();
-            values[chosen] = 0;
-            if (!complete || count >= limit) {
-                complete = false;
-                return;
-            }
-        }
-    };
-    // Reject contradictory entries before branching.
-    for (const run of runs)
-        if (!runAllows(run, values, -1, 0))
-            return { count: 0, solution: null, complete: true, nodes: 0 };
-    visit();
-    return { count, solution, complete, nodes };
-}
-function runAllows(run, values, targetCell, candidate) {
-    let sum = 0;
-    const used = new Set();
-    for (const cell of run.cells) {
-        const value = cell === targetCell ? candidate : values[cell];
-        if (!value)
-            continue;
-        if (used.has(value))
-            return false;
-        used.add(value);
-        sum += value;
+    whites.forEach((cell, i) => { const value = entries[cell]; if (value)
+        decide(csp, start, i, 9 * i + value - 1); });
+    const found = solveCsp(csp, start, limit, budget);
+    let solution = null;
+    if (found.solution) {
+        solution = Array(board.cells.length).fill(0);
+        whites.forEach((cell, i) => { for (let d = 0; d < 9; d += 1)
+            if (found.solution[9 * i + d])
+                solution[cell] = d + 1; });
     }
-    const slots = run.cells.filter(cell => !values[cell] && cell !== targetCell).length;
-    return sum <= run.sum && canReach(run.sum - sum, slots, [...used]);
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/kakuroTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { KakuroPuzzle } from "./kakuro.types.ts";
+/** The first generator, kept as the fallback that cannot fail on a 10×10: a seeded family of crossing runs, returned only when uniquely proved. */
+export declare function templateKakuro(seed?: number): Omit<KakuroPuzzle, "level">;

package/dist/kakuroTemplate.js

@@ -0,0 +1,130 @@
+import { KAKURO_GENERATION_ATTEMPTS, KAKURO_GENERATION_NODES, KAKURO_MAX_ATTEMPTS, KAKURO_MAX_NODES } from "./kakuro.constants.js";
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { solveKakuro } from "./kakuroSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** The first generator, kept as the fallback that cannot fail on a 10×10: a seeded family of crossing runs, returned only when uniquely proved. */
+export function templateKakuro(seed = 1) {
+    if (!isKazuSeed(seed))
+        throw new RangeError("Invalid Kakuro seed.");
+    const random = seededRandom(seed);
+    const budget = { attempts: KAKURO_GENERATION_ATTEMPTS, nodes: KAKURO_GENERATION_NODES };
+    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
+        budget.attempts -= 1;
+        const rowGroups = random() < .5 ? [2, 2, 2] : random() < .5 ? [2, 3] : [3, 2];
+        const columnGroups = rowGroups.length === 3 ? [2, 2, 2] : [2, 3];
+        if (random() < .5)
+            columnGroups.reverse();
+        const rowStarts = groupStarts(rowGroups, random);
+        const columnStarts = groupStarts(columnGroups, random);
+        const cells = Array.from({ length: 100 }, () => ({ kind: "black", across: null, down: null }));
+        const solution = Array(100).fill(0);
+        const board = { width: 10, height: 10, cells };
+        let failed = false;
+        for (const [rowIndex, rowStart] of rowStarts.entries()) {
+            for (const [columnIndex, columnStart] of columnStarts.entries()) {
+                const shape = { height: rowGroups[rowIndex], width: columnGroups[columnIndex] };
+                const local = chooseUniqueTile(shape.width, shape.height, random, budget);
+                if (!local) {
+                    failed = true;
+                    break;
+                }
+                placeTile(board, solution, rowStart, columnStart, local);
+            }
+            if (failed)
+                break;
+        }
+        if (failed)
+            continue;
+        if (!isKakuroBoard(board))
+            throw new Error(JSON.stringify(board));
+        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(KAKURO_MAX_NODES, budget.nodes) });
+        budget.nodes -= Math.min(budget.nodes, proof.nodes);
+        if (proof.complete && proof.count === 1 && proof.solution) {
+            return { ...board, seed, solution: proof.solution };
+        }
+    }
+    throw new Error("No uniquely solvable Kakuro board was proved within the generation budget.");
+}
+function groupStarts(groups, random) {
+    const used = groups.reduce((sum, size) => sum + size, 0) + groups.length - 1;
+    let at = 1 + (8 - used > 0 && random() < .5 ? 8 - used : 0);
+    return groups.map(size => { const start = at; at += size + 1; return start; });
+}
+function chooseUniqueTile(width, height, random, budget) {
+    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
+        budget.attempts -= 1;
+        const candidate = randomRectangle(width, height, random);
+        if (!candidate)
+            continue;
+        const board = tileBoard(candidate);
+        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(25000, budget.nodes) });
+        budget.nodes -= Math.min(budget.nodes, proof.nodes);
+        if (!budget.nodes)
+            return null;
+        if (proof.complete && proof.count === 1)
+            return proof.solution ? splitSolution(proof.solution, width, height) : candidate;
+    }
+    return null;
+}
+function randomRectangle(width, height, random) {
+    const rows = [];
+    for (let y = 0; y < height; y += 1) {
+        let row = null;
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const available = shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9], random);
+            const candidate = available.slice(0, width);
+            if (candidate.every((digit, x) => rows.every(previous => previous[x] !== digit))) {
+                row = candidate;
+                break;
+            }
+        }
+        if (!row)
+            return null;
+        rows.push(row);
+    }
+    return rows;
+}
+function tileBoard(solution) {
+    const height = solution.length + 1, width = solution[0].length + 1;
+    const cells = Array.from({ length: width * height }, () => ({ kind: "black", across: null, down: null }));
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            cells[(y + 1) * width + x + 1] = { kind: "white" };
+    for (let y = 0; y < solution.length; y += 1)
+        cells[(y + 1) * width].across = solution[y].reduce((sum, value) => sum + value, 0);
+    for (let x = 0; x < solution[0].length; x += 1)
+        cells[x + 1].down = solution.reduce((sum, row) => sum + row[x], 0);
+    return { width, height, cells };
+}
+function placeTile(board, full, top, left, solution) {
+    const width = board.width;
+    const cells = board.cells;
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            full[(top + y) * width + left + x] = solution[y][x];
+    for (let y = 0; y < solution.length; y += 1) {
+        const clue = (top + y) * width + left - 1;
+        cells[clue].across = solution[y].reduce((sum, value) => sum + value, 0);
+    }
+    for (let x = 0; x < solution[0].length; x += 1) {
+        const clue = (top - 1) * width + left + x;
+        cells[clue].down = solution.reduce((sum, row) => sum + row[x], 0);
+    }
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            cells[(top + y) * width + left + x] = { kind: "white" };
+}
+function splitSolution(values, width, height) {
+    const result = [];
+    for (let y = 1; y <= height; y += 1)
+        result.push(values.slice(y * (width + 1) + 1, y * (width + 1) + width + 1));
+    return result;
+}
+function shuffled(items, random) {
+    const result = [...items];
+    for (let i = result.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}

package/dist/kinds.js

@@ -10,7 +10,7 @@ export const KAZU_KINDS = ["number-place", "jigsaw", "diagonal", "sum-cages", "m
 /** How hard a puzzle is made: what the solver needed. Easy yields to singles alone, medium to one guess, hard to whatever it takes. */
 export const KAZU_LEVELS = ["easy", "medium", "hard"];
 export const KAZU_SPECS = {
-    "number-place": { sizes: [4, 6, 9, 16], defaultSize: 9, mostCells: 256 },
+    "number-place": { sizes: [4, 6, 9, 16, 25], defaultSize: 9, mostCells: 625 },
     jigsaw: { sizes: [5, 6, 7, 9], defaultSize: 7, mostCells: 162 },
     diagonal: { sizes: [6, 9], defaultSize: 9, mostCells: 81 },
     "sum-cages": { sizes: [6, 9], defaultSize: 9, mostCells: 286 },

package/dist/layout.js

@@ -19,6 +19,7 @@ export const KAZU_BOXES = {
     6: { rows: 2, cols: 3 },
     9: { rows: 3, cols: 3 },
     16: { rows: 4, cols: 4 },
+    25: { rows: 5, cols: 5 },
 };
 /** The box a cell is in, numbered row-major from 0. */
 export function boxOf(size, index) {