@johnmorrisdotca/kazu 1.2.0 → 1.4.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-entry.d.ts

@@ -3,6 +3,7 @@ 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

@@ -3,5 +3,6 @@ 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.constants.d.ts

@@ -1,5 +1,9 @@
 export declare const FILLOMINO_MOST_SIDE = 12;
-export declare const FILLOMINO_GENERATOR_MOST_CELLS = 36;
+export declare const FILLOMINO_GENERATOR_MOST_CELLS = 144;
 export declare const FILLOMINO_MOST_NODES = 80000;
 export declare const FILLOMINO_MOST_ATTEMPTS = 120;
-export declare const FILLOMINO_LEVELS: readonly ["easy", "medium", "hard"];
+/** 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

@@ -1,5 +1,9 @@
 export const FILLOMINO_MOST_SIDE = 12;
-export const FILLOMINO_GENERATOR_MOST_CELLS = 36;
+export const FILLOMINO_GENERATOR_MOST_CELLS = 144;
 export const FILLOMINO_MOST_NODES = 80000;
 export const FILLOMINO_MOST_ATTEMPTS = 120;
-export const FILLOMINO_LEVELS = ["easy", "medium", "hard"];
+/** 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

@@ -8,7 +8,7 @@ export type FillominoPuzzle = FillominoBoard & {
     level: FillominoLevel;
     solution: readonly number[];
 };
-export type FillominoLevel = "easy" | "medium" | "hard";
+export type FillominoLevel = "easy" | "medium" | "hard" | "extra-hard";
 export type FillominoCheck = {
     ok: boolean;
     complete: boolean;
@@ -28,3 +28,20 @@ export type FillominoGame = {
     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/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/fillominoGenerate.d.ts

@@ -1,3 +1,9 @@
 import type { FillominoLevel, FillominoPuzzle } from "./fillomino.types.ts";
-/** Makes an original connected-region partition, then keeps only independently proved unique clues. */
+/**
+ * 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;

package/dist/fillominoGenerate.js

@@ -1,125 +1,93 @@
-import { FILLOMINO_GENERATOR_MOST_CELLS, FILLOMINO_LEVELS, FILLOMINO_MOST_ATTEMPTS } from "./fillomino.constants.js";
-import { checkFillomino, fillominoNeighbours } from "./fillominoBoard.js";
+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 an original connected-region partition, then keeps only independently proved unique clues. */
+/**
+ * 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 >= 4 && value <= 8) || width * height > FILLOMINO_GENERATOR_MOST_CELLS
+    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–8 cells per side and a valid level and seed");
+        throw new RangeError("Fillomino generation supports 4–12 cells per side and a valid level and seed");
     }
     const random = seededRandom(seed);
-    for (let attempt = 0; attempt < FILLOMINO_MOST_ATTEMPTS; attempt += 1) {
-        const solution = partitionBoard(width, height, level, random);
-        if (!solution)
-            continue;
-        const regions = regionCells(width, height, solution);
-        if (regions.length >= width * height * 0.34)
-            continue;
-        const givens = Array(width * height).fill(0);
-        const extraClues = [];
-        for (const region of regions) {
-            const choices = shuffled(region, random);
-            const count = level === "easy" && region.length > 1 ? 2 : level === "hard" && random() < 0.2 ? 0 : 1;
-            for (const cell of choices.slice(0, count))
-                givens[cell] = solution[cell];
-            extraClues.push(...choices.slice(count));
-        }
-        const clueOrder = shuffled(extraClues, random);
-        const board = { width, height, givens };
-        const maximumGivens = Math.floor(width * height * ({ easy: 0.9, medium: 0.72, hard: 0.62 }[level]));
-        for (let added = 0;; added += 1) {
-            const proof = solveFillomino(board, givens);
+    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 };
             }
-            if (added >= clueOrder.length || givens.filter(Boolean).length >= maximumGivens)
-                break;
-            const cell = clueOrder[added];
-            givens[cell] = solution[cell];
         }
     }
-    throw new Error("No unique Fillomino found within the generation budget; try another seed or smaller board");
+    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 };
 }
-function partitionBoard(width, height, level, random) {
-    const board = { width, height, givens: Array(width * height).fill(0) };
-    const entries = Array(width * height).fill(0);
-    const maxArea = { easy: 4, medium: 6, hard: 8 }[level];
-    let trials = 0;
-    const visit = () => {
-        if (++trials > 12000)
-            return false;
-        const anchor = entries.findIndex(value => value === 0);
-        if (anchor < 0)
-            return true;
-        const remaining = entries.filter(value => value === 0).length;
-        const preferred = Array.from({ length: Math.min(maxArea, remaining) }, (_, index) => index + 1);
-        const sizes = shuffled(preferred, random).sort((left, right) => right - left);
-        for (const area of sizes) {
-            for (let proposal = 0; proposal < 5; proposal += 1) {
-                if (fillominoNeighbours(board, anchor).some(cell => entries[cell] === area))
-                    continue;
-                const shape = growShape(board, anchor, area, entries, random);
-                if (!shape)
-                    continue;
-                for (const cell of shape)
-                    entries[cell] = area;
-                if (visit())
-                    return true;
-                for (const cell of shape)
-                    entries[cell] = 0;
-            }
-        }
-        return false;
+/** 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 };
     };
-    const result = visit() ? [...entries] : null;
-    return result && checkFillomino(board, result).ok ? result : null;
-}
-function growShape(board, anchor, area, entries, random) {
-    const cells = [anchor];
-    const 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] !== 0 || members.has(next))
-                    continue;
-                if (fillominoNeighbours(board, next).some(adjacent => entries[adjacent] === area))
-                    continue;
-                frontier.add(next);
-            }
-        }
-        const choices = [...frontier];
-        if (!choices.length)
-            return null;
-        const next = choices[Math.floor(random() * choices.length)];
-        cells.push(next);
-        members.add(next);
+    // 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;
     }
-    return cells;
-}
-function regionCells(width, height, entries) {
-    const board = { width, height, givens: Array(width * height).fill(0) };
-    const visited = new Set();
-    const regions = [];
-    for (let start = 0; start < entries.length; start += 1) {
-        if (visited.has(start))
+    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 value = entries[start];
-        const region = [];
-        const pending = [start];
-        visited.add(start);
-        while (pending.length) {
-            const cell = pending.pop();
-            region.push(cell);
-            for (const next of fillominoNeighbours(board, cell)) {
-                if (!visited.has(next) && entries[next] === value) {
-                    visited.add(next);
-                    pending.push(next);
-                }
-            }
+        const was = givens[cell];
+        givens[cell] = 0;
+        if (!roomy() && unique() && (level === "extra-hard" || bySupposing())) {
+            taken += 1;
+            if (taken >= (level === "hard" ? 3 : 6))
+                break;
         }
-        regions.push(region);
+        else
+            givens[cell] = was;
     }
-    return regions;
+    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;
+};