@johnmorrisdotca/kazu 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -6,6 +6,13 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-10-04
+
+### Added
+
+- Shikaku: unique seeded rectangle puzzles, exact-cover solving, immutable play and progress, SVG drawing, accessible bilingual controls and worker-backed generation.
+- Square, wide, tall and custom rectangle demos using the shared family styling. Existing six number-entry kinds and saved codes remain compatible.
+
 ## [1.0.0] - 2026-10-01
 
 The Numbers family of grid puzzles, taken out of itsutsu.com so that the site can import them as it

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">Kazu <sub>数</sub></h1>
 
 <p align="center"><strong>Grid number puzzles for JavaScript and TypeScript.</strong><br>
-Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers. A seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles and runs as short codes; the grid drawn as SVG; and played by touch, mouse and keyboard in any page, with pencil marks, undo and a clock, as one call or one tag. No dependencies.</p>
+Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers and Shikaku. A seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles and runs as short codes; the grid drawn as SVG; and played by touch, mouse and keyboard in any page, with pencil marks, undo and a clock, as one call or one tag. No dependencies.</p>
 
 <p align="center">
   <a href="https://github.com/johnmorrisdotca/kazu/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/johnmorrisdotca/kazu/actions/workflows/ci.yml/badge.svg"></a>
@@ -17,7 +17,7 @@ Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki a
   <img src="docs/phone.jpg" alt="A 6×6 Skyscrapers puzzle part filled in, on a phone in dark mode and in Japanese: the clues round the edge, the number pad, the buttons and the first of the settings under it" width="200">
 </p>
 
