@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/mount.d.ts

@@ -2,24 +2,6 @@ import { type KazuGame } from "./game.ts";
 import { type KazuHint } from "./hint.ts";
 import type { KazuKind, KazuLevel } from "./kinds.ts";
 import { type KazuLanguage } from "./strings.ts";
-/**
- * A PLAYABLE KAZU BOARD IN ANY PAGE: `mountKazu(host, options)` draws a puzzle into an element and plays
- * it by touch, mouse and keyboard. Tap a cell and tap a number on the pad (or type it); tap the chosen
- * cell again to step it on, 1, 2, 3 … and back to empty; turn Pencil on and the pad writes small notes
- * instead; Undo takes the last change back; Hint says which cell to fill next and why; Check says how
- * many are wrong, never which. A clock starts on the first entry and stops when the last cell is right.
- *
- * The keys: the arrows move, a number (1 to 9, and A to G on the 16×16) fills the chosen cell, Shift
- * with a number writes it as a pencil mark, Backspace empties the cell, N turns Pencil on or off,
- * Ctrl or Cmd with Z undoes, and Escape lets the cell go.
- *
- * What happens is told in events, on the host as DOM events and to the callbacks given: `kazu-change`
- * for every change to the grid, `kazu-hint` for each hint, `kazu-check` for each check, and `kazu-solve`
- * once, with the answer ready for `checkKazu`. Every button is also a method of the returned handle.
- * The rules it plays by are `game.ts`'s, and the drawing is `drawKazu`'s: both are usable alone.
- *
- * Needs a page. Its words are English and Japanese and follow the page's `lang`.
- */
 /** What every event tells of the board. */
 export type KazuEventDetail = {
     kind: KazuKind;

package/dist/mount.js

@@ -7,6 +7,27 @@ import { KAZU_PLAY_STYLE } from "./playStyle.js";
 import { decodeNotes, decodeRun, encodeNotes, encodeRun, notesOf } from "./progress.js";
 import { solveKazu } from "./solve.js";
 import { kazuLanguageOf, kazuNameOf, kazuSay } from "./strings.js";
+/**
+ * A PLAYABLE KAZU BOARD IN ANY PAGE: `mountKazu(host, options)` draws a puzzle into an element and plays
+ * it by touch, mouse and keyboard. Tap a cell and tap a number on the pad (or type it); tap the chosen
+ * cell again to step it on, 1, 2, 3 … and back to empty; turn Pencil on and the pad writes small notes
+ * instead; Undo takes the last change back; Hint says which cell to fill next and why; Check says how
+ * many are wrong, never which. A clock starts on the first entry and stops when the last cell is right.
+ *
+ * The keys: the arrows move, a number (1 to 9, then A to G on the 16×16 and on to P on the 25×25) fills
+ * the chosen cell, Shift with a number writes it as a pencil mark, Backspace empties the cell, N turns
+ * Pencil on or off (the slash key on the 25×25, where N is the number 23), Ctrl or Cmd with Z undoes,
+ * and Escape lets the cell go.
+ *
+ * What happens is told in events, on the host as DOM events and to the callbacks given: `kazu-change`
+ * for every change to the grid, `kazu-hint` for each hint, `kazu-check` for each check, and `kazu-solve`
+ * once, with the answer ready for `checkKazu`. Every button is also a method of the returned handle.
+ * The rules it plays by are `game.ts`'s, and the drawing is `drawKazu`'s: both are usable alone.
+ *
+ * Needs a page. Its words are English and Japanese and follow the page's `lang`.
+ */
+/** From this side up the letter N is a number (A is 10, so N is 23), and Pencil moves to the slash key. */
+const NOTES_KEY_IS_A_NUMBER = 23;
 /** Put the style in the page once: in the document's head, or in the shadow root the host is in. */
 export function ensureKazuPlayStyle(host) {
     const root = host.getRootNode();
@@ -210,7 +231,7 @@ export function mountKazu(host, options) {
         host.dataset.kind = game.kind;
         host.dataset.size = String(game.size);
         box.setAttribute("aria-label", say("board", { name: kazuNameOf(game.kind, language), size: game.size }));
-        keysNote.textContent = say("keys");
+        keysNote.textContent = say(game.size >= NOTES_KEY_IS_A_NUMBER ? "keysColossus" : "keys");
         const counts = numberCounts(game);
         padKeys.forEach((key, at) => {
             const value = at + 1;
@@ -328,13 +349,13 @@ export function mountKazu(host, options) {
             event.preventDefault();
             api.enter(0);
         }
-        else if (event.key.toLowerCase() === "n") {
+        else if (event.key.toLowerCase() === (game.size >= NOTES_KEY_IS_A_NUMBER ? "/" : "n")) {
             event.preventDefault();
             api.pencil();
         }
         else if (event.shiftKey && selected !== null) {
             // Shift with a number is a pencil mark, whatever the keyboard writes for a shifted digit: read the key's place, not its symbol.
-            const code = /^Digit([1-9])$/.exec(event.code)?.[1] ?? /^Key([A-G])$/.exec(event.code)?.[1];
+            const code = /^Digit([1-9])$/.exec(event.code)?.[1] ?? /^Key([A-P])$/.exec(event.code)?.[1];
             const value = code === undefined ? 0 : valueOfSymbol(code);
             if (value >= 1 && value <= game.size) {
                 event.preventDefault();

package/dist/names.js

@@ -11,13 +11,13 @@ export const KAZU_NAMES = {
             en: [
                 "Fill every empty cell with a number from 1 up to the side of the grid, so that each row, each column and each box holds every number exactly once.",
                 "The numbers already printed are the givens. They stay where they are, and every puzzle has exactly one answer that fits them.",
-                "The 16×16 Giant has sixteen symbols: 1 to 9, then A to G for 10 to 16.",
+                "The 16×16 Giant has sixteen symbols: 1 to 9, then A to G for 10 to 16. The 25×25 Colossus has twenty-five: A to P for 10 to 25.",
                 "Easy yields to reasoning alone: every cell can be found from what is already there. Medium and hard ask you to try something and see.",
             ],
             ja: [
                 "空いているマスに、1から盤の一辺の数までの数字を入れます。どの行、列、ブロックにも、同じ数字が一つずつ入ります。",
                 "最初から書かれている数字はそのままです。どの問題も、答えはちょうど一つだけです。",
-                "16×16の「特大」は、1から9までの数字に、10から16までを表すAからGを足した16種類を使います。",
+                "16×16の「特大」は、1から9までの数字に、10から16までを表すAからGを足した16種類を使います。25×25の「巨大」は、10から25までを表すAからPまでを使う25種類です。",
                 "やさしい問題は、推理だけで全部のマスが決まります。ふつうとむずかしい問題では、試してみる場面があります。",
             ],
         },
@@ -154,7 +154,7 @@ export const KAZU_NAMES = {
 };
 /** What each side is for, under its size on a chooser: the quick one, the usual one, the long one. */
 export const KAZU_SIZE_NAMES = {
-    "number-place": { 4: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" }, 16: { en: "Giant", ja: "特大" } },
+    "number-place": { 4: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" }, 16: { en: "Giant", ja: "特大" }, 25: { en: "Colossus", ja: "巨大" } },
     jigsaw: { 5: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 7: { en: "Standard", ja: "定番" }, 9: { en: "Classic", ja: "本格" } },
     diagonal: { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },
     "sum-cages": { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },

package/dist/numberPlace.d.ts

@@ -8,7 +8,7 @@ import { type Random } from "./random.ts";
  * puzzle on a layout (Sudoku, Diagonal and Jigsaw).
  */
 export declare function carve(solution: Grid, layout: Layout, level: KazuLevel, floor: number, random: Random): Grid;
-/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9, 16 or 25. */
 export declare function generateNumberPlace(size: number, level: KazuLevel, seed: number): KazuPuzzle;
 /** A Diagonal Sudoku (Sudoku X): Sudoku with the two long diagonals as groups too. 6 or 9. */
 export declare function generateDiagonal(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/numberPlace.js

@@ -1,5 +1,5 @@
 import { encodeCells } from "./cells.js";
-import { countSolutions, guessDepth } from "./groupSolve.js";
+import { countSolutions, guessDepth, provedByGuessing } from "./groupSolve.js";
 import { boxedLayout } from "./layout.js";
 import { seededRandom, shuffled } from "./random.js";
 /**
@@ -22,10 +22,21 @@ import { seededRandom, shuffled } from "./random.js";
  * hard puzzle would be a medium one with a different label.
  */
 const LEVELS = {
-    easy: { depth: 0, floor: { 4: 9, 6: 20, 9: 40, 16: 150 } },
-    medium: { depth: 1, floor: { 4: 7, 6: 15, 9: 31, 16: 125 } },
-    hard: { depth: Infinity, floor: { 4: 5, 6: 11, 9: 24, 16: 116 } },
+    easy: { depth: 0, floor: { 4: 9, 6: 20, 9: 40, 16: 150, 25: 366 } },
+    medium: { depth: 1, floor: { 4: 7, 6: 15, 9: 31, 16: 125, 25: 305 } },
+    hard: { depth: Infinity, floor: { 4: 5, 6: 11, 9: 24, 16: 116, 25: 283 } },
 };
+/** Past this side the exact count of answers and the exact depth are not asked, only a proof (see `LARGE_GUESSES`). */
+const LARGEST_COUNTED = 16;
+/**
+ * The 25×25 is carved by proof, not by counting. Counting every answer of a sparse 625-cell grid can run for
+ * minutes (a single removal took 20 s), and the exact guess depth of one is as bad. What a person does is
+ * what is asked instead: singles, then at most this many guesses at the most constrained cell, each value
+ * of it either finished by singles or shown wrong by them. A puzzle that passes has exactly one answer, and
+ * the work for each removal is bounded however the grid looks. Hard allows two nested guesses and no more,
+ * so a 25×25 hard puzzle is one a person can finish, and easy is singles alone, as it is at every size.
+ */
+const LARGE_GUESSES = { easy: 0, medium: 1, hard: 2 };
 /**
  * A whole grid, filled cell by cell in reading order with the values tried in a seeded order. The
  * groups come from the layout, so the diagonals are honoured the same way.
@@ -65,7 +76,7 @@ function fillInOrder(layout, random) {
  * into a dead end deep in a 256-cell grid and take seconds to climb out. A grid that is right by
  * construction (each row the one above it shifted a box's width, each band shifted by one), then
  * shuffled in every way that keeps it right (the numbers relabelled, rows within a band, the
- * bands, columns within a stack, the stacks), is as varied and costs nothing. Only 16×16 is made
+ * bands, columns within a stack, the stacks), is as varied and costs nothing. Only 16×16 and 25×25 are made
  * this way, so every smaller grid comes out of its seed exactly as it always has.
  */
 function fillByPattern(size, random) {
@@ -91,7 +102,9 @@ export function carve(solution, layout, level, floor, random) {
             break;
         const value = givens[index];
         givens[index] = 0;
-        const stillOne = countSolutions(givens, layout, 2) === 1 && guessDepth(givens, layout) <= depth;
+        const stillOne = layout.size > LARGEST_COUNTED
+            ? provedByGuessing(givens, layout, LARGE_GUESSES[level]) === 1
+            : countSolutions(givens, layout, 2) === 1 && guessDepth(givens, layout) <= depth;
         if (stillOne)
             left -= 1;
         else
@@ -99,11 +112,11 @@ export function carve(solution, layout, level, floor, random) {
     }
     return givens;
 }
-/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9, 16 or 25. */
 export function generateNumberPlace(size, level, seed) {
     const random = seededRandom(seed);
     const layout = boxedLayout(size);
-    const solution = size === 16 ? fillByPattern(size, random) : fillInOrder(layout, random);
+    const solution = size >= 16 ? fillByPattern(size, random) : fillInOrder(layout, random);
     const givens = carve(solution, layout, level, LEVELS[level].floor[size], random);
     return { kind: "number-place", size, level, seed, givens: encodeCells(givens), solution: encodeCells(solution) };
 }

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

package/dist/shikakuGenerate.d.ts

@@ -1,3 +1,8 @@
 import type { ShikakuLevel, ShikakuPuzzle } from "./shikaku.types.ts";
-/** Seeded partitions with an independently counted, unique answer. Levels choose rectangle sizes, not a promised human rating. */
+/**
+ * Seeded rectangles packed into the board, one number each, with an independently counted, unique answer. The board
+ * is rated by solving it: easy by the first two rules (a number with one fitting rectangle, a square one rectangle can
+ * cover), medium once the third rule is needed too, hard by supposing, extra-hard the most-supposing of several boards. If no board of the level is found within the attempts
+ * the next level down is tried, and the first generator is the last resort.
+ */
 export declare function generateShikaku(width?: number, height?: number, level?: ShikakuLevel, seed?: number): ShikakuPuzzle;

package/dist/shikakuGenerate.js

@@ -1,43 +1,58 @@
-import { SHIKAKU_LEVELS, SHIKAKU_MOST_ATTEMPTS } from "./shikaku.constants.js";
-import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { SHIKAKU_LEVELS, SHIKAKU_MOST_ATTEMPTS, SHIKAKU_MOST_SIDE } from "./shikaku.constants.js";
+import { checkShikaku } from "./shikakuBoard.js";
+import { candidateShikaku } from "./shikakuBuild.js";
+import { shikakuModel } from "./shikakuLogic.js";
 import { solveShikaku } from "./shikakuSolve.js";
+import { templateShikaku } from "./shikakuTemplate.js";
+import { logicCsp, openSlots } from "./csp.js";
 import { isKazuSeed, seededRandom } from "./random.js";
-/** Seeded partitions with an independently counted, unique answer. Levels choose rectangle sizes, not a promised human rating. */
+/**
+ * Seeded rectangles packed into the board, one number each, with an independently counted, unique answer. The board
+ * is rated by solving it: easy by the first two rules (a number with one fitting rectangle, a square one rectangle can
+ * cover), medium once the third rule is needed too, hard by supposing, extra-hard the most-supposing of several boards. If no board of the level is found within the attempts
+ * the next level down is tried, and the first generator is the last resort.
+ */
 export function generateShikaku(width = 7, height = width, level = "medium", seed = 1) {
-    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= 16))
-        throw new RangeError("Invalid Shikaku dimensions");
-    const empty = { width, height, clues: Array(width * height).fill(0) };
-    if (!isKazuSeed(seed) || !SHIKAKU_LEVELS.includes(level)
-        || !isShikakuBoard({ ...empty, clues: [width * height, ...empty.clues.slice(1)] }))
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= SHIKAKU_MOST_SIDE)
+        || !isKazuSeed(seed) || !SHIKAKU_LEVELS.includes(level))
         throw new RangeError("Invalid Shikaku settings");
-    const random = seededRandom(seed), maximum = { easy: 5, medium: 9, hard: 15 }[level];
-    for (let attempt = 0; attempt < SHIKAKU_MOST_ATTEMPTS; attempt += 1) {
-        const solution = [];
-        const split = (r) => {
-            if (r.width * r.height <= maximum && (r.width * r.height < 3 || random() < .6)) {
-                solution.push(r);
-                return;
-            }
-            const vertical = r.height === 1 || (r.width > 1 && random() < .5);
-            const cut = 1 + Math.floor(random() * ((vertical ? r.width : r.height) - 1));
-            if (vertical) {
-                split({ ...r, width: cut });
-                split({ ...r, x: r.x + cut, width: r.width - cut });
-            }
-            else {
-                split({ ...r, height: cut });
-                split({ ...r, y: r.y + cut, height: r.height - cut });
+    const random = seededRandom(seed);
+    for (let aim = SHIKAKU_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = SHIKAKU_LEVELS[aim];
+        const wanted = aimed === "extra-hard" ? 3 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < SHIKAKU_MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const built = candidateShikaku(width, height, aimed, random);
+            if (!built)
+                continue;
+            const score = scored(built.board, aimed);
+            if (score === null)
+                continue;
+            found += 1;
+            if (!best || score > best.score)
+                best = { board: built.board, score };
+        }
+        if (best) {
+            const proof = solveShikaku(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkShikaku(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
             }
-        };
-        split({ x: 0, y: 0, width, height });
-        const clues = [...empty.clues];
-        for (const r of solution) {
-            const cells = shikakuCells(empty, r);
-            clues[cells[Math.floor(random() * cells.length)]] = cells.length;
         }
-        const board = { width, height, clues }, counted = solveShikaku(board);
-        if (counted.complete && counted.count === 1)
-            return { ...board, seed, level, solution: counted.solution };
     }
-    throw new Error("No unique Shikaku found within the generation budget; try another seed");
+    return { ...templateShikaku(width, height, level === "extra-hard" ? "hard" : level, seed), level };
+}
+/** Whether a board suits a level, and how well: higher is harder. */
+function scored(board, level) {
+    const models = [shikakuModel(board, 1), shikakuModel(board, 2)];
+    const solves = (index, depth) => logicCsp(models[index].csp, openSlots(models[index].csp), depth);
+    if (solves(0, 0).solved)
+        return level === "easy" ? 0 : null;
+    if (level === "easy")
+        return null;
+    if (solves(1, 0).solved)
+        return level === "medium" ? 0 : null;
+    if (level === "medium")
+        return null;
+    const probing = solves(1, 1);
+    return probing.solved ? probing.probes : level === "extra-hard" ? 1000 : null;
 }

package/dist/shikakuLogic.d.ts

@@ -0,0 +1,13 @@
+import type { Csp } from "./csp.ts";
+import type { ShikakuBoard, ShikakuRectangle } from "./shikaku.types.ts";
+/**
+ * Shikaku as variables: one per numbered square, its slots the rectangles it could be the one number of. A rectangle
+ * that is settled keeps every other rectangle off its squares. With `strength` 1 a square only one rectangle can
+ * still cover is covered by it, and with 2 a square only one number can still reach forces that number's rectangle to cover it.
+ */
+export declare function shikakuModel(board: ShikakuBoard, strength?: 0 | 1 | 2): {
+    csp: Csp;
+    clues: readonly number[];
+    rectangles: readonly ShikakuRectangle[];
+    owner: Int32Array;
+};

package/dist/shikakuLogic.js

@@ -0,0 +1,84 @@
+import { shikakuCandidates, shikakuCells } from "./shikakuBoard.js";
+/**
+ * Shikaku as variables: one per numbered square, its slots the rectangles it could be the one number of. A rectangle
+ * that is settled keeps every other rectangle off its squares. With `strength` 1 a square only one rectangle can
+ * still cover is covered by it, and with 2 a square only one number can still reach forces that number's rectangle to cover it.
+ */
+export function shikakuModel(board, strength = 2) {
+    const clues = board.clues.flatMap((n, cell) => n ? [cell] : []);
+    const rectangles = [], owner = [], covers = [], starts = [0];
+    clues.forEach((cell, variable) => {
+        for (const rectangle of shikakuCandidates(board, cell)) {
+            rectangles.push(rectangle);
+            owner.push(variable);
+            covers.push(Int32Array.from(shikakuCells(board, rectangle)));
+        }
+        starts.push(rectangles.length);
+    });
+    const through = Array.from({ length: board.clues.length }, () => []);
+    covers.forEach((cells, slot) => cells.forEach(cell => through[cell].push(slot)));
+    const propagate = (alive) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let v = 0; v < clues.length; v += 1) {
+                let left = 0, only = -1;
+                for (let s = starts[v]; s < starts[v + 1]; s += 1)
+                    if (alive[s]) {
+                        left += 1;
+                        only = s;
+                    }
+                if (!left)
+                    return false;
+                if (left !== 1)
+                    continue;
+                const cells = covers[only];
+                for (let k = 0; k < cells.length; k += 1) {
+                    const others = through[cells[k]];
+                    for (let j = 0; j < others.length; j += 1) {
+                        const t = others[j];
+                        if (t !== only && alive[t] && owner[t] !== v) {
+                            alive[t] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            if (strength < 1)
+                continue;
+            for (let cell = 0; cell < through.length; cell += 1) {
+                const slots = through[cell];
+                let count = 0, only = -1, single = true, first = -1;
+                for (let k = 0; k < slots.length; k += 1) {
+                    const s = slots[k];
+                    if (!alive[s])
+                        continue;
+                    count += 1;
+                    only = s;
+                    if (first < 0)
+                        first = owner[s];
+                    else if (owner[s] !== first)
+                        single = false;
+                }
+                if (!count)
+                    return false;
+                if (count === 1) {
+                    for (let s = starts[owner[only]]; s < starts[owner[only] + 1]; s += 1)
+                        if (s !== only && alive[s]) {
+                            alive[s] = 0;
+                            changed = true;
+                        }
+                }
+                else if (single && strength > 1) {
+                    for (let s = starts[first]; s < starts[first + 1]; s += 1)
+                        if (alive[s] && !covers[s].includes(cell)) {
+                            alive[s] = 0;
+                            changed = true;
+                        }
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts: Int32Array.from(starts), propagate }, clues, rectangles, owner: Int32Array.from(owner) };
+}

package/dist/shikakuRate.d.ts

@@ -0,0 +1,3 @@
+import type { ShikakuBoard, ShikakuRating } from "./shikaku.types.ts";
+/** Rates a board with one answer by solving it with the first rule, with the first two, with all three, then by supposing. */
+export declare function rateShikaku(board: ShikakuBoard): ShikakuRating;