@johnmorrisdotca/kazu 1.1.0 → 1.3.0

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) };
+}

package/dist/nurikabeStrings.d.ts

@@ -0,0 +1,70 @@
+import type { NurikabeLanguage } from "./nurikabePlay.types.ts";
+export declare const NURIKABE_STRINGS: {
+    readonly en: {
+        readonly title: "Nurikabe";
+        readonly help: "Shade cells to build one connected wall. Black cells cannot form a 2×2 square. Each remaining white region contains one number and has that exact area. Tap or press Space to shade; arrows move.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly won: "Solved!";
+        readonly helped: "Solved with help.";
+        readonly wrong: "Some rules are broken.";
+        readonly good: "No rule errors yet. Keep going.";
+        readonly noHint: "No proved hint is available.";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly sea: "sea";
+        readonly white: "island";
+    };
+    readonly ja: {
+        readonly title: "ぬりかべ";
+        readonly help: "黒マスをつなげて一つの壁にします。黒マスで2×2の四角形を作れません。白い島には数字が一つだけあり、島の面積はその数字と同じです。マスを押すかスペースで黒くし、矢印キーで移動します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly won: "完成！";
+        readonly helped: "ヒントを使って完成。";
+        readonly wrong: "ルールに合わないところがあります。";
+        readonly good: "今のところルール違反はありません。";
+        readonly noHint: "確かなヒントはありません。";
+        readonly row: "行";
+        readonly column: "列";
+        readonly sea: "海";
+        readonly white: "島";
+    };
+};
+export declare function nurikabeWords(language?: NurikabeLanguage): {
+    readonly title: "Nurikabe";
+    readonly help: "Shade cells to build one connected wall. Black cells cannot form a 2×2 square. Each remaining white region contains one number and has that exact area. Tap or press Space to shade; arrows move.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly won: "Solved!";
+    readonly helped: "Solved with help.";
+    readonly wrong: "Some rules are broken.";
+    readonly good: "No rule errors yet. Keep going.";
+    readonly noHint: "No proved hint is available.";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly sea: "sea";
+    readonly white: "island";
+} | {
+    readonly title: "ぬりかべ";
+    readonly help: "黒マスをつなげて一つの壁にします。黒マスで2×2の四角形を作れません。白い島には数字が一つだけあり、島の面積はその数字と同じです。マスを押すかスペースで黒くし、矢印キーで移動します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確認";
+    readonly restart: "やり直す";
+    readonly won: "完成！";
+    readonly helped: "ヒントを使って完成。";
+    readonly wrong: "ルールに合わないところがあります。";
+    readonly good: "今のところルール違反はありません。";
+    readonly noHint: "確かなヒントはありません。";
+    readonly row: "行";
+    readonly column: "列";
+    readonly sea: "海";
+    readonly white: "島";
+};

package/dist/nurikabeStrings.js

