@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/kakuroBuild.js

@@ -0,0 +1,337 @@
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { countCsp, logicCsp, openSlots } from "./csp.js";
+import { shuffled } from "./random.js";
+/** How the black squares are scattered, and the longest run a level allows. */
+export const SHAPE = {
+    easy: { black: .34, longest: 4 },
+    medium: { black: .3, longest: 5 },
+    hard: { black: .26, longest: 7 },
+    "extra-hard": { black: .22, longest: 9 },
+};
+/** Which squares are white: no run shorter than two, none longer than the level allows, and all of them one connected piece. */
+export function kakuroPattern(side, level, random) {
+    for (let attempt = 0; attempt < 60; attempt += 1) {
+        const white = laidRows(side, level, random);
+        if (white && oneStrip(side, white))
+            return white;
+    }
+    return null;
+}
+/**
+ * Lays the squares out row by row, each row left to right, so that a run is never one square or longer than the
+ * level allows: a column whose run is one square long must go on, one at the limit must stop, and a row's own
+ * runs are kept the same way. A square is white with the level's chance, except where a rule forces it.
+ */
+function laidRows(side, level, random) {
+    const { black, longest } = SHAPE[level];
+    const white = Array(side * side).fill(false), above = Array(side).fill(0);
+    const chance = 1 - black * (.85 + random() * .3);
+    for (let row = 1; row < side; row += 1) {
+        const last = row === side - 1, chosen = Array(side).fill(false);
+        let steps = 0;
+        const place = (col, run) => {
+            if (++steps > 4000)
+                return false;
+            if (col === side)
+                return run !== 1;
+            const mustWhite = above[col] === 1;
+            const mustBlack = above[col] === longest || last && above[col] === 0;
+            const options = [];
+            if (mustWhite && mustBlack)
+                return false;
+            if (mustWhite)
+                options.push(true);
+            else if (mustBlack)
+                options.push(false);
+            else
+                options.push(...(random() < chance ? [true, false] : [false, true]));
+            for (const isWhite of options) {
+                if (isWhite && run + 1 > longest)
+                    continue;
+                if (!isWhite && run === 1)
+                    continue;
+                chosen[col] = isWhite;
+                if (place(col + 1, isWhite ? run + 1 : 0))
+                    return true;
+            }
+            return false;
+        };
+        if (!place(1, 0))
+            return null;
+        for (let col = 1; col < side; col += 1) {
+            white[row * side + col] = chosen[col];
+            above[col] = chosen[col] ? above[col] + 1 : 0;
+        }
+    }
+    return white;
+}
+/** How many different sets of digits can make `sum` out of `length` squares. */
+export function kakuroWays(length, sum) {
+    let ways = 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)
+            ways += 1;
+    }
+    return ways;
+}
+const WAYS = Array.from({ length: 10 }, (_, length) => Array.from({ length: 46 }, (_, sum) => length < 2 ? 0 : kakuroWays(length, sum)));
+/** A random digit for every white square with no digit repeated in a run, or null when the search gives up. */
+export function kakuroDigits(side, white, random) {
+    const digits = Array(white.length).fill(0);
+    let steps = 0;
+    const fill = (at) => {
+        while (at < white.length && !white[at])
+            at += 1;
+        if (at === white.length)
+            return true;
+        if (++steps > 40000)
+            return false;
+        const used = new Set();
+        for (let left = at - 1; left >= 0 && white[left] && (left + 1) % side !== 0; left -= 1)
+            used.add(digits[left]);
+        for (let up = at - side; up >= 0 && white[up]; up -= side)
+            used.add(digits[up]);
+        for (const digit of shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d)), random)) {
+            digits[at] = digit;
+            if (fill(at + 1))
+                return true;
+        }
+        digits[at] = 0;
+        return false;
+    };
+    return fill(0) ? digits : null;
+}
+/**
+ * Changes digits one square at a time, keeping every run free of repeats, to make runs whose totals can be made in
+ * few ways: a run that says a lot about its digits lets the solver start from the rules alone. A change is kept when
+ * it does not raise the count of ways, summed over runs, which is `weight` raised to the number of ways.
+ */
+export function kakuroTighten(side, white, digits, random, rounds) {
+    const runsAt = (cell) => {
+        const across = [cell], down = [cell];
+        for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+            across.push(at);
+        for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+            across.push(at);
+        for (let at = cell - side; at >= 0 && white[at]; at -= side)
+            down.push(at);
+        for (let at = cell + side; at < white.length && white[at]; at += side)
+            down.push(at);
+        return { across, down };
+    };
+    const ways = (run, swap) => {
+        let sum = 0;
+        for (const at of run)
+            sum += swap && at === swap.cell ? swap.digit : digits[at];
+        return WAYS[run.length][sum];
+    };
+    const cells = white.flatMap((w, i) => w ? [i] : []);
+    for (let round = 0; round < rounds; round += 1) {
+        const cell = cells[Math.floor(random() * cells.length)];
+        const { across, down } = runsAt(cell);
+        const used = new Set();
+        for (const at of [...across, ...down])
+            if (at !== cell)
+                used.add(digits[at]);
+        const options = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d) && d !== digits[cell]);
+        if (!options.length)
+            continue;
+        const digit = options[Math.floor(random() * options.length)];
+        const before = ways(across) + ways(down), after = ways(across, { cell, digit }) + ways(down, { cell, digit });
+        if (after <= before)
+            digits[cell] = digit;
+    }
+}
+/** The totals of a pattern and its digits, as a board. */
+export function kakuroBoardOf(side, white, digits) {
+    const cells = white.map(w => w ? { kind: "white" } : { kind: "black", across: null, down: null });
+    for (let cell = 0; cell < white.length; cell += 1) {
+        if (white[cell])
+            continue;
+        const black = cells[cell];
+        if (cell % side < side - 1 && white[cell + 1]) {
+            let sum = 0;
+            for (let at = cell + 1; white[at]; at += 1) {
+                sum += digits[at];
+                if ((at + 1) % side === 0)
+                    break;
+            }
+            black.across = sum;
+        }
+        if (cell + side < white.length && white[cell + side]) {
+            let sum = 0;
+            for (let at = cell + side; at < white.length && white[at]; at += side)
+                sum += digits[at];
+            black.down = sum;
+        }
+    }
+    return { width: side, height: side, cells };
+}
+/** Whether the white squares are one connected piece. */
+function oneStrip(side, white) {
+    const first = white.indexOf(true);
+    if (first < 0)
+        return false;
+    const seen = new Set([first]), stack = [first];
+    while (stack.length) {
+        const at = stack.pop();
+        for (const next of [at - 1, at + 1, at - side, at + side]) {
+            if (next < 0 || next >= white.length || !white[next] || seen.has(next) || (next === at + 1 && next % side === 0))
+                continue;
+            seen.add(next);
+            stack.push(next);
+        }
+    }
+    return seen.size === white.filter(Boolean).length;
+}
+/** The squares in the same row or column strip as `cell` that have the given digit, to see what digits it may take. */
+function digitsAround(side, white, digits, cell) {
+    const used = new Set();
+    for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+        used.add(digits[at]);
+    for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+        used.add(digits[at]);
+    for (let at = cell - side; at >= 0 && white[at]; at -= side)
+        used.add(digits[at]);
+    for (let at = cell + side; at < white.length && white[at]; at += side)
+        used.add(digits[at]);
+    return used;
+}
+/**
+ * A board with exactly one answer, or null. While the board has other answers, each one is broken: a square the
+ * two answers disagree on is turned black (when every run stays two long and the squares stay one piece) or given
+ * another digit that still repeats nowhere in its runs, which changes two totals.
+ */
+export function candidateKakuro(side, level, random) {
+    // Easy and medium boards are also eased until the rules they promise are enough to solve them.
+    const eased = level === "easy" ? 0 : level === "medium" ? 1 : -1;
+    const white = kakuroPattern(side, level, random);
+    if (!white)
+        return null;
+    const digits = kakuroDigits(side, white, random);
+    if (!digits)
+        return null;
+    if (level === "easy" || level === "medium")
+        kakuroTighten(side, white, digits, random, side * side * (level === "easy" ? 60 : 25));
+    const valid = () => {
+        for (let cell = 0; cell < white.length; cell += 1) {
+            if (!white[cell])
+                continue;
+            let across = 1, down = 1;
+            for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+                across += 1;
+            for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+                across += 1;
+            for (let at = cell - side; at >= 0 && white[at]; at -= side)
+                down += 1;
+            for (let at = cell + side; at < white.length && white[at]; at += side)
+                down += 1;
+            if (across < 2 || down < 2)
+                return false;
+        }
+        return oneStrip(side, white);
+    };
+    for (let repair = 0; repair < 150; repair += 1) {
+        const board = kakuroBoardOf(side, white, digits);
+        if (!isKakuroBoard(board))
+            return null;
+        const model = kakuroModel(board, 1, random);
+        let found = countCsp(model.csp, openSlots(model.csp), 8, 3000);
+        for (let restart = 0; restart < 5 && found.exhausted; restart += 1)
+            found = countCsp(model.csp, openSlots(model.csp), 8, 3000);
+        if (found.exhausted) {
+            // Too many answers to even count: darken any square that can be darkened and look again.
+            const any = shuffled(white.flatMap((w, cell) => w ? [cell] : []), random).find(cell => { white[cell] = false; if (valid())
+                return true; white[cell] = true; return false; });
+            if (any === undefined)
+                return null;
+            continue;
+        }
+        if (found.count === 1 && eased < 0)
+            return { board, digits };
+        if (found.count === 1) {
+            const rules = kakuroModel(board, eased);
+            const run = logicCsp(rules.csp, openSlots(rules.csp), 0);
+            if (run.solved)
+                return { board, digits };
+            if (white.filter(Boolean).length < (side - 1) * (side - 1) * .42)
+                return null;
+            const open = rules.whites.filter((_, i) => { let n = 0; for (let k = 0; k < 9; k += 1)
+                n += run.alive[9 * i + k]; return n > 1; });
+            // Squares still open, then the others that share a run with one.
+            const near = new Set(open);
+            for (const cell of open) {
+                for (let at = cell - 1; at >= 0 && white[at] && (at + 1) % side !== 0; at -= 1)
+                    near.add(at);
+                for (let at = cell + 1; at < white.length && white[at] && at % side !== 0; at += 1)
+                    near.add(at);
+                for (let at = cell - side; at >= 0 && white[at]; at -= side)
+                    near.add(at);
+                for (let at = cell + side; at < white.length && white[at]; at += side)
+                    near.add(at);
+            }
+            const stuck = [...shuffled(open, random), ...shuffled([...near].filter(cell => !open.includes(cell)), random)];
+            let eased_ = false;
+            for (const cell of stuck) {
+                white[cell] = false;
+                if (valid()) {
+                    eased_ = true;
+                    break;
+                }
+                white[cell] = true;
+            }
+            if (!eased_) {
+                const any = shuffled(white.flatMap((w, cell) => w ? [cell] : []), random).find(cell => { white[cell] = false; if (valid())
+                    return true; white[cell] = true; return false; });
+                if (any === undefined)
+                    return null;
+            }
+            continue;
+        }
+        const digitOf = (answer, cell) => { const index = model.index[cell]; let d = 0; for (let k = 0; k < 9; k += 1)
+            if (answer[9 * index + k])
+                d = k + 1; return d; };
+        let moved = false;
+        for (const answer of found.solutions) {
+            const differing = shuffled(white.flatMap((w, cell) => w && digitOf(answer, cell) !== digits[cell] ? [cell] : []), random);
+            if (!differing.length)
+                continue;
+            const blacken = () => {
+                for (const cell of differing) {
+                    if (!white[cell])
+                        continue;
+                    white[cell] = false;
+                    if (valid())
+                        return true;
+                    white[cell] = true;
+                }
+                return false;
+            };
+            const change = () => {
+                for (const cell of differing) {
+                    if (!white[cell])
+                        continue;
+                    const used = digitsAround(side, white, digits, cell);
+                    const options = [1, 2, 3, 4, 5, 6, 7, 8, 9].filter(d => !used.has(d));
+                    if (!options.length)
+                        continue;
+                    digits[cell] = options[Math.floor(random() * options.length)];
+                    return true;
+                }
+                return false;
+            };
+            if (random() < .5 ? blacken() || change() : change() || blacken())
+                moved = true;
+        }
+        if (!moved)
+            return null;
+    }
+    return null;
+}

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,10 @@
+import type { KakuroLevel, KakuroPuzzle } from "./kakuro.types.ts";
+/**
+ * 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 declare function generateKakuro(seed?: number, level?: KakuroLevel, size?: number): KakuroPuzzle;

package/dist/kakuroGenerate.js

@@ -0,0 +1,62 @@
+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";
+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);
+    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 };
+        }
+        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 (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;
+};