@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/csp.js

@@ -0,0 +1,162 @@
+/**
+ * ONE SMALL ENGINE for the puzzles that are solved by narrowing down what each square, edge or rectangle can
+ * still be. A puzzle supplies its variables and one function that prunes; this file does the two things
+ * every one of them needs: counting answers (a search that stops at a limit) and rating how hard a puzzle
+ * is (how deep the reasoning must go before the grid is decided).
+ *
+ * A variable has a few slots (its possible values). `alive[slot]` is 1 while that value is still possible.
+ * A variable is decided when exactly one of its slots is alive and impossible when none is.
+ */
+/** How many values a variable still has. */
+export function slotsLeft(csp, alive, variable) {
+    let left = 0;
+    for (let slot = csp.starts[variable]; slot < csp.starts[variable + 1]; slot += 1)
+        left += alive[slot];
+    return left;
+}
+/** Every value of every variable still possible. */
+export function openSlots(csp) {
+    return new Uint8Array(csp.starts[csp.starts.length - 1]).fill(1);
+}
+/** Leaves `variable` with only `slot` (a slot number, not an offset). */
+export function decide(csp, alive, variable, slot) {
+    for (let at = csp.starts[variable]; at < csp.starts[variable + 1]; at += 1)
+        alive[at] = at === slot ? 1 : 0;
+}
+/** The slot a decided variable has left, or -1 when it has more than one or none. */
+export function decidedSlot(csp, alive, variable) {
+    let found = -1;
+    for (let slot = csp.starts[variable]; slot < csp.starts[variable + 1]; slot += 1) {
+        if (!alive[slot])
+            continue;
+        if (found >= 0)
+            return -1;
+        found = slot;
+    }
+    return found;
+}
+/**
+ * Counts the ways to decide every variable, up to `limit`. `exhausted` says the node budget ran out;
+ * `stopped` says the limit was reached. Either way the count must not be read as proof of anything
+ * beyond what was seen.
+ */
+export function countCsp(csp, start, limit, budget) {
+    const variables = csp.starts.length - 1;
+    let count = 0, nodes = 0, exhausted = false, stopped = false;
+    let solution = null;
+    const solutions = [];
+    const visit = (alive, hint) => {
+        if (exhausted || stopped)
+            return;
+        if (++nodes > budget) {
+            exhausted = true;
+            return;
+        }
+        if (!csp.propagate(alive, hint))
+            return;
+        let pick = csp.choose ? csp.choose(alive) : -1, best = 99999;
+        if (!csp.choose) {
+            for (let v = 0; v < variables; v += 1) {
+                const left = slotsLeft(csp, alive, v);
+                if (left > 1 && left < best) {
+                    best = left;
+                    pick = v;
+                    if (left === 2)
+                        break;
+                }
+            }
+        }
+        if (pick < 0) {
+            count += 1;
+            solution ?? (solution = alive.slice());
+            solutions.push(alive.slice());
+            if (count >= limit)
+                stopped = true;
+            return;
+        }
+        for (let slot = csp.starts[pick]; slot < csp.starts[pick + 1]; slot += 1) {
+            if (!alive[slot])
+                continue;
+            const next = alive.slice();
+            decide(csp, next, pick, slot);
+            visit(next, pick);
+            if (exhausted || stopped)
+                return;
+        }
+    };
+    visit(start.slice());
+    return { count, solution, solutions, stopped, exhausted, nodes: Math.min(nodes, budget) };
+}
+/**
+ * Solves by reasoning alone, never by guessing a value and keeping it. `depth` 0 is the rules' own
+ * pruning. Depth 1 adds probing: suppose one value, prune, and when that breaks a rule the value is
+ * ruled out. Depth 2 lets a probe probe. `probes` counts the values ruled out by supposing, which is how
+ * much supposing the puzzle asks of a person.
+ */
+export function logicCsp(csp, start, depth) {
+    const variables = csp.starts.length - 1;
+    let probes = 0;
+    const decidedAll = (alive) => {
+        for (let v = 0; v < variables; v += 1)
+            if (slotsLeft(csp, alive, v) > 1)
+                return false;
+        return true;
+    };
+    const run = (alive, level, hint) => {
+        let first = hint;
+        for (;;) {
+            if (!csp.propagate(alive, first))
+                return false;
+            first = undefined;
+            let open = false;
+            for (let v = 0; v < variables && !open; v += 1)
+                if (slotsLeft(csp, alive, v) > 1)
+                    open = true;
+            if (!open)
+                return "solved";
+            if (level === 0)
+                return "stuck";
+            let moved = false;
+            for (let v = 0; v < variables; v += 1) {
+                if (slotsLeft(csp, alive, v) < 2)
+                    continue;
+                for (let slot = csp.starts[v]; slot < csp.starts[v + 1]; slot += 1) {
+                    if (!alive[slot] || slotsLeft(csp, alive, v) < 2)
+                        continue;
+                    const trial = alive.slice();
+                    decide(csp, trial, v, slot);
+                    const result = run(trial, level - 1, v);
+                    if (result === false) {
+                        alive[slot] = 0;
+                        probes += 1;
+                        moved = true;
+                        if (!csp.propagate(alive))
+                            return false;
+                        if (decidedAll(alive))
+                            return "solved";
+                    }
+                }
+            }
+            if (!moved)
+                return "stuck";
+        }
+    };
+    const alive = start.slice();
+    const result = run(alive, depth);
+    return { solved: result === "solved", contradiction: result === false, probes, alive };
+}
+/**
+ * Counts answers like `countCsp`, but first tries to settle the puzzle by reasoning (rules, then one level of
+ * supposing): reasoning that leaves every variable decided proves exactly one answer, and reasoning that breaks a
+ * rule proves none, in far fewer steps than a search. Only a puzzle that reasoning leaves open is searched, from the
+ * state reasoning reached.
+ */
+export function solveCsp(csp, start, limit, budget, depth = 1) {
+    const plain = logicCsp(csp, start, 0);
+    const reasoned = plain.solved || plain.contradiction || depth < 1 ? plain : logicCsp(csp, start, 1);
+    if (reasoned.contradiction)
+        return { count: 0, solution: null, solutions: [], stopped: false, exhausted: false, nodes: 0 };
+    if (reasoned.solved)
+        return { count: 1, solution: reasoned.alive, solutions: [reasoned.alive], stopped: limit <= 1, exhausted: false, nodes: 0 };
+    return countCsp(csp, reasoned.alive, limit, budget);
+}

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,9 @@
+export * from "./fillomino.types.ts";
+export * from "./fillomino.constants.ts";
+export * from "./fillominoBoard.ts";
+export * from "./fillominoSolve.ts";
+export * from "./fillominoGenerate.ts";
+export * from "./fillominoRate.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,8 @@
+export * from "./fillomino.types.js";
+export * from "./fillomino.constants.js";
+export * from "./fillominoBoard.js";
+export * from "./fillominoSolve.js";
+export * from "./fillominoGenerate.js";
+export * from "./fillominoRate.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,9 @@
+export declare const FILLOMINO_MOST_SIDE = 12;
+export declare const FILLOMINO_GENERATOR_MOST_CELLS = 144;
+export declare const FILLOMINO_MOST_NODES = 80000;
+export declare const FILLOMINO_MOST_ATTEMPTS = 120;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateFillomino`. */
+export declare const FILLOMINO_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 4 to `FILLOMINO_MOST_SIDE` can be made. */
+export declare const FILLOMINO_SIZES: readonly [6, 8, 10, 12];
+export declare const FILLOMINO_LEAST_GENERATED_SIDE = 4;

package/dist/fillomino.constants.js

@@ -0,0 +1,9 @@
+export const FILLOMINO_MOST_SIDE = 12;
+export const FILLOMINO_GENERATOR_MOST_CELLS = 144;
+export const FILLOMINO_MOST_NODES = 80000;
+export const FILLOMINO_MOST_ATTEMPTS = 120;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateFillomino`. */
+export const FILLOMINO_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 4 to `FILLOMINO_MOST_SIDE` can be made. */
+export const FILLOMINO_SIZES = [6, 8, 10, 12];
+export const FILLOMINO_LEAST_GENERATED_SIDE = 4;