@@ -0,0 +1,5 @@
+export const NURIKABE_STRINGS = {
+    en: { title: "Nurikabe", help: "Shade cells to build one connected wall. Black cells cannot form a 2×2 square. Each remaining white region contains one number and has that exact area. Tap or press Space to shade; arrows move.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", won: "Solved!", helped: "Solved with help.", wrong: "Some rules are broken.", good: "No rule errors yet. Keep going.", noHint: "No proved hint is available.", row: "Row", column: "column", sea: "sea", white: "island" },
+    ja: { title: "ぬりかべ", help: "黒マスをつなげて一つの壁にします。黒マスで2×2の四角形を作れません。白い島には数字が一つだけあり、島の面積はその数字と同じです。マスを押すかスペースで黒くし、矢印キーで移動します。", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", won: "完成！", helped: "ヒントを使って完成。", wrong: "ルールに合わないところがあります。", good: "今のところルール違反はありません。", noHint: "確かなヒントはありません。", row: "行", column: "列", sea: "海", white: "島" },
+};
+export function nurikabeWords(language = "en") { return NURIKABE_STRINGS[language]; }

package/dist/nurikabeStyle.d.ts

@@ -0,0 +1 @@
+export declare const NURIKABE_PLAY_STYLE = "\n.kn-root{font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto;color:var(--ks-ink,#1f2320)}\n.kn-board{position:relative;width:100%;touch-action:manipulation}\n.kn-cells{position:absolute;inset:0;display:grid;padding:2px}\n.kn-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;cursor:pointer;touch-action:manipulation}\n.kn-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px}\n.kn-tools{display:flex;gap:8px;flex-wrap:wrap;margin:16px 0}\n.kn-tools button{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:inherit;cursor:pointer}\n.kn-tools button:disabled{opacity:.45}.kn-status{min-height:1.5em}.kn-help{font-size:14px;opacity:.8}";

package/dist/nurikabeStyle.js

@@ -0,0 +1,9 @@
+export const NURIKABE_PLAY_STYLE = `
+.kn-root{font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto;color:var(--ks-ink,#1f2320)}
+.kn-board{position:relative;width:100%;touch-action:manipulation}
+.kn-cells{position:absolute;inset:0;display:grid;padding:2px}
+.kn-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;cursor:pointer;touch-action:manipulation}
+.kn-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px}
+.kn-tools{display:flex;gap:8px;flex-wrap:wrap;margin:16px 0}
+.kn-tools button{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:inherit;cursor:pointer}
+.kn-tools button:disabled{opacity:.45}.kn-status{min-height:1.5em}.kn-help{font-size:14px;opacity:.8}`;

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

@@ -0,0 +1,2 @@
+export { drawRipple } from "./rippleDraw.ts";
+export type { RippleDrawOptions } from "./ripplePlay.types.ts";

package/dist/ripple-draw-entry.js

@@ -0,0 +1 @@
+export { drawRipple } from "./rippleDraw.js";

package/dist/ripple-entry.d.ts

@@ -0,0 +1,12 @@
+/** Ripple Effect has its own room and spacing model. */
+export * from "./ripple.types.ts";
+export * from "./ripple.constants.ts";
+export * from "./rippleBoard.ts";
+export * from "./rippleSolve.ts";
+export * from "./rippleGenerate.ts";
+export * from "./rippleGame.ts";
+export { drawRipple } from "./rippleDraw.ts";
+export { mountRipple } from "./rippleMount.ts";
+export { RIPPLE_PLAY_STYLE } from "./rippleStyle.ts";
+export { RIPPLE_STRINGS } from "./rippleStrings.ts";
+export type * from "./ripplePlay.types.ts";

package/dist/ripple-entry.js

@@ -0,0 +1,11 @@
+/** Ripple Effect has its own room and spacing model. */
+export * from "./ripple.types.js";
+export * from "./ripple.constants.js";
+export * from "./rippleBoard.js";
+export * from "./rippleSolve.js";
+export * from "./rippleGenerate.js";
+export * from "./rippleGame.js";
+export { drawRipple } from "./rippleDraw.js";
+export { mountRipple } from "./rippleMount.js";
+export { RIPPLE_PLAY_STYLE } from "./rippleStyle.js";
+export { RIPPLE_STRINGS } from "./rippleStrings.js";

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

@@ -0,0 +1,4 @@
+export { mountRipple } from "./rippleMount.ts";
+export { RIPPLE_PLAY_STYLE } from "./rippleStyle.ts";
+export { RIPPLE_STRINGS } from "./rippleStrings.ts";
+export type * from "./ripplePlay.types.ts";

package/dist/ripple-play-entry.js

@@ -0,0 +1,3 @@
+export { mountRipple } from "./rippleMount.js";
+export { RIPPLE_PLAY_STYLE } from "./rippleStyle.js";
+export { RIPPLE_STRINGS } from "./rippleStrings.js";

package/dist/ripple.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const RIPPLE_MIN_SIDE = 9;
+export declare const RIPPLE_MAX_SIDE = 9;
+export declare const RIPPLE_MAX_NODES = 250000;
+export declare const RIPPLE_MAX_ATTEMPTS = 80;

package/dist/ripple.constants.js

@@ -0,0 +1,4 @@
+export const RIPPLE_MIN_SIDE = 9;
+export const RIPPLE_MAX_SIDE = 9;
+export const RIPPLE_MAX_NODES = 250000;
+export const RIPPLE_MAX_ATTEMPTS = 80;

package/dist/ripple.types.d.ts

@@ -0,0 +1,34 @@
+export type RippleBoard = {
+    width: number;
+    height: number;
+    rooms: readonly number[];
+    clues: readonly (number | null)[];
+};
+export type RipplePuzzle = RippleBoard & {
+    seed: number;
+    solution: readonly number[];
+};
+export type RippleCheck = {
+    ok: boolean;
+    errors: readonly number[];
+    complete: boolean;
+};
+export type RippleSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type RippleGame = {
+    board: RippleBoard;
+    values: readonly number[];
+    notes: readonly (readonly number[])[];
+    history: readonly {
+        values: readonly number[];
+        notes: readonly (readonly number[])[];
+    }[];
+    helped: boolean;
+};
+export type RippleLanguage = "en" | "ja";
+export type RippleMaterial = "ivory" | "wood" | "slate";
+export type RipplePieces = "ink" | "tiles";

package/dist/ripple.types.js

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

package/dist/rippleBoard.d.ts

@@ -0,0 +1,7 @@
+import type { RippleBoard, RippleCheck } from "./ripple.types.ts";
+export declare function isRippleBoard(value: unknown): value is RippleBoard;
+export declare function rippleRoomSizes(board: RippleBoard): number[];
+/** Checks room permutations and the at-least-N-cell gap between equal N clues in a line. */
+export declare function checkRipple(board: RippleBoard, values: readonly number[]): RippleCheck;
+/** Partial progress check; missing entries are allowed, but impossible room/ripple pairs are flagged. */
+export declare function progressRipple(board: RippleBoard, values: readonly number[]): RippleCheck;