@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/juosanPlay.types.d.ts

@@ -0,0 +1,24 @@
+import type { JuosanBoard, JuosanGame } from "./juosan.types.ts";
+export type JuosanMaterial = "ivory" | "wood" | "slate";
+export type JuosanPieces = "ink" | "tiles";
+export type JuosanLanguage = "en" | "ja";
+export type JuosanDrawOptions = {
+    marks?: JuosanGame["marks"];
+    selected?: number | null;
+    material?: JuosanMaterial;
+    pieces?: JuosanPieces;
+    language?: JuosanLanguage;
+};
+export type JuosanMountOptions = JuosanDrawOptions & {
+    board: JuosanBoard;
+    progress?: string;
+    onChange?: (game: JuosanGame) => void;
+    onFinish?: (game: JuosanGame) => void;
+};
+export type JuosanMount = {
+    game: () => JuosanGame;
+    progress: () => string;
+    set: (options: JuosanDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/juosanPlay.types.js

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

package/dist/juosanSolve.d.ts

@@ -0,0 +1,3 @@
+import type { JuosanBoard, JuosanSolve } from "./juosan.types.ts";
+/** Counts labeled solutions up to a limit; `complete` distinguishes exhaustion from cutoff. */
+export declare function solveJuosan(board: JuosanBoard, limit?: number, maxNodes?: number): JuosanSolve;

package/dist/juosanSolve.js

@@ -0,0 +1,82 @@
+import { JUOSAN_MOST_NODES } from "./juosan.constants.js";
+import { checkJuosan, isJuosanBoard } from "./juosanBoard.js";
+/** Counts labeled solutions up to a limit; `complete` distinguishes exhaustion from cutoff. */
+export function solveJuosan(board, limit = 2, maxNodes = JUOSAN_MOST_NODES) {
+    if (!isJuosanBoard(board) ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        !Number.isInteger(maxNodes) ||
+        maxNodes < 1) {
+        throw new RangeError("Invalid Juosan search settings");
+    }
+    const cellCount = board.width * board.height;
+    const marks = Array(cellCount).fill(0);
+    const solutions = [];
+    const territoryAt = Array(cellCount).fill(-1);
+    board.territories.forEach((territory, index) => {
+        territory.cells.forEach(cell => {
+            territoryAt[cell] = index;
+        });
+    });
+    let nodes = 0;
+    let cutOff = false;
+    const visit = (cell) => {
+        if (solutions.length >= limit)
+            return;
+        if (nodes >= maxNodes) {
+            cutOff = true;
+            return;
+        }
+        nodes += 1;
+        if (cell === cellCount) {
+            const answer = marks;
+            if (checkJuosan(board, answer).ok)
+                solutions.push([...answer]);
+            return;
+        }
+        const x = cell % board.width;
+        const y = Math.floor(cell / board.width);
+        const territory = board.territories[territoryAt[cell]];
+        for (const mark of [1, 2]) {
+            if (mark === 2 &&
+                x >= 2 &&
+                marks[cell - 1] === 2 &&
+                marks[cell - 2] === 2) {
+                continue;
+            }
+            if (mark === 1 &&
+                y >= 2 &&
+                marks[cell - board.width] === 1 &&
+                marks[cell - 2 * board.width] === 1) {
+                continue;
+            }
+            marks[cell] = mark;
+            if (!canStillMeetDifference(territory.cells, marks, territory.difference)) {
+                marks[cell] = 0;
+                continue;
+            }
+            visit(cell + 1);
+            marks[cell] = 0;
+            if (solutions.length >= limit || cutOff)
+                return;
+        }
+    };
+    visit(0);
+    return {
+        count: solutions.length,
+        solution: solutions[0] ?? null,
+        complete: !cutOff && solutions.length < limit,
+        nodes,
+    };
+}
+function canStillMeetDifference(cells, marks, difference) {
+    if (difference === null)
+        return true;
+    const assigned = cells.filter(cell => marks[cell] !== 0);
+    const horizontal = assigned.filter(cell => marks[cell] === 1).length;
+    const vertical = assigned.length - horizontal;
+    const remaining = cells.length - assigned.length;
+    const smallestDifference = Math.max(0, Math.abs(horizontal - vertical) - remaining);
+    const largestDifference = Math.abs(horizontal - vertical) + remaining;
+    return smallestDifference <= difference && largestDifference >= difference;
+}

package/dist/juosanStrings.d.ts

@@ -0,0 +1,77 @@
+export declare const JUOSAN_STRINGS: {
+    readonly en: {
+        readonly title: "Juosan";
+        readonly ready: "Fill every cell with a horizontal or vertical mark.";
+        readonly won: "Solved.";
+        readonly assisted: "Solved with a hint.";
+        readonly help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly restart: "Restart";
+        readonly check: "Check";
+        readonly checked: "The marks follow the rules.";
+        readonly wrong: "Some marks break a territory clue or run rule.";
+        readonly horizontal: "horizontal";
+        readonly vertical: "vertical";
+        readonly blank: "unmarked";
+        readonly row: "row";
+        readonly column: "column";
+        readonly hintWhy: "This mark follows the printed territory clue and line rules.";
+    };
+    readonly ja: {
+        readonly title: "じゅうさん";
+        readonly ready: "各マスに横線か縦線を入れます。";
+        readonly won: "できました。";
+        readonly assisted: "ヒントを使ってできました。";
+        readonly help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly restart: "最初から";
+        readonly check: "確認";
+        readonly checked: "ルールに合っています。";
+        readonly wrong: "陣地の数字か線の並びを確認してください。";
+        readonly horizontal: "横線";
+        readonly vertical: "縦線";
+        readonly blank: "未記入";
+        readonly row: "行";
+        readonly column: "列";
+        readonly hintWhy: "この線は、陣地の数字と線のルールに合います。";
+    };
+};
+export declare function juosanWords(language?: "en" | "ja"): {
+    readonly title: "Juosan";
+    readonly ready: "Fill every cell with a horizontal or vertical mark.";
+    readonly won: "Solved.";
+    readonly assisted: "Solved with a hint.";
+    readonly help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly restart: "Restart";
+    readonly check: "Check";
+    readonly checked: "The marks follow the rules.";
+    readonly wrong: "Some marks break a territory clue or run rule.";
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+    readonly blank: "unmarked";
+    readonly row: "row";
+    readonly column: "column";
+    readonly hintWhy: "This mark follows the printed territory clue and line rules.";
+} | {
+    readonly title: "じゅうさん";
+    readonly ready: "各マスに横線か縦線を入れます。";
+    readonly won: "できました。";
+    readonly assisted: "ヒントを使ってできました。";
+    readonly help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly restart: "最初から";
+    readonly check: "確認";
+    readonly checked: "ルールに合っています。";
+    readonly wrong: "陣地の数字か線の並びを確認してください。";
+    readonly horizontal: "横線";
+    readonly vertical: "縦線";
+    readonly blank: "未記入";
+    readonly row: "行";
+    readonly column: "列";
+    readonly hintWhy: "この線は、陣地の数字と線のルールに合います。";
+};

package/dist/juosanStrings.js

@@ -0,0 +1,43 @@
+export const JUOSAN_STRINGS = {
+    en: {
+        title: "Juosan",
+        ready: "Fill every cell with a horizontal or vertical mark.",
+        won: "Solved.",
+        assisted: "Solved with a hint.",
+        help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.",
+        undo: "Undo",
+        hint: "Hint",
+        restart: "Restart",
+        check: "Check",
+        checked: "The marks follow the rules.",
+        wrong: "Some marks break a territory clue or run rule.",
+        horizontal: "horizontal",
+        vertical: "vertical",
+        blank: "unmarked",
+        row: "row",
+        column: "column",
+        hintWhy: "This mark follows the printed territory clue and line rules.",
+    },
+    ja: {
+        title: "じゅうさん",
+        ready: "各マスに横線か縦線を入れます。",
+        won: "できました。",
+        assisted: "ヒントを使ってできました。",
+        help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。",
+        undo: "戻す",
+        hint: "ヒント",
+        restart: "最初から",
+        check: "確認",
+        checked: "ルールに合っています。",
+        wrong: "陣地の数字か線の並びを確認してください。",
+        horizontal: "横線",
+        vertical: "縦線",
+        blank: "未記入",
+        row: "行",
+        column: "列",
+        hintWhy: "この線は、陣地の数字と線のルールに合います。",
+    },
+};
+export function juosanWords(language = "en") {
+    return JUOSAN_STRINGS[language];
+}

package/dist/juosanStyle.d.ts

@@ -0,0 +1 @@
+export declare const JUOSAN_PLAY_STYLE = ".js-board{position:relative;outline:none}.js-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--juosan-width),1fr);grid-template-rows:repeat(var(--juosan-height),1fr)}.js-cell{border:0;background:transparent;color:transparent;min-width:0;min-height:0;cursor:pointer}.js-cell:focus-visible{outline:2px solid var(--kz-focus,#316c50);outline-offset:-3px}.js-tools{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.75rem}.js-tools button{font:inherit;padding:.45rem .8rem;border-radius:.5rem}.js-status{min-height:1.5em}.js-help{opacity:.8;font-size:.9em}";

package/dist/juosanStyle.js

@@ -0,0 +1 @@
+export const JUOSAN_PLAY_STYLE = `.js-board{position:relative;outline:none}.js-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--juosan-width),1fr);grid-template-rows:repeat(var(--juosan-height),1fr)}.js-cell{border:0;background:transparent;color:transparent;min-width:0;min-height:0;cursor:pointer}.js-cell:focus-visible{outline:2px solid var(--kz-focus,#316c50);outline-offset:-3px}.js-tools{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.75rem}.js-tools button{font:inherit;padding:.45rem .8rem;border-radius:.5rem}.js-status{min-height:1.5em}.js-help{opacity:.8;font-size:.9em}`;

package/dist/kakuro-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawKakuro } from "./kakuroDraw.ts";
+export type { KakuroDrawOptions } from "./kakuroDraw.ts";

package/dist/kakuro-draw-entry.js

@@ -0,0 +1 @@
+export { drawKakuro } from "./kakuroDraw.js";

package/dist/kakuro-entry.d.ts

@@ -0,0 +1,13 @@
+export * from "./kakuro.types.ts";
+export * from "./kakuro.constants.ts";
+export * from "./kakuroBoard.ts";
+export * from "./kakuroSolve.ts";
+export * from "./kakuroGenerate.ts";
+export * from "./kakuroRate.ts";
+export * from "./kakuroGame.ts";
+export { drawKakuro } from "./kakuroDraw.ts";
+export type { KakuroDrawOptions } from "./kakuroDraw.ts";
+export { mountKakuro } from "./kakuroMount.ts";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.ts";
+export { KAKURO_STRINGS } from "./kakuroStrings.ts";
+export type * from "./kakuroPlay.types.ts";

package/dist/kakuro-entry.js

@@ -0,0 +1,11 @@
+export * from "./kakuro.types.js";
+export * from "./kakuro.constants.js";
+export * from "./kakuroBoard.js";
+export * from "./kakuroSolve.js";
+export * from "./kakuroGenerate.js";
+export * from "./kakuroRate.js";
+export * from "./kakuroGame.js";
+export { drawKakuro } from "./kakuroDraw.js";
+export { mountKakuro } from "./kakuroMount.js";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.js";
+export { KAKURO_STRINGS } from "./kakuroStrings.js";

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

@@ -0,0 +1,4 @@
+export { mountKakuro } from "./kakuroMount.ts";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.ts";
+export { KAKURO_STRINGS } from "./kakuroStrings.ts";
+export type * from "./kakuroPlay.types.ts";

package/dist/kakuro-play-entry.js

@@ -0,0 +1,3 @@
+export { mountKakuro } from "./kakuroMount.js";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.js";
+export { KAKURO_STRINGS } from "./kakuroStrings.js";

package/dist/kakuro.constants.d.ts

@@ -0,0 +1,11 @@
+export declare const KAKURO_MIN_SIDE = 3;
+export declare const KAKURO_MAX_SIDE = 12;
+export declare const KAKURO_MAX_NODES = 250000;
+export declare const KAKURO_MAX_ATTEMPTS = 120;
+export declare const KAKURO_GENERATION_ATTEMPTS = 1200;
+export declare const KAKURO_GENERATION_NODES = 1000000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateKakuro`. */
+export declare const KAKURO_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer, counting the row and column of totals; any side from 5 to `KAKURO_MAX_SIDE` can be made. */
+export declare const KAKURO_SIZES: readonly [6, 8, 10, 12];
+export declare const KAKURO_LEAST_GENERATED_SIDE = 5;

package/dist/kakuro.constants.js

@@ -0,0 +1,11 @@
+export const KAKURO_MIN_SIDE = 3;
+export const KAKURO_MAX_SIDE = 12;
+export const KAKURO_MAX_NODES = 250000;
+export const KAKURO_MAX_ATTEMPTS = 120;
+export const KAKURO_GENERATION_ATTEMPTS = 1200;
+export const KAKURO_GENERATION_NODES = 1000000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateKakuro`. */
+export const KAKURO_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer, counting the row and column of totals; any side from 5 to `KAKURO_MAX_SIDE` can be made. */
+export const KAKURO_SIZES = [6, 8, 10, 12];
+export const KAKURO_LEAST_GENERATED_SIDE = 5;

package/dist/kakuro.types.d.ts

@@ -0,0 +1,65 @@
+export type KakuroCell = {
+    kind: "white";
+} | {
+    kind: "black";
+    across: number | null;
+    down: number | null;
+};
+export type KakuroBoard = {
+    width: number;
+    height: number;
+    cells: readonly KakuroCell[];
+};
+export type KakuroRun = {
+    direction: "across" | "down";
+    clueCell: number;
+    cells: readonly number[];
+    sum: number;
+};
+export type KakuroLevel = "easy" | "medium" | "hard" | "extra-hard";
+export type KakuroPuzzle = KakuroBoard & {
+    seed: number;
+    level: KakuroLevel;
+    solution: readonly number[];
+};
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the rules solve it, 1 that somebody has to suppose a
+ * digit and watch it break, 2 that more than that is needed; `plain` says the single-run rules were enough (no
+ * digit that must appear had to be traced). `probes` is how many suppositions depth 1 needed. The rest describes the runs.
+ */
+export type KakuroRating = {
+    depth: 0 | 1 | 2;
+    plain: boolean;
+    probes: number;
+    whites: number;
+    runs: number;
+    longest: number;
+    /** Mean number of squares in a run. */
+    meanRun: number;
+    /** Runs whose total can be made in only one way, as a share of the runs. */
+    fixedShare: number;
+};
+export type KakuroCheck = {
+    ok: boolean;
+    complete: boolean;
+    errors: readonly number[];
+};
+export type KakuroSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type KakuroGame = {
+    board: KakuroBoard;
+    values: readonly number[];
+    notes: readonly (readonly number[])[];
+    history: readonly {
+        values: readonly number[];
+        notes: readonly (readonly number[])[];
+    }[];
+    helped: boolean;
+};
+export type KakuroLanguage = "en" | "ja";
+export type KakuroMaterial = "ivory" | "wood" | "slate";
+export type KakuroPieces = "ink" | "tiles";

package/dist/kakuro.types.js

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

package/dist/kakuroBoard.d.ts

@@ -0,0 +1,8 @@
+import type { KakuroBoard, KakuroCheck, KakuroRun } from "./kakuro.types.ts";
+export declare function isKakuroBoard(value: unknown): value is KakuroBoard;
+export declare function kakuroRuns(board: KakuroBoard): KakuroRun[];
+/** Checks exact run sums and distinct digits independently of a stored answer. */
+export declare function checkKakuro(board: KakuroBoard, values: readonly number[]): KakuroCheck;
+/** Allows unfinished runs while flagging duplicate digits and impossible remaining totals. */
+export declare function progressKakuro(board: KakuroBoard, values: readonly number[]): KakuroCheck;
+export declare function canReach(target: number, slots: number, used: readonly number[]): boolean;

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/kakuroBuild.d.ts

@@ -0,0 +1,30 @@
+import type { KakuroBoard, KakuroLevel } from "./kakuro.types.ts";
+import type { Random } from "./random.ts";
+/** How the black squares are scattered, and the longest run a level allows. */
+export declare const SHAPE: Record<KakuroLevel, {
+    black: number;
+    longest: number;
+}>;
+/** Which squares are white: no run shorter than two, none longer than the level allows, and all of them one connected piece. */
+export declare function kakuroPattern(side: number, level: KakuroLevel, random: Random): boolean[] | null;
+/** How many different sets of digits can make `sum` out of `length` squares. */
+export declare function kakuroWays(length: number, sum: number): number;
+/** A random digit for every white square with no digit repeated in a run, or null when the search gives up. */
+export declare function kakuroDigits(side: number, white: readonly boolean[], random: Random): number[] | 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 declare function kakuroTighten(side: number, white: readonly boolean[], digits: number[], random: Random, rounds: number): void;
+/** The totals of a pattern and its digits, as a board. */
+export declare function kakuroBoardOf(side: number, white: readonly boolean[], digits: readonly number[]): KakuroBoard;
+/**
+ * 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 declare function candidateKakuro(side: number, level: KakuroLevel, random: Random): {
+    board: KakuroBoard;
+    digits: readonly number[];
+} | null;