@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/kakuroBoard.js

@@ -0,0 +1,117 @@
+import { KAKURO_MAX_SIDE, KAKURO_MIN_SIDE } from "./kakuro.constants.js";
+export function isKakuroBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!Number.isInteger(board.width) || board.width < KAKURO_MIN_SIDE || board.width > KAKURO_MAX_SIDE
+        || !Number.isInteger(board.height) || board.height < KAKURO_MIN_SIDE || board.height > KAKURO_MAX_SIDE
+        || !Array.isArray(board.cells) || board.cells.length !== board.width * board.height
+        || board.cells.some(cell => !validCell(cell)))
+        return false;
+    const runs = collectRuns(board);
+    if (!runs)
+        return false;
+    return runs.length > 0 && runs.every(run => {
+        const length = run.cells.length;
+        const min = length * (length + 1) / 2;
+        const max = length * (19 - length) / 2;
+        return length >= 2 && length <= 9 && run.sum >= min && run.sum <= max;
+    });
+}
+function validCell(cell) {
+    if (!cell || typeof cell !== "object")
+        return false;
+    if (cell.kind === "white")
+        return true;
+    return cell.kind === "black" && [cell.across, cell.down].every(value => value === null
+        || Number.isInteger(value) && value >= 3 && value <= 45);
+}
+export function kakuroRuns(board) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    return collectRuns(board);
+}
+function collectRuns(board) {
+    const runs = [];
+    const acrossCount = Array(board.cells.length).fill(0), downCount = Array(board.cells.length).fill(0);
+    for (let cell = 0; cell < board.cells.length; cell += 1) {
+        const x = cell % board.width, y = Math.floor(cell / board.width), tile = board.cells[cell];
+        if (tile.kind === "white")
+            continue;
+        const rightWhite = x + 1 < board.width && board.cells[cell + 1]?.kind === "white";
+        const downWhite = y + 1 < board.height && board.cells[cell + board.width]?.kind === "white";
+        if ((tile.across !== null) !== rightWhite || (tile.down !== null) !== downWhite)
+            return null;
+        if (rightWhite) {
+            const cells = [];
+            for (let at = cell + 1; at < (y + 1) * board.width && board.cells[at]?.kind === "white"; at += 1)
+                cells.push(at);
+            if (cells.length < 2 || cells.length > 9)
+                return null;
+            cells.forEach(at => { acrossCount[at] += 1; });
+            runs.push({ direction: "across", clueCell: cell, cells, sum: tile.across });
+        }
+        if (downWhite) {
+            const cells = [];
+            for (let at = cell + board.width; at < board.cells.length && board.cells[at]?.kind === "white"; at += board.width)
+                cells.push(at);
+            if (cells.length < 2 || cells.length > 9)
+                return null;
+            cells.forEach(at => { downCount[at] += 1; });
+            runs.push({ direction: "down", clueCell: cell, cells, sum: tile.down });
+        }
+    }
+    for (let cell = 0; cell < board.cells.length; cell += 1) {
+        if (board.cells[cell].kind === "white" && (acrossCount[cell] !== 1 || downCount[cell] !== 1))
+            return null;
+    }
+    return runs;
+}
+/** Checks exact run sums and distinct digits independently of a stored answer. */
+export function checkKakuro(board, values) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    if (values.length !== board.cells.length)
+        throw new RangeError("Invalid Kakuro values");
+    const errors = new Set(), runs = kakuroRuns(board);
+    values.forEach((value, cell) => {
+        if (board.cells[cell].kind === "black" ? value !== 0 : !Number.isInteger(value) || value < 0 || value > 9)
+            errors.add(cell);
+    });
+    for (const run of runs) {
+        const filled = run.cells.map(cell => values[cell]).filter(value => value > 0);
+        const duplicate = new Set(filled.filter((value, index) => filled.indexOf(value) !== index));
+        const sum = filled.reduce((total, value) => total + value, 0);
+        const missing = run.cells.length - filled.length;
+        if (duplicate.size || sum > run.sum || !canReach(run.sum - sum, missing, filled))
+            run.cells.forEach(cell => errors.add(cell));
+        if (missing === 0 && sum !== run.sum)
+            run.cells.forEach(cell => errors.add(cell));
+    }
+    const complete = board.cells.every((cell, index) => cell.kind === "black" || values[index] > 0);
+    return { ok: complete && errors.size === 0, complete, errors: [...errors].sort((a, b) => a - b) };
+}
+/** Allows unfinished runs while flagging duplicate digits and impossible remaining totals. */
+export function progressKakuro(board, values) {
+    const result = checkKakuro(board, values);
+    return { ...result, ok: result.errors.length === 0 };
+}
+export function canReach(target, slots, used) {
+    if (slots === 0)
+        return target === 0;
+    if (target < 1 || slots > 9)
+        return false;
+    const mask = used.reduce((bits, value) => bits | (1 << value), 0);
+    const visit = (next, remaining, count) => {
+        if (count === 0)
+            return remaining === 0;
+        for (let digit = next; digit <= 9; digit += 1) {
+            if (mask & (1 << digit))
+                continue;
+            if (visit(digit + 1, remaining - digit, count - 1))
+                return true;
+        }
+        return false;
+    };
+    return visit(1, target, slots);
+}