package/dist/fillomino.types.d.ts

@@ -0,0 +1,47 @@
+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" | "extra-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;
+};
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the rules solve it, 1 that somebody has to suppose a
+ * number in a square and watch it break, 2 that more than that is needed; `probes` is how many suppositions depth 1
+ * needed. The rest describes the board.
+ */
+export type FillominoRating = {
+    depth: 0 | 1 | 2;
+    probes: number;
+    givens: number;
+    /** Squares that are given, as a share of the board. */
+    givenShare: number;
+    regions: number;
+    /** Regions with no given in them: they are found only by what is round them. */
+    unnamed: number;
+    largest: number;
+    meanRegion: number;
+};

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/fillominoBuild.d.ts

@@ -0,0 +1,10 @@
+import type { FillominoLevel } from "./fillomino.types.ts";
+import type { Random } from "./random.ts";
+/** How likely each region size is, by level: a small board of small regions is easy, long ones with few givens are not. */
+export declare const FILLOMINO_SIZES_BY_LEVEL: Record<FillominoLevel, readonly number[]>;
+/**
+ * A full Fillomino answer: the board cut into connected regions, every region holding its own size, and no two
+ * regions of the same size touching. Regions are grown one at a time from the square with the fewest free neighbours;
+ * null when a corner of the board cannot be finished, so the caller tries again.
+ */
+export declare function partitionFillomino(width: number, height: number, level: FillominoLevel, random: Random): number[] | null;

