@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/akariMount.js

@@ -0,0 +1,214 @@
+import { akariVisible, checkAkari } from "./akariBoard.js";
+import { akariFinished, decodeAkari, encodeAkari, hintAkari, newAkari, toggleAkari, undoAkari, } from "./akariGame.js";
+import { drawAkari } from "./akariDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { AKARI_PLAY_STYLE } from "./akariStyle.js";
+import { akariWords } from "./akariStrings.js";
+/** Mounts the player in a host element; call destroy when the host is removed. */
+export function mountAkari(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeAkari(initial.progress) : null;
+    game ?? (game = newAkari(initial.board));
+    let selected = game.board.cells.findIndex(cell => cell === null);
+    let errors = [];
+    let message = "";
+    let finished = akariFinished(game);
+    let dead = false;
+    const root = doc.createElement("div");
+    const style = doc.createElement("style");
+    const board = doc.createElement("div");
+    const status = doc.createElement("p");
+    const tools = doc.createElement("div");
+    const help = doc.createElement("p");
+    root.className = "ka-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ka-palette") + AKARI_PLAY_STYLE;
+    board.className = "ka-board";
+    status.className = "ka-status";
+    status.setAttribute("role", "status");
+    tools.className = "ka-tools";
+    help.className = "ka-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({
+        ...game,
+        board: { ...game.board, cells: [...game.board.cells] },
+        bulbs: [...game.bulbs],
+        history: game.history.map(turn => [...turn]),
+    });
+    const words = () => akariWords(options.language);
+    const button = (label, action, disabled = false) => {
+        const control = doc.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.onclick = action;
+        tools.append(control);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        const won = akariFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("akari-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("akari-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const toggle = (cell) => {
+        if (finished || game.board.cells[cell] !== null)
+            return;
+        selected = cell;
+        game = toggleAkari(game, cell);
+        changed();
+    };
+    const restart = () => {
+        game = newAkari(game.board);
+        finished = false;
+        selected = game.board.cells.findIndex(cell => cell === null);
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words();
+        const current = game.board;
+        const focused = board.contains(doc.activeElement);
+        const check = checkAkari(current, game.bulbs);
+        board.classList.toggle("ka-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawAkari(current, { ...options, bulbs: game.bulbs, selected, errors });
+        const cells = doc.createElement("div");
+        cells.className = "ka-cells";
+        cells.setAttribute("role", "grid");
+        cells.style.gridTemplateColumns = `repeat(${current.width},1fr)`;
+        for (let cellIndex = 0; cellIndex < current.cells.length; cellIndex += 1) {
+            const white = current.cells[cellIndex] === null;
+            const bulb = game.bulbs.includes(cellIndex);
+            const lit = white && game.bulbs.some(on => akariVisible(current, on).includes(cellIndex));
+            const control = doc.createElement("button");
+            const row = Math.floor(cellIndex / current.width) + 1;
+            const column = cellIndex % current.width + 1;
+            control.type = "button";
+            control.className = "ka-cell";
+            control.dataset.cell = String(cellIndex);
+            control.tabIndex = white && cellIndex === selected ? 0 : -1;
+            control.disabled = !white;
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-pressed", String(bulb));
+            control.setAttribute("aria-label", cellLabel(w, current.cells[cellIndex], row, column, lit, bulb, white));
+            control.onclick = () => toggle(cellIndex);
+            control.onkeydown = event => handleKey(event, cellIndex, current.width, current.cells);
+            cells.append(control);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = check.ok ? (game.helped ? w.helped : w.won) : message || w.checked;
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => {
+            game = undoAkari(game);
+            finished = akariFinished(game);
+            changed();
+        }, !game.history.length);
+        button(w.check, () => {
+            errors = [...new Set([...check.dark, ...check.numbered, ...check.conflicts])];
+            message = check.ok ? w.won : w.wrong;
+            render();
+        });
+        button(w.hint, () => {
+            const cell = hintAkari(game);
+            if (cell === null) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...toggleAkari(game, cell), helped: true };
+            changed();
+            message = w.hintWhy;
+            render();
+        }, finished);
+        button(w.restart, restart);
+        button(w.expand, expand);
+    };
+    function cellLabel(w, value, row, column, lit, bulb, white) {
+        const position = `${w.row} ${row}, ${w.column} ${column}`;
+        if (!white)
+            return `${position}: ${w.black}${typeof value === "number" && value ? ` ${value}` : ""}`;
+        return `${position}: ${w.white}${lit ? `, ${w.lit}` : `, ${w.dark}`}${bulb ? `, ${w.bulb}` : ""}`;
+    }
+    function handleKey(event, cell, width, values) {
+        const steps = {
+            ArrowLeft: -1,
+            ArrowRight: 1,
+            ArrowUp: -width,
+            ArrowDown: width,
+        };
+        if (event.key in steps) {
+            event.preventDefault();
+            const delta = steps[event.key];
+            let next = cell;
+            while (true) {
+                const candidate = next + delta;
+                if (candidate < 0 || candidate >= values.length)
+                    break;
+                if (Math.abs(delta) === 1 && Math.floor(candidate / width) !== Math.floor(next / width))
+                    break;
+                next = candidate;
+                if (values[next] === null)
+                    break;
+            }
+            if (values[next] === null) {
+                selected = next;
+                render();
+            }
+        }
+        else if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            toggle(cell);
+        }
+        else if (event.key === "Delete" || event.key === "Backspace") {
+            event.preventDefault();
+            if (game.bulbs.includes(cell))
+                toggle(cell);
+        }
+    }
+    function expand() {
+        if (root.parentElement !== host)
+            return;
+        const dialog = doc.createElement("dialog");
+        const close = doc.createElement("button");
+        dialog.className = "ka-dialog";
+        close.className = "ka-close";
+        close.textContent = words().close;
+        close.onclick = () => dialog.close();
+        dialog.append(close, root);
+        host.append(dialog);
+        dialog.onclose = () => {
+            host.append(root);
+            dialog.remove();
+        };
+        dialog.showModal();
+    }
+    render();
+    return {
+        game: copy,
+        progress: () => encodeAkari(game),
+        restart,
+        set: (next) => {
+            if (next.language && next.language !== options.language)
+                message = "";
+            options = { ...options, ...next };
+            render();
+        },
+        destroy: () => {
+            dead = true;
+            const dialog = root.closest("dialog");
+            root.remove();
+            dialog?.remove();
+        },
+    };
+}

