@johnmorrisdotca/kazu 1.2.0 → 1.3.0

package/dist/akariLogic.js

@@ -0,0 +1,84 @@
+import { akariNeighbours, akariVisible } from "./akariBoard.js";
+/** Builds the pruning rules of Akari: a bulb shades its lines, a number counts its neighbours, every white square needs a lamp. */
+export function akariModel(board) {
+    const whites = board.cells.flatMap((value, cell) => value === null ? [cell] : []);
+    const index = new Int32Array(board.cells.length).fill(-1);
+    whites.forEach((cell, i) => { index[cell] = i; });
+    const sees = whites.map(cell => Int32Array.from(akariVisible(board, cell).filter(other => other !== cell).map(other => index[other])));
+    const clues = board.cells.flatMap((value, cell) => typeof value === "number"
+        ? [{ need: value, near: Int32Array.from(akariNeighbours(board, cell).filter(other => index[other] >= 0).map(other => index[other])) }]
+        : []);
+    const starts = Int32Array.from({ length: whites.length + 1 }, (_, i) => i * 2);
+    const propagate = (alive) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let i = 0; i < whites.length; i += 1) {
+                if (!alive[2 * i] && !alive[2 * i + 1])
+                    return false;
+                if (alive[2 * i] || !alive[2 * i + 1])
+                    continue;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        alive[2 * j + 1] = 0;
+                        changed = true;
+                        if (!alive[2 * j])
+                            return false;
+                    }
+                }
+            }
+            for (const clue of clues) {
+                let on = 0, maybe = 0;
+                for (let k = 0; k < clue.near.length; k += 1) {
+                    const j = clue.near[k];
+                    if (alive[2 * j + 1]) {
+                        maybe += 1;
+                        if (!alive[2 * j])
+                            on += 1;
+                    }
+                }
+                if (on > clue.need || maybe < clue.need)
+                    return false;
+                if (on === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j + 1] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+                else if (maybe === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < whites.length; i += 1) {
+                let lamps = alive[2 * i + 1] ? 1 : 0, only = alive[2 * i + 1] ? i : -1;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length && lamps < 2; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        lamps += 1;
+                        only = j;
+                    }
+                }
+                if (lamps === 0)
+                    return false;
+                if (lamps === 1 && alive[2 * only]) {
+                    alive[2 * only] = 0;
+                    changed = true;
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts, propagate }, whites, index };
+}

package/dist/akariRate.d.ts

@@ -0,0 +1,6 @@
+import type { AkariBoard, AkariRating } from "./akari.types.ts";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export declare function rateAkari(board: AkariBoard): AkariRating;

package/dist/akariRate.js

@@ -0,0 +1,34 @@
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/**
+ * Rates a board by solving it as a person would: with the rules alone (depth 0), then with one supposition at
+ * a time (depth 1), and anything beyond that is depth 2. A board with no single answer cannot be rated.
+ */
+export function rateAkari(board) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const { csp, whites } = akariModel(board);
+    const proof = solveCsp(csp, openSlots(csp), 2, 250000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Akari rating needs a board with one answer");
+    const plain = logicCsp(csp, openSlots(csp), 0);
+    const probing = plain.solved ? plain : logicCsp(csp, openSlots(csp), 1);
+    const blacks = board.cells.length - whites.length;
+    const clues = board.cells.filter(cell => typeof cell === "number").length;
+    const lit = board.cells.map((cell, at) => cell === false || typeof cell === "number" ? at : -1).filter(at => at >= 0);
+    const touching = lit.filter(at => {
+        const x = at % board.width, y = Math.floor(at / board.width);
+        return [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]].some(([nx, ny]) => nx >= 0 && ny >= 0 && nx < board.width && ny < board.height && board.cells[ny * board.width + nx] === null);
+    }).length;
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        whites: whites.length,
+        blacks,
+        clues,
+        bulbs: proof.solution ? whites.filter((_, i) => proof.solution[2 * i + 1] === 1).length : 0,
+        clueShare: touching ? clues / touching : 0,
+        openShare: whites.length / board.cells.length,
+    };
+}

package/dist/akariSolve.d.ts

@@ -1,5 +1,5 @@
 import type { AkariBoard, AkariSolve } from "./akari.types.ts";
