@johnmorrisdotca/kazu 1.2.0 → 1.3.0

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;
+};

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.js

@@ -1,4 +1,5 @@
 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";
@@ -98,7 +99,9 @@ export function mountFillomino(host, initial) {
         const number = document.createElement("select");
         number.setAttribute("aria-label", words.selectNumber);
         number.dataset.number = "true";
-        for (let value = 1; value <= game.entries.length; value += 1) {
+        // 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);

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,
+    };
+}