@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/akariSolve.js

@@ -0,0 +1,106 @@
+import { AKARI_MOST_NODES } from "./akari.constants.js";
+import { akariNeighbours, akariVisible, checkAkari, isAkariBoard } from "./akariBoard.js";
+/** Bounded binary constraint search; 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 whites = board.cells.flatMap((value, cell) => value === null ? [cell] : []);
+    const visible = whites.map(cell => akariVisible(board, cell));
+    let nodes = 0;
+    let count = 0;
+    let complete = true;
+    let solution = null;
+    const search = (start) => {
+        if (!complete)
+            return;
+        nodes += 1;
+        if (nodes > budget) {
+            complete = false;
+            return;
+        }
+        const assigned = start.slice();
+        let changed = true;
+        while (changed) {
+            changed = false;
+            // A placed bulb rules out every other white square in its four rays.
+            for (let i = 0; i < whites.length; i += 1) {
+                if (assigned[i] !== 1)
+                    continue;
+                for (const cell of visible[i]) {
+                    if (cell === whites[i])
+                        continue;
+                    const other = whites.indexOf(cell);
+                    if (assigned[other] === 1)
+                        return;
+                    if (assigned[other] < 0) {
+                        assigned[other] = 0;
+                        changed = true;
+                    }
+                }
+            }
+            // Numbered black squares provide lower and upper bounds on adjacent bulbs.
+            for (let cell = 0; cell < board.cells.length; cell += 1) {
+                const clue = board.cells[cell];
+                if (typeof clue !== "number")
+                    continue;
+                const nearby = akariNeighbours(board, cell)
+                    .map(neighbour => whites.indexOf(neighbour))
+                    .filter(index => index >= 0);
+                const on = nearby.filter(index => assigned[index] === 1).length;
+                const unknown = nearby.filter(index => assigned[index] < 0);
+                if (on > clue || on + unknown.length < clue)
+                    return;
+                if (on === clue) {
+                    for (const index of unknown) {
+                        assigned[index] = 0;
+                        changed = true;
+                    }
+                }
+                if (on + unknown.length === clue) {
+                    for (const index of unknown) {
+                        assigned[index] = 1;
+                        changed = true;
+                    }
+                }
+            }
+            // Every white cell still needs a possible source of light.
+            for (let i = 0; i < whites.length; i += 1) {
+                const ray = visible[i].map(cell => whites.indexOf(cell));
+                if (ray.some(index => assigned[index] === 1))
+                    continue;
+                const unknown = ray.filter(index => assigned[index] < 0);
+                if (!unknown.length)
+                    return;
+                if (unknown.length === 1) {
+                    assigned[unknown[0]] = 1;
+                    changed = true;
+                }
+            }
+        }
+        const branch = assigned.findIndex(value => value < 0);
+        if (branch < 0) {
+            const bulbs = whites.filter((_, index) => assigned[index] === 1);
+            if (!checkAkari(board, bulbs).ok)
+                return;
+            count += 1;
+            solution ?? (solution = bulbs);
+            if (count >= limit)
+                complete = false;
+            return;
+        }
+        for (const value of [1, 0]) {
+            const next = assigned.slice();
+            next[branch] = value;
+            search(next);
+            if (!complete)
+                return;
+        }
+    };
+    search(new Int8Array(whites.length).fill(-1));
+    return { count, solution, complete, 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/fillomino-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawFillomino } from "./fillominoDraw.ts";
+export type { FillominoDrawOptions } from "./fillominoPlay.types.ts";

package/dist/fillomino-draw-entry.js

@@ -0,0 +1 @@
+export { drawFillomino } from "./fillominoDraw.js";

package/dist/fillomino-entry.d.ts

@@ -0,0 +1,8 @@
+export * from "./fillomino.types.ts";
+export * from "./fillomino.constants.ts";
+export * from "./fillominoBoard.ts";
+export * from "./fillominoSolve.ts";
+export * from "./fillominoGenerate.ts";
+export * from "./fillominoGame.ts";
+export { drawFillomino } from "./fillominoDraw.ts";
+export type { FillominoDrawOptions } from "./fillominoPlay.types.ts";

package/dist/fillomino-entry.js

@@ -0,0 +1,7 @@
+export * from "./fillomino.types.js";
+export * from "./fillomino.constants.js";
+export * from "./fillominoBoard.js";
+export * from "./fillominoSolve.js";
+export * from "./fillominoGenerate.js";
+export * from "./fillominoGame.js";
+export { drawFillomino } from "./fillominoDraw.js";

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

@@ -0,0 +1,4 @@
+export { mountFillomino } from "./fillominoMount.ts";
+export { FILLOMINO_PLAY_STYLE } from "./fillominoStyle.ts";
+export { FILLOMINO_STRINGS } from "./fillominoStrings.ts";
+export type * from "./fillominoPlay.types.ts";

package/dist/fillomino-play-entry.js

@@ -0,0 +1,3 @@
+export { mountFillomino } from "./fillominoMount.js";
+export { FILLOMINO_PLAY_STYLE } from "./fillominoStyle.js";
+export { FILLOMINO_STRINGS } from "./fillominoStrings.js";

package/dist/fillomino.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const FILLOMINO_MOST_SIDE = 12;
+export declare const FILLOMINO_GENERATOR_MOST_CELLS = 36;
+export declare const FILLOMINO_MOST_NODES = 80000;
+export declare const FILLOMINO_MOST_ATTEMPTS = 120;
+export declare const FILLOMINO_LEVELS: readonly ["easy", "medium", "hard"];

package/dist/fillomino.constants.js

@@ -0,0 +1,5 @@
+export const FILLOMINO_MOST_SIDE = 12;
+export const FILLOMINO_GENERATOR_MOST_CELLS = 36;
+export const FILLOMINO_MOST_NODES = 80000;
+export const FILLOMINO_MOST_ATTEMPTS = 120;
+export const FILLOMINO_LEVELS = ["easy", "medium", "hard"];

package/dist/fillomino.types.d.ts

@@ -0,0 +1,30 @@
+export type FillominoBoard = {
+    width: number;
+    height: number;
+    givens: readonly number[];
+};
+export type FillominoPuzzle = FillominoBoard & {
+    seed: number;
+    level: FillominoLevel;
+    solution: readonly number[];
+};
+export type FillominoLevel = "easy" | "medium" | "hard";
+export type FillominoCheck = {
+    ok: boolean;
+    complete: boolean;
+    filled: number;
+    regions: number;
+    errors: readonly number[];
+};
+export type FillominoSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type FillominoGame = {
+    board: FillominoBoard;
+    entries: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};

package/dist/fillomino.types.js

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

package/dist/fillominoBoard.d.ts

@@ -0,0 +1,6 @@
+import type { FillominoBoard, FillominoCheck } from "./fillomino.types.ts";
+export declare function isFillominoBoard(value: unknown): value is FillominoBoard;
+export declare function fillominoNeighbours(board: FillominoBoard, cell: number): number[];
+export declare function fillominoRegions(board: FillominoBoard, entries: readonly number[]): number[][];
+/** Checks region connectivity and area without consulting a generated answer. */
+export declare function checkFillomino(board: FillominoBoard, entries: readonly number[]): FillominoCheck;

