@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/fillominoGenerate.js

@@ -0,0 +1,93 @@
+import { FILLOMINO_LEAST_GENERATED_SIDE, FILLOMINO_LEVELS, FILLOMINO_MOST_ATTEMPTS, FILLOMINO_MOST_SIDE } from "./fillomino.constants.js";
+import { checkFillomino } from "./fillominoBoard.js";
+import { partitionFillomino } from "./fillominoBuild.js";
+import { fillominoModel, fillominoMostValue } from "./fillominoLogic.js";
+import { solveFillomino } from "./fillominoSolve.js";
+import { countCsp, decide, logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+/**
+ * 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 function generateFillomino(width = 5, height = width, level = "medium", seed = 1) {
+    if (![width, height].every(value => Number.isInteger(value) && value >= FILLOMINO_LEAST_GENERATED_SIDE && value <= FILLOMINO_MOST_SIDE)
+        || !FILLOMINO_LEVELS.includes(level) || !isKazuSeed(seed)) {
+        throw new RangeError("Fillomino generation supports 4–12 cells per side and a valid level and seed");
+    }
+    const random = seededRandom(seed);
+    for (let aim = FILLOMINO_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = FILLOMINO_LEVELS[aim];
+        for (let attempt = 0; attempt < FILLOMINO_MOST_ATTEMPTS; attempt += 1) {
+            const solution = partitionFillomino(width, height, aimed, random);
+            if (!solution)
+                continue;
+            const board = thin(width, height, solution, aimed, random);
+            if (!board)
+                continue;
+            const proof = solveFillomino(board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkFillomino(board, proof.solution).ok) {
+                return { ...board, seed, level, solution: proof.solution };
+            }
+        }
+    }
+    const board = { width, height, givens: [] };
+    const answer = partitionFillomino(width, height, "easy", random) ?? Array(width * height).fill(1);
+    return { ...board, givens: [...answer], seed, level, solution: answer };
+}
+/** Takes givens away from a full answer while the level's way of solving still works; null when the result is not the level. */
+function thin(width, height, solution, level, random) {
+    const givens = [...solution];
+    let calls = 0;
+    const model = () => {
+        const { csp: inner, most } = fillominoModel({ width, height, givens }, givens);
+        const csp = { ...inner, propagate: (alive, decided) => { calls += 1; return inner.propagate(alive, decided); } };
+        const start = openSlots(csp);
+        givens.forEach((value, cell) => { if (value)
+            decide(csp, start, cell, cell * most + value - 1); });
+        return { csp, start };
+    };
+    // A region with no given can be as big as the squares with none joined together, which the solver must allow for; keeping
+    // those stretches short keeps every proof short, and keeps the board fair: no vast blank area.
+    const roomy = () => fillominoMostValue({ width, height, givens }, givens) > Math.max(12, Math.max(...solution));
+    const byRules = () => { const { csp, start } = model(); return logicCsp(csp, start, 0).solved; };
+    const unique = () => { const { csp, start } = model(); const count = countCsp(csp, start, 2, 500); return !count.exhausted && count.count === 1; };
+    const bySupposing = () => { const { csp, start } = model(); return logicCsp(csp, start, 1).solved; };
+    const keepAtLeast = level === "easy" ? Math.ceil(solution.length * .5) : 0;
+    let left = givens.length;
+    const order = shuffled(givens.map((_, i) => i), random);
+    // First as many as the rules alone allow.
+    for (const cell of order) {
+        if (left <= keepAtLeast)
+            break;
+        const was = givens[cell];
+        givens[cell] = 0;
+        if (!roomy() && byRules())
+            left -= 1;
+        else
+            givens[cell] = was;
+    }
+    if (level === "easy" || level === "medium")
+        return { width, height, givens };
+    // Then, beyond the rules: hard takes the first given that leaves a board solved by supposing, extra-hard keeps going while the answer stays single.
+    let taken = 0;
+    const from = calls, budget = width * height * 60;
+    for (const cell of order) {
+        if (!givens[cell] || calls - from > budget)
+            continue;
+        const was = givens[cell];
+        givens[cell] = 0;
+        if (!roomy() && unique() && (level === "extra-hard" || bySupposing())) {
+            taken += 1;
+            if (taken >= (level === "hard" ? 3 : 6))
+                break;
+        }
+        else
+            givens[cell] = was;
+    }
+    if (!taken || byRules())
+        return null;
+    return { width, height, givens };
+}

package/dist/fillominoLogic.d.ts

@@ -0,0 +1,14 @@
+import type { Csp } from "./csp.ts";
+import type { FillominoBoard } from "./fillomino.types.ts";
+/** The most any square can be: a region holding a given or an entry is that number, and one with none lies among the squares with neither. */
+export declare function fillominoMostValue(board: FillominoBoard, fixed: readonly number[]): number;
+/**
+ * Fillomino as variables: one per square, a slot for each number it can be (1 up to `most`). A finished group of
+ * equal numbers keeps its neighbours off that number; a group still short must be able to grow, to squares that can
+ * still be that number, until it is the right size, and settles on them when there is exactly room; and a square
+ * can only be a number if the squares that can still be it, joined up, make a group big enough.
+ */
+export declare function fillominoModel(board: FillominoBoard, fixed: readonly number[], most?: number): {
+    csp: Csp;
+    most: number;
+};

package/dist/fillominoLogic.js

@@ -0,0 +1,177 @@
+import { fillominoNeighbours } from "./fillominoBoard.js";
+/** The most any square can be: a region holding a given or an entry is that number, and one with none lies among the squares with neither. */
+export function fillominoMostValue(board, fixed) {
+    let most = 1;
+    for (const value of fixed)
+        if (value > most)
+            most = value;
+    const seen = new Uint8Array(fixed.length);
+    for (let start = 0; start < fixed.length; start += 1) {
+        if (fixed[start] || seen[start])
+            continue;
+        let size = 0;
+        const stack = [start];
+        seen[start] = 1;
+        while (stack.length) {
+            const cell = stack.pop();
+            size += 1;
+            for (const next of fillominoNeighbours(board, cell))
+                if (!fixed[next] && !seen[next]) {
+                    seen[next] = 1;
+                    stack.push(next);
+                }
+        }
+        if (size > most)
+            most = size;
+    }
+    return most;
+}
+/**
+ * Fillomino as variables: one per square, a slot for each number it can be (1 up to `most`). A finished group of
+ * equal numbers keeps its neighbours off that number; a group still short must be able to grow, to squares that can
+ * still be that number, until it is the right size, and settles on them when there is exactly room; and a square
+ * can only be a number if the squares that can still be it, joined up, make a group big enough.
+ */
+export function fillominoModel(board, fixed, most = fillominoMostValue(board, fixed)) {
+    const cells = board.width * board.height, values = most;
+    const nb = new Int32Array(cells * 4).fill(-1);
+    for (let cell = 0; cell < cells; cell += 1)
+        fillominoNeighbours(board, cell).forEach((next, k) => { nb[cell * 4 + k] = next; });
+    const starts = Int32Array.from({ length: cells + 1 }, (_, i) => i * values);
+    const only = new Int32Array(cells), label = new Int32Array(cells), size = new Int32Array(cells + 1), stack = new Int32Array(cells + 1), members = new Int32Array(cells), seen = new Int32Array(cells);
+    const dirty = new Uint8Array(values + 1);
+    let stamp = 0;
+    const propagate = (alive) => {
+        let changed = true;
+        dirty.fill(1);
+        while (changed) {
+            changed = false;
+            for (let cell = 0; cell < cells; cell += 1) {
+                let left = 0, last = 0;
+                const base = cell * values;
+                for (let v = 0; v < values; v += 1)
+                    if (alive[base + v]) {
+                        left += 1;
+                        last = v + 1;
+                    }
+                if (!left)
+                    return false;
+                only[cell] = left === 1 ? last : 0;
+            }
+            // Groups of squares already settled on the same number.
+            label.fill(0);
+            for (let start = 0; start < cells; start += 1) {
+                const v = only[start];
+                if (!v || label[start])
+                    continue;
+                let count = 0, top = 0;
+                stack[top++] = start;
+                label[start] = 1;
+                while (top) {
+                    const cell = stack[--top];
+                    members[count++] = cell;
+                    for (let k = 0; k < 4; k += 1) {
+                        const next = nb[cell * 4 + k];
+                        if (next >= 0 && only[next] === v && !label[next]) {
+                            label[next] = 1;
+                            stack[top++] = next;
+                        }
+                    }
+                }
+                if (count > v)
+                    return false;
+                if (count === v) {
+                    for (let m = 0; m < count; m += 1)
+                        for (let k = 0; k < 4; k += 1) {
+                            const next = nb[members[m] * 4 + k];
+                            if (next >= 0 && only[next] !== v && alive[next * values + v - 1]) {
+                                alive[next * values + v - 1] = 0;
+                                dirty[v] = 1;
+                                changed = true;
+                            }
+                        }
+                    continue;
+                }
+                // Short of its size: grow through squares that can still be v.
+                stamp += 1;
+                let reached = count, frontier = 0, lastFrontier = -1;
+                for (let m = 0; m < count; m += 1)
+                    seen[members[m]] = stamp;
+                for (let at = 0; at < reached; at += 1) {
+                    const cell = members[at];
+                    for (let k = 0; k < 4; k += 1) {
+                        const next = nb[cell * 4 + k];
+                        if (next < 0 || seen[next] === stamp || !alive[next * values + v - 1])
+                            continue;
+                        seen[next] = stamp;
+                        members[reached++] = next;
+                        if (at < count) {
+                            frontier += 1;
+                            lastFrontier = next;
+                        }
+                    }
+                }
+                if (reached < v)
+                    return false;
+                if (reached === v) {
+                    for (let m = 0; m < reached; m += 1) {
+                        const base = members[m] * values;
+                        for (let other = 0; other < values; other += 1)
+                            if (other !== v - 1 && alive[base + other]) {
+                                alive[base + other] = 0;
+                                dirty[other + 1] = 1;
+                                changed = true;
+                            }
+                    }
+                }
+                else if (frontier === 1 && !only[lastFrontier]) {
+                    const base = lastFrontier * values;
+                    for (let other = 0; other < values; other += 1)
+                        if (other !== v - 1 && alive[base + other]) {
+                            alive[base + other] = 0;
+                            dirty[other + 1] = 1;
+                            changed = true;
+                        }
+                }
+            }
+            // A number needs room: the squares that can be it, joined up, must make a group at least that big.
+            for (let v = 2; v <= values; v += 1) {
+                if (!dirty[v])
+                    continue;
+                dirty[v] = 0;
+                label.fill(0);
+                let components = 0;
+                const slot = v - 1;
+                for (let start = 0; start < cells; start += 1) {
+                    if (label[start] || !alive[start * values + slot])
+                        continue;
+                    components += 1;
+                    let count = 0, top = 0;
+                    stack[top++] = start;
+                    label[start] = components;
+                    while (top) {
+                        const cell = stack[--top];
+                        count += 1;
+                        for (let k = 0; k < 4; k += 1) {
+                            const next = nb[cell * 4 + k];
+                            if (next >= 0 && !label[next] && alive[next * values + slot]) {
+                                label[next] = components;
+                                stack[top++] = next;
+                            }
+                        }
+                    }
+                    size[components] = count;
+                }
+                for (let cell = 0; cell < cells; cell += 1) {
+                    if (label[cell] && size[label[cell]] < v) {
+                        alive[cell * values + slot] = 0;
+                        dirty[v] = 1;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts, propagate }, most: values };
+}

package/dist/fillominoMount.d.ts

@@ -0,0 +1,2 @@
+import type { FillominoMount, FillominoMountOptions } from "./fillominoPlay.types.ts";
+export declare function mountFillomino(host: HTMLElement, initial: FillominoMountOptions): FillominoMount;

package/dist/fillominoMount.js

@@ -0,0 +1,214 @@
+import { checkFillomino } from "./fillominoBoard.js";
+import { fillominoMostValue } from "./fillominoLogic.js";
+import { drawFillomino } from "./fillominoDraw.js";
+import { decodeFillomino, encodeFillomino, hintFillomino, newFillomino, restartFillomino, setFillominoCell, undoFillomino } from "./fillominoGame.js";
+import { FILLOMINO_PLAY_STYLE } from "./fillominoStyle.js";
+import { fillominoWords } from "./fillominoStrings.js";
+export function mountFillomino(host, initial) {
+    const document = host.ownerDocument;
+    let options = { ...initial };
+    let game = restoreGame(initial);
+    let selected = null;
+    let errors = [];
+    let message = "";
+    let destroyed = false;
+    let lastFinishState = false;
+    const style = document.createElement("style");
+    style.textContent = FILLOMINO_PLAY_STYLE;
+    const root = document.createElement("div");
+    root.className = "fillomino-play";
+    const status = document.createElement("p");
+    status.className = "fillomino-status";
+    status.setAttribute("role", "status");
+    const board = document.createElement("div");
+    board.className = "fillomino-board";
+    const controls = document.createElement("div");
+    controls.className = "fillomino-controls";
+    root.append(status, board, controls);
+    host.append(style, root);
+    const language = () => options.language ?? "en";
+    const copyGame = (state = game) => ({
+        board: { ...state.board, givens: [...state.board.givens] },
+        entries: [...state.entries],
+        history: state.history.map(entries => [...entries]),
+        helped: state.helped,
+    });
+    const emit = () => {
+        const snapshot = copyGame();
+        options.onChange?.(snapshot);
+        host.dispatchEvent(new document.defaultView.CustomEvent("fillomino-change", { detail: snapshot }));
+    };
+    const button = (label, action, disabled = false) => {
+        const control = document.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.addEventListener("click", action);
+        controls.append(control);
+    };
+    const update = () => {
+        if (destroyed)
+            return;
+        const words = fillominoWords(language());
+        const checked = checkFillomino(game.board, game.entries);
+        status.textContent = message || (checked.ok ? game.helped ? words.helped : words.solved : checked.errors.length ? words.wrong : words.remaining);
+        board.replaceChildren();
+        board.style.setProperty("--fillomino-width", String(game.board.width));
+        board.style.setProperty("--fillomino-height", String(game.board.height));
+        const drawing = document.createElement("div");
+        drawing.className = "fillomino-drawing";
+        drawing.innerHTML = drawFillomino(game.board, {
+            entries: game.entries,
+            selected,
+            errors,
+            material: options.material,
+            pieces: options.pieces,
+            language: language(),
+        });
+        const cells = document.createElement("div");
+        cells.className = "fillomino-cells";
+        cells.setAttribute("role", "grid");
+        cells.setAttribute("aria-label", words.title);
+        for (let cell = 0; cell < game.entries.length; cell += 1) {
+            const x = cell % game.board.width;
+            const y = Math.floor(cell / game.board.width);
+            const given = game.board.givens[cell];
+            const value = game.entries[cell];
+            const control = document.createElement("button");
+            control.type = "button";
+            control.className = "fillomino-cell";
+            control.dataset.cell = String(cell);
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-label", `${words.row} ${y + 1}, ${words.column} ${x + 1}, ${value || words.empty}${value ? `, ${words.filled}` : ""}${given ? `, ${words.clue}` : ""}`);
+            control.setAttribute("aria-pressed", String(selected === cell));
+            control.tabIndex = selected === cell || (selected === null && cell === 0) ? 0 : -1;
+            control.addEventListener("click", () => {
+                selected = cell;
+                message = "";
+                update();
+            });
+            control.addEventListener("keydown", event => moveByKeyboard(event, cell));
+            cells.append(control);
+        }
+        drawing.append(cells);
+        board.append(drawing);
+        controls.replaceChildren();
+        const label = document.createElement("label");
+        label.className = "fillomino-number-label";
+        label.textContent = words.selectNumber;
+        const number = document.createElement("select");
+        number.setAttribute("aria-label", words.selectNumber);
+        number.dataset.number = "true";
+        // Only numbers an answer can hold: more than the biggest given only fits among squares that have no given.
+        const most = Math.max(fillominoMostValue(game.board, game.board.givens), ...game.entries);
+        for (let value = 1; value <= most; value += 1) {
+            const option = document.createElement("option");
+            option.value = String(value);
+            option.textContent = String(value);
+            number.append(option);
+        }
+        label.append(number);
+        controls.append(label);
+        button(words.fill, () => applySelected(Number(number.value)), selected === null || Boolean(game.board.givens[selected]));
+        button(words.clear, () => applySelected(0), selected === null || Boolean(game.board.givens[selected]));
+        button(words.undo, () => {
+            game = undoFillomino(game);
+            errors = [];
+            message = "";
+            emit();
+            update();
+        }, game.history.length === 0);
+        button(words.check, checkBoard);
+        button(words.hint, giveHint);
+        button(words.restart, restart);
+        const nowFinished = checked.ok;
+        if (nowFinished && !lastFinishState)
+            options.onFinish?.(copyGame());
+        lastFinishState = nowFinished;
+    };
+    const applySelected = (value) => {
+        if (selected === null)
+            return;
+        const next = setFillominoCell(game, selected, value);
+        if (next === game)
+            return;
+        game = next;
+        errors = [];
+        message = "";
+        emit();
+        update();
+    };
+    const moveByKeyboard = (event, cell) => {
+        const x = cell % game.board.width;
+        const y = Math.floor(cell / game.board.width);
+        const moves = {
+            ArrowUp: y > 0 ? cell - game.board.width : cell,
+            ArrowDown: y + 1 < game.board.height ? cell + game.board.width : cell,
+            ArrowLeft: x > 0 ? cell - 1 : cell,
+            ArrowRight: x + 1 < game.board.width ? cell + 1 : cell,
+        };
+        if (event.key in moves) {
+            event.preventDefault();
+            selected = moves[event.key];
+            update();
+            board.querySelector(`button[data-cell="${selected}"]`)?.focus();
+            return;
+        }
+        if (/^[1-9]$/.test(event.key)) {
+            event.preventDefault();
+            selected = cell;
+            applySelected(Number(event.key));
+            return;
+        }
+        if (event.key === "Backspace" || event.key === "Delete") {
+            event.preventDefault();
+            selected = cell;
+            applySelected(0);
+        }
+    };
+    const checkBoard = () => {
+        const checked = checkFillomino(game.board, game.entries);
+        errors = checked.errors;
+        message = checked.ok ? game.helped ? fillominoWords(language()).helped : fillominoWords(language()).solved
+            : checked.errors.length ? fillominoWords(language()).wrong : fillominoWords(language()).checked;
+        update();
+    };
+    const giveHint = () => {
+        const hint = hintFillomino(game);
+        if (!hint) {
+            message = fillominoWords(language()).noHint;
+            update();
+            return;
+        }
+        game = setFillominoCell(game, hint.cell, hint.value);
+        game = { ...game, helped: true };
+        selected = hint.cell;
+        errors = [];
+        message = fillominoWords(language()).hintWhy;
+        emit();
+        update();
+    };
+    const restart = () => {
+        game = restartFillomino(game);
+        selected = null;
+        errors = [];
+        message = "";
+        emit();
+        update();
+    };
+    update();
+    return {
+        game: () => copyGame(),
+        progress: () => encodeFillomino(game),
+        set: (next) => { options = { ...options, ...next }; update(); },
+        restart,
+        destroy: () => { destroyed = true; root.remove(); style.remove(); },
+    };
+}
+function restoreGame(source) {
+    const saved = source.progress ? decodeFillomino(source.progress) : null;
+    return saved && saved.board.width === source.board.width && saved.board.height === source.board.height
+        && saved.board.givens.every((given, cell) => given === source.board.givens[cell])
+        ? saved
+        : newFillomino(source.board);
+}

package/dist/fillominoPlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { FillominoBoard, FillominoGame } from "./fillomino.types.ts";
+export type FillominoLanguage = "en" | "ja";
+export type FillominoMaterial = "ivory" | "wood" | "slate";
+export type FillominoPieces = "ink" | "tiles";
+export type FillominoDrawOptions = {
+    entries?: readonly number[];
+    errors?: readonly number[];
+    selected?: number | null;
+    material?: FillominoMaterial;
+    pieces?: FillominoPieces;
+    language?: FillominoLanguage;
+};
+export type FillominoMountOptions = FillominoDrawOptions & {
+    board: FillominoBoard;
+    progress?: string;
+    onChange?: (game: FillominoGame) => void;
+    onFinish?: (game: FillominoGame) => void;
+};
+export type FillominoMount = {
+    game: () => FillominoGame;
+    progress: () => string;
+    set: (options: FillominoDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/fillominoPlay.types.js

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

package/dist/fillominoRate.d.ts

@@ -0,0 +1,3 @@
+import type { FillominoBoard, FillominoRating } from "./fillomino.types.ts";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one number at a time. */
+export declare function rateFillomino(board: FillominoBoard): FillominoRating;

package/dist/fillominoRate.js

@@ -0,0 +1,57 @@
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoModel } from "./fillominoLogic.js";
+import { decide, logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one number at a time. */
+export function rateFillomino(board) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    const { csp, most } = fillominoModel(board, board.givens);
+    const start = openSlots(csp);
+    board.givens.forEach((value, cell) => { if (value)
+        decide(csp, start, cell, cell * most + value - 1); });
+    const proof = solveCsp(csp, start, 2, 200000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Fillomino rating needs a board with one answer");
+    const plain = logicCsp(csp, start, 0);
+    const probing = plain.solved ? plain : logicCsp(csp, start, 1);
+    const answer = Array.from({ length: board.givens.length }, (_, cell) => { for (let v = 0; v < most; v += 1)
+        if (proof.solution[cell * most + v])
+            return v + 1; return 0; });
+    const regions = new Map();
+    const label = Array(answer.length).fill(-1);
+    let count = 0, largest = 0, unnamed = 0;
+    for (let first = 0; first < answer.length; first += 1) {
+        if (label[first] >= 0)
+            continue;
+        const members = [first];
+        label[first] = count;
+        for (let at = 0; at < members.length; at += 1) {
+            const cell = members[at], x = cell % board.width, y = Math.floor(cell / board.width);
+            for (const [nx, ny] of [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]) {
+                if (nx < 0 || ny < 0 || nx >= board.width || ny >= board.height)
+                    continue;
+                const next = ny * board.width + nx;
+                if (label[next] < 0 && answer[next] === answer[first]) {
+                    label[next] = count;
+                    members.push(next);
+                }
+            }
+        }
+        largest = Math.max(largest, members.length);
+        if (!members.some(cell => board.givens[cell]))
+            unnamed += 1;
+        regions.set(String(count), members.length);
+        count += 1;
+    }
+    const givens = board.givens.filter(Boolean).length;
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        givens,
+        givenShare: givens / board.givens.length,
+        regions: count,
+        unnamed,
+        largest,
+        meanRegion: board.givens.length / count,
+    };
+}

package/dist/fillominoSolve.d.ts

@@ -0,0 +1,6 @@
+import type { FillominoBoard, FillominoSolve } from "./fillomino.types.ts";
+/** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
+export declare function solveFillomino(board: FillominoBoard, entries?: readonly number[], options?: {
+    limit?: number;
+    nodes?: number;
+}): FillominoSolve;

package/dist/fillominoSolve.js

@@ -0,0 +1,38 @@
+import { FILLOMINO_MOST_NODES } from "./fillomino.constants.js";
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoModel } from "./fillominoLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
+/** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
+export function solveFillomino(board, entries = board.givens, options = {}) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    const limit = options.limit ?? 2;
+    const budget = options.nodes ?? FILLOMINO_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
+        throw new RangeError("Invalid search bounds");
+    }
+    if (!Array.isArray(entries) || entries.length !== board.givens.length) {
+        throw new RangeError("Invalid Fillomino entries");
+    }
+    const fixed = entries.map((value, cell) => {
+        if (!Number.isInteger(value) || value < 0 || value > entries.length)
+            return -1;
+        if (board.givens[cell] && value !== board.givens[cell])
+            return -1;
+        return value || board.givens[cell];
+    });
+    if (fixed.some(value => value < 0))
+        return { count: 0, solution: null, complete: true, nodes: 0 };
+    const { csp, most } = fillominoModel(board, fixed);
+    const start = openSlots(csp);
+    fixed.forEach((value, cell) => { if (value)
+        decide(csp, start, cell, cell * most + value - 1); });
+    const found = solveCsp(csp, start, limit, budget);
+    const solution = found.solution ? Array.from({ length: fixed.length }, (_, cell) => {
+        for (let v = 0; v < most; v += 1)
+            if (found.solution[cell * most + v])
+                return v + 1;
+        return 0;
+    }) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
+}