@johnmorrisdotca/kazu 1.2.0 → 1.3.0

package/dist/kakuroLogic.js

@@ -0,0 +1,153 @@
+import { kakuroRuns } from "./kakuroBoard.js";
+/** Every way to choose `length` different digits that add to `sum`, as 9-bit masks (bit d - 1 for digit d), by length then sum. */
+const COMBINATIONS = (() => {
+    const table = Array.from({ length: 10 }, () => Array.from({ length: 46 }, () => []));
+    for (let mask = 1; mask < 512; mask += 1) {
+        let length = 0, sum = 0;
+        for (let d = 1; d <= 9; d += 1)
+            if (mask & 1 << d - 1) {
+                length += 1;
+                sum += d;
+            }
+        table[length][sum].push(mask);
+    }
+    return table;
+})();
+/**
+ * Kakuro as variables: one per white square, nine slots for the digits 1 to 9. A run's pruning keeps only the digit
+ * sets that add up to its total and fit what its squares can still be, so a square keeps only digits some such
+ * set uses; a digit that every such set uses must appear somewhere (`strength` 1), and a digit that only one square
+ * can take is that square's.
+ */
+export function kakuroModel(board, strength = 1, random) {
+    const whites = board.cells.flatMap((tile, cell) => tile.kind === "white" ? [cell] : []);
+    const index = new Int32Array(board.cells.length).fill(-1);
+    whites.forEach((cell, i) => { index[cell] = i; });
+    const runs = kakuroRuns(board).map(run => ({ cells: Int32Array.from(run.cells.map(cell => index[cell])), sum: run.sum, combos: COMBINATIONS[run.cells.length][run.sum] }));
+    const runsOf = whites.map(() => []);
+    runs.forEach((run, r) => run.cells.forEach(cell => runsOf[cell].push(r)));
+    const starts = Int32Array.from({ length: whites.length + 1 }, (_, i) => i * 9);
+    const domain = new Int16Array(whites.length), loaded = new Int32Array(whites.length), touched = new Int32Array(whites.length), changedCells = new Int32Array(whites.length);
+    const queue = new Int32Array(runs.length * 4 + 4), queued = new Uint8Array(runs.length);
+    let stamp = 0;
+    const propagate = (alive, decided) => {
+        stamp += 1;
+        let changes = 0;
+        // A square's digits are read from `alive` the first time a run asks, so a call after one decision touches only what that reaches.
+        const read = (i) => {
+            if (loaded[i] !== stamp) {
+                let mask = 0;
+                for (let d = 0; d < 9; d += 1)
+                    if (alive[9 * i + d])
+                        mask |= 1 << d;
+                domain[i] = mask;
+                loaded[i] = stamp;
+            }
+            return domain[i];
+        };
+        let head = 0, tail = 0;
+        const push = (r) => { if (!queued[r]) {
+            queued[r] = 1;
+            queue[tail++ % queue.length] = r;
+        } };
+        if (decided === undefined)
+            for (let r = 0; r < runs.length; r += 1)
+                push(r);
+        else
+            for (const r of runsOf[decided])
+                push(r);
+        while (head < tail) {
+            const r = queue[head++ % queue.length], run = runs[r], cells = run.cells;
+            queued[r] = 0;
+            let known = 0, union = 0;
+            for (let k = 0; k < cells.length; k += 1) {
+                const mask = read(cells[k]);
+                if (!mask)
+                    return fail();
+                union |= mask;
+                if (!(mask & mask - 1)) {
+                    if (known & mask)
+                        return fail();
+                    known |= mask;
+                }
+            }
+            let usable = 0, always = 511, viable = 0;
+            for (let c = 0; c < run.combos.length; c += 1) {
+                const combo = run.combos[c];
+                if (combo & ~union || known & ~combo)
+                    continue;
+                let fits = true;
+                for (let k = 0; k < cells.length && fits; k += 1)
+                    if (!(domain[cells[k]] & combo))
+                        fits = false;
+                if (!fits)
+                    continue;
+                viable += 1;
+                usable |= combo;
+                always &= combo;
+            }
+            if (!viable)
+                return fail();
+            for (let k = 0; k < cells.length; k += 1) {
+                const cell = cells[k], was = domain[cell];
+                let mask = was & usable;
+                // Squares not yet decided cannot take the digits the decided ones of the run hold.
+                if (was & was - 1)
+                    mask &= ~known;
+                if (strength > 0 && always && mask & mask - 1) {
+                    // A digit every viable set uses must go somewhere: if only this square can hold it, it does.
+                    for (let d = 0; d < 9; d += 1) {
+                        if (!(always & 1 << d) || !(mask & 1 << d))
+                            continue;
+                        let holders = 0;
+                        for (let j = 0; j < cells.length; j += 1)
+                            if (domain[cells[j]] & 1 << d)
+                                holders += 1;
+                        if (holders === 1) {
+                            mask = 1 << d;
+                            break;
+                        }
+                    }
+                }
+                if (!mask)
+                    return fail();
+                if (mask !== was) {
+                    if (touched[cell] !== stamp) {
+                        touched[cell] = stamp;
+                        changedCells[changes++] = cell;
+                    }
+                    domain[cell] = mask;
+                    for (const other of runsOf[cell])
+                        push(other);
+                }
+            }
+        }
+        for (let c = 0; c < changes; c += 1) {
+            const i = changedCells[c];
+            for (let d = 0; d < 9; d += 1)
+                alive[9 * i + d] = domain[i] & 1 << d ? 1 : 0;
+        }
+        return true;
+    };
+    const fail = () => { queued.fill(0); return false; };
+    // A search that picks at random among the squares with fewest digits left can be restarted when it gets lost.
+    const choose = random ? (alive) => {
+        let best = 10, count = 0, pick = -1;
+        for (let i = 0; i < whites.length; i += 1) {
+            let left = 0;
+            for (let d = 0; d < 9; d += 1)
+                left += alive[9 * i + d];
+            if (left < 2 || left > best)
+                continue;
+            if (left < best) {
+                best = left;
+                count = 0;
+            }
+            count += 1;
+            if (random() * count < 1)
+                pick = i;
+        }
+        return pick;
+    } : undefined;
+    return { csp: { starts, propagate, choose }, whites, index };
+}

