@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/rippleStrings.d.ts

@@ -0,0 +1,86 @@
+import type { RippleLanguage } from "./ripple.types.ts";
+export declare const RIPPLE_STRINGS: {
+    readonly en: {
+        readonly title: "Ripple Effect";
+        readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+        readonly undo: "Undo";
+        readonly check: "Check";
+        readonly hint: "Hint";
+        readonly restart: "Restart";
+        readonly pencil: "Pencil";
+        readonly won: "Every room and ripple rule is correct.";
+        readonly wrong: "Some entries break a room or ripple rule.";
+        readonly checked: "Fill the rooms and check the spacing.";
+        readonly noHint: "No single proved answer is available yet.";
+        readonly hintWhy: "This value follows from the room and spacing rules.";
+        readonly view: "Just the board";
+        readonly close: "Close";
+        readonly cell: "Row {row}, column {column}";
+        readonly clue: "clue {value}";
+        readonly empty: "empty";
+        readonly entry: "{value}";
+        readonly note: "notes {values}";
+    };
+    readonly ja: {
+        readonly title: "波及効果";
+        readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+        readonly undo: "戻す";
+        readonly check: "確認";
+        readonly hint: "ヒント";
+        readonly restart: "やり直す";
+        readonly pencil: "メモ";
+        readonly won: "部屋と間隔のルールをすべて満たしました。";
+        readonly wrong: "部屋か数字の間隔に誤りがあります。";
+        readonly checked: "部屋を埋めて間隔を確認してください。";
+        readonly noHint: "確定できるヒントはまだありません。";
+        readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+        readonly view: "盤だけ";
+        readonly close: "閉じる";
+        readonly cell: "{row}行{column}列";
+        readonly clue: "手がかり {value}";
+        readonly empty: "空き";
+        readonly entry: "{value}";
+        readonly note: "メモ {values}";
+    };
+};
+export declare function rippleWords(language?: RippleLanguage): {
+    readonly title: "Ripple Effect";
+    readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+    readonly undo: "Undo";
+    readonly check: "Check";
+    readonly hint: "Hint";
+    readonly restart: "Restart";
+    readonly pencil: "Pencil";
+    readonly won: "Every room and ripple rule is correct.";
+    readonly wrong: "Some entries break a room or ripple rule.";
+    readonly checked: "Fill the rooms and check the spacing.";
+    readonly noHint: "No single proved answer is available yet.";
+    readonly hintWhy: "This value follows from the room and spacing rules.";
+    readonly view: "Just the board";
+    readonly close: "Close";
+    readonly cell: "Row {row}, column {column}";
+    readonly clue: "clue {value}";
+    readonly empty: "empty";
+    readonly entry: "{value}";
+    readonly note: "notes {values}";
+} | {
+    readonly title: "波及効果";
+    readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+    readonly undo: "戻す";
+    readonly check: "確認";
+    readonly hint: "ヒント";
+    readonly restart: "やり直す";
+    readonly pencil: "メモ";
+    readonly won: "部屋と間隔のルールをすべて満たしました。";
+    readonly wrong: "部屋か数字の間隔に誤りがあります。";
+    readonly checked: "部屋を埋めて間隔を確認してください。";
+    readonly noHint: "確定できるヒントはまだありません。";
+    readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+    readonly view: "盤だけ";
+    readonly close: "閉じる";
+    readonly cell: "{row}行{column}列";
+    readonly clue: "手がかり {value}";
+    readonly empty: "空き";
+    readonly entry: "{value}";
+    readonly note: "メモ {values}";
+};

package/dist/rippleStrings.js

