@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/masyuSolve.js

@@ -0,0 +1,88 @@
+import { MASYU_NODE_BUDGET } from "./masyu.constants.js";
+import { checkMasyu, isMasyuBoard, masyuEdgeCount, masyuNeighbors } from "./masyuBoard.js";
+/** Counts distinct single loops with local pearl rules; budget stops never claim a proof. */
+export function solveMasyu(board, options = {}) {
+    if (!isMasyuBoard(board))
+        throw new RangeError("Invalid Masyu board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? MASYU_NODE_BUDGET;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const edgeState = Array(masyuEdgeCount(board)).fill(-1);
+    const configs = board.pearls.map((pearl, cell) => {
+        const validDirections = masyuNeighbors(board, cell).map(next => next.direction);
+        const choices = [];
+        for (let mask = 0; mask < 16; mask += 1) {
+            const bits = [0, 1, 2, 3].filter(direction => mask & (1 << direction));
+            if (bits.length !== 0 && bits.length !== 2)
+                continue;
+            if (bits.some(direction => !validDirections.includes(direction)))
+                continue;
+            if (pearl && bits.length !== 2)
+                continue;
+            const straight = bits.length === 2 && (bits[0] + 2) % 4 === bits[1];
+            if (pearl === 1 && !straight || pearl === 2 && straight)
+                continue;
+            choices.push(mask);
+        }
+        return choices;
+    });
+    let count = 0, nodes = 0, complete = true, answer = null;
+    const assigned = Array(board.pearls.length).fill(false);
+    const visit = (depth) => {
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        if (depth === board.pearls.length) {
+            const edges = edgeState.flatMap((value, edge) => value === 1 ? [edge] : []);
+            if (!checkMasyu(board, edges).ok)
+                return;
+            count += 1;
+            answer ?? (answer = edges);
+            if (count >= limit)
+                complete = false;
+            return;
+        }
+        let chosen = -1, available = null;
+        for (let cell = 0; cell < board.pearls.length; cell += 1) {
+            if (assigned[cell])
+                continue;
+            const neighbors = masyuNeighbors(board, cell);
+            const candidates = configs[cell].filter(mask => neighbors.every(next => edgeState[next.edge] < 0 || edgeState[next.edge] === (mask & (1 << next.direction) ? 1 : 0)));
+            if (!candidates.length)
+                return;
+            if (!available || candidates.length < available.length) {
+                chosen = cell;
+                available = candidates;
+                if (candidates.length === 1)
+                    break;
+            }
+        }
+        const neighbors = masyuNeighbors(board, chosen);
+        assigned[chosen] = true;
+        for (const mask of available ?? []) {
+            const changes = [];
+            let valid = true;
+            for (const next of neighbors) {
+                const value = mask & (1 << next.direction) ? 1 : 0;
+                if (edgeState[next.edge] >= 0 && edgeState[next.edge] !== value) {
+                    valid = false;
+                    break;
+                }
+                if (edgeState[next.edge] < 0) {
+                    edgeState[next.edge] = value;
+                    changes.push(next.edge);
+                }
+            }
+            if (valid)
+                visit(depth + 1);
+            for (const edge of changes)
+                edgeState[edge] = -1;
+            if (!complete)
+                return;
+        }
+        assigned[chosen] = false;
+    };
+    visit(0);
+    return { count, solution: answer, complete, nodes };
+}

package/dist/masyuStrings.d.ts

@@ -0,0 +1,28 @@
+export declare const MASYU_STRINGS: {
+    readonly en: {
+        readonly title: "Masyu";
+        readonly help: "Draw one loop through every pearl. White pearls go straight and turn at a neighboring cell; black pearls turn and go straight through the neighboring cell on each side.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly won: "Solved!";
+        readonly helped: "Solved with help.";
+        readonly good: "The loop is still open. Keep going.";
+        readonly bad: "Check the marked line ends and pearls.";
+        readonly pearl: readonly ["empty", "white pearl", "black pearl"];
+    };
+    readonly ja: {
+        readonly title: "ましゅ";
+        readonly help: "すべての真珠を通る一つの輪を描きます。白真珠では直進して隣のマスで曲がり、黒真珠では曲がって両隣のマスで直進します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly won: "完成！";
+        readonly helped: "ヒントを使って完成。";
+        readonly good: "輪はまだ閉じていません。続けましょう。";
+        readonly bad: "線の端や真珠の周りを確認してください。";
+        readonly pearl: readonly ["なし", "白真珠", "黒真珠"];
+    };
+};

package/dist/masyuStrings.js

@@ -0,0 +1,4 @@
+export const MASYU_STRINGS = {
+    en: { title: "Masyu", help: "Draw one loop through every pearl. White pearls go straight and turn at a neighboring cell; black pearls turn and go straight through the neighboring cell on each side.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", won: "Solved!", helped: "Solved with help.", good: "The loop is still open. Keep going.", bad: "Check the marked line ends and pearls.", pearl: ["empty", "white pearl", "black pearl"] },
+    ja: { title: "ましゅ", help: "すべての真珠を通る一つの輪を描きます。白真珠では直進して隣のマスで曲がり、黒真珠では曲がって両隣のマスで直進します。", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", won: "完成！", helped: "ヒントを使って完成。", good: "輪はまだ閉じていません。続けましょう。", bad: "線の端や真珠の周りを確認してください。", pearl: ["なし", "白真珠", "黒真珠"] },
+};

package/dist/masyuStyle.d.ts

@@ -0,0 +1 @@
+export declare const MASYU_PLAY_STYLE = "\n.kazu-masyu { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }\n.kazu-masyu .km-board { position:relative; max-width:440px; margin:auto; }\n.kazu-masyu svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }\n.kazu-masyu .km-cells { position:absolute; inset:6%; display:grid; }\n.kazu-masyu .km-cell { border:0; background:transparent; border-radius:50%; color:transparent; cursor:pointer; }\n.kazu-masyu .km-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }\n.kazu-masyu .km-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }\n.kazu-masyu button { font:inherit; padding:.45rem .8rem; }\n.kazu-masyu .km-status { min-height:1.5em; text-align:center; }\n";

package/dist/masyuStyle.js

@@ -0,0 +1,11 @@
+export const MASYU_PLAY_STYLE = `
+.kazu-masyu { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }
+.kazu-masyu .km-board { position:relative; max-width:440px; margin:auto; }
+.kazu-masyu svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }
+.kazu-masyu .km-cells { position:absolute; inset:6%; display:grid; }
+.kazu-masyu .km-cell { border:0; background:transparent; border-radius:50%; color:transparent; cursor:pointer; }
+.kazu-masyu .km-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }
+.kazu-masyu .km-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }
+.kazu-masyu button { font:inherit; padding:.45rem .8rem; }
+.kazu-masyu .km-status { min-height:1.5em; text-align:center; }
+`;

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

@@ -0,0 +1,2 @@
+export { drawNurikabe } from "./nurikabeDraw.ts";
+export type { NurikabeDrawOptions } from "./nurikabePlay.types.ts";

package/dist/nurikabe-draw-entry.js

@@ -0,0 +1 @@
+export { drawNurikabe } from "./nurikabeDraw.js";

package/dist/nurikabe-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./nurikabe.types.ts";
+export * from "./nurikabe.constants.ts";
+export * from "./nurikabeBoard.ts";
+export * from "./nurikabeSolve.ts";
+export * from "./nurikabeGenerate.ts";
+export * from "./nurikabeGame.ts";

package/dist/nurikabe-entry.js

@@ -0,0 +1,6 @@
+export * from "./nurikabe.types.js";
+export * from "./nurikabe.constants.js";
+export * from "./nurikabeBoard.js";
+export * from "./nurikabeSolve.js";
+export * from "./nurikabeGenerate.js";
+export * from "./nurikabeGame.js";

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

@@ -0,0 +1,4 @@
+export { mountNurikabe } from "./nurikabeMount.ts";
+export { NURIKABE_PLAY_STYLE } from "./nurikabeStyle.ts";
+export { NURIKABE_STRINGS } from "./nurikabeStrings.ts";
+export type * from "./nurikabePlay.types.ts";

package/dist/nurikabe-play-entry.js

@@ -0,0 +1,3 @@
+export { mountNurikabe } from "./nurikabeMount.js";
+export { NURIKABE_PLAY_STYLE } from "./nurikabeStyle.js";
+export { NURIKABE_STRINGS } from "./nurikabeStrings.js";

package/dist/nurikabe.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NURIKABE_MAX_NODES = 250000;
+export declare const NURIKABE_SIZES: readonly [5];

package/dist/nurikabe.constants.js

@@ -0,0 +1,2 @@
+export const NURIKABE_MAX_NODES = 250000;
+export const NURIKABE_SIZES = [5];

package/dist/nurikabe.types.d.ts

@@ -0,0 +1,20 @@
+export type NurikabeBoard = {
+    size: 5;
+    clues: readonly number[];
+};
+export type NurikabePuzzle = NurikabeBoard & {
+    seed: number;
+    solution: readonly boolean[];
+};
+export type NurikabeSolve = {
+    count: number;
+    solution: readonly boolean[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type NurikabeGame = {
+    board: NurikabeBoard;
+    sea: readonly boolean[];
+    history: readonly (readonly boolean[])[];
+    helped: boolean;
+};

package/dist/nurikabe.types.js

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

package/dist/nurikabeBoard.d.ts

@@ -0,0 +1,8 @@
+import type { NurikabeBoard } from "./nurikabe.types.ts";
+export declare function isNurikabeBoard(board: NurikabeBoard): boolean;
+export declare function nurikabeNeighbors(size: number, cell: number): number[];
+/** Checks island areas and separation, the connected sea, and the ban on 2×2 sea blocks. */
+export declare function checkNurikabe(board: NurikabeBoard, sea: readonly boolean[]): {
+    ok: boolean;
+    errors: readonly number[];
+};

package/dist/nurikabeBoard.js

@@ -0,0 +1,72 @@
+export function isNurikabeBoard(board) {
+    return !!board && board.size === 5 && Array.isArray(board.clues)
+        && board.clues.length === board.size * board.size
+        && board.clues.every(value => Number.isInteger(value) && value >= 0 && value <= board.size ** 2)
+        && board.clues.some(value => value > 0)
+        && board.clues.reduce((sum, value) => sum + value, 0) < board.size * board.size;
+}
+export function nurikabeNeighbors(size, cell) {
+    const x = cell % size, y = Math.floor(cell / size), neighbors = [];
+    if (x > 0)
+        neighbors.push(cell - 1);
+    if (x < size - 1)
+        neighbors.push(cell + 1);
+    if (y > 0)
+        neighbors.push(cell - size);
+    if (y < size - 1)
+        neighbors.push(cell + size);
+    return neighbors;
+}
+/** Checks island areas and separation, the connected sea, and the ban on 2×2 sea blocks. */
+export function checkNurikabe(board, sea) {
+    if (!isNurikabeBoard(board) || sea.length !== board.size * board.size || !sea.every(value => typeof value === "boolean"))
+        return { ok: false, errors: [] };
+    const size = board.size, total = size * size, errors = new Set();
+    for (let cell = 0; cell < total; cell += 1)
+        if (board.clues[cell] && sea[cell])
+            errors.add(cell);
+    for (let y = 0; y < size - 1; y += 1)
+        for (let x = 0; x < size - 1; x += 1) {
+            const square = [y * size + x, y * size + x + 1, (y + 1) * size + x, (y + 1) * size + x + 1];
+            if (square.every(cell => sea[cell]))
+                square.forEach(cell => errors.add(cell));
+        }
+    const visited = new Set(), islands = [];
+    for (let start = 0; start < total; start += 1)
+        if (!sea[start] && !visited.has(start)) {
+            const stack = [start], cells = [], clues = [];
+            visited.add(start);
+            while (stack.length) {
+                const cell = stack.pop();
+                cells.push(cell);
+                if (board.clues[cell])
+                    clues.push(cell);
+                for (const next of nurikabeNeighbors(size, cell))
+                    if (!sea[next] && !visited.has(next)) {
+                        visited.add(next);
+                        stack.push(next);
+                    }
+            }
+            islands.push({ cells, clues });
+            if (clues.length !== 1 || board.clues[clues[0]] !== cells.length)
+                cells.forEach(cell => errors.add(cell));
+        }
+    for (let cell = 0; cell < total; cell += 1)
+        if (board.clues[cell] && !islands.some(island => island.clues[0] === cell))
+            errors.add(cell);
+    const black = sea.map((value, cell) => value ? cell : -1).filter(cell => cell >= 0), connected = new Set();
+    if (black.length) {
+        const stack = [black[0]];
+        connected.add(black[0]);
+        while (stack.length)
+            for (const next of nurikabeNeighbors(size, stack.pop()))
+                if (sea[next] && !connected.has(next)) {
+                    connected.add(next);
+                    stack.push(next);
+                }
+    }
+    for (const cell of black)
+        if (!connected.has(cell))
+            errors.add(cell);
+    return { ok: errors.size === 0, errors: [...errors].sort((a, b) => a - b) };
+}

package/dist/nurikabeDraw.d.ts

@@ -0,0 +1,4 @@
+import type { NurikabeBoard } from "./nurikabe.types.ts";
+import type { NurikabeDrawOptions } from "./nurikabePlay.types.ts";
+/** SVG text contains the numbered clues and the player's sea marks only. */
+export declare function drawNurikabe(board: NurikabeBoard, options?: NurikabeDrawOptions): string;

package/dist/nurikabeDraw.js

@@ -0,0 +1,15 @@
+import { isNurikabeBoard } from "./nurikabeBoard.js";
+/** SVG text contains the numbered clues and the player's sea marks only. */
+export function drawNurikabe(board, options = {}) {
+    if (!isNurikabeBoard(board))
+        throw new RangeError("Invalid Nurikabe board");
+    const n = board.size, cell = 52;
+    const palettes = { ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"], wood: ["#e5cda6", "#493e2f", "#bca582"], slate: ["#333a42", "#f1eee7", "#707984"] };
+    const [paper, ink, grid] = palettes[options.material ?? "ivory"], sea = options.sea ?? [];
+    const cells = board.clues.map((clue, c) => {
+        const x = c % n * cell, y = Math.floor(c / n) * cell, black = sea[c], selected = options.selected === c, error = options.errors?.includes(c);
+        const tile = options.pieces === "tiles" && clue && !black ? `<rect x="${x + 10}" y="${y + 10}" width="32" height="32" rx="6" fill="${paper}" stroke="${grid}"/>` : "";
+        return `<g><rect x="${x}" y="${y}" width="${cell}" height="${cell}" fill="${black ? ink : selected ? `${ink}22` : paper}" stroke="${grid}" stroke-width="1"/>${tile}${clue ? `<text x="${x + cell / 2}" y="${y + cell / 2}" text-anchor="middle" dominant-baseline="middle" fill="${black ? paper : error ? "#b5452c" : ink}" font-size="22" font-weight="700" font-family="system-ui,sans-serif">${clue}</text>` : ""}</g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${n * cell + 4} ${n * cell + 4}" role="img" aria-label="Nurikabe" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${n * cell}" height="${n * cell}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/nurikabeGame.d.ts

@@ -0,0 +1,8 @@
+import type { NurikabeBoard, NurikabeGame } from "./nurikabe.types.ts";
+export declare function newNurikabe(board: NurikabeBoard): NurikabeGame;
+export declare function markNurikabeSea(game: NurikabeGame, cell: number): NurikabeGame;
+export declare function undoNurikabe(game: NurikabeGame): NurikabeGame;
+export declare function restartNurikabe(game: NurikabeGame): NurikabeGame;
+export declare function hintNurikabe(game: NurikabeGame): number | null;
+export declare function encodeNurikabe(game: NurikabeGame): string;
+export declare function decodeNurikabe(code: string): NurikabeGame | null;

package/dist/nurikabeGame.js

@@ -0,0 +1,40 @@
+import { isNurikabeBoard } from "./nurikabeBoard.js";
+import { solveNurikabe } from "./nurikabeSolve.js";
+export function newNurikabe(board) {
+    if (!isNurikabeBoard(board))
+        throw new RangeError("Invalid Nurikabe board");
+    return { board: { size: board.size, clues: [...board.clues] }, sea: Array(board.size ** 2).fill(false), history: [], helped: false };
+}
+export function markNurikabeSea(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.sea.length || game.board.clues[cell])
+        return game;
+    const sea = [...game.sea];
+    sea[cell] = !sea[cell];
+    return { ...game, sea, history: [...game.history, [...game.sea]] };
+}
+export function undoNurikabe(game) {
+    const prior = game.history.at(-1);
+    return prior ? { ...game, sea: [...prior], history: game.history.slice(0, -1) } : game;
+}
+export function restartNurikabe(game) { return { ...game, sea: Array(game.sea.length).fill(false), history: [], helped: false }; }
+export function hintNurikabe(game) {
+    const solved = solveNurikabe(game.board);
+    if (!solved.complete || solved.count !== 1 || !solved.solution)
+        return null;
+    const cell = solved.solution.findIndex((value, i) => value !== game.sea[i]);
+    return cell < 0 ? null : cell;
+}
+export function encodeNurikabe(game) { return JSON.stringify({ version: 1, board: game.board, sea: game.sea, helped: game.helped }); }
+export function decodeNurikabe(code) {
+    try {
+        if (code.length > 10000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isNurikabeBoard(value.board) || !Array.isArray(value.sea) || value.sea.length !== value.board.size ** 2 || !value.sea.every((item) => typeof item === "boolean") || typeof value.helped !== "boolean")
+            return null;
+        return { ...newNurikabe(value.board), sea: [...value.sea], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/nurikabeGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { NurikabePuzzle } from "./nurikabe.types.ts";
+/** Seeded symmetries of original 5×5 layouts are returned only after the solver proves uniqueness. */
+export declare function generateNurikabe(seed?: number): NurikabePuzzle;

package/dist/nurikabeGenerate.js

@@ -0,0 +1,31 @@
+import { NURIKABE_MAX_NODES } from "./nurikabe.constants.js";
+import { checkNurikabe } from "./nurikabeBoard.js";
+import { solveNurikabe } from "./nurikabeSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+const originals = [
+    { clues: [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 7, 0, 0], solution: [false, true, true, false, true, true, false, true, true, true, true, true, true, false, true, false, true, false, false, false, true, true, false, false, false] },
+    { clues: [0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 3], solution: [true, true, true, true, true, true, false, false, true, false, false, true, true, true, true, false, true, false, true, false, true, true, true, false, false] },
+    { clues: [1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 1], solution: [false, true, true, true, true, true, true, false, true, false, false, true, false, true, false, false, true, false, true, true, false, false, true, true, false] },
+    { clues: [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 6, 0], solution: [false, true, true, true, false, false, true, false, true, true, false, true, false, false, true, true, true, true, false, true, false, false, true, false, false] },
+    { clues: [0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 1, 0, 0, 0], solution: [true, true, true, false, true, true, false, false, true, true, true, false, true, true, false, true, true, true, false, false, true, false, true, false, false] },
+];
+/** Seeded symmetries of original 5×5 layouts are returned only after the solver proves uniqueness. */
+export function generateNurikabe(seed = 1) {
+    if (!isKazuSeed(seed))
+        throw new RangeError("Invalid Nurikabe seed");
+    const random = seededRandom(seed), sample = originals[Math.floor(random() * originals.length)], rotation = Math.floor(random() * 4), reflect = random() < 0.5;
+    const size = 5, clues = Array(size * size).fill(0), solution = Array(size * size).fill(false);
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1) {
+            let sx = reflect ? size - 1 - x : x, sy = y;
+            for (let turn = 0; turn < rotation; turn += 1)
+                [sx, sy] = [size - 1 - sy, sx];
+            const from = sy * size + sx, to = y * size + x;
+            clues[to] = sample.clues[from];
+            solution[to] = sample.solution[from];
+        }
+    const board = { size: 5, clues }, proof = solveNurikabe(board, { nodes: NURIKABE_MAX_NODES });
+    if (!checkNurikabe(board, solution).ok || !proof.complete || proof.count !== 1 || !proof.solution)
+        throw new Error("No uniquely solvable Nurikabe found within the generation budget; try another seed");
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/nurikabeMount.d.ts

@@ -0,0 +1,3 @@
+import type { NurikabeMount, NurikabeMountOptions } from "./nurikabePlay.types.ts";
+/** A keyboard- and touch-friendly Nurikabe player, mounted in any host element. */
+export declare function mountNurikabe(host: HTMLElement, initial: NurikabeMountOptions): NurikabeMount;

package/dist/nurikabeMount.js

@@ -0,0 +1,99 @@
+import { checkNurikabe } from "./nurikabeBoard.js";
+import { decodeNurikabe, encodeNurikabe, hintNurikabe, markNurikabeSea, newNurikabe, restartNurikabe, undoNurikabe } from "./nurikabeGame.js";
+import { drawNurikabe } from "./nurikabeDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { NURIKABE_PLAY_STYLE } from "./nurikabeStyle.js";
+import { nurikabeWords } from "./nurikabeStrings.js";
+/** A keyboard- and touch-friendly Nurikabe player, mounted in any host element. */
+export function mountNurikabe(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial }, game = initial.progress ? decodeNurikabe(initial.progress) : null;
+    game ?? (game = newNurikabe(initial.board));
+    let selected = 0, errors = [], message = "", finished = checkNurikabe(game.board, game.sea).ok, dead = false;
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div"), status = doc.createElement("p"), tools = doc.createElement("div"), help = doc.createElement("p");
+    root.className = "kn-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ks-palette") + NURIKABE_PLAY_STYLE;
+    board.className = "kn-board";
+    status.className = "kn-status";
+    status.setAttribute("role", "status");
+    tools.className = "kn-tools";
+    help.className = "kn-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({ ...game, board: { ...game.board, clues: [...game.board.clues] }, sea: [...game.sea], history: game.history.map(turn => [...turn]) });
+    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 wasFinished = finished;
+        finished = checkNurikabe(game.board, game.sea).ok;
+        render();
+        options.onChange?.(copy());
+        if (finished && !wasFinished)
+            options.onFinish?.(copy());
+    };
+    const mark = (cell) => { if (finished)
+        return; selected = cell; game = markNurikabeSea(game, cell); changed(); };
+    const render = () => {
+        if (dead)
+            return;
+        const words = nurikabeWords(options.language), focused = board.contains(doc.activeElement);
+        board.innerHTML = drawNurikabe(game.board, { ...options, sea: game.sea, selected, errors });
+        const cells = doc.createElement("div");
+        cells.className = "kn-cells";
+        cells.style.gridTemplateColumns = `repeat(${game.board.size},1fr)`;
+        for (let cell = 0; cell < game.sea.length; cell += 1) {
+            const control = doc.createElement("button");
+            control.type = "button";
+            control.className = "kn-cell";
+            control.dataset.cell = String(cell);
+            control.tabIndex = cell === selected ? 0 : -1;
+            control.setAttribute("aria-label", `${words.row} ${Math.floor(cell / game.board.size) + 1}, ${words.column} ${cell % game.board.size + 1}: ${game.board.clues[cell] || (game.sea[cell] ? words.sea : words.white)}`);
+            control.onclick = () => mark(cell);
+            control.onkeydown = event => {
+                const n = game.board.size, moves = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -n, ArrowDown: n };
+                if (event.key in moves) {
+                    event.preventDefault();
+                    selected = Math.max(0, Math.min(game.sea.length - 1, cell + moves[event.key]));
+                    render();
+                }
+                else if (event.key === " " || event.key === "Enter") {
+                    event.preventDefault();
+                    mark(cell);
+                }
+            };
+            cells.append(control);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = finished ? (game.helped ? words.helped : words.won) : message;
+        help.textContent = words.help;
+        tools.replaceChildren();
+        button(words.undo, () => { game = undoNurikabe(game); changed(); }, !game.history.length);
+        button(words.check, () => { errors = checkNurikabe(game.board, game.sea).errors; message = errors.length ? words.wrong : words.good; render(); });
+        button(words.hint, () => {
+            const cell = hintNurikabe(game);
+            if (cell === null) {
+                message = words.noHint;
+                render();
+                return;
+            }
+            game = { ...markNurikabeSea(game, cell), helped: true };
+            changed();
+        }, finished);
+        button(words.restart, () => { game = restartNurikabe(game); finished = false; changed(); });
+    };
+    render();
+    return {
+        game: copy, progress: () => encodeNurikabe(game), restart: () => { game = restartNurikabe(game); finished = false; changed(); },
+        set: (next) => { options = { ...options, ...next }; render(); }, destroy: () => { dead = true; root.remove(); },
+    };
+}

package/dist/nurikabePlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { NurikabeBoard, NurikabeGame } from "./nurikabe.types.ts";
+export type NurikabeLanguage = "en" | "ja";
+export type NurikabeMaterial = "ivory" | "wood" | "slate";
+export type NurikabePieces = "ink" | "tiles";
+export type NurikabeDrawOptions = {
+    sea?: readonly boolean[];
+    selected?: number | null;
+    errors?: readonly number[];
+    material?: NurikabeMaterial;
+    pieces?: NurikabePieces;
+    language?: NurikabeLanguage;
+};
+export type NurikabeMountOptions = NurikabeDrawOptions & {
+    board: NurikabeBoard;
+    progress?: string;
+    onChange?: (game: NurikabeGame) => void;
+    onFinish?: (game: NurikabeGame) => void;
+};
+export type NurikabeMount = {
+    game: () => NurikabeGame;
+    progress: () => string;
+    restart: () => void;
+    set: (options: NurikabeDrawOptions) => void;
+    destroy: () => void;
+};

package/dist/nurikabePlay.types.js

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

package/dist/nurikabeSolve.d.ts

@@ -0,0 +1,6 @@
+import type { NurikabeBoard, NurikabeSolve } from "./nurikabe.types.ts";
+/** Counts valid island placements and checks the remaining cells as the sea under a finite budget. */
+export declare function solveNurikabe(board: NurikabeBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): NurikabeSolve;

package/dist/nurikabeSolve.js

@@ -0,0 +1,75 @@
+import { NURIKABE_MAX_NODES } from "./nurikabe.constants.js";
+import { checkNurikabe, isNurikabeBoard, nurikabeNeighbors } from "./nurikabeBoard.js";
+function islandShapes(board, clue) {
+    let shapes = new Map([[String(clue.cell), new Set([clue.cell])]]);
+    for (let area = 1; area < clue.size; area += 1) {
+        const next = new Map();
+        for (const shape of shapes.values()) {
+            const fringe = new Set();
+            for (const cell of shape)
+                for (const neighbor of nurikabeNeighbors(board.size, cell)) {
+                    if ((!board.clues[neighbor] || neighbor === clue.cell) && !shape.has(neighbor))
+                        fringe.add(neighbor);
+                }
+            for (const cell of fringe) {
+                const grown = new Set(shape);
+                grown.add(cell);
+                const key = [...grown].sort((a, b) => a - b).join(",");
+                next.set(key, grown);
+            }
+        }
+        shapes = next;
+    }
+    return [...shapes.values()].map(shape => [...shape]);
+}
+/** Counts valid island placements and checks the remaining cells as the sea under a finite budget. */
+export function solveNurikabe(board, options = {}) {
+    if (!isNurikabeBoard(board))
+        throw new RangeError("Invalid Nurikabe board");
+    const total = board.size ** 2, limit = Math.max(1, Math.floor(options.limit ?? 2)), budget = Math.max(1, Math.floor(options.nodes ?? NURIKABE_MAX_NODES));
+    const clues = board.clues.map((size, cell) => size ? { cell, size } : null).filter((clue) => !!clue);
+    const choices = clues.map(clue => islandShapes(board, clue));
+    const placed = [];
+    let nodes = 0, count = 0, solution = null, stopped = false;
+    const visit = (depth) => {
+        if (count >= limit || stopped)
+            return;
+        nodes += 1;
+        if (nodes > budget) {
+            stopped = true;
+            return;
+        }
+        if (depth === clues.length) {
+            const sea = Array(total).fill(true);
+            for (const island of placed)
+                for (const cell of island)
+                    sea[cell] = false;
+            if (checkNurikabe(board, sea).ok) {
+                count += 1;
+                solution ?? (solution = sea);
+            }
+            return;
+        }
+        let selected = -1, candidates = null;
+        for (let clue = 0; clue < clues.length; clue += 1)
+            if (!placed[clue]) {
+                const available = choices[clue].filter(shape => placed.every(other => !other
+                    || !shape.some(cell => other.some(neighbor => cell === neighbor || nurikabeNeighbors(board.size, cell).includes(neighbor)))));
+                if (!candidates || available.length < candidates.length) {
+                    selected = clue;
+                    candidates = available;
+                }
+            }
+        if (selected < 0 || !candidates?.length)
+            return;
+        for (const shape of candidates) {
+            placed[selected] = shape;
+            visit(depth + 1);
+            delete placed[selected];
+            if (count >= limit || stopped)
+                return;
+        }
+    };
+    visit(0);
+    return { count, solution, complete: !stopped && count < limit, nodes: Math.min(nodes, budget) };
+}