package/dist/kakuroDraw.d.ts

@@ -0,0 +1,10 @@
+import type { KakuroBoard, KakuroMaterial, KakuroPieces } from "./kakuro.types.ts";
+export type KakuroDrawOptions = {
+    values?: readonly number[];
+    notes?: readonly (readonly number[])[];
+    selected?: number;
+    material?: KakuroMaterial;
+    pieces?: KakuroPieces;
+    errors?: readonly number[];
+};
+export declare function drawKakuro(board: KakuroBoard, options?: KakuroDrawOptions): string;

package/dist/kakuroDraw.js

@@ -0,0 +1,21 @@
+import { isKakuroBoard } from "./kakuroBoard.js";
+export function drawKakuro(board, options = {}) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    const size = 56, paper = options.material === "slate" ? "#262a27" : options.material === "wood" ? "#e5cda6" : "var(--kz-paper,#fbf8f1)";
+    const ink = options.material === "slate" ? "#ece8dc" : options.material === "wood" ? "#493e2f" : "var(--kz-ink,#1f2320)";
+    const grid = options.material === "slate" ? "#454a44" : "var(--kz-grid,#cfc6b2)";
+    const cells = board.cells.map((tile, cell) => {
+        const x = cell % board.width * size, y = Math.floor(cell / board.width) * size;
+        const white = tile.kind === "white", value = options.values?.[cell] ?? 0;
+        const mark = options.errors?.includes(cell) ? "var(--kz-bad,#b5452c)" : ink;
+        const bg = white ? options.selected === cell ? "var(--kz-selected,#e9dfca)" : paper : "#333630";
+        const clue = white ? "" : `<path d="M${x},${y + size} L${x + size},${y} M${x + 6},${y + size - 6} L${x + size - 6},${y + 6}" stroke="#858174"/><text x="${x + size - 7}" y="${y + 16}" text-anchor="end" fill="#fff" font-size="15" aria-label="Across ${tile.across ?? ""}">${tile.across ?? ""}</text><text x="${x + 7}" y="${y + size - 7}" fill="#fff" font-size="15" aria-label="Down ${tile.down ?? ""}">${tile.down ?? ""}</text>`;
+        const notes = !white || value ? "" : (options.notes?.[cell] ?? []).map((n, index) => `<text x="${x + 8 + index % 3 * 15}" y="${y + 17 + Math.floor(index / 3) * 14}" fill="${ink}" font-size="10">${n}</text>`).join("");
+        const piece = value && options.pieces === "tiles"
+            ? `<rect x="${x + 10}" y="${y + 8}" width="36" height="40" rx="8" fill="${paper}" stroke="${grid}"/>`
+            : "";
+        return `<g data-kakuro-cell="${cell}"><rect x="${x}" y="${y}" width="${size}" height="${size}" fill="${bg}" stroke="${grid}"/><title>${white ? `Cell ${Math.floor(cell / board.width) + 1}, ${cell % board.width + 1}` : `Across ${tile.across ?? "—"}; down ${tile.down ?? "—"}`}</title>${clue}${piece}${value ? `<text x="${x + size / 2}" y="${y + size / 2 + 7}" text-anchor="middle" fill="${mark}" font-size="27" font-weight="700">${value}</text>` : notes}</g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${board.width * size} ${board.height * size}" role="img" aria-label="Kakuro crossword sum grid" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="3"/></svg>`;
+}

package/dist/kakuroGame.d.ts

@@ -0,0 +1,12 @@
+import type { KakuroBoard, KakuroGame } from "./kakuro.types.ts";
+export declare function newKakuro(board: KakuroBoard): KakuroGame;
+export declare function enterKakuro(game: KakuroGame, cell: number, digit: number, pencil?: boolean): KakuroGame;
+export declare function undoKakuro(game: KakuroGame): KakuroGame;
+export declare function restartKakuro(game: KakuroGame): KakuroGame;
+export declare function finishedKakuro(game: KakuroGame): boolean;
+export declare function hintKakuro(game: KakuroGame): {
+    cell: number;
+    digit: number;
+} | null;
+export declare function encodeKakuro(game: KakuroGame): string;
+export declare function decodeKakuro(code: string): KakuroGame | null;

package/dist/kakuroGame.js

@@ -0,0 +1,74 @@
+import { checkKakuro, isKakuroBoard } from "./kakuroBoard.js";
+import { solveKakuro } from "./kakuroSolve.js";
+export function newKakuro(board) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    return { board: { width: board.width, height: board.height, cells: board.cells.map(cell => ({ ...cell })) },
+        values: Array(board.cells.length).fill(0), notes: board.cells.map(() => []), history: [], helped: false };
+}
+export function enterKakuro(game, cell, digit, pencil = false) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.values.length || game.board.cells[cell].kind !== "white"
+        || !Number.isInteger(digit) || digit < 0 || digit > 9)
+        return game;
+    const values = [...game.values], notes = game.notes.map(mark => [...mark]);
+    if (pencil) {
+        if (!digit)
+            return game;
+        const index = notes[cell].indexOf(digit);
+        if (index < 0)
+            notes[cell].push(digit);
+        else
+            notes[cell].splice(index, 1);
+        notes[cell].sort((a, b) => a - b);
+    }
+    else {
+        values[cell] = digit;
+        notes[cell] = [];
+    }
+    return { ...game, values, notes, history: [...game.history, snapshot(game)] };
+}
+export function undoKakuro(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, ...previous, history: game.history.slice(0, -1) } : game;
+}
+export function restartKakuro(game) { return newKakuro(game.board); }
+export function finishedKakuro(game) { return checkKakuro(game.board, game.values).ok; }
+export function hintKakuro(game) {
+    const proof = solveKakuro(game.board, game.values, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution)
+        return null;
+    const cell = game.board.cells.findIndex((tile, at) => tile.kind === "white" && game.values[at] === 0);
+    return cell < 0 ? null : { cell, digit: proof.solution[cell] };
+}
+export function encodeKakuro(game) {
+    return JSON.stringify({ version: 1, board: game.board, values: game.values, notes: game.notes, helped: game.helped });
+}
+export function decodeKakuro(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isKakuroBoard(value.board) || typeof value.helped !== "boolean"
+            || !Array.isArray(value.values) || value.values.length !== value.board.cells.length
+            || !Array.isArray(value.notes) || value.notes.length !== value.board.cells.length)
+            return null;
+        let game = newKakuro(value.board);
+        for (let cell = 0; cell < value.values.length; cell += 1) {
+            const digit = value.values[cell];
+            if (!Number.isInteger(digit) || digit < 0 || digit > 9 || value.board.cells[cell].kind === "black" && digit !== 0)
+                return null;
+            if (digit)
+                game = enterKakuro(game, cell, digit);
+            const marks = value.notes[cell];
+            if (!Array.isArray(marks) || marks.some(n => !Number.isInteger(n) || n < 1 || n > 9) || new Set(marks).size !== marks.length)
+                return null;
+            for (const mark of marks)
+                game = enterKakuro(game, cell, mark, true);
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}
+function snapshot(game) { return { values: [...game.values], notes: game.notes.map(mark => [...mark]) }; }