-Kazu is the family of grid puzzles Sudoku belongs to: fill every cell with a number, so that no number repeats where the rules say it must not. It is
+Kazu is a family of grid puzzles built around numbers. Sudoku and its companions fill cells with numbers; Shikaku divides cells into numbered rectangles. It is
 played at [itsutsu.com](https://itsutsu.com), which this package was taken out of, and in
 [the demo](https://johnmorrisdotca.github.io/kazu/), with nothing to install.
 
@@ -442,6 +442,43 @@ Not here yet, and each welcome as an [issue](https://github.com/johnmorrisdotca/
 
 Left out on purpose: a puzzle with more than one answer, and any account, ranking or storage. A page keeps its own runs: `onChange` hands them over.
 
+## Shikaku — rectangles in Kazu
+
+The demo includes square, wide (10 × 6), tall (6 × 10) and custom rectangular boards, with width and height from 2 to 16. Shares and saved settings preserve both dimensions. It uses Kazu’s unchanged shared family stylesheet and header controls. Irregular outlines are not part of this classic rectangle-partition game.
+
+Shikaku belongs to the number-and-grid family. Its moves are rectangles rather than number entries, so it has a dedicated model and optional entry points; the existing six `KazuKind` values and saved Sudoku codes remain compatible.
+
+```js
+import { generateShikaku, newShikaku, placeShikaku, checkShikaku } from "@johnmorrisdotca/kazu/shikaku";
+import { mountShikaku } from "@johnmorrisdotca/kazu/shikaku/play";
+
+const puzzle = generateShikaku(7, 7, "medium", 42);
+const player = mountShikaku(document.querySelector("#board"), {
+  board: puzzle, material: "ivory", pieces: "ink", language: "en",
+  onFinish: game => console.log(game.helped ? "Solved with help" : "Solved"),
+});
+// player.progress() saves public clues and rectangles; player.destroy() removes the player.
+```
+
+Use `@johnmorrisdotca/kazu/shikaku`, `@johnmorrisdotca/kazu/shikaku/play`, or `@johnmorrisdotca/kazu/shikaku/draw`.
+
+The root entry re-exports the engine, `/play` re-exports `mountShikaku`, and `/draw` re-exports `drawShikaku`. The dedicated entries let a consumer load only Shikaku. There are no runtime dependencies.
+
+- `ShikakuBoard`: `width`, `height`, and row-major `clues` (zero for an empty cell). Dimensions are 2–16; clue areas sum to the grid area.
+- `ShikakuRectangle`: zero-based `x`, `y`, `width`, `height`.
+- `generateShikaku(width, height, level, seed)`: deterministic puzzle and solution. The answer is counted independently. Generation rejects ambiguous boards and stops after 200 attempts with an error; it never silently returns an unproved board. The seed range matches Kazu. Levels `easy`, `medium`, `hard` favor small, mixed and larger rectangles; these are generation profiles, not calibrated human difficulty ratings.
+- `solveShikaku(board, placements?, {limit?, nodes?})`: exact-cover count, first answer, nodes visited and `complete`. The default limit is two answers and 100,000 nodes. Only `complete && count === 1` proves uniqueness; a stopped search is explicitly incomplete.
+- `checkShikaku(board, rectangles)`: coverage and rectangle rule errors, independent of a stored answer. It accepts any valid completion.
+- `newShikaku`, `placeShikaku`, `removeShikaku`, `undoShikaku`: immutable game operations. A placement replaces intersecting rectangles, and rule errors are allowed until checked. The game strips generated solutions.
+- `hintShikaku(game)`: a rectangle from the single proved remaining partition, or `null`. Hints in the mounted player mark the run as helped.
+- `encodeShikaku`, `decodeShikaku`: versioned JSON with only public puzzle data and placements, validated on restore. Undo history and the clock are session-only.
+- `drawShikaku(board, options)`: SVG. Materials `ivory`, `wood`, `slate`; numbers `ink`, `tiles`; language `en`, `ja`.
+- `mountShikaku(host, options)`: tap two opposite corner cells, or use arrows and Enter/Space. Delete removes a selected rectangle; Escape cancels a pending corner. Undo, Check, Hint, Restart and a modal board view are built in. The handle has `game`, `progress`, `set`, `restart`, `destroy`; callbacks and bubbling `shikaku-change` / `shikaku-finish` events carry copies of public state. Mount once per puzzle; use `set` for appearance changes.
+
+The demo is `site/shikaku.html` after `pnpm site`; its generator runs in a module worker at `dist/shikakuWorker.js`. Deploy the worker with the built files and permit same-origin module workers. The npm player accepts a board synchronously; hosts can use their own worker when generating large custom boards. The demo stores progress locally and shares settings through the address. Shared seeds start fresh; they do not share your placements. Restart and page reload reset the session clock.
+
+[Shikaku's rules are described by Nikoli](https://www.nikoli.co.jp/en/puzzles/shikaku/). This implementation generates its own puzzles and does not copy Nikoli's puzzle grids, wording or artwork.
+
 ## Architecture
 
 The generators, the solvers, the check, the hint and the game are plain functions over short codes, with no
@@ -449,6 +486,21 @@ DOM. The drawing is SVG text in an entry of its own, so a server that only check
 the page's part (the mount and the element) is another.
 
 ```text
+├── shikaku-draw-entry.ts
+├── shikaku-entry.ts
+├── shikaku-play-entry.ts
+├── shikaku.constants.ts
+├── shikaku.types.ts
+├── shikakuBoard.ts
+├── shikakuDraw.ts
+├── shikakuGame.ts
+├── shikakuGenerate.ts
+├── shikakuMount.ts
+├── shikakuPlay.types.ts
+├── shikakuSolve.ts
+├── shikakuStrings.ts
+├── shikakuStyle.ts
+├── shikakuWorker.ts
 src/
 ├── index.ts            the main entry: everything but the drawing and the page
 ├── kinds.ts            the six puzzles' keys, sizes and levels, and the shape of a puzzle

package/dist/draw-entry.d.ts

@@ -12,3 +12,4 @@ export { KAZU_STRINGS, kazuLanguageOf, kazuNameOf, kazuSay } from "./strings.ts"
 export type { KazuLanguage } from "./strings.ts";
 export { KAZU_NAMES, KAZU_SIZE_NAMES } from "./names.ts";
 export type { KazuName } from "./names.ts";
+export * from "./shikaku-draw-entry.ts";

package/dist/draw-entry.js

@@ -8,3 +8,4 @@ export { kazuGeometry, KAZU_CELL } from "./geometry.js";
 export { KAZU_STYLE } from "./style.js";
 export { KAZU_STRINGS, kazuLanguageOf, kazuNameOf, kazuSay } from "./strings.js";
 export { KAZU_NAMES, KAZU_SIZE_NAMES } from "./names.js";
+export * from "./shikaku-draw-entry.js";

package/dist/index.d.ts

@@ -34,3 +34,4 @@ export type { Boxes } from "./layout.ts";
 export { seededRandom, shuffled, freshKazuSeed, isKazuSeed, KAZU_SEED_MOST } from "./random.ts";
 export type { Random } from "./random.ts";
 export { VERSION } from "./version.ts";
+export * from "./shikaku-entry.ts";

package/dist/index.js

@@ -29,3 +29,4 @@ export { encodeTowers, decodeTowers, cluesOf, lineFrom, towersSeen, noClues, TOW
 export { boxedLayout, boxOf, KAZU_BOXES, neighbours, regionsAreSound } from "./layout.js";
 export { seededRandom, shuffled, freshKazuSeed, isKazuSeed, KAZU_SEED_MOST } from "./random.js";
 export { VERSION } from "./version.js";
+export * from "./shikaku-entry.js";

package/dist/play-entry.d.ts

@@ -7,3 +7,4 @@ export { ensureKazuPlayStyle, mountKazu } from "./mount.ts";
 export type { KazuEventDetail, KazuMount, KazuMountOptions, KazuMountSettings } from "./mount.ts";
 export { KAZU_PLAY_STYLE } from "./playStyle.ts";
 export { kazuClockText } from "./clock.ts";
+export * from "./shikaku-play-entry.ts";

package/dist/play-entry.js

@@ -6,3 +6,4 @@
 export { ensureKazuPlayStyle, mountKazu } from "./mount.js";
 export { KAZU_PLAY_STYLE } from "./playStyle.js";
 export { kazuClockText } from "./clock.js";
+export * from "./shikaku-play-entry.js";

package/dist/shikaku-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawShikaku } from "./shikakuDraw.ts";
+export type { ShikakuDrawOptions } from "./shikakuPlay.types.ts";

package/dist/shikaku-draw-entry.js

@@ -0,0 +1 @@
+export { drawShikaku } from "./shikakuDraw.js";

package/dist/shikaku-entry.d.ts

@@ -0,0 +1,7 @@
+/** Shikaku shares Kazu's number puzzle package, with its own rectangle model. */
+export * from "./shikaku.types.ts";
+export * from "./shikaku.constants.ts";
+export * from "./shikakuBoard.ts";
+export * from "./shikakuSolve.ts";
+export * from "./shikakuGenerate.ts";
+export * from "./shikakuGame.ts";

package/dist/shikaku-entry.js

@@ -0,0 +1,7 @@
+/** Shikaku shares Kazu's number puzzle package, with its own rectangle model. */
+export * from "./shikaku.types.js";
+export * from "./shikaku.constants.js";
+export * from "./shikakuBoard.js";
+export * from "./shikakuSolve.js";
+export * from "./shikakuGenerate.js";
+export * from "./shikakuGame.js";

package/dist/shikaku-play-entry.d.ts

@@ -0,0 +1,4 @@
+export { mountShikaku } from "./shikakuMount.ts";
+export { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.ts";
+export { SHIKAKU_STRINGS } from "./shikakuStrings.ts";
+export type * from "./shikakuPlay.types.ts";

package/dist/shikaku-play-entry.js

@@ -0,0 +1,3 @@
+export { mountShikaku } from "./shikakuMount.js";
+export { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.js";
+export { SHIKAKU_STRINGS } from "./shikakuStrings.js";

package/dist/shikaku.constants.d.ts

@@ -0,0 +1,5 @@
+/** 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"];

package/dist/shikaku.constants.js

@@ -0,0 +1,5 @@
+/** 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"];

package/dist/shikaku.types.d.ts

@@ -0,0 +1,36 @@
+/** A rectangle uses zero-based column and row coordinates. */
+export type ShikakuRectangle = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** One area clue per rectangle; zero is an unnumbered cell. */
+export type ShikakuBoard = {
+    width: number;
+    height: number;
+    clues: readonly number[];
+};
+export type ShikakuLevel = "easy" | "medium" | "hard";
+export type ShikakuPuzzle = ShikakuBoard & {
+    seed: number;
+    level: ShikakuLevel;
+    solution: readonly ShikakuRectangle[];
+};
+export type ShikakuCheck = {
+    ok: boolean;
+    covered: number;
+    errors: readonly number[];
+};
+export type ShikakuSolve = {
+    count: number;
+    solution: readonly ShikakuRectangle[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type ShikakuGame = {
+    board: ShikakuBoard;
+    rectangles: readonly ShikakuRectangle[];
+    history: readonly (readonly ShikakuRectangle[])[];
+    helped: boolean;
+};

package/dist/shikaku.types.js

@@ -0,0 +1 @@
+export {};

package/dist/shikakuBoard.d.ts

@@ -0,0 +1,9 @@
+import type { ShikakuBoard, ShikakuCheck, ShikakuRectangle } from "./shikaku.types.ts";
+/** Whether dimensions and area clues describe a possible partition. */
+export declare function isShikakuBoard(value: unknown): value is ShikakuBoard;
+/** Cells of a bounded rectangle, or null for invalid coordinates. */
+export declare function shikakuCells(board: ShikakuBoard, r: ShikakuRectangle): number[] | null;
+/** A finished partition is checked against the rules, never against a stored answer. */
+export declare function checkShikaku(board: ShikakuBoard, rectangles: readonly ShikakuRectangle[]): ShikakuCheck;
+/** All legal rectangles for a numbered cell, in a stable order. */
+export declare function shikakuCandidates(board: ShikakuBoard, cell: number): ShikakuRectangle[];

package/dist/shikakuBoard.js

@@ -0,0 +1,59 @@
+import { SHIKAKU_MOST_SIDE } from "./shikaku.constants.js";
+/** Whether dimensions and area clues describe a possible partition. */
+export function isShikakuBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const b = value;
+    return Number.isInteger(b.width) && b.width >= 2 && b.width <= SHIKAKU_MOST_SIDE
+        && Number.isInteger(b.height) && b.height >= 2 && b.height <= SHIKAKU_MOST_SIDE
+        && Array.isArray(b.clues) && b.clues.length === b.width * b.height
+        && b.clues.every(n => Number.isInteger(n) && n >= 0 && n <= b.clues.length)
+        && b.clues.reduce((a, n) => a + n, 0) === b.clues.length;
+}
+/** Cells of a bounded rectangle, or null for invalid coordinates. */
+export function shikakuCells(board, r) {
+    if (!r || ![r.x, r.y, r.width, r.height].every(Number.isInteger)
+        || r.x < 0 || r.y < 0 || r.width < 1 || r.height < 1
+        || r.x + r.width > board.width || r.y + r.height > board.height)
+        return null;
+    return Array.from({ length: r.width * r.height }, (_, i) => (r.y + Math.floor(i / r.width)) * board.width + r.x + i % r.width);
+}
+/** A finished partition is checked against the rules, never against a stored answer. */
+export function checkShikaku(board, rectangles) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const occupied = new Set(), errors = [];
+    rectangles.forEach((r, index) => {
+        const cells = shikakuCells(board, r);
+        const clues = cells?.filter(c => board.clues[c] > 0) ?? [];
+        if (!cells || clues.length !== 1 || board.clues[clues[0]] !== cells.length
+            || cells.some(c => occupied.has(c)))
+            errors.push(index);
+        cells?.forEach(c => occupied.add(c));
+    });
+    return { ok: errors.length === 0 && occupied.size === board.clues.length, covered: occupied.size, errors };
+}
+/** All legal rectangles for a numbered cell, in a stable order. */
+export function shikakuCandidates(board, cell) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const area = board.clues[cell], out = [];
+    if (!area)
+        return out;
+    const cx = cell % board.width, cy = Math.floor(cell / board.width);
+    for (let w = 1; w <= board.width; w += 1) {
+        if (area % w)
+            continue;
+        const h = area / w;
+        if (h > board.height)
+            continue;
+        for (let y = Math.max(0, cy - h + 1); y <= Math.min(cy, board.height - h); y += 1) {
+            for (let x = Math.max(0, cx - w + 1); x <= Math.min(cx, board.width - w); x += 1) {
+                const r = { x, y, width: w, height: h };
+                if (shikakuCells(board, r).every(c => c === cell || board.clues[c] === 0))
+                    out.push(r);
+            }
+        }
+    }
+    return out;
+}

package/dist/shikakuDraw.d.ts

@@ -0,0 +1,4 @@
+import type { ShikakuBoard } from "./shikaku.types.ts";
+import type { ShikakuDrawOptions } from "./shikakuPlay.types.ts";
+/** SVG text with only the public clues and the player's rectangles. */
+export declare function drawShikaku(board: ShikakuBoard, options?: ShikakuDrawOptions): string;

package/dist/shikakuDraw.js

@@ -0,0 +1,23 @@
+import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { shikakuWords } from "./shikakuStrings.js";
+/** SVG text with only the public clues and the player's rectangles. */
+export function drawShikaku(board, options = {}) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const words = shikakuWords(options.language), size = 48;
+    const palettes = { ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"], wood: ["#e5cda6", "#493e2f", "#bca582"], slate: ["#262a27", "#ece8dc", "#454a44"] };
+    const [paper, ink, grid] = palettes[options.material ?? "ivory"];
+    const marks = [];
+    for (const [index, r] of (options.rectangles ?? []).entries()) {
+        if (!shikakuCells(board, r))
+            continue;
+        const colour = options.errors?.includes(index) ? "var(--kz-bad,#b5452c)" : ink;
+        marks.push(`<rect x="${r.x * size + 3}" y="${r.y * size + 3}" width="${r.width * size - 6}" height="${r.height * size - 6}" rx="3" fill="${colour}" fill-opacity=".10" stroke="${colour}" stroke-width="2.5"/>`);
+    }
+    const cells = board.clues.map((n, c) => {
+        const x = c % board.width * size, y = Math.floor(c / board.width) * size;
+        const active = c === options.selected || c === options.anchor;
+        return `<g data-shikaku-cell="${c}"><rect x="${x}" y="${y}" width="48" height="48" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".15" : "1"}" stroke="${grid}" stroke-width="1"/>${n ? `${options.pieces === "tiles" ? `<rect x="${x + 10}" y="${y + 10}" width="28" height="28" rx="6" fill="${paper}" stroke="${grid}"/>` : ""}<text x="${x + 24}" y="${y + 25}" dominant-baseline="middle" text-anchor="middle" fill="${ink}" font-size="21" font-weight="700" font-family="system-ui,sans-serif">${n}</text>` : ""}</g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${board.width * size + 4} ${board.height * size + 4}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}${marks.join("")}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/shikakuGame.d.ts

@@ -0,0 +1,14 @@
+import type { ShikakuBoard, ShikakuGame, ShikakuRectangle } from "./shikaku.types.ts";
+/** Begin with a copy of just the public clues; a generated answer is never kept in play. */
+export declare function newShikaku(board: ShikakuBoard): ShikakuGame;
+/** Place a rectangle, replacing any it touches. Local rule errors are allowed for the player to check. */
+export declare function placeShikaku(game: ShikakuGame, rectangle: ShikakuRectangle): ShikakuGame;
+/** Remove the rectangle containing a cell. */
+export declare function removeShikaku(game: ShikakuGame, cell: number): ShikakuGame;
+export declare function undoShikaku(game: ShikakuGame): ShikakuGame;
+/** A rectangle is offered only when the remaining partition has one proved answer. */
+export declare function hintShikaku(game: ShikakuGame): ShikakuRectangle | null;
+export declare function shikakuFinished(game: ShikakuGame): boolean;
+/** Versioned public puzzle and placement data, with no hidden answer. */
+export declare function encodeShikaku(game: ShikakuGame): string;
+export declare function decodeShikaku(code: string): ShikakuGame | null;

package/dist/shikakuGame.js

@@ -0,0 +1,61 @@
+import { checkShikaku, isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { solveShikaku } from "./shikakuSolve.js";
+/** Begin with a copy of just the public clues; a generated answer is never kept in play. */
+export function newShikaku(board) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    return { board: { width: board.width, height: board.height, clues: [...board.clues] }, rectangles: [], history: [], helped: false };
+}
+/** Place a rectangle, replacing any it touches. Local rule errors are allowed for the player to check. */
+export function placeShikaku(game, rectangle) {
+    const cells = shikakuCells(game.board, rectangle);
+    if (!cells)
+        return game;
+    const covered = new Set(cells);
+    return { ...game, rectangles: [...game.rectangles.filter(r => !shikakuCells(game.board, r).some(c => covered.has(c))), { ...rectangle }],
+        history: [...game.history, game.rectangles.map(r => ({ ...r }))] };
+}
+/** Remove the rectangle containing a cell. */
+export function removeShikaku(game, cell) {
+    const rectangles = game.rectangles.filter(r => !shikakuCells(game.board, r).includes(cell));
+    return rectangles.length === game.rectangles.length ? game : { ...game, rectangles, history: [...game.history, game.rectangles] };
+}
+export function undoShikaku(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, rectangles: previous.map(r => ({ ...r })), history: game.history.slice(0, -1) } : game;
+}
+/** A rectangle is offered only when the remaining partition has one proved answer. */
+export function hintShikaku(game) {
+    const solved = solveShikaku(game.board, game.rectangles);
+    if (!solved.complete || solved.count !== 1)
+        return null;
+    return solved.solution.find(r => !game.rectangles.some(p => p.x === r.x && p.y === r.y && p.width === r.width && p.height === r.height)) ?? null;
+}
+export function shikakuFinished(game) { return checkShikaku(game.board, game.rectangles).ok; }
+/** Versioned public puzzle and placement data, with no hidden answer. */
+export function encodeShikaku(game) {
+    return JSON.stringify({ version: 1, board: game.board, rectangles: game.rectangles, helped: game.helped });
+}
+export function decodeShikaku(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isShikakuBoard(value.board) || !Array.isArray(value.rectangles)
+            || value.rectangles.length > value.board.clues.length || typeof value.helped !== "boolean")
+            return null;
+        let game = newShikaku(value.board);
+        for (const r of value.rectangles) {
+            if (!shikakuCells(game.board, r))
+                return null;
+            const next = placeShikaku(game, r);
+            if (next.rectangles.length !== game.rectangles.length + 1)
+                return null;
+            game = next;
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shikakuGenerate.d.ts

@@ -0,0 +1,3 @@
+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. */
+export declare function generateShikaku(width?: number, height?: number, level?: ShikakuLevel, seed?: number): ShikakuPuzzle;

package/dist/shikakuGenerate.js

@@ -0,0 +1,43 @@
+import { SHIKAKU_LEVELS, SHIKAKU_MOST_ATTEMPTS } from "./shikaku.constants.js";
+import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { solveShikaku } from "./shikakuSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** Seeded partitions with an independently counted, unique answer. Levels choose rectangle sizes, not a promised human rating. */
+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)] }))
+        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 });
+            }
+        };
+        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");
+}

