@johnmorrisdotca/kazu 1.1.0 → 1.3.0

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/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/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.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,33 @@
+import { KAKURO_MAX_NODES } from "./kakuro.constants.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))
+        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 { 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 };
+        }
+    }
+    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; });
+    }
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
+}

package/dist/kakuroStrings.d.ts

@@ -0,0 +1,82 @@
+export type KakuroLanguage = "en" | "ja";
+export declare const KAKURO_STRINGS: {
+    readonly en: {
+        readonly title: "Kakuro";
+        readonly help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly ready: "Choose a white cell.";
+        readonly won: "Every run is correct. Solved!";
+        readonly helped: "Solved with help.";
+        readonly checked: "No run errors so far. Keep filling.";
+        readonly wrong: "Some runs have a repeated digit or impossible total.";
+        readonly across: "Across";
+        readonly down: "Down";
+        readonly pencil: "Pencil marks";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly blank: "blank";
+        readonly clear: "Clear";
+    };
+    readonly ja: {
+        readonly title: "カックロ";
+        readonly help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly ready: "白マスを選んでください。";
+        readonly won: "すべての合計が合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly checked: "ここまでの合計に誤りはありません。続けてください。";
+        readonly wrong: "同じ数字または合計の誤りがあります。";
+        readonly across: "横";
+        readonly down: "縦";
+        readonly pencil: "メモ";
+        readonly row: "行";
+        readonly column: "列";
+        readonly blank: "空白";
+        readonly clear: "消す";
+    };
+};
+export declare function kakuroWords(language?: KakuroLanguage): {
+    readonly title: "Kakuro";
+    readonly help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly ready: "Choose a white cell.";
+    readonly won: "Every run is correct. Solved!";
+    readonly helped: "Solved with help.";
+    readonly checked: "No run errors so far. Keep filling.";
+    readonly wrong: "Some runs have a repeated digit or impossible total.";
+    readonly across: "Across";
+    readonly down: "Down";
+    readonly pencil: "Pencil marks";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly blank: "blank";
+    readonly clear: "Clear";
+} | {
+    readonly title: "カックロ";
+    readonly help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確認";
+    readonly restart: "やり直す";
+    readonly ready: "白マスを選んでください。";
+    readonly won: "すべての合計が合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly checked: "ここまでの合計に誤りはありません。続けてください。";
+    readonly wrong: "同じ数字または合計の誤りがあります。";
+    readonly across: "横";
+    readonly down: "縦";
+    readonly pencil: "メモ";
+    readonly row: "行";
+    readonly column: "列";
+    readonly blank: "空白";
+    readonly clear: "消す";
+};

package/dist/kakuroStrings.js

@@ -0,0 +1,5 @@
+export const KAKURO_STRINGS = {
+    en: { title: "Kakuro", help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", ready: "Choose a white cell.", won: "Every run is correct. Solved!", helped: "Solved with help.", checked: "No run errors so far. Keep filling.", wrong: "Some runs have a repeated digit or impossible total.", across: "Across", down: "Down", pencil: "Pencil marks", row: "Row", column: "column", blank: "blank", clear: "Clear" },
+    ja: { title: "カックロ", help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", ready: "白マスを選んでください。", won: "すべての合計が合いました。完成！", helped: "ヒントを使って完成！", checked: "ここまでの合計に誤りはありません。続けてください。", wrong: "同じ数字または合計の誤りがあります。", across: "横", down: "縦", pencil: "メモ", row: "行", column: "列", blank: "空白", clear: "消す" }
+};
+export function kakuroWords(language = "en") { return KAKURO_STRINGS[language]; }

package/dist/kakuroStyle.d.ts

@@ -0,0 +1 @@
+export declare const KAKURO_PLAY_STYLE = ".kk-root{max-width:760px;margin:auto;color:var(--ink,#1f2320);font:16px/1.5 system-ui,sans-serif}.kk-board{position:relative;width:100%;touch-action:manipulation}.kk-cells{position:absolute;inset:2px;display:grid}.kk-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;touch-action:manipulation}.kk-cell:focus-visible,.kk-pad button:focus-visible{outline:3px solid #b5452c;outline-offset:-3px}.kk-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}.kk-tools button,.kk-pad button{font:inherit;min-height:44px;padding:0 14px;border-radius:999px;border:1px solid #ddd6c6;background:#fbf8f1;color:inherit}.kk-pad{display:grid;grid-template-columns:repeat(5,minmax(44px,1fr));gap:8px;margin:12px 0}.kk-pad button{padding:0;touch-action:manipulation}.kk-status{min-height:1.5em}.kk-help{opacity:.8;font-size:14px}";

package/dist/kakuroStyle.js

@@ -0,0 +1 @@
+export const KAKURO_PLAY_STYLE = `.kk-root{max-width:760px;margin:auto;color:var(--ink,#1f2320);font:16px/1.5 system-ui,sans-serif}.kk-board{position:relative;width:100%;touch-action:manipulation}.kk-cells{position:absolute;inset:2px;display:grid}.kk-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;touch-action:manipulation}.kk-cell:focus-visible,.kk-pad button:focus-visible{outline:3px solid #b5452c;outline-offset:-3px}.kk-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}.kk-tools button,.kk-pad button{font:inherit;min-height:44px;padding:0 14px;border-radius:999px;border:1px solid #ddd6c6;background:#fbf8f1;color:inherit}.kk-pad{display:grid;grid-template-columns:repeat(5,minmax(44px,1fr));gap:8px;margin:12px 0}.kk-pad button{padding:0;touch-action:manipulation}.kk-status{min-height:1.5em}.kk-help{opacity:.8;font-size:14px}`;

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/masyu-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawMasyu } from "./masyuDraw.ts";
+export type { MasyuDrawOptions } from "./masyu.types.ts";

package/dist/masyu-draw-entry.js

@@ -0,0 +1 @@
+export { drawMasyu } from "./masyuDraw.js";

package/dist/masyu-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./masyu.types.ts";
+export * from "./masyu.constants.ts";
+export * from "./masyuBoard.ts";
+export * from "./masyuSolve.ts";
+export * from "./masyuGenerate.ts";
+export * from "./masyuGame.ts";

package/dist/masyu-entry.js

@@ -0,0 +1,6 @@
+export * from "./masyu.types.js";
+export * from "./masyu.constants.js";
+export * from "./masyuBoard.js";
+export * from "./masyuSolve.js";
+export * from "./masyuGenerate.js";
+export * from "./masyuGame.js";

package/dist/masyu-play-entry.d.ts

@@ -0,0 +1,4 @@
+export { mountMasyu } from "./masyuMount.ts";
+export { MASYU_PLAY_STYLE } from "./masyuStyle.ts";
+export { MASYU_STRINGS } from "./masyuStrings.ts";
+export type * from "./masyuPlay.types.ts";

package/dist/masyu-play-entry.js

@@ -0,0 +1,3 @@
+export { mountMasyu } from "./masyuMount.js";
+export { MASYU_PLAY_STYLE } from "./masyuStyle.js";
+export { MASYU_STRINGS } from "./masyuStrings.js";

package/dist/masyu.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MASYU_SIZES: readonly [5, 7];
+export declare const MASYU_NODE_BUDGET = 250000;