package/dist/kakuroGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { KakuroPuzzle } from "./kakuro.types.ts";
+/** Makes a seeded 10×10 family of crossing runs and returns only a uniquely proved puzzle. */
+export declare function generateKakuro(seed?: number): KakuroPuzzle;

package/dist/kakuroGenerate.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";
+/** 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 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/kakuroMount.d.ts

@@ -0,0 +1,2 @@
+import type { KakuroMount, KakuroMountOptions } from "./kakuroPlay.types.ts";
+export declare function mountKakuro(host: HTMLElement, initial: KakuroMountOptions): KakuroMount;

package/dist/kakuroMount.js

@@ -0,0 +1,109 @@
+import { progressKakuro } from "./kakuroBoard.js";
+import { drawKakuro } from "./kakuroDraw.js";
+import { decodeKakuro, encodeKakuro, enterKakuro, finishedKakuro, hintKakuro, newKakuro, undoKakuro } from "./kakuroGame.js";
+import { KAKURO_PLAY_STYLE } from "./kakuroStyle.js";
+import { kakuroWords } from "./kakuroStrings.js";
+export function mountKakuro(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    const words = () => kakuroWords(options.language);
+    let game = initial.progress ? decodeKakuro(initial.progress) ?? newKakuro(initial.board) : newKakuro(initial.board);
+    let selected = game.board.cells.findIndex(cell => cell.kind === "white"), pencil = false, message = "", dead = false;
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div"), tools = doc.createElement("div"), pad = doc.createElement("div"), status = doc.createElement("p"), help = doc.createElement("p"), grid = doc.createElement("div");
+    root.className = "kk-root";
+    style.textContent = KAKURO_PLAY_STYLE;
+    board.className = "kk-board";
+    tools.className = "kk-tools";
+    pad.className = "kk-pad";
+    pad.setAttribute("role", "group");
+    status.className = "kk-status";
+    status.setAttribute("role", "status");
+    help.className = "kk-help";
+    grid.className = "kk-cells";
+    board.append(doc.createElement("div"), grid);
+    root.append(style, board, pad, status, tools, help);
+    host.append(root);
+    const copy = () => ({ ...game, board: { ...game.board, cells: game.board.cells.map(cell => ({ ...cell })) }, values: [...game.values], notes: game.notes.map(mark => [...mark]), history: [] });
+    const update = (next) => { game = next; render(); options.onChange?.(copy()); if (finishedKakuro(game))
+        options.onFinish?.(copy()); };
+    const button = (label, action) => { const item = doc.createElement("button"); item.type = "button"; item.textContent = label; item.onclick = action; tools.append(item); };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words(), b = game.board, focus = grid.contains(doc.activeElement);
+        board.firstElementChild.innerHTML = drawKakuro(b, { values: game.values, notes: game.notes, selected, material: options.material, pieces: options.pieces });
+        grid.style.gridTemplateColumns = `repeat(${b.width},1fr)`;
+        grid.replaceChildren();
+        b.cells.forEach((cell, index) => {
+            const button = doc.createElement("button");
+            button.type = "button";
+            button.className = "kk-cell";
+            button.disabled = cell.kind === "black";
+            button.tabIndex = selected === index ? 0 : -1;
+            const row = Math.floor(index / b.width) + 1, column = index % b.width + 1;
+            const tile = cell.kind === "black" ? `${w.across} ${cell.across ?? "—"}, ${w.down} ${cell.down ?? "—"}` : game.values[index] || game.notes[index].length ? `value ${game.values[index] || game.notes[index].join(",")}` : w.blank;
+            button.setAttribute("aria-label", `${w.row} ${row}, ${w.column} ${column}: ${tile}`);
+            button.onclick = () => { selected = index; render(); };
+            button.onkeydown = event => {
+                const step = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -b.width, ArrowDown: b.width };
+                if (event.key in step) {
+                    event.preventDefault();
+                    let next = index;
+                    do {
+                        next += step[event.key];
+                    } while (next >= 0 && next < b.cells.length && b.cells[next].kind === "black");
+                    if (next >= 0 && next < b.cells.length)
+                        selected = next;
+                    render();
+                }
+                else if (/^[1-9]$/.test(event.key)) {
+                    event.preventDefault();
+                    update(enterKakuro(game, index, Number(event.key), pencil));
+                }
+                else if (event.key === "0" || event.key === "Backspace" || event.key === "Delete") {
+                    event.preventDefault();
+                    update(enterKakuro(game, index, 0));
+                }
+                else if (event.key.toLowerCase() === "p") {
+                    event.preventDefault();
+                    pencil = !pencil;
+                    render();
+                }
+            };
+            grid.append(button);
+        });
+        if (focus)
+            grid.querySelector(`button[aria-label^="${w.row} ${Math.floor(selected / b.width) + 1}, ${w.column} ${selected % b.width + 1}:"]`)?.focus();
+        tools.replaceChildren();
+        button(w.undo, () => update(undoKakuro(game)));
+        button(w.pencil, () => { pencil = !pencil; render(); });
+        button(w.hint, () => { const hint = hintKakuro(game); if (!hint) {
+            message = w.wrong;
+            render();
+            return;
+        } update({ ...enterKakuro(game, hint.cell, hint.digit), helped: true }); message = `${w.row} ${Math.floor(hint.cell / b.width) + 1}, ${w.column} ${hint.cell % b.width + 1}: ${hint.digit}`; render(); });
+        button(w.check, () => { const result = progressKakuro(game.board, game.values); message = result.errors.length ? w.wrong : finishedKakuro(game) ? game.helped ? w.helped : w.won : w.checked; render(); });
+        button(w.restart, () => { game = newKakuro(game.board); message = w.ready; render(); });
+        pad.replaceChildren();
+        for (let digit = 1; digit <= 9; digit += 1) {
+            const key = doc.createElement("button");
+            key.type = "button";
+            key.textContent = String(digit);
+            key.setAttribute("aria-label", `${digit}`);
+            key.onclick = () => { if (selected >= 0)
+                update(enterKakuro(game, selected, digit, pencil)); };
+            pad.append(key);
+        }
+        const clear = doc.createElement("button");
+        clear.type = "button";
+        clear.textContent = w.clear;
+        clear.setAttribute("aria-label", w.clear);
+        clear.onclick = () => { if (selected >= 0)
+            update(enterKakuro(game, selected, 0)); };
+        pad.append(clear);
+        status.textContent = finishedKakuro(game) ? game.helped ? w.helped : w.won : message || w.ready;
+        help.textContent = w.help;
+    };
+    render();
+    return { game: copy, progress: () => encodeKakuro(game), set: next => { options = { ...options, ...next }; render(); }, restart: () => { game = newKakuro(game.board); render(); }, destroy: () => { dead = true; root.remove(); } };
+}

package/dist/kakuroPlay.types.d.ts

@@ -0,0 +1,20 @@
+import type { KakuroBoard, KakuroGame, KakuroLanguage, KakuroMaterial, KakuroPieces } from "./kakuro.types.ts";
+import type { KakuroDrawOptions } from "./kakuroDraw.ts";
+export type KakuroMountOptions = KakuroDrawOptions & {
+    board: KakuroBoard;
+    language?: KakuroLanguage;
+    progress?: string;
+    onChange?: (game: KakuroGame) => void;
+    onFinish?: (game: KakuroGame) => void;
+    material?: KakuroMaterial;
+    pieces?: KakuroPieces;
+};
+export type KakuroMount = {
+    game: () => KakuroGame;
+    progress: () => string;
+    set: (options: KakuroDrawOptions & {
+        language?: KakuroLanguage;
+    }) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/kakuroPlay.types.js

@@ -0,0 +1 @@
+export {};

package/dist/kakuroSolve.d.ts

@@ -0,0 +1,6 @@
+import type { KakuroBoard, KakuroSolve } from "./kakuro.types.ts";
+/** Bounded exact counter over across and down runs; an interrupted search never proves uniqueness. */
+export declare function solveKakuro(board: KakuroBoard, entries?: readonly number[], options?: {
+    limit?: number;
+    nodes?: number;
+}): KakuroSolve;

package/dist/kakuroSolve.js

@@ -0,0 +1,85 @@
+import { KAKURO_MAX_NODES } from "./kakuro.constants.js";
+import { canReach, isKakuroBoard, kakuroRuns } from "./kakuroBoard.js";
+/** Bounded exact counter over across and down runs; an interrupted search never proves uniqueness. */
+export function solveKakuro(board, entries = [], options = {}) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? KAKURO_MAX_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        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];
+        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;
+    }
+    const slots = run.cells.filter(cell => !values[cell] && cell !== targetCell).length;
+    return sum <= run.sum && canReach(run.sum - sum, slots, [...used]);
+}