package/dist/shikakuMount.d.ts

@@ -0,0 +1,3 @@
+import type { ShikakuMount, ShikakuMountOptions } from "./shikakuPlay.types.ts";
+/** A rectangle player in any element; mount once, update appearance with set, destroy on unmount. */
+export declare function mountShikaku(host: HTMLElement, initial: ShikakuMountOptions): ShikakuMount;

package/dist/shikakuMount.js

@@ -0,0 +1,143 @@
+import { checkShikaku, shikakuCells } from "./shikakuBoard.js";
+import { decodeShikaku, encodeShikaku, hintShikaku, newShikaku, placeShikaku, removeShikaku, shikakuFinished, undoShikaku } from "./shikakuGame.js";
+import { drawShikaku } from "./shikakuDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.js";
+import { shikakuWords } from "./shikakuStrings.js";
+/** A rectangle player in any element; mount once, update appearance with set, destroy on unmount. */
+export function mountShikaku(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial }, game = initial.progress ? decodeShikaku(initial.progress) : null;
+    game ?? (game = newShikaku(initial.board));
+    let selected = 0, anchor = null, errors = [], message = "", finished = shikakuFinished(game), dead = false;
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div"), status = doc.createElement("p"), tools = doc.createElement("div"), help = doc.createElement("p");
+    root.className = "ks-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ks-palette") + SHIKAKU_PLAY_STYLE;
+    board.className = "ks-board";
+    status.className = "ks-status";
+    status.setAttribute("role", "status");
+    tools.className = "ks-tools";
+    help.className = "ks-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({ ...game, board: { ...game.board, clues: [...game.board.clues] }, rectangles: game.rectangles.map(r => ({ ...r })), history: game.history.map(turn => turn.map(r => ({ ...r }))) });
+    const words = () => shikakuWords(options.language);
+    const button = (text, action, disabled = false) => {
+        const b = doc.createElement("button");
+        b.type = "button";
+        b.textContent = text;
+        b.disabled = disabled;
+        b.onclick = action;
+        tools.append(b);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        anchor = null;
+        const won = shikakuFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("shikaku-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("shikaku-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const choose = (cell) => {
+        if (finished)
+            return;
+        selected = cell;
+        if (anchor === null) {
+            anchor = cell;
+            message = "";
+            render();
+            return;
+        }
+        const a = anchor, width = game.board.width, ax = a % width, ay = Math.floor(a / width), x = cell % width, y = Math.floor(cell / width);
+        game = placeShikaku(game, { x: Math.min(ax, x), y: Math.min(ay, y), width: Math.abs(ax - x) + 1, height: Math.abs(ay - y) + 1 });
+        changed();
+    };
+    const remove = () => { game = removeShikaku(game, selected); changed(); };
+    const restart = () => { game = newShikaku(game.board); finished = false; changed(); };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words(), b = game.board, focused = board.contains(doc.activeElement);
+        board.classList.toggle("ks-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawShikaku(b, { ...options, rectangles: game.rectangles, selected, anchor, errors });
+        const cells = doc.createElement("div");
+        cells.className = "ks-cells";
+        cells.style.gridTemplateColumns = `repeat(${b.width},1fr)`;
+        for (let c = 0; c < b.clues.length; c += 1) {
+            const cell = doc.createElement("button");
+            cell.type = "button";
+            cell.className = "ks-cell";
+            cell.dataset.cell = String(c);
+            cell.tabIndex = c === selected ? 0 : -1;
+            const inside = game.rectangles.find(r => shikakuCells(b, r).includes(c));
+            cell.setAttribute("aria-label", `${w.row} ${Math.floor(c / b.width) + 1}, ${w.column} ${c % b.width + 1}: ${b.clues[c] ? `${w.clue} ${b.clues[c]}` : w.blank}${inside ? `, ${w.covered}` : ""}`);
+            cell.onclick = () => choose(c);
+            cell.onkeydown = e => {
+                const steps = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -b.width, ArrowDown: b.width };
+                if (e.key in steps) {
+                    e.preventDefault();
+                    selected = Math.max(0, Math.min(b.clues.length - 1, c + steps[e.key]));
+                    render();
+                }
+                else if (e.key === "Escape") {
+                    e.preventDefault();
+                    anchor = null;
+                    render();
+                }
+                else if (e.key === "Delete" || e.key === "Backspace") {
+                    e.preventDefault();
+                    selected = c;
+                    remove();
+                }
+            };
+            cells.append(cell);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = shikakuFinished(game) ? (game.helped ? w.helped : w.won) : message || (anchor === null ? w.ready : w.corner);
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => { game = undoShikaku(game); finished = shikakuFinished(game); changed(); }, !game.history.length);
+        button(w.remove, remove, finished || !game.rectangles.some(r => shikakuCells(b, r).includes(selected)));
+        button(w.cancel, () => { anchor = null; message = ""; render(); }, anchor === null);
+        button(w.check, () => { errors = checkShikaku(b, game.rectangles).errors; message = errors.length ? w.wrong : w.checked; render(); });
+        button(w.hint, () => {
+            const r = hintShikaku(game);
+            if (!r) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...placeShikaku(game, r), helped: true };
+            changed();
+            message = w.hintWhy;
+            render();
+        }, finished);
+        button(w.restart, restart);
+        button(w.expand, () => {
+            if (root.parentElement !== host)
+                return;
+            const dialog = doc.createElement("dialog"), close = doc.createElement("button");
+            dialog.className = "ks-dialog";
+            close.className = "ks-close";
+            close.textContent = w.close;
+            close.onclick = () => dialog.close();
+            dialog.append(close, root);
+            host.append(dialog);
+            dialog.onclose = () => { host.append(root); dialog.remove(); };
+            dialog.showModal();
+        });
+    };
+    render();
+    return { game: copy, progress: () => encodeShikaku(game), restart,
+        set: (next) => { if (next.language && next.language !== options.language)
+            message = ""; options = { ...options, ...next }; render(); },
+        destroy: () => { dead = true; const dialog = root.closest("dialog"); root.remove(); dialog?.remove(); } };
+}