package/dist/kakuroRate.d.ts

@@ -0,0 +1,3 @@
+import type { KakuroBoard, KakuroRating } from "./kakuro.types.ts";
+/** Rates a board with one answer by solving it: with the single-run rules, with the digit-that-must-appear rule, then by supposing. */
+export declare function rateKakuro(board: KakuroBoard): KakuroRating;

package/dist/kakuroRate.js

@@ -0,0 +1,40 @@
+import { isKakuroBoard, kakuroRuns } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+const COMBOS = (length, sum) => {
+    let count = 0;
+    for (let mask = 1; mask < 512; mask += 1) {
+        let n = 0, total = 0;
+        for (let d = 1; d <= 9; d += 1)
+            if (mask & 1 << d - 1) {
+                n += 1;
+                total += d;
+            }
+        if (n === length && total === sum)
+            count += 1;
+    }
+    return count;
+};
+/** Rates a board with one answer by solving it: with the single-run rules, with the digit-that-must-appear rule, then by supposing. */
+export function rateKakuro(board) {
+    if (!isKakuroBoard(board))
+        throw new RangeError("Invalid Kakuro board");
+    const weak = kakuroModel(board, 0), strong = kakuroModel(board, 1);
+    const proof = solveCsp(strong.csp, openSlots(strong.csp), 2, 250000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Kakuro rating needs a board with one answer");
+    const plain = logicCsp(weak.csp, openSlots(weak.csp), 0);
+    const rules = plain.solved ? plain : logicCsp(strong.csp, openSlots(strong.csp), 0);
+    const probing = rules.solved ? rules : logicCsp(strong.csp, openSlots(strong.csp), 1);
+    const runs = kakuroRuns(board);
+    return {
+        depth: rules.solved ? 0 : probing.solved ? 1 : 2,
+        plain: plain.solved,
+        probes: rules.solved ? 0 : probing.probes,
+        whites: strong.whites.length,
+        runs: runs.length,
+        longest: Math.max(...runs.map(run => run.cells.length)),
+        meanRun: runs.reduce((total, run) => total + run.cells.length, 0) / runs.length,
+        fixedShare: runs.filter(run => COMBOS(run.cells.length, run.sum) === 1).length / runs.length,
+    };
+}

package/dist/kakuroSolve.js

@@ -1,5 +1,7 @@
 import { KAKURO_MAX_NODES } from "./kakuro.constants.js";
-import { canReach, isKakuroBoard, kakuroRuns } from "./kakuroBoard.js";
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { kakuroModel } from "./kakuroLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
 /** Bounded exact counter over across and down runs; an interrupted search never proves uniqueness. */
 export function solveKakuro(board, entries = [], options = {}) {
     if (!isKakuroBoard(board))
@@ -9,77 +11,23 @@ export function solveKakuro(board, entries = [], options = {}) {
         throw new RangeError("Invalid search bounds");
     if (entries.length && entries.length !== board.cells.length)
         throw new RangeError("Invalid Kakuro entries");
-    const runs = kakuroRuns(board), values = entries.length ? [...entries] : Array(board.cells.length).fill(0);
-    const memberships = board.cells.map(() => []);
-    runs.forEach((run, index) => run.cells.forEach(cell => memberships[cell].push(index)));
-    for (let cell = 0; cell < values.length; cell += 1) {
-        const value = values[cell];
+    const { csp, whites } = kakuroModel(board);
+    const start = openSlots(csp);
+    for (let cell = 0; cell < entries.length; cell += 1) {
+        const value = entries[cell];
         if (board.cells[cell].kind === "black" ? value !== 0 : !Number.isInteger(value) || value < 0 || value > 9) {
             return { count: 0, solution: null, complete: true, nodes: 0 };
         }
     }
-    let count = 0, nodes = 0, complete = true, solution = null;
-    const domains = (cell) => {
-        const possible = [];
-        for (let digit = 1; digit <= 9; digit += 1) {
-            if (memberships[cell].every(index => runAllows(runs[index], values, cell, digit)))
-                possible.push(digit);
-        }
-        return possible;
-    };
-    const visit = () => {
-        if (++nodes > budget) {
-            complete = false;
-            return;
-        }
-        let chosen = -1, optionsForCell = [];
-        for (let cell = 0; cell < values.length; cell += 1) {
-            if (board.cells[cell].kind === "black" || values[cell])
-                continue;
-            const possible = domains(cell);
-            if (!possible.length)
-                return;
-            if (chosen < 0 || possible.length < optionsForCell.length) {
-                chosen = cell;
-                optionsForCell = possible;
-                if (possible.length === 1)
-                    break;
-            }
-        }
-        if (chosen < 0) {
-            count += 1;
-            solution ?? (solution = [...values]);
-            return;
-        }
-        for (const digit of optionsForCell) {
-            values[chosen] = digit;
-            visit();
-            values[chosen] = 0;
-            if (!complete || count >= limit) {
-                complete = false;
-                return;
-            }
-        }
-    };
-    // Reject contradictory entries before branching.
-    for (const run of runs)
-        if (!runAllows(run, values, -1, 0))
-            return { count: 0, solution: null, complete: true, nodes: 0 };
-    visit();
-    return { count, solution, complete, nodes };
-}
-function runAllows(run, values, targetCell, candidate) {
-    let sum = 0;
-    const used = new Set();
-    for (const cell of run.cells) {
-        const value = cell === targetCell ? candidate : values[cell];
-        if (!value)
-            continue;
-        if (used.has(value))
-            return false;
-        used.add(value);
-        sum += value;
+    whites.forEach((cell, i) => { const value = entries[cell]; if (value)
+        decide(csp, start, i, 9 * i + value - 1); });
+    const found = solveCsp(csp, start, limit, budget);
+    let solution = null;
+    if (found.solution) {
+        solution = Array(board.cells.length).fill(0);
+        whites.forEach((cell, i) => { for (let d = 0; d < 9; d += 1)
+            if (found.solution[9 * i + d])
+                solution[cell] = d + 1; });
     }
-    const slots = run.cells.filter(cell => !values[cell] && cell !== targetCell).length;
-    return sum <= run.sum && canReach(run.sum - sum, slots, [...used]);
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/kakuroTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { KakuroPuzzle } from "./kakuro.types.ts";
+/** The first generator, kept as the fallback that cannot fail on a 10×10: a seeded family of crossing runs, returned only when uniquely proved. */
+export declare function templateKakuro(seed?: number): Omit<KakuroPuzzle, "level">;

package/dist/kakuroTemplate.js

@@ -0,0 +1,130 @@
+import { KAKURO_GENERATION_ATTEMPTS, KAKURO_GENERATION_NODES, KAKURO_MAX_ATTEMPTS, KAKURO_MAX_NODES } from "./kakuro.constants.js";
+import { isKakuroBoard } from "./kakuroBoard.js";
+import { solveKakuro } from "./kakuroSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** The first generator, kept as the fallback that cannot fail on a 10×10: a seeded family of crossing runs, returned only when uniquely proved. */
+export function templateKakuro(seed = 1) {
+    if (!isKazuSeed(seed))
+        throw new RangeError("Invalid Kakuro seed.");
+    const random = seededRandom(seed);
+    const budget = { attempts: KAKURO_GENERATION_ATTEMPTS, nodes: KAKURO_GENERATION_NODES };
+    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
+        budget.attempts -= 1;
+        const rowGroups = random() < .5 ? [2, 2, 2] : random() < .5 ? [2, 3] : [3, 2];
+        const columnGroups = rowGroups.length === 3 ? [2, 2, 2] : [2, 3];
+        if (random() < .5)
+            columnGroups.reverse();
+        const rowStarts = groupStarts(rowGroups, random);
+        const columnStarts = groupStarts(columnGroups, random);
+        const cells = Array.from({ length: 100 }, () => ({ kind: "black", across: null, down: null }));
+        const solution = Array(100).fill(0);
+        const board = { width: 10, height: 10, cells };
+        let failed = false;
+        for (const [rowIndex, rowStart] of rowStarts.entries()) {
+            for (const [columnIndex, columnStart] of columnStarts.entries()) {
+                const shape = { height: rowGroups[rowIndex], width: columnGroups[columnIndex] };
+                const local = chooseUniqueTile(shape.width, shape.height, random, budget);
+                if (!local) {
+                    failed = true;
+                    break;
+                }
+                placeTile(board, solution, rowStart, columnStart, local);
+            }
+            if (failed)
+                break;
+        }
+        if (failed)
+            continue;
+        if (!isKakuroBoard(board))
+            throw new Error(JSON.stringify(board));
+        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(KAKURO_MAX_NODES, budget.nodes) });
+        budget.nodes -= Math.min(budget.nodes, proof.nodes);
+        if (proof.complete && proof.count === 1 && proof.solution) {
+            return { ...board, seed, solution: proof.solution };
+        }
+    }
+    throw new Error("No uniquely solvable Kakuro board was proved within the generation budget.");
+}
+function groupStarts(groups, random) {
+    const used = groups.reduce((sum, size) => sum + size, 0) + groups.length - 1;
+    let at = 1 + (8 - used > 0 && random() < .5 ? 8 - used : 0);
+    return groups.map(size => { const start = at; at += size + 1; return start; });
+}
+function chooseUniqueTile(width, height, random, budget) {
+    for (let attempt = 0; attempt < KAKURO_MAX_ATTEMPTS && budget.attempts > 0 && budget.nodes > 0; attempt += 1) {
+        budget.attempts -= 1;
+        const candidate = randomRectangle(width, height, random);
+        if (!candidate)
+            continue;
+        const board = tileBoard(candidate);
+        const proof = solveKakuro(board, [], { limit: 2, nodes: Math.min(25000, budget.nodes) });
+        budget.nodes -= Math.min(budget.nodes, proof.nodes);
+        if (!budget.nodes)
+            return null;
+        if (proof.complete && proof.count === 1)
+            return proof.solution ? splitSolution(proof.solution, width, height) : candidate;
+    }
+    return null;
+}
+function randomRectangle(width, height, random) {
+    const rows = [];
+    for (let y = 0; y < height; y += 1) {
+        let row = null;
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const available = shuffled([1, 2, 3, 4, 5, 6, 7, 8, 9], random);
+            const candidate = available.slice(0, width);
+            if (candidate.every((digit, x) => rows.every(previous => previous[x] !== digit))) {
+                row = candidate;
+                break;
+            }
+        }
+        if (!row)
+            return null;
+        rows.push(row);
+    }
+    return rows;
+}
+function tileBoard(solution) {
+    const height = solution.length + 1, width = solution[0].length + 1;
+    const cells = Array.from({ length: width * height }, () => ({ kind: "black", across: null, down: null }));
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            cells[(y + 1) * width + x + 1] = { kind: "white" };
+    for (let y = 0; y < solution.length; y += 1)
+        cells[(y + 1) * width].across = solution[y].reduce((sum, value) => sum + value, 0);
+    for (let x = 0; x < solution[0].length; x += 1)
+        cells[x + 1].down = solution.reduce((sum, row) => sum + row[x], 0);
+    return { width, height, cells };
+}
+function placeTile(board, full, top, left, solution) {
+    const width = board.width;
+    const cells = board.cells;
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            full[(top + y) * width + left + x] = solution[y][x];
+    for (let y = 0; y < solution.length; y += 1) {
+        const clue = (top + y) * width + left - 1;
+        cells[clue].across = solution[y].reduce((sum, value) => sum + value, 0);
+    }
+    for (let x = 0; x < solution[0].length; x += 1) {
+        const clue = (top - 1) * width + left + x;
+        cells[clue].down = solution.reduce((sum, row) => sum + row[x], 0);
+    }
+    for (let y = 0; y < solution.length; y += 1)
+        for (let x = 0; x < solution[y].length; x += 1)
+            cells[(top + y) * width + left + x] = { kind: "white" };
+}
+function splitSolution(values, width, height) {
+    const result = [];
+    for (let y = 1; y <= height; y += 1)
+        result.push(values.slice(y * (width + 1) + 1, y * (width + 1) + width + 1));
+    return result;
+}
+function shuffled(items, random) {
+    const result = [...items];
+    for (let i = result.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}

package/dist/shikaku-entry.d.ts

@@ -4,5 +4,6 @@ export * from "./shikaku.constants.ts";
 export * from "./shikakuBoard.ts";
 export * from "./shikakuSolve.ts";
 export * from "./shikakuGenerate.ts";
+export * from "./shikakuRate.ts";
 export * from "./shikakuGame.ts";
 export * from "./shikakuPacks.ts";

package/dist/shikaku-entry.js

@@ -4,5 +4,6 @@ export * from "./shikaku.constants.js";
 export * from "./shikakuBoard.js";
 export * from "./shikakuSolve.js";
 export * from "./shikakuGenerate.js";
+export * from "./shikakuRate.js";
 export * from "./shikakuGame.js";
 export * from "./shikakuPacks.js";

package/dist/shikaku.constants.d.ts

@@ -1,5 +1,8 @@
 /** Bounds keep custom boards and searches finite. */
 export declare const SHIKAKU_MOST_SIDE = 16;
 export declare const SHIKAKU_MOST_NODES = 100000;
-export declare const SHIKAKU_MOST_ATTEMPTS = 200;
-export declare const SHIKAKU_LEVELS: readonly ["easy", "medium", "hard"];
+export declare const SHIKAKU_MOST_ATTEMPTS = 1500;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateShikaku`. */
+export declare const SHIKAKU_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 2 to `SHIKAKU_MOST_SIDE` can be made. */
+export declare const SHIKAKU_SIZES: readonly [5, 7, 10, 14];

package/dist/shikaku.constants.js

@@ -1,5 +1,8 @@
 /** Bounds keep custom boards and searches finite. */
 export const SHIKAKU_MOST_SIDE = 16;
 export const SHIKAKU_MOST_NODES = 100000;
-export const SHIKAKU_MOST_ATTEMPTS = 200;
-export const SHIKAKU_LEVELS = ["easy", "medium", "hard"];
+export const SHIKAKU_MOST_ATTEMPTS = 1500;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateShikaku`. */
+export const SHIKAKU_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 2 to `SHIKAKU_MOST_SIDE` can be made. */
+export const SHIKAKU_SIZES = [5, 7, 10, 14];

package/dist/shikaku.types.d.ts

@@ -11,7 +11,7 @@ export type ShikakuBoard = {
     height: number;
     clues: readonly number[];
 };
-export type ShikakuLevel = "easy" | "medium" | "hard";
+export type ShikakuLevel = "easy" | "medium" | "hard" | "extra-hard";
 export type ShikakuPuzzle = ShikakuBoard & {
     seed: number;
     level: ShikakuLevel;
@@ -34,3 +34,20 @@ export type ShikakuGame = {
     history: readonly (readonly ShikakuRectangle[])[];
     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
+ * rectangle and watch it break, 2 that more than that is needed. `rules` is how many of the three rules a depth-0
+ * solve needed: 1 for a number with one fitting rectangle (a settled rectangle clears its squares), 2 adding that a
+ * square only one rectangle can cover is covered by it, 3 adding that a square only one number can reach makes that
+ * number's rectangle cover it. `probes` is the suppositions depth 1 needed.
+ */
+export type ShikakuRating = {
+    depth: 0 | 1 | 2;
+    rules: 1 | 2 | 3;
+    probes: number;
+    rectangles: number;
+    meanArea: number;
+    largest: number;
+    /** Mean number of rectangles a number could be at the start. */
+    ambiguity: number;
+};

package/dist/shikakuBuild.d.ts

@@ -0,0 +1,21 @@
+import type { ShikakuBoard, ShikakuLevel, ShikakuRectangle } from "./shikaku.types.ts";
+import type { Random } from "./random.ts";
+/** The smallest and largest rectangle a level cuts the board into. */
+export declare const SHIKAKU_AREAS: Record<ShikakuLevel, {
+    least: number;
+    most: number;
+}>;
+/**
+ * Cuts a board into rectangles by packing: the square with the fewest free neighbours is covered next, by a random
+ * rectangle of a random allowed area that fits the free squares round it. Unlike cutting the board in two over and
+ * over, this makes pinwheels and rectangles that interlock.
+ */
+export declare function packRectangles(width: number, height: number, level: ShikakuLevel, random: Random): ShikakuRectangle[];
+/**
+ * A board with exactly one answer, or null. Each rectangle's number sits in a random square of it; while there is
+ * another answer, the numbers of the rectangles the two answers disagree on move to new squares.
+ */
+export declare function candidateShikaku(width: number, height: number, level: ShikakuLevel, random: Random): {
+    board: ShikakuBoard;
+    solution: readonly ShikakuRectangle[];
+} | null;

package/dist/shikakuBuild.js

@@ -0,0 +1,135 @@
+import { shikakuModel } from "./shikakuLogic.js";
+import { countCsp, openSlots } from "./csp.js";
+import { shuffled } from "./random.js";
+/** The smallest and largest rectangle a level cuts the board into. */
+export const SHIKAKU_AREAS = {
+    easy: { least: 2, most: 6 },
+    medium: { least: 3, most: 12 },
+    hard: { least: 3, most: 9 },
+    "extra-hard": { least: 4, most: 9 },
+};
+/**
+ * Cuts a board into rectangles by packing: the square with the fewest free neighbours is covered next, by a random
+ * rectangle of a random allowed area that fits the free squares round it. Unlike cutting the board in two over and
+ * over, this makes pinwheels and rectangles that interlock.
+ */
+export function packRectangles(width, height, level, random) {
+    const free = new Uint8Array(width * height).fill(1);
+    const { least, most: wanted } = SHIKAKU_AREAS[level];
+    const most = Math.max(least, Math.min(wanted, Math.round(width * height * .3)));
+    const freeAt = (x, y) => x >= 0 && y >= 0 && x < width && y < height && free[y * width + x] === 1;
+    const rectangles = [];
+    for (;;) {
+        let anchor = -1, fewest = 9, ties = 0;
+        for (let cell = 0; cell < free.length; cell += 1) {
+            if (!free[cell])
+                continue;
+            const x = cell % width, y = Math.floor(cell / width);
+            const around = +freeAt(x - 1, y) + +freeAt(x + 1, y) + +freeAt(x, y - 1) + +freeAt(x, y + 1);
+            if (around < fewest) {
+                fewest = around;
+                anchor = cell;
+                ties = 1;
+            }
+            else if (around === fewest && random() * ++ties < 1)
+                anchor = cell;
+        }
+        if (anchor < 0)
+            return rectangles;
+        const ax = anchor % width, ay = Math.floor(anchor / width);
+        const fits = [];
+        for (let w = 1; w <= Math.min(width, most); w += 1)
+            for (let h = 1; w * h <= most; h += 1) {
+                for (let ox = 0; ox < w; ox += 1)
+                    for (let oy = 0; oy < h; oy += 1) {
+                        const x = ax - ox, y = ay - oy;
+                        let all = x >= 0 && y >= 0 && x + w <= width && y + h <= height;
+                        for (let k = 0; all && k < w * h; k += 1)
+                            if (!free[(y + Math.floor(k / w)) * width + x + k % w])
+                                all = false;
+                        if (all)
+                            fits.push({ x, y, width: w, height: h });
+                    }
+            }
+        // Prefer rectangles that leave no square with nowhere to go, then rectangles of a decent size.
+        const leavesIsland = (r) => {
+            const inside = (x, y) => x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height;
+            for (let x = r.x - 1; x <= r.x + r.width; x += 1)
+                for (let y = r.y - 1; y <= r.y + r.height; y += 1) {
+                    if (inside(x, y) || !freeAt(x, y))
+                        continue;
+                    const exits = [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]].filter(([nx, ny]) => freeAt(nx, ny) && !inside(nx, ny)).length;
+                    if (!exits)
+                        return true;
+                }
+            return false;
+        };
+        const sound = fits.filter(r => !leavesIsland(r));
+        const roomy = (sound.length ? sound : fits).filter(r => r.width * r.height >= least);
+        const pool = roomy.length ? roomy : sound.length ? sound : fits;
+        const areas = [...new Set(pool.map(r => r.width * r.height))];
+        const area = areas[Math.floor(random() * areas.length)];
+        const same = pool.filter(r => r.width * r.height === area);
+        const pick = same[Math.floor(random() * same.length)];
+        rectangles.push(pick);
+        for (let k = 0; k < pick.width * pick.height; k += 1)
+            free[(pick.y + Math.floor(k / pick.width)) * width + pick.x + k % pick.width] = 0;
+    }
+}
+/**
+ * A board with exactly one answer, or null. Each rectangle's number sits in a random square of it; while there is
+ * another answer, the numbers of the rectangles the two answers disagree on move to new squares.
+ */
+export function candidateShikaku(width, height, level, random) {
+    const solution = packRectangles(width, height, level, random);
+    if (solution.length < 2 || solution.some(r => r.width * r.height === 1))
+        return null;
+    const cellsOf = (r) => Array.from({ length: r.width * r.height }, (_, i) => (r.y + Math.floor(i / r.width)) * width + r.x + i % r.width);
+    // Where a number sits decides how many rectangles it could be: easy boards put it where it has the fewest, the others anywhere.
+    const freedom = (r, cell) => {
+        const area = r.width * r.height;
+        let count = 0;
+        for (let w = 1; w <= area && w <= width; w += 1) {
+            if (area % w || area / w > height)
+                continue;
+            const h = area / w;
+            count += (Math.min(cell % width, width - w) - Math.max(0, cell % width - w + 1) + 1) * (Math.min(Math.floor(cell / width), height - h) - Math.max(0, Math.floor(cell / width) - h + 1) + 1);
+        }
+        return count;
+    };
+    const chooseSpot = (r, not) => {
+        const cells = shuffled(cellsOf(r).filter(c => c !== not), random);
+        if (!cells.length)
+            return not;
+        if (level !== "easy")
+            return cells[0];
+        const ranked = [...cells].sort((a, b) => freedom(r, a) - freedom(r, b));
+        return ranked[Math.floor(random() * Math.min(2, ranked.length))];
+    };
+    const spot = solution.map(r => chooseSpot(r));
+    for (let repair = 0; repair < 40; repair += 1) {
+        const clues = Array(width * height).fill(0);
+        solution.forEach((r, i) => { clues[spot[i]] = r.width * r.height; });
+        const board = { width, height, clues };
+        const model = shikakuModel(board);
+        const found = countCsp(model.csp, openSlots(model.csp), 2, 20000);
+        if (found.exhausted)
+            return null;
+        if (found.count === 1)
+            return { board, solution };
+        const alt = found.solutions[1];
+        let moved = false;
+        solution.forEach((r, i) => {
+            const slot = model.rectangles.findIndex((c, s) => model.owner[s] === model.clues.indexOf(spot[i]) && c.x === r.x && c.y === r.y && c.width === r.width && c.height === r.height);
+            if (slot >= 0 && alt[slot])
+                return;
+            if (cellsOf(r).length < 2)
+                return;
+            spot[i] = shuffled(cellsOf(r).filter(c => c !== spot[i]), random)[0];
+            moved = true;
+        });
+        if (!moved)
+            return null;
+    }
+    return null;
+}