-/** Bounded binary constraint search; a stopped proof is always marked incomplete. */
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
 export declare function solveAkari(board: AkariBoard, options?: {
     limit?: number;
     nodes?: number;

package/dist/akariSolve.js

@@ -1,6 +1,8 @@
 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. */
+import { isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/** Bounded constraint search over the rules in `akariLogic.ts`; a stopped proof is always marked incomplete. */
 export function solveAkari(board, options = {}) {
     if (!isAkariBoard(board))
         throw new RangeError("Invalid Akari board");
@@ -9,98 +11,8 @@ export function solveAkari(board, options = {}) {
     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 };
+    const { csp, whites } = akariModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const solution = found.solution ? whites.filter((_, i) => found.solution[2 * i + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/akariTemplate.d.ts

@@ -0,0 +1,7 @@
+import type { AkariPuzzle } from "./akari.types.ts";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export declare function templateAkari(width?: number, height?: number, seed?: number): Omit<AkariPuzzle, "level">;

package/dist/akariTemplate.js

@@ -0,0 +1,78 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * The first generator, kept as the fallback that cannot fail: makes a seeded board from two original room-grid families: horizontal or vertical paired
+ * corridors, with isolated singleton rooms at the edges. Seeded bulb direction and reflections
+ * vary each layout. Generation returns only after the independent counter proves uniqueness.
+ */
+export function templateAkari(width = 7, height = width, seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Akari settings");
+    const random = seededRandom(seed);
+    const cells = Array(width * height).fill(false);
+    const bulbs = [];
+    const horizontal = random() < .5;
+    if (horizontal) {
+        const firstRow = height > 2 ? 1 : 0;
+        for (let y = firstRow; y < height; y += 3) {
+            const clueY = y > 0 ? y - 1 : y + 1;
+            for (let x = 0; x < width; x += 3) {
+                const room = y * width + x;
+                if (x + 1 < width) {
+                    const bulbX = random() < .5 ? x : x + 1;
+                    cells[room] = null;
+                    cells[room + 1] = null;
+                    cells[clueY * width + bulbX] = 1;
+                    bulbs.push(y * width + bulbX);
+                }
+                else {
+                    cells[room] = null;
+                    cells[clueY * width + x] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    else {
+        const firstColumn = width > 2 ? 1 : 0;
+        for (let x = firstColumn; x < width; x += 3) {
+            const clueX = x > 0 ? x - 1 : x + 1;
+            for (let y = 0; y < height; y += 3) {
+                const room = y * width + x;
+                if (y + 1 < height) {
+                    const bulbY = random() < .5 ? y : y + 1;
+                    cells[room] = null;
+                    cells[room + width] = null;
+                    cells[bulbY * width + clueX] = 1;
+                    bulbs.push(bulbY * width + x);
+                }
+                else {
+                    cells[room] = null;
+                    cells[y * width + clueX] = 1;
+                    bulbs.push(room);
+                }
+            }
+        }
+    }
+    // Reflections are applied to the board and the construction answer together.
+    const reflectX = random() < .5, reflectY = random() < .5;
+    const original = [...cells];
+    const map = (cell) => {
+        const x = cell % width, y = Math.floor(cell / width);
+        return (reflectY ? height - 1 - y : y) * width + (reflectX ? width - 1 - x : x);
+    };
+    for (let cell = 0; cell < original.length; cell += 1)
+        cells[map(cell)] = original[cell];
+    const answer = bulbs.map(map);
+    const board = { width, height, cells };
+    if (!isAkariBoard(board) || !checkAkari(board, answer).ok)
+        throw new Error("Unable to construct Akari puzzle");
+    const proof = solveAkari(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Akari found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/csp.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+export type Csp = {
+    /** The slots of variable `v` are `starts[v]` up to, not including, `starts[v + 1]`. */
+    starts: Int32Array;
+    /**
+     * Prunes `alive` as far as the rules force and says `false` when they cannot all be kept. Never guesses.
+     * `decided` names a variable that was just narrowed from a state that was already pruned, so a rule may
+     * look only at what that can change; leaving it out means look at everything.
+     */
+    propagate: (alive: Uint8Array, decided?: number) => boolean;
+    /** Which variable to branch on in a search; the default is the one with the fewest values left. */
+    choose?: (alive: Uint8Array) => number;
+};
+/** How many values a variable still has. */
+export declare function slotsLeft(csp: Csp, alive: Uint8Array, variable: number): number;
+/** Every value of every variable still possible. */
+export declare function openSlots(csp: Csp): Uint8Array;
+/** Leaves `variable` with only `slot` (a slot number, not an offset). */
+export declare function decide(csp: Csp, alive: Uint8Array, variable: number, slot: number): void;
+/** The slot a decided variable has left, or -1 when it has more than one or none. */
+export declare function decidedSlot(csp: Csp, alive: Uint8Array, variable: number): number;
+export type CspCount = {
+    count: number;
+    solution: Uint8Array | null;
+    solutions: Uint8Array[];
+    stopped: boolean;
+    exhausted: boolean;
+    nodes: number;
+};
+/**
+ * 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 declare function countCsp(csp: Csp, start: Uint8Array, limit: number, budget: number): CspCount;
+export type CspLogic = {
+    solved: boolean;
+    contradiction: boolean;
+    probes: number;
+    alive: Uint8Array;
+};
+/**
+ * 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 declare function logicCsp(csp: Csp, start: Uint8Array, depth: number): CspLogic;
+/**
+ * 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 declare function solveCsp(csp: Csp, start: Uint8Array, limit: number, budget: number, depth?: number): CspCount;

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;