@@ -0,0 +1,5 @@
+export const RIPPLE_STRINGS = {
+    en: { title: "Ripple Effect", help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.", undo: "Undo", check: "Check", hint: "Hint", restart: "Restart", pencil: "Pencil", won: "Every room and ripple rule is correct.", wrong: "Some entries break a room or ripple rule.", checked: "Fill the rooms and check the spacing.", noHint: "No single proved answer is available yet.", hintWhy: "This value follows from the room and spacing rules.", view: "Just the board", close: "Close", cell: "Row {row}, column {column}", clue: "clue {value}", empty: "empty", entry: "{value}", note: "notes {values}" },
+    ja: { title: "波及効果", help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。", undo: "戻す", check: "確認", hint: "ヒント", restart: "やり直す", pencil: "メモ", won: "部屋と間隔のルールをすべて満たしました。", wrong: "部屋か数字の間隔に誤りがあります。", checked: "部屋を埋めて間隔を確認してください。", noHint: "確定できるヒントはまだありません。", hintWhy: "部屋と間隔のルールから確定する数字です。", view: "盤だけ", close: "閉じる", cell: "{row}行{column}列", clue: "手がかり {value}", empty: "空き", entry: "{value}", note: "メモ {values}" },
+};
+export function rippleWords(language = "en") { return RIPPLE_STRINGS[language]; }

package/dist/rippleStyle.d.ts

@@ -0,0 +1 @@
+export declare const RIPPLE_PLAY_STYLE = ".rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}";

package/dist/rippleStyle.js

@@ -0,0 +1 @@
+export const RIPPLE_PLAY_STYLE = `.rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}`;

package/dist/shikaku-entry.d.ts

@@ -4,4 +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,4 +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/shikakuPacks.d.ts

@@ -0,0 +1,27 @@
+import type { ShikakuLevel, ShikakuPuzzle } from "./shikaku.types.ts";
+export type ShikakuPackKey = "square" | "wide" | "tall";
+export type ShikakuChallenge = {
+    pack: ShikakuPackKey;
+    packTitle: string;
+    name: string;
+    level: ShikakuLevel;
+    width: number;
+    height: number;
+    seed: number;
+};
+export type ShikakuChallengePuzzle = ShikakuChallenge & {
+    puzzle: ShikakuPuzzle;
+};
+/** Three short, named challenge routes using the regular seeded unique-puzzle generator. */
+export declare const SHIKAKU_CHALLENGE_PACKS: Readonly<Record<ShikakuPackKey, {
+    title: string;
+    description: string;
+    width: number;
+    height: number;
+    challenges: readonly {
+        name: string;
+        level: ShikakuLevel;
+        seed: number;
+    }[];
+}>>;
+export declare function generateShikakuChallenge(pack: ShikakuPackKey, challenge?: number): ShikakuChallengePuzzle;

package/dist/shikakuPacks.js

@@ -0,0 +1,26 @@
+import { generateShikaku } from "./shikakuGenerate.js";
+/** Three short, named challenge routes using the regular seeded unique-puzzle generator. */
+export const SHIKAKU_CHALLENGE_PACKS = {
+    square: {
+        title: "The Courtyard", description: "A compact square route.", width: 7, height: 7,
+        challenges: [{ name: "First Cut", level: "easy", seed: 1 }, { name: "Crossing", level: "medium", seed: 2 }, { name: "Mosaic", level: "hard", seed: 3 }],
+    },
+    wide: {
+        title: "The Long Table", description: "Three puzzles across a wide board.", width: 10, height: 6,
+        challenges: [{ name: "Harbour", level: "easy", seed: 1 }, { name: "Causeway", level: "medium", seed: 2 }, { name: "Headland", level: "hard", seed: 3 }],
+    },
+    tall: {
+        title: "The Narrow Garden", description: "A tall route with long edges.", width: 6, height: 10,
+        challenges: [{ name: "Gate", level: "easy", seed: 1 }, { name: "Pavilion", level: "medium", seed: 2 }, { name: "Lantern Walk", level: "hard", seed: 3 }],
+    },
+};
+export function generateShikakuChallenge(pack, challenge = 1) {
+    const definition = SHIKAKU_CHALLENGE_PACKS[pack], entry = definition?.challenges[challenge - 1];
+    if (!definition || !entry)
+        throw new RangeError("Unknown Shikaku challenge");
+    return {
+        pack, packTitle: definition.title, name: entry.name, level: entry.level,
+        width: definition.width, height: definition.height, seed: entry.seed,
+        puzzle: generateShikaku(definition.width, definition.height, entry.level, entry.seed),
+    };
+}

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;

package/dist/shikakuRate.js

@@ -0,0 +1,27 @@
+import { isShikakuBoard } from "./shikakuBoard.js";
+import { shikakuModel } from "./shikakuLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it with the first rule, with the first two, with all three, then by supposing. */
+export function rateShikaku(board) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const first = shikakuModel(board, 0), second = shikakuModel(board, 1), strong = shikakuModel(board, 2);
+    const proof = solveCsp(strong.csp, openSlots(strong.csp), 2, 100000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Shikaku rating needs a board with one answer");
+    const one = logicCsp(first.csp, openSlots(first.csp), 0);
+    const two = one.solved ? one : logicCsp(second.csp, openSlots(second.csp), 0);
+    const rules = two.solved ? two : logicCsp(strong.csp, openSlots(strong.csp), 0);
+    const probing = rules.solved ? rules : logicCsp(strong.csp, openSlots(strong.csp), 1);
+    const areas = strong.clues.map(cell => board.clues[cell]);
+    const options = strong.clues.map((_, v) => strong.csp.starts[v + 1] - strong.csp.starts[v]);
+    return {
+        depth: rules.solved ? 0 : probing.solved ? 1 : 2,
+        rules: one.solved ? 1 : two.solved ? 2 : 3,
+        probes: rules.solved ? 0 : probing.probes,
+        rectangles: areas.length,
+        meanArea: board.clues.length / areas.length,
+        largest: Math.max(...areas),
+        ambiguity: options.reduce((a, b) => a + b, 0) / options.length,
+    };
+}

package/dist/shikakuSolve.d.ts

@@ -1,5 +1,5 @@
 import type { ShikakuBoard, ShikakuRectangle, ShikakuSolve } from "./shikaku.types.ts";
-/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+/** Exact cover over squares. A bounded search reports incompleteness instead of claiming uniqueness. */
 export declare function solveShikaku(board: ShikakuBoard, placed?: readonly ShikakuRectangle[], options?: {
     limit?: number;
     nodes?: number;