package/dist/akariPlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { AkariBoard, AkariGame } from "./akari.types.ts";
+export type AkariMaterial = "ivory" | "wood" | "slate";
+export type AkariPieces = "ink" | "tiles";
+export type AkariLanguage = "en" | "ja";
+export type AkariDrawOptions = {
+    bulbs?: AkariGame["bulbs"];
+    selected?: number | null;
+    errors?: readonly number[];
+    material?: AkariMaterial;
+    pieces?: AkariPieces;
+    language?: AkariLanguage;
+};
+export type AkariMountOptions = AkariDrawOptions & {
+    board: AkariBoard;
+    progress?: string;
+    onChange?: (game: AkariGame) => void;
+    onFinish?: (game: AkariGame) => void;
+};
+export type AkariMount = {
+    game: () => AkariGame;
+    progress: () => string;
+    set: (options: AkariDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/akariPlay.types.js

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

package/dist/akariRate.d.ts

@@ -0,0 +1,6 @@
+import type { AkariBoard, AkariRating } from "./akari.types.ts";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export declare function rateAkari(board: AkariBoard): AkariRating;

package/dist/akariRate.js

@@ -0,0 +1,34 @@
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export function rateAkari(board) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const { csp, whites } = akariModel(board);
+    const proof = solveCsp(csp, openSlots(csp), 2, 250000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Akari rating needs a board with one answer");
+    const plain = logicCsp(csp, openSlots(csp), 0);
+    const probing = plain.solved ? plain : logicCsp(csp, openSlots(csp), 1);
+    const blacks = board.cells.length - whites.length;
+    const clues = board.cells.filter(cell => typeof cell === "number").length;
+    const lit = board.cells.map((cell, at) => cell === false || typeof cell === "number" ? at : -1).filter(at => at >= 0);
+    const touching = lit.filter(at => {
+        const x = at % board.width, y = Math.floor(at / board.width);
+        return [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]].some(([nx, ny]) => nx >= 0 && ny >= 0 && nx < board.width && ny < board.height && board.cells[ny * board.width + nx] === null);
+    }).length;
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        whites: whites.length,
+        blacks,
+        clues,
+        bulbs: proof.solution ? whites.filter((_, i) => proof.solution[2 * i + 1] === 1).length : 0,
+        clueShare: touching ? clues / touching : 0,
+        openShare: whites.length / board.cells.length,
+    };
+}