package/dist/fillominoBoard.js

@@ -0,0 +1,84 @@
+import { FILLOMINO_MOST_SIDE } from "./fillomino.constants.js";
+export function isFillominoBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    const cells = board.width * board.height;
+    return Number.isInteger(board.width) && board.width >= 2 && board.width <= FILLOMINO_MOST_SIDE
+        && Number.isInteger(board.height) && board.height >= 2 && board.height <= FILLOMINO_MOST_SIDE
+        && Array.isArray(board.givens) && board.givens.length === cells
+        && board.givens.every(value => Number.isInteger(value) && value >= 0 && value <= cells);
+}
+export function fillominoNeighbours(board, cell) {
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const neighbours = [];
+    if (x > 0)
+        neighbours.push(cell - 1);
+    if (x + 1 < board.width)
+        neighbours.push(cell + 1);
+    if (y > 0)
+        neighbours.push(cell - board.width);
+    if (y + 1 < board.height)
+        neighbours.push(cell + board.width);
+    return neighbours;
+}
+export function fillominoRegions(board, entries) {
+    const seen = new Set();
+    const regions = [];
+    for (let start = 0; start < entries.length; start += 1) {
+        if (!entries[start] || seen.has(start))
+            continue;
+        const value = entries[start];
+        const region = [];
+        const pending = [start];
+        seen.add(start);
+        while (pending.length) {
+            const cell = pending.pop();
+            region.push(cell);
+            for (const next of fillominoNeighbours(board, cell)) {
+                if (!seen.has(next) && entries[next] === value) {
+                    seen.add(next);
+                    pending.push(next);
+                }
+            }
+        }
+        regions.push(region);
+    }
+    return regions;
+}
+/** Checks region connectivity and area without consulting a generated answer. */
+export function checkFillomino(board, entries) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    if (!Array.isArray(entries) || entries.length !== board.givens.length)
+        throw new RangeError("Invalid Fillomino entries");
+    const errors = new Set();
+    let filled = 0;
+    entries.forEach((value, cell) => {
+        if (!Number.isInteger(value) || value < 0 || value > entries.length) {
+            errors.add(cell);
+            return;
+        }
+        if (value > 0)
+            filled += 1;
+        if (board.givens[cell] && value !== board.givens[cell])
+            errors.add(cell);
+    });
+    const regions = fillominoRegions(board, entries);
+    for (const region of regions) {
+        const number = entries[region[0]];
+        if (region.length > number)
+            region.forEach(cell => errors.add(cell));
+    }
+    const componentErrors = errors.size > 0;
+    const complete = filled === entries.length;
+    const validAreas = regions.every(region => region.length === entries[region[0]]);
+    return {
+        ok: complete && !componentErrors && validAreas,
+        complete,
+        filled,
+        regions: regions.length,
+        errors: [...errors].sort((a, b) => a - b),
+    };
+}