package/dist/fillominoBuild.js

@@ -0,0 +1,78 @@
+import { fillominoNeighbours } from "./fillominoBoard.js";
+import { shuffled } from "./random.js";
+/** How likely each region size is, by level: a small board of small regions is easy, long ones with few givens are not. */
+export const FILLOMINO_SIZES_BY_LEVEL = {
+    easy: [1, 2, 2, 2, 3, 3, 3, 4, 4],
+    medium: [1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6],
+    hard: [2, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 8],
+    "extra-hard": [2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 8, 8, 9],
+};
+/**
+ * A full Fillomino answer: the board cut into connected regions, every region holding its own size, and no two
+ * regions of the same size touching. Regions are grown one at a time from the square with the fewest free neighbours;
+ * null when a corner of the board cannot be finished, so the caller tries again.
+ */
+export function partitionFillomino(width, height, level, random) {
+    const board = { width, height, givens: Array(width * height).fill(0) };
+    const entries = Array(width * height).fill(0);
+    const sizes = FILLOMINO_SIZES_BY_LEVEL[level];
+    for (let guard = 0; guard < width * height; guard += 1) {
+        let anchor = -1, fewest = 9, ties = 0;
+        for (let cell = 0; cell < entries.length; cell += 1) {
+            if (entries[cell])
+                continue;
+            const free = fillominoNeighbours(board, cell).filter(next => !entries[next]).length;
+            if (free < fewest) {
+                fewest = free;
+                anchor = cell;
+                ties = 1;
+            }
+            else if (free === fewest && random() * ++ties < 1)
+                anchor = cell;
+        }
+        if (anchor < 0)
+            return entries;
+        const left = entries.filter(value => !value).length;
+        let done = false;
+        const tried = new Set();
+        // Sizes come in the order of a shuffle of the weighted list, so common sizes are tried first more often.
+        for (const area of shuffled(sizes, random)) {
+            if (tried.has(area) || area > left)
+                continue;
+            tried.add(area);
+            if (fillominoNeighbours(board, anchor).some(next => entries[next] === area))
+                continue;
+            for (let proposal = 0; proposal < 6 && !done; proposal += 1) {
+                const cells = [anchor], members = new Set(cells);
+                while (cells.length < area) {
+                    const frontier = new Set();
+                    for (const cell of cells)
+                        for (const next of fillominoNeighbours(board, cell)) {
+                            if (entries[next] || members.has(next))
+                                continue;
+                            if (fillominoNeighbours(board, next).some(other => entries[other] === area))
+                                continue;
+                            frontier.add(next);
+                        }
+                    if (!frontier.size)
+                        break;
+                    // Prefer squares that are hard to reach later: those with few free neighbours.
+                    const options = [...frontier].sort((a, b) => fillominoNeighbours(board, a).filter(n => !entries[n] && !members.has(n)).length - fillominoNeighbours(board, b).filter(n => !entries[n] && !members.has(n)).length);
+                    const pick = random() < .55 ? options[0] : options[Math.floor(random() * options.length)];
+                    cells.push(pick);
+                    members.add(pick);
+                }
+                if (cells.length !== area)
+                    continue;
+                for (const cell of cells)
+                    entries[cell] = area;
+                done = true;
+            }
+            if (done)
+                break;
+        }
+        if (!done)
+            return null;
+    }
+    return null;
+}

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,9 @@
+import type { FillominoLevel, FillominoPuzzle } from "./fillomino.types.ts";
+/**
+ * Makes a seeded puzzle and proves its answer is the only one. The board is cut into connected regions, each holding
+ * its own size, with no two of one size touching; every square starts given, and givens are taken away for as long as
+ * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most givens),
+ * hard by supposing one number at a time, extra-hard for as long as the answer stays single. If no board of the level
+ * is found within the attempts the next level down is tried, and a puzzle that gives every square is the last resort.
+ */
+export declare function generateFillomino(width?: number, height?: number, level?: FillominoLevel, seed?: number): FillominoPuzzle;