package/dist/shikakuPlay.types.d.ts

@@ -0,0 +1,26 @@
+import type { ShikakuBoard, ShikakuGame } from "./shikaku.types.ts";
+export type ShikakuMaterial = "ivory" | "wood" | "slate";
+export type ShikakuPieces = "ink" | "tiles";
+export type ShikakuLanguage = "en" | "ja";
+export type ShikakuDrawOptions = {
+    rectangles?: ShikakuGame["rectangles"];
+    selected?: number | null;
+    anchor?: number | null;
+    errors?: readonly number[];
+    material?: ShikakuMaterial;
+    pieces?: ShikakuPieces;
+    language?: ShikakuLanguage;
+};
+export type ShikakuMountOptions = ShikakuDrawOptions & {
+    board: ShikakuBoard;
+    progress?: string;
+    onChange?: (game: ShikakuGame) => void;
+    onFinish?: (game: ShikakuGame) => void;
+};
+export type ShikakuMount = {
+    game: () => ShikakuGame;
+    progress: () => string;
+    set: (options: ShikakuDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/shikakuPlay.types.js

@@ -0,0 +1 @@
+export {};

package/dist/shikakuSolve.d.ts

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

package/dist/shikakuSolve.js

@@ -0,0 +1,54 @@
+import { SHIKAKU_MOST_NODES } from "./shikaku.constants.js";
+import { checkShikaku, isShikakuBoard, shikakuCandidates, shikakuCells } from "./shikakuBoard.js";
+/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+export function solveShikaku(board, placed = [], options = {}) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? SHIKAKU_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const maskOf = (r) => shikakuCells(board, r).reduce((m, c) => m | 1n << BigInt(c), 0n);
+    if (checkShikaku(board, placed).errors.length)
+        return { count: 0, solution: null, complete: true, nodes: 0 };
+    const all = (1n << BigInt(board.clues.length)) - 1n;
+    let occupied = 0n;
+    for (const r of placed)
+        occupied |= maskOf(r);
+    const candidates = board.clues.flatMap((n, c) => n ? shikakuCandidates(board, c).map(r => ({ r, mask: maskOf(r) })) : []);
+    const byCell = board.clues.map((_, c) => candidates.filter(r => (r.mask & 1n << BigInt(c)) !== 0n));
+    let count = 0, nodes = 0, complete = true, solution = null;
+    const visit = (mask, rectangles) => {
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        if (mask === all) {
+            count += 1;
+            solution ?? (solution = rectangles.map(r => ({ ...r })));
+            return;
+        }
+        let choices = null;
+        for (let c = 0; c < board.clues.length; c += 1) {
+            if ((mask & 1n << BigInt(c)) !== 0n)
+                continue;
+            const available = byCell[c].filter(r => (mask & r.mask) === 0n);
+            if (!available.length)
+                return;
+            if (!choices || available.length < choices.length)
+                choices = available;
+            if (choices.length === 1)
+                break;
+        }
+        for (const next of choices ?? []) {
+            visit(mask | next.mask, [...rectangles, next.r]);
+            if (!complete)
+                return;
+            if (count >= limit) {
+                complete = false;
+                return;
+            }
+        }
+    };
+    visit(occupied, placed);
+    return { count, solution, complete, nodes };
+}

package/dist/shikakuStrings.d.ts

@@ -0,0 +1,102 @@
+import type { ShikakuLanguage } from "./shikakuPlay.types.ts";
+export declare const SHIKAKU_STRINGS: {
+    readonly en: {
+        readonly title: "Shikaku";
+        readonly help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly cancel: "Cancel";
+        readonly expand: "Just the board";
+        readonly close: "Close";
+        readonly ready: "Choose the first corner.";
+        readonly corner: "Choose the opposite corner.";
+        readonly won: "Every rectangle fits. Solved!";
+        readonly helped: "Every rectangle fits. Solved with help.";
+        readonly hintWhy: "This rectangle occurs in the only remaining complete partition.";
+        readonly noHint: "No proved hint: undo a conflicting rectangle or continue drawing.";
+        readonly checked: "All drawn rectangles follow the rules. Keep filling the board.";
+        readonly wrong: "Some rectangles need changing: each must hold one number equal to its area.";
+        readonly remove: "Remove selected rectangle";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly clue: "area";
+        readonly blank: "no clue";
+        readonly covered: "in a rectangle";
+    };
+    readonly ja: {
+        readonly title: "四角に切れ";
+        readonly help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly cancel: "取り消す";
+        readonly expand: "盤だけ";
+        readonly close: "閉じる";
+        readonly ready: "最初の角を選びます。";
+        readonly corner: "向かいの角を選びます。";
+        readonly won: "全部の長方形が合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly hintWhy: "残った唯一の答えに、この長方形があります。";
+        readonly noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。";
+        readonly checked: "描いた長方形はルールに合っています。残りも埋めましょう。";
+        readonly wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。";
+        readonly remove: "選んだ長方形を消す";
+        readonly row: "行";
+        readonly column: "列";
+        readonly clue: "面積";
+        readonly blank: "数字なし";
+        readonly covered: "長方形の中";
+    };
+};
+export declare function shikakuWords(language?: ShikakuLanguage): {
+    readonly title: "Shikaku";
+    readonly help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly cancel: "Cancel";
+    readonly expand: "Just the board";
+    readonly close: "Close";
+    readonly ready: "Choose the first corner.";
+    readonly corner: "Choose the opposite corner.";
+    readonly won: "Every rectangle fits. Solved!";
+    readonly helped: "Every rectangle fits. Solved with help.";
+    readonly hintWhy: "This rectangle occurs in the only remaining complete partition.";
+    readonly noHint: "No proved hint: undo a conflicting rectangle or continue drawing.";
+    readonly checked: "All drawn rectangles follow the rules. Keep filling the board.";
+    readonly wrong: "Some rectangles need changing: each must hold one number equal to its area.";
+    readonly remove: "Remove selected rectangle";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly clue: "area";
+    readonly blank: "no clue";
+    readonly covered: "in a rectangle";
+} | {
+    readonly title: "四角に切れ";
+    readonly help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly cancel: "取り消す";
+    readonly expand: "盤だけ";
+    readonly close: "閉じる";
+    readonly ready: "最初の角を選びます。";
+    readonly corner: "向かいの角を選びます。";
+    readonly won: "全部の長方形が合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly hintWhy: "残った唯一の答えに、この長方形があります。";
+    readonly noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。";
+    readonly checked: "描いた長方形はルールに合っています。残りも埋めましょう。";
+    readonly wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。";
+    readonly remove: "選んだ長方形を消す";
+    readonly row: "行";
+    readonly column: "列";
+    readonly clue: "面積";
+    readonly blank: "数字なし";
+    readonly covered: "長方形の中";
+};

package/dist/shikakuStrings.js

@@ -0,0 +1,5 @@
+export const SHIKAKU_STRINGS = {
+    en: { title: "Shikaku", help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", cancel: "Cancel", expand: "Just the board", close: "Close", ready: "Choose the first corner.", corner: "Choose the opposite corner.", won: "Every rectangle fits. Solved!", helped: "Every rectangle fits. Solved with help.", hintWhy: "This rectangle occurs in the only remaining complete partition.", noHint: "No proved hint: undo a conflicting rectangle or continue drawing.", checked: "All drawn rectangles follow the rules. Keep filling the board.", wrong: "Some rectangles need changing: each must hold one number equal to its area.", remove: "Remove selected rectangle", row: "Row", column: "column", clue: "area", blank: "no clue", covered: "in a rectangle" },
+    ja: { title: "四角に切れ", help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。", undo: "戻す", hint: "ヒント", check: "確かめる", restart: "やり直す", cancel: "取り消す", expand: "盤だけ", close: "閉じる", ready: "最初の角を選びます。", corner: "向かいの角を選びます。", won: "全部の長方形が合いました。完成！", helped: "ヒントを使って完成！", hintWhy: "残った唯一の答えに、この長方形があります。", noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。", checked: "描いた長方形はルールに合っています。残りも埋めましょう。", wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。", remove: "選んだ長方形を消す", row: "行", column: "列", clue: "面積", blank: "数字なし", covered: "長方形の中" }
+};
+export function shikakuWords(language = "en") { return SHIKAKU_STRINGS[language]; }

package/dist/shikakuStyle.d.ts

@@ -0,0 +1 @@
+export declare const SHIKAKU_PLAY_STYLE = "\n.ks-root{color:var(--ks-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}\n.ks-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}\n.ks-cells{position:absolute;inset:0;display:grid;padding:2px}\n.ks-cell{background:transparent;border:0;min-width:0;min-height:0;padding:0;cursor:crosshair;touch-action:manipulation}\n.ks-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}\n.ks-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}\n.ks-tools button,.ks-close{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:var(--ks-ink,#1f2320);cursor:pointer}\n.ks-tools button:disabled{opacity:.45;cursor:default}.ks-status{min-height:1.5em}.ks-help{font-size:14px;opacity:.8}\n.ks-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ks-ink:var(--ink,#1f2320);--ks-surface:var(--surface,#fbf8f1);--ks-rule:var(--rule,#ddd6c6)}.ks-dialog::backdrop{background:#172c28bb}\n.ks-close{float:right;margin-bottom:10px}.ks-dialog .ks-root{clear:both}\n";

package/dist/shikakuStyle.js

@@ -0,0 +1,12 @@
+export const SHIKAKU_PLAY_STYLE = `
+.ks-root{color:var(--ks-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}
+.ks-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}
+.ks-cells{position:absolute;inset:0;display:grid;padding:2px}
+.ks-cell{background:transparent;border:0;min-width:0;min-height:0;padding:0;cursor:crosshair;touch-action:manipulation}
+.ks-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}
+.ks-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.ks-tools button,.ks-close{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:var(--ks-ink,#1f2320);cursor:pointer}
+.ks-tools button:disabled{opacity:.45;cursor:default}.ks-status{min-height:1.5em}.ks-help{font-size:14px;opacity:.8}
+.ks-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ks-ink:var(--ink,#1f2320);--ks-surface:var(--surface,#fbf8f1);--ks-rule:var(--rule,#ddd6c6)}.ks-dialog::backdrop{background:#172c28bb}
+.ks-close{float:right;margin-bottom:10px}.ks-dialog .ks-root{clear:both}
+`;

package/dist/shikakuWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shikakuWorker.js

@@ -0,0 +1,10 @@
+import { generateShikaku } from "./shikakuGenerate.js";
+self.onmessage = (event) => {
+    try {
+        const { width, height, level, seed } = event.data;
+        self.postMessage({ puzzle: generateShikaku(width, height, level, seed) });
+    }
+    catch (error) {
+        self.postMessage({ error: error instanceof Error ? error.message : String(error) });
+    }
+};

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.0.0";
+export declare const VERSION = "1.1.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.0.0";
+export const VERSION = "1.1.0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kazu",
-  "version": "1.0.0",
-  "description": "Kazu 数, grid number puzzles for JavaScript and TypeScript: Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers. A seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles as short codes; the grid drawn as SVG; and played by touch, mouse and keyboard in any page, with pencil marks, undo and a clock, as a function call or a tag. Zero dependencies.",
+  "version": "1.1.0",
+  "description": "Kazu \u6570, grid number puzzles for JavaScript and TypeScript: Sudoku (4\u00d74 to a 16\u00d716 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers and Shikaku. Shikaku uses a dedicated rectangle model, exact-cover solver and player. A seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles as short codes; the grid drawn as SVG; and played by touch, mouse and keyboard in any page, with pencil marks, undo and a clock, as a function call or a tag. Zero dependencies.",
   "keywords": [
     "puzzle",
     "sudoku",
@@ -23,7 +23,8 @@
     "zero-dependencies",
     "browser",
     "node",
-    "itsutsu"
+    "itsutsu",
+    "shikaku"
   ],
   "homepage": "https://github.com/johnmorrisdotca/kazu#readme",
   "repository": {
@@ -67,6 +68,21 @@
       "types": "./dist/element-define.d.ts",
       "import": "./dist/element-define.js",
       "default": "./dist/element-define.js"
+    },
+    "./shikaku": {
+      "types": "./dist/shikaku-entry.d.ts",
+      "import": "./dist/shikaku-entry.js",
+      "default": "./dist/shikaku-entry.js"
+    },
+    "./shikaku/play": {
+      "types": "./dist/shikaku-play-entry.d.ts",
+      "import": "./dist/shikaku-play-entry.js",
+      "default": "./dist/shikaku-play-entry.js"
+    },
+    "./shikaku/draw": {
+      "types": "./dist/shikaku-draw-entry.d.ts",
+      "import": "./dist/shikaku-draw-entry.js",
+      "default": "./dist/shikaku-draw-entry.js"
     }
   },
   "files": [