package/dist/akariSolve.d.ts

@@ -0,0 +1,6 @@
+import type { AkariBoard, AkariSolve } from "./akari.types.ts";
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
+export declare function solveAkari(board: AkariBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): AkariSolve;

package/dist/akariSolve.js

@@ -0,0 +1,18 @@
+import { AKARI_MOST_NODES } from "./akari.constants.js";
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
+export function solveAkari(board, options = {}) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const limit = options.limit ?? 2;
+    const budget = options.nodes ?? AKARI_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
+        throw new RangeError("Invalid search bounds");
+    }
+    const { csp, whites } = akariModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const solution = found.solution ? whites.filter((_, i) => found.solution[2 * i + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
+}

package/dist/akariStrings.d.ts

@@ -0,0 +1,98 @@
+import type { AkariLanguage } from "./akariPlay.types.ts";
+export declare const AKARI_STRINGS: {
+    readonly en: {
+        readonly title: "Akari";
+        readonly help: "Place bulbs on white squares. Each bulb lights along its row and column until a black square or the edge. Light every white square; bulbs cannot see one another. Numbered black squares touch exactly that many bulbs. Click, tap or press Enter or Space to toggle a bulb; arrows move; Delete removes it.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly expand: "Just the board";
+        readonly close: "Close";
+        readonly won: "Every square is lit. Solved!";
+        readonly helped: "Solved with help.";
+        readonly checked: "No rule conflicts so far. Keep lighting the board.";
+        readonly wrong: "Check the dark squares, bulb lines and numbered squares.";
+        readonly hintWhy: "A bulb from the only proved solution was placed.";
+        readonly noHint: "No proved hint is available.";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly white: "white square";
+        readonly bulb: "bulb";
+        readonly lit: "lit";
+        readonly dark: "dark";
+        readonly black: "black square";
+        readonly clue: "number";
+    };
+    readonly ja: {
+        readonly title: "美術館";
+        readonly help: "白マスに電球を置きます。電球は黒マスか盤の端まで、縦横に光ります。白マスすべてを照らし、電球同士が見えないようにします。数字のある黒マスには、その数だけ電球を隣接させます。タップ、クリック、Enter、Spaceで電球を切り替えます。矢印キーで移動し、Deleteで消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly expand: "盤だけ";
+        readonly close: "閉じる";
+        readonly won: "全部照らしました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly checked: "ここまでルールに合っています。残りも照らしましょう。";
+        readonly wrong: "暗いマス、電球の見通し、数字のマスを確かめましょう。";
+        readonly hintWhy: "唯一の解答で必要な電球を置きました。";
+        readonly noHint: "確かなヒントがありません。";
+        readonly row: "行";
+        readonly column: "列";
+        readonly white: "白マス";
+        readonly bulb: "電球";
+        readonly lit: "照明あり";
+        readonly dark: "暗い";
+        readonly black: "黒マス";
+        readonly clue: "数字";
+    };
+};
+export declare function akariWords(language?: AkariLanguage): {
+    readonly title: "Akari";
+    readonly help: "Place bulbs on white squares. Each bulb lights along its row and column until a black square or the edge. Light every white square; bulbs cannot see one another. Numbered black squares touch exactly that many bulbs. Click, tap or press Enter or Space to toggle a bulb; arrows move; Delete removes it.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly expand: "Just the board";
+    readonly close: "Close";
+    readonly won: "Every square is lit. Solved!";
+    readonly helped: "Solved with help.";
+    readonly checked: "No rule conflicts so far. Keep lighting the board.";
+    readonly wrong: "Check the dark squares, bulb lines and numbered squares.";
+    readonly hintWhy: "A bulb from the only proved solution was placed.";
+    readonly noHint: "No proved hint is available.";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly white: "white square";
+    readonly bulb: "bulb";
+    readonly lit: "lit";
+    readonly dark: "dark";
+    readonly black: "black square";
+    readonly clue: "number";
+} | {
+    readonly title: "美術館";
+    readonly help: "白マスに電球を置きます。電球は黒マスか盤の端まで、縦横に光ります。白マスすべてを照らし、電球同士が見えないようにします。数字のある黒マスには、その数だけ電球を隣接させます。タップ、クリック、Enter、Spaceで電球を切り替えます。矢印キーで移動し、Deleteで消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly expand: "盤だけ";
+    readonly close: "閉じる";
+    readonly won: "全部照らしました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly checked: "ここまでルールに合っています。残りも照らしましょう。";
+    readonly wrong: "暗いマス、電球の見通し、数字のマスを確かめましょう。";
+    readonly hintWhy: "唯一の解答で必要な電球を置きました。";
+    readonly noHint: "確かなヒントがありません。";
+    readonly row: "行";
+    readonly column: "列";
+    readonly white: "白マス";
+    readonly bulb: "電球";
+    readonly lit: "照明あり";
+    readonly dark: "暗い";
+    readonly black: "黒マス";
+    readonly clue: "数字";
+};

package/dist/akariStrings.js

@@ -0,0 +1,53 @@
+export const AKARI_STRINGS = {
+    en: {
+        title: "Akari",
+        help: "Place bulbs on white squares. Each bulb lights along its row and column until a black square or the edge. Light every white square; bulbs cannot see one another. Numbered black squares touch exactly that many bulbs. Click, tap or press Enter or Space to toggle a bulb; arrows move; Delete removes it.",
+        undo: "Undo",
+        hint: "Hint",
+        check: "Check",
+        restart: "Restart",
+        expand: "Just the board",
+        close: "Close",
+        won: "Every square is lit. Solved!",
+        helped: "Solved with help.",
+        checked: "No rule conflicts so far. Keep lighting the board.",
+        wrong: "Check the dark squares, bulb lines and numbered squares.",
+        hintWhy: "A bulb from the only proved solution was placed.",
+        noHint: "No proved hint is available.",
+        row: "Row",
+        column: "column",
+        white: "white square",
+        bulb: "bulb",
+        lit: "lit",
+        dark: "dark",
+        black: "black square",
+        clue: "number",
+    },
+    ja: {
+        title: "美術館",
+        help: "白マスに電球を置きます。電球は黒マスか盤の端まで、縦横に光ります。白マスすべてを照らし、電球同士が見えないようにします。数字のある黒マスには、その数だけ電球を隣接させます。タップ、クリック、Enter、Spaceで電球を切り替えます。矢印キーで移動し、Deleteで消します。",
+        undo: "戻す",
+        hint: "ヒント",
+        check: "確かめる",
+        restart: "やり直す",
+        expand: "盤だけ",
+        close: "閉じる",
+        won: "全部照らしました。完成！",
+        helped: "ヒントを使って完成！",
+        checked: "ここまでルールに合っています。残りも照らしましょう。",
+        wrong: "暗いマス、電球の見通し、数字のマスを確かめましょう。",
+        hintWhy: "唯一の解答で必要な電球を置きました。",
+        noHint: "確かなヒントがありません。",
+        row: "行",
+        column: "列",
+        white: "白マス",
+        bulb: "電球",
+        lit: "照明あり",
+        dark: "暗い",
+        black: "黒マス",
+        clue: "数字",
+    },
+};
+export function akariWords(language = "en") {
+    return AKARI_STRINGS[language];
+}

package/dist/akariStyle.d.ts

@@ -0,0 +1 @@
+export declare const AKARI_PLAY_STYLE = "\n.ka-root{color:var(--ka-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}\n.ka-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}.ka-cells{position:absolute;inset:0;display:grid;padding:2px}\n.ka-cell{border:0;min-width:0;min-height:0;padding:0;cursor:pointer;touch-action:manipulation;font:inherit;color:inherit;background:transparent}\n.ka-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}.ka-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}\n.ka-tools button,.ka-close{font:inherit;border:1px solid var(--ka-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ka-surface,#fbf8f1);color:var(--ka-ink,#1f2320);cursor:pointer}\n.ka-tools button:disabled{opacity:.45;cursor:default}.ka-status{min-height:1.5em}.ka-help{font-size:14px;opacity:.8}\n.ka-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ka-ink:var(--ink,#1f2320);--ka-surface:var(--surface,#fbf8f1);--ka-rule:var(--rule,#ddd6c6)}.ka-dialog::backdrop{background:#172c28bb}.ka-close{float:right;margin-bottom:10px}.ka-dialog .ka-root{clear:both}\n";

package/dist/akariStyle.js

@@ -0,0 +1,9 @@
+export const AKARI_PLAY_STYLE = `
+.ka-root{color:var(--ka-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}
+.ka-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}.ka-cells{position:absolute;inset:0;display:grid;padding:2px}
+.ka-cell{border:0;min-width:0;min-height:0;padding:0;cursor:pointer;touch-action:manipulation;font:inherit;color:inherit;background:transparent}
+.ka-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}.ka-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.ka-tools button,.ka-close{font:inherit;border:1px solid var(--ka-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ka-surface,#fbf8f1);color:var(--ka-ink,#1f2320);cursor:pointer}
+.ka-tools button:disabled{opacity:.45;cursor:default}.ka-status{min-height:1.5em}.ka-help{font-size:14px;opacity:.8}
+.ka-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ka-ink:var(--ink,#1f2320);--ka-surface:var(--surface,#fbf8f1);--ka-rule:var(--rule,#ddd6c6)}.ka-dialog::backdrop{background:#172c28bb}.ka-close{float:right;margin-bottom:10px}.ka-dialog .ka-root{clear:both}
+`;

package/dist/akariTemplate.d.ts

@@ -0,0 +1,7 @@
+import type { AkariPuzzle } from "./akari.types.ts";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export declare function templateAkari(width?: number, height?: number, seed?: number): Omit<AkariPuzzle, "level">;

package/dist/akariTemplate.js

@@ -0,0 +1,78 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export function templateAkari(width = 7, height = width, seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Akari settings");
+    const random = seededRandom(seed);
+    const cells = Array(width * height).fill(false);
+    const bulbs = [];
+    const horizontal = random() < .5;
+    if (horizontal) {
+        const firstRow = height > 2 ? 1 : 0;
+        for (let y = firstRow; y < height; y += 3) {
+            const clueY = y > 0 ? y - 1 : y + 1;
+            for (let x = 0; x < width; x += 3) {
+                const room = y * width + x;
+                if (x + 1 < width) {
+                    const bulbX = random() < .5 ? x : x + 1;
+                    cells[room] = null;
+                    cells[room + 1] = null;
+                    cells[clueY * width + bulbX] = 1;
+                    bulbs.push(y * width + bulbX);
+                }
+                else {
+                    cells[room] = null;
+                    cells[clueY * width + x] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    else {
+        const firstColumn = width > 2 ? 1 : 0;
+        for (let x = firstColumn; x < width; x += 3) {
+            const clueX = x > 0 ? x - 1 : x + 1;
+            for (let y = 0; y < height; y += 3) {
+                const room = y * width + x;
+                if (y + 1 < height) {
+                    const bulbY = random() < .5 ? y : y + 1;
+                    cells[room] = null;
+                    cells[room + width] = null;
+                    cells[bulbY * width + clueX] = 1;
+                    bulbs.push(bulbY * width + x);
+                }
+                else {
+                    cells[room] = null;
+                    cells[y * width + clueX] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    // Reflections are applied to the board and the construction answer together.
+    const reflectX = random() < .5, reflectY = random() < .5;
+    const original = [...cells];
+    const map = (cell) => {
+        const x = cell % width, y = Math.floor(cell / width);
+        return (reflectY ? height - 1 - y : y) * width + (reflectX ? width - 1 - x : x);
+    };
+    for (let cell = 0; cell < original.length; cell += 1)
+        cells[map(cell)] = original[cell];
+    const answer = bulbs.map(map);
+    const board = { width, height, cells };
+    if (!isAkariBoard(board) || !checkAkari(board, answer).ok)
+        throw new Error("Unable to construct Akari puzzle");
+    const proof = solveAkari(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Akari found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/csp.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ONE SMALL ENGINE for the puzzles that are solved by narrowing down what each square, edge or rectangle can
+ * still be. A puzzle supplies its variables and one function that prunes; this file does the two things
+ * every one of them needs: counting answers (a search that stops at a limit) and rating how hard a puzzle
+ * is (how deep the reasoning must go before the grid is decided).
+ *
+ * A variable has a few slots (its possible values). `alive[slot]` is 1 while that value is still possible.
+ * A variable is decided when exactly one of its slots is alive and impossible when none is.
+ */
+export type Csp = {
+    /** The slots of variable `v` are `starts[v]` up to, not including, `starts[v + 1]`. */
+    starts: Int32Array;
+    /**
+     * Prunes `alive` as far as the rules force and says `false` when they cannot all be kept. Never guesses.
+     * `decided` names a variable that was just narrowed from a state that was already pruned, so a rule may
+     * look only at what that can change; leaving it out means look at everything.
+     */
+    propagate: (alive: Uint8Array, decided?: number) => boolean;
+    /** Which variable to branch on in a search; the default is the one with the fewest values left. */
+    choose?: (alive: Uint8Array) => number;
+};
+/** How many values a variable still has. */
+export declare function slotsLeft(csp: Csp, alive: Uint8Array, variable: number): number;
+/** Every value of every variable still possible. */
+export declare function openSlots(csp: Csp): Uint8Array;
+/** Leaves `variable` with only `slot` (a slot number, not an offset). */
+export declare function decide(csp: Csp, alive: Uint8Array, variable: number, slot: number): void;
+/** The slot a decided variable has left, or -1 when it has more than one or none. */
+export declare function decidedSlot(csp: Csp, alive: Uint8Array, variable: number): number;
+export type CspCount = {
+    count: number;
+    solution: Uint8Array | null;
+    solutions: Uint8Array[];
+    stopped: boolean;
+    exhausted: boolean;
+    nodes: number;
+};
+/**
+ * Counts the ways to decide every variable, up to `limit`. `exhausted` says the node budget ran out;
+ * `stopped` says the limit was reached. Either way the count must not be read as proof of anything
+ * beyond what was seen.
+ */
+export declare function countCsp(csp: Csp, start: Uint8Array, limit: number, budget: number): CspCount;
+export type CspLogic = {
+    solved: boolean;
+    contradiction: boolean;
+    probes: number;
+    alive: Uint8Array;
+};
+/**
+ * Solves by reasoning alone, never by guessing a value and keeping it. `depth` 0 is the rules' own
+ * pruning. Depth 1 adds probing: suppose one value, prune, and when that breaks a rule the value is
+ * ruled out. Depth 2 lets a probe probe. `probes` counts the values ruled out by supposing, which is how
+ * much supposing the puzzle asks of a person.
+ */
+export declare function logicCsp(csp: Csp, start: Uint8Array, depth: number): CspLogic;
+/**
+ * Counts answers like `countCsp`, but first tries to settle the puzzle by reasoning (rules, then one level of
+ * supposing): reasoning that leaves every variable decided proves exactly one answer, and reasoning that breaks a
+ * rule proves none, in far fewer steps than a search. Only a puzzle that reasoning leaves open is searched, from the
+ * state reasoning reached.
+ */
+export declare function solveCsp(csp: Csp, start: Uint8Array, limit: number, budget: number, depth?: number): CspCount;