package/dist/fillominoDraw.d.ts

@@ -0,0 +1,3 @@
+import type { FillominoBoard } from "./fillomino.types.ts";
+import type { FillominoDrawOptions } from "./fillominoPlay.types.ts";
+export declare function drawFillomino(board: FillominoBoard, options?: FillominoDrawOptions): string;

package/dist/fillominoDraw.js

@@ -0,0 +1,31 @@
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoWords } from "./fillominoStrings.js";
+export function drawFillomino(board, options = {}) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    const words = fillominoWords(options.language);
+    const size = 48;
+    const [paper, ink, grid] = {
+        ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"],
+        wood: ["#e5cda6", "#493e2f", "#bca582"],
+        slate: ["#262a27", "#ece8dc", "#454a44"],
+    }[options.material ?? "ivory"];
+    const entries = options.entries ?? board.givens;
+    const markedErrors = new Set(options.errors ?? []);
+    const cells = board.givens.map((given, cell) => {
+        const x = cell % board.width * size;
+        const y = Math.floor(cell / board.width) * size;
+        const value = entries[cell] ?? 0;
+        const active = options.selected === cell;
+        const error = markedErrors.has(cell);
+        const fill = error ? "var(--kz-bad,#b5452c)" : active ? "var(--kz-focus,#d8bd68)" : "transparent";
+        const tile = value && options.pieces === "tiles"
+            ? `<rect x="${x + 10}" y="${y + 10}" width="28" height="28" rx="6" fill="${paper}" stroke="${grid}"/>`
+            : "";
+        const text = value
+            ? `<text x="${x + 24}" y="${y + 25}" dominant-baseline="middle" text-anchor="middle" fill="${ink}" font-size="21" font-weight="${given ? 750 : 500}" font-family="system-ui,sans-serif">${value}</text>`
+            : "";
+        return `<g data-fillomino-cell="${cell}"><rect x="${x}" y="${y}" width="${size}" height="${size}" fill="${fill}" fill-opacity="${active || error ? ".28" : "1"}" stroke="${grid}"/>${tile}${text}</g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${board.width * size + 4} ${board.height * size + 4}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/fillominoGame.d.ts

@@ -0,0 +1,13 @@
+import type { FillominoBoard, FillominoGame } from "./fillomino.types.ts";
+export declare function newFillomino(board: FillominoBoard): FillominoGame;
+export declare function setFillominoCell(game: FillominoGame, cell: number, value: number): FillominoGame;
+export declare function undoFillomino(game: FillominoGame): FillominoGame;
+export declare function hintFillomino(game: FillominoGame): {
+    cell: number;
+    value: number;
+    why: string;
+} | null;
+export declare function fillominoFinished(game: FillominoGame): boolean;
+export declare function restartFillomino(game: FillominoGame): FillominoGame;
+export declare function encodeFillomino(game: FillominoGame): string;
+export declare function decodeFillomino(value: string): FillominoGame | null;

package/dist/fillominoGame.js

@@ -0,0 +1,65 @@
+import { checkFillomino, isFillominoBoard } from "./fillominoBoard.js";
+import { solveFillomino } from "./fillominoSolve.js";
+export function newFillomino(board) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    return {
+        board: { width: board.width, height: board.height, givens: [...board.givens] },
+        entries: [...board.givens],
+        history: [],
+        helped: false,
+    };
+}
+export function setFillominoCell(game, cell, value) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.entries.length
+        || !Number.isInteger(value) || value < 0 || value > game.entries.length
+        || game.board.givens[cell])
+        return game;
+    if (game.entries[cell] === value)
+        return game;
+    const entries = [...game.entries];
+    entries[cell] = value;
+    return { ...game, entries, history: [...game.history, [...game.entries]] };
+}
+export function undoFillomino(game) {
+    const previous = game.history.at(-1);
+    return previous
+        ? { ...game, entries: [...previous], history: game.history.slice(0, -1) }
+        : game;
+}
+export function hintFillomino(game) {
+    const result = solveFillomino(game.board, game.entries);
+    if (!result.complete || result.count !== 1 || !result.solution)
+        return null;
+    const cell = result.solution.findIndex((value, index) => !game.entries[index] && value > 0);
+    return cell < 0 ? null : { cell, value: result.solution[cell], why: "unique-completion" };
+}
+export function fillominoFinished(game) {
+    return checkFillomino(game.board, game.entries).ok;
+}
+export function restartFillomino(game) {
+    return { ...newFillomino(game.board), helped: game.helped };
+}
+export function encodeFillomino(game) {
+    return JSON.stringify({ version: 1, board: game.board, entries: game.entries, helped: game.helped });
+}
+export function decodeFillomino(value) {
+    try {
+        if (value.length > 40000)
+            return null;
+        const parsed = JSON.parse(value);
+        if (parsed.version !== 1 || !isFillominoBoard(parsed.board) || !Array.isArray(parsed.entries)
+            || typeof parsed.helped !== "boolean" || parsed.entries.length !== parsed.board.givens.length) {
+            return null;
+        }
+        const entries = parsed.entries;
+        if (entries.some(entry => !Number.isInteger(entry) || Number(entry) < 0 || Number(entry) > entries.length))
+            return null;
+        if (parsed.board.givens.some((given, cell) => given > 0 && entries[cell] !== given))
+            return null;
+        return { ...newFillomino(parsed.board), entries: [...entries], helped: parsed.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/fillominoGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { FillominoLevel, FillominoPuzzle } from "./fillomino.types.ts";
+/** Makes an original connected-region partition, then keeps only independently proved unique clues. */
+export declare function generateFillomino(width?: number, height?: number, level?: FillominoLevel, seed?: number): FillominoPuzzle;