@johnmorrisdotca/kazu 1.1.0 → 1.2.0

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;

package/dist/rippleBoard.js

@@ -0,0 +1,99 @@
+import { RIPPLE_MAX_SIDE, RIPPLE_MIN_SIDE } from "./ripple.constants.js";
+export function isRippleBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!Number.isInteger(board.width) || board.width < RIPPLE_MIN_SIDE || board.width > RIPPLE_MAX_SIDE
+        || !Number.isInteger(board.height) || board.height < RIPPLE_MIN_SIDE || board.height > RIPPLE_MAX_SIDE
+        || !Array.isArray(board.rooms) || !Array.isArray(board.clues)
+        || board.rooms.length !== board.width * board.height || board.clues.length !== board.rooms.length
+        || board.rooms.some(id => !Number.isInteger(id) || id < 0))
+        return false;
+    const members = new Map();
+    board.rooms.forEach((id, cell) => members.set(id, [...(members.get(id) ?? []), cell]));
+    const ids = [...members.keys()].sort((a, b) => a - b);
+    if (ids.some((id, index) => id !== index))
+        return false;
+    const sizes = new Map([...members].map(([id, cells]) => [id, cells.length]));
+    if (board.clues.some((clue, cell) => clue !== null && (!Number.isInteger(clue) || clue < 1 || clue > sizes.get(board.rooms[cell]))))
+        return false;
+    return [...members].every(([id, cells]) => connected(board, id, cells));
+}
+function connected(board, room, cells) {
+    const reached = new Set([cells[0]]);
+    const queue = [cells[0]];
+    while (queue.length) {
+        const cell = queue.pop();
+        for (const next of [cell - board.width, cell + board.width, cell - 1, cell + 1]) {
+            if (next < 0 || next >= board.rooms.length || (Math.abs(next - cell) === 1 && Math.floor(next / board.width) !== Math.floor(cell / board.width)))
+                continue;
+            if (board.rooms[next] === room && !reached.has(next)) {
+                reached.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    return reached.size === cells.length;
+}
+export function rippleRoomSizes(board) {
+    const sizes = [];
+    board.rooms.forEach(id => { sizes[id] = (sizes[id] ?? 0) + 1; });
+    return sizes;
+}
+/** Checks room permutations and the at-least-N-cell gap between equal N clues in a line. */
+export function checkRipple(board, values) {
+    if (!isRippleBoard(board))
+        throw new RangeError("Invalid Ripple Effect board");
+    if (values.length !== board.rooms.length)
+        throw new RangeError("Invalid Ripple Effect values");
+    const errors = new Set();
+    const sizes = rippleRoomSizes(board);
+    const seen = new Map();
+    values.forEach((value, cell) => {
+        const clue = board.clues[cell];
+        if (!Number.isInteger(value) || value < 0 || value > sizes[board.rooms[cell]]
+            || clue !== null && value !== clue) {
+            errors.add(cell);
+            return;
+        }
+        if (value > 0)
+            seen.set(board.rooms[cell], [...(seen.get(board.rooms[cell]) ?? []), value]);
+    });
+    for (const room of seen.keys()) {
+        const cells = values.flatMap((value, cell) => board.rooms[cell] === room && value > 0 ? [value] : []);
+        const duplicates = new Set(cells.filter((value, index) => cells.indexOf(value) !== index));
+        if (duplicates.size)
+            values.forEach((value, cell) => { if (board.rooms[cell] === room && duplicates.has(value))
+                errors.add(cell); });
+    }
+    const lines = [...Array.from({ length: board.height }, (_, y) => Array.from({ length: board.width }, (_, x) => y * board.width + x)),
+        ...Array.from({ length: board.width }, (_, x) => Array.from({ length: board.height }, (_, y) => y * board.width + x))];
+    for (const line of lines)
+        for (let a = 0; a < line.length; a += 1) {
+            const cell = line[a], value = values[cell];
+            if (!value)
+                continue;
+            for (let b = a + 1; b < line.length; b += 1) {
+                const other = line[b];
+                if (values[other] === value && b - a <= value) {
+                    errors.add(cell);
+                    errors.add(other);
+                }
+            }
+        }
+    const complete = values.every(value => value > 0);
+    if (complete) {
+        for (let room = 0; room < sizes.length; room += 1) {
+            const list = values.flatMap((value, cell) => board.rooms[cell] === room ? [value] : []).sort((a, b) => a - b);
+            if (list.some((value, index) => value !== index + 1))
+                board.rooms.forEach((id, cell) => { if (id === room)
+                    errors.add(cell); });
+        }
+    }
+    return { ok: errors.size === 0 && complete, errors: [...errors].sort((a, b) => a - b), complete };
+}
+/** Partial progress check; missing entries are allowed, but impossible room/ripple pairs are flagged. */
+export function progressRipple(board, values) {
+    const result = checkRipple(board, values);
+    return { ...result, ok: result.errors.length === 0 };
+}

package/dist/rippleDraw.d.ts

@@ -0,0 +1,3 @@
+import type { RippleBoard } from "./ripple.types.ts";
+import type { RippleDrawOptions } from "./ripplePlay.types.ts";
+export declare function drawRipple(board: RippleBoard, options?: RippleDrawOptions): string;

package/dist/rippleDraw.js

@@ -0,0 +1,32 @@
+import { rippleRoomSizes } from "./rippleBoard.js";
+export function drawRipple(board, options = {}) {
+    const size = 56, margin = 8, width = board.width * size, height = board.height * size;
+    const ink = options.material === "slate" ? "#f1eee5" : options.material === "wood" ? "#382d20" : "#252824";
+    const line = options.material === "slate" ? "#899697" : options.material === "wood" ? "#80613c" : "#8b8578";
+    const surface = options.material === "slate" ? "#354247" : options.material === "wood" ? "#dfc18f" : "#faf7ef";
+    const values = options.values ?? board.clues.map(clue => clue ?? 0);
+    const notes = options.notes ?? board.rooms.map(() => []);
+    const sizes = rippleRoomSizes(board);
+    const cells = Array.from({ length: board.rooms.length }, (_, cell) => {
+        const x = cell % board.width * size, y = Math.floor(cell / board.width) * size;
+        const room = board.rooms[cell];
+        const clue = board.clues[cell];
+        const value = values[cell] ?? 0;
+        const text = clue !== null ? `<text class="rp-clue" x="${x + size / 2}" y="${y + size * .64}">${clue}</text>`
+            : value ? `<text class="rp-value" x="${x + size / 2}" y="${y + size * .64}">${value}</text>`
+                : (notes[cell] ?? []).map((note, i) => `<text class="rp-note" x="${x + 14 + i % 3 * 14}" y="${y + 18 + Math.floor(i / 3) * 14}">${note}</text>`).join("");
+        const selected = options.selected === cell;
+        const piece = options.pieces === "tiles" ? `<rect class="rp-piece" x="${x + 9}" y="${y + 9}" width="${size - 18}" height="${size - 18}" rx="6"/>` : "";
+        const error = options.errors?.includes(cell) ?? false;
+        return `<rect x="${x}" y="${y}" width="${size}" height="${size}" fill="${selected ? "#dce9c9" : surface}" stroke="${error ? "#c34b3e" : line}" stroke-width="1"/>${piece}${text}<title>${Math.floor(cell / board.width) + 1}, ${cell % board.width + 1}: ${clue !== null ? `clue ${clue}` : value ? `entry ${value}` : `room of ${sizes[room]}`}</title>`;
+    }).join("");
+    const walls = board.rooms.flatMap((room, cell) => {
+        const x = cell % board.width, y = Math.floor(cell / board.width), edges = [];
+        if (x + 1 < board.width && board.rooms[cell + 1] !== room)
+            edges.push(`<path d="M${(x + 1) * size} ${y * size}v${size}"/>`);
+        if (y + 1 < board.height && board.rooms[cell + board.width] !== room)
+            edges.push(`<path d="M${x * size} ${(y + 1) * size}h${size}"/>`);
+        return edges;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-label="Ripple Effect ${board.width} by ${board.height}" viewBox="-${margin} -${margin} ${width + margin * 2} ${height + margin * 2}" style="color:${ink}"><style>.rp-clue,.rp-value{font:500 27px system-ui;text-anchor:middle;fill:${ink}}.rp-clue{font-weight:700}.rp-note{font:12px system-ui;text-anchor:middle;fill:${ink}}.rp-piece{fill:none;stroke:${line};stroke-width:2}</style>${cells}<g fill="none" stroke="${ink}" stroke-width="3">${walls}</g></svg>`;
+}

package/dist/rippleGame.d.ts

@@ -0,0 +1,13 @@
+import type { RippleBoard, RippleGame } from "./ripple.types.ts";
+export declare function newRipple(board: RippleBoard): RippleGame;
+export declare function setRippleValue(game: RippleGame, cell: number, value: number): RippleGame;
+export declare function toggleRippleNote(game: RippleGame, cell: number, value: number): RippleGame;
+export declare function undoRipple(game: RippleGame): RippleGame;
+export declare function rippleFinished(game: RippleGame): boolean;
+/** Offers a cell only when the current public entries leave one proved completion. */
+export declare function hintRipple(game: RippleGame): {
+    cell: number;
+    value: number;
+} | null;
+export declare function encodeRipple(game: RippleGame): string;
+export declare function decodeRipple(code: string): RippleGame | null;

package/dist/rippleGame.js

@@ -0,0 +1,85 @@
+import { isRippleBoard, checkRipple, rippleRoomSizes } from "./rippleBoard.js";
+import { solveRipple } from "./rippleSolve.js";
+export function newRipple(board) {
+    if (!isRippleBoard(board))
+        throw new RangeError("Invalid Ripple Effect board");
+    return { board: { width: board.width, height: board.height, rooms: [...board.rooms], clues: [...board.clues] },
+        values: board.clues.map(clue => clue ?? 0), notes: board.rooms.map(() => []), history: [], helped: false };
+}
+export function setRippleValue(game, cell, value) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.values.length || game.board.clues[cell] !== null
+        || !Number.isInteger(value) || value < 0 || value > rippleRoomSizes(game.board)[game.board.rooms[cell]])
+        return game;
+    if (game.values[cell] === value)
+        return game;
+    const values = [...game.values];
+    values[cell] = value;
+    const notes = game.notes.map((list, index) => index === cell ? [] : [...list]);
+    return { ...game, values, notes, history: [...game.history, snapshot(game)] };
+}
+export function toggleRippleNote(game, cell, value) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.values.length || game.board.clues[cell] !== null || game.values[cell] !== 0
+        || !Number.isInteger(value) || value < 1 || value > rippleRoomSizes(game.board)[game.board.rooms[cell]])
+        return game;
+    const notes = game.notes.map(list => [...list]);
+    const current = new Set(notes[cell]);
+    if (current.has(value))
+        current.delete(value);
+    else
+        current.add(value);
+    notes[cell] = [...current].sort((a, b) => a - b);
+    return { ...game, notes, history: [...game.history, snapshot(game)] };
+}
+export function undoRipple(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, values: [...previous.values], notes: previous.notes.map(list => [...list]), history: game.history.slice(0, -1) } : game;
+}
+export function rippleFinished(game) { return checkRipple(game.board, game.values).ok; }
+/** Offers a cell only when the current public entries leave one proved completion. */
+export function hintRipple(game) {
+    const clues = game.values.map((value, cell) => game.board.clues[cell] ?? (value || null));
+    const solved = solveRipple({ ...game.board, clues });
+    if (!solved.complete || solved.count !== 1 || !solved.solution)
+        return null;
+    const cell = solved.solution.findIndex((value, index) => game.values[index] === 0 && value > 0);
+    return cell < 0 ? null : { cell, value: solved.solution[cell] };
+}
+export function encodeRipple(game) {
+    return JSON.stringify({ version: 1, board: game.board, values: game.values, notes: game.notes, helped: game.helped });
+}
+export function decodeRipple(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const data = JSON.parse(code);
+        if (data.version !== 1 || !isRippleBoard(data.board) || !Array.isArray(data.values)
+            || data.values.length !== data.board.rooms.length || !Array.isArray(data.notes)
+            || data.notes.length !== data.board.rooms.length || typeof data.helped !== "boolean")
+            return null;
+        let game = newRipple(data.board);
+        for (let cell = 0; cell < data.values.length; cell += 1) {
+            const value = data.values[cell];
+            if (game.board.clues[cell] !== null && value !== game.board.clues[cell])
+                return null;
+            if (game.board.clues[cell] === null && value) {
+                const next = setRippleValue(game, cell, value);
+                if (next === game)
+                    return null;
+                game = next;
+            }
+            const list = data.notes[cell];
+            if (!Array.isArray(list) || new Set(list).size !== list.length
+                || list.some(note => !Number.isInteger(note) || note < 1 || note > rippleRoomSizes(game.board)[game.board.rooms[cell]]))
+                return null;
+            for (const note of list)
+                game = toggleRippleNote(game, cell, note);
+        }
+        return { ...game, history: [], helped: data.helped };
+    }
+    catch {
+        return null;
+    }
+}
+function snapshot(game) {
+    return { values: [...game.values], notes: game.notes.map(list => [...list]) };
+}

package/dist/rippleGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { RipplePuzzle } from "./ripple.types.ts";
+/** Builds a seeded block-room family and accepts it only after a bounded uniqueness proof. */
+export declare function generateRipple(width?: number, height?: number, seed?: number): RipplePuzzle;

package/dist/rippleGenerate.js

@@ -0,0 +1,57 @@
+import { RIPPLE_MAX_ATTEMPTS } from "./ripple.constants.js";
+import { checkRipple } from "./rippleBoard.js";
+import { solveRipple } from "./rippleSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** Builds a seeded block-room family and accepts it only after a bounded uniqueness proof. */
+export function generateRipple(width = 9, height = width, seed = 1) {
+    if (width !== 9 || height !== 9 || !isKazuSeed(seed)) {
+        throw new RangeError("Ripple Effect currently supports original 9×9 boards and valid integer seeds.");
+    }
+    const random = seededRandom(seed);
+    for (let attempt = 0; attempt < RIPPLE_MAX_ATTEMPTS; attempt += 1) {
+        const rooms = Array.from({ length: 81 }, (_, cell) => Math.floor(Math.floor(cell / 9) / 3) * 3 + Math.floor(cell % 9 / 3));
+        const solution = blockSolution(random);
+        const clues = [...solution];
+        const order = Array.from({ length: clues.length }, (_, cell) => cell);
+        order.splice(0, order.length, ...shuffled(order, random));
+        const target = 42 + Math.floor(random() * 7);
+        let clueCount = clues.length;
+        for (const cell of order) {
+            if (clueCount <= target)
+                break;
+            const previous = clues[cell];
+            clues[cell] = null;
+            const board = { width, height, rooms, clues };
+            const proof = solveRipple(board, { limit: 2 });
+            if (!proof.complete || proof.count !== 1) {
+                clues[cell] = previous;
+                continue;
+            }
+            clueCount -= 1;
+        }
+        if (clueCount > 58 || clueCount >= clues.length)
+            continue;
+        const board = { width, height, rooms, clues };
+        const proof = solveRipple(board, { limit: 2 });
+        if (proof.complete && proof.count === 1 && proof.solution && checkRipple(board, proof.solution).ok) {
+            return { ...board, seed, solution: proof.solution };
+        }
+    }
+    throw new Error("No uniquely solvable Ripple Effect board was proved within the generation budget.");
+}
+function blockSolution(random) {
+    const bands = shuffled([0, 1, 2], random);
+    const stacks = shuffled([0, 1, 2], random);
+    const rows = bands.flatMap(band => shuffled([0, 1, 2], random).map(row => band * 3 + row));
+    const columns = stacks.flatMap(stack => shuffled([0, 1, 2], random).map(column => stack * 3 + column));
+    const digits = shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9], random);
+    return rows.flatMap(row => columns.map(column => digits[(row * 3 + Math.floor(row / 3) + column) % 9]));
+}
+function shuffled(items, random) {
+    const result = [...items];
+    for (let i = result.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}

package/dist/rippleMount.d.ts

@@ -0,0 +1,2 @@
+import type { RippleMount, RippleMountOptions } from "./ripplePlay.types.ts";
+export declare function mountRipple(host: HTMLElement, initial: RippleMountOptions): RippleMount;