@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -6,6 +6,45 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-10-05
+
+### Added
+
+- **Four levels on six grid puzzles.** Shikaku, Akari, Slitherlink, Hitori, Fillomino and Kakuro each make `easy`, `medium`, `hard` and `extra-hard` boards (the level types and `SHIKAKU_LEVELS`, `AKARI_LEVELS`, `SLITHERLINK_LEVELS`, `HITORI_LEVELS`, `FILLOMINO_LEVELS` and `KAKURO_LEVELS`), every one with exactly one answer, and every puzzle now carries its `level`. Easy and medium are solved by plain rules (easy keeps more of its numbers, medium has as few as the rules allow); hard needs supposing something and seeing it break; extra-hard needs the most of that.
+- **More sizes.** `AKARI_SIZES` (5, 7, 10, 14), `SLITHERLINK_SIZES` (5, 7, 10), `HITORI_SIZES` (5, 6, 7, 8, 9, 10, 12), `FILLOMINO_SIZES` (6, 8, 10, 12), `KAKURO_SIZES` (6, 8, 10, 12) and `SHIKAKU_SIZES` (5, 7, 10, 14) list what the demo offers. Hitori takes any side from 4 to 12 (was 5 and 7), Kakuro any side from 5 to 12 (was one size, 10), Fillomino any side from 4 to 12 (was 4 to 8 and 36 squares).
+- **A measured difficulty.** `rateShikaku`, `rateAkari`, `rateSlitherlink`, `rateHitori`, `rateFillomino` and `rateKakuro` solve a board with one answer the way a person does (the rules alone, then supposing one thing, then more) and report how deep that went (`depth`, `probes`) and what the board is made of (numbers, runs, regions, loop length). `docs/LEVELS.md` defines each level per kind and tables the measures and the generation times by size and level; `node scripts/measure-levels.mjs` makes the tables again, and draws a puzzle as text with `--show`.
+- A shared engine (`src/csp.ts`) under the six kinds: counting answers, reasoning with and without supposing, and proving one answer by reasoning when that is enough.
+- `generateAkari`, `generateSlitherlink`, `generateHitori` and `generateKakuro` take the level as a last argument (`generateAkari(width, height, seed, level?)`, `generateSlitherlink(width, height, seed, level?)`, `generateHitori(size, seed, level?)`, `generateKakuro(seed, level?, size?)`), `"medium"` if left out; Shikaku and Fillomino keep `(width, height, level, seed)` and add `extra-hard`.
+- The demo has a Level choice, in English and Japanese, on all six pages, and the sizes above.
+
+### Changed
+
+- **The six generators make new boards.** Akari, Slitherlink, Hitori and Kakuro used fixed layouts (the Akari rooms, a loop of one or two blocks with nearly every square numbered and most of them 0, three or four shaded squares in Hitori, a 10×10 of 2×2 to 3×3 blocks) and made the same few motifs again and again; they now build random boards: Akari scatters black squares and takes numbers away, Slitherlink grows a winding loop and takes numbers away (few say 0), Hitori shades about a quarter of the squares and repairs the numbers until the answer is single, Kakuro lays runs out row by row and repairs digits, and Shikaku packs interlocking rectangles instead of cutting straight lines. Fillomino's generator is new and no longer slow (a 6×6 took up to 1.7 s). **A seed makes a different puzzle from the one 1.2.0 made** for Shikaku, Akari, Slitherlink, Hitori, Kakuro and Fillomino; a progress code carries its board, so a saved game is unaffected, but a site that keeps a game as kind, size, level and seed will find that seed is another puzzle. The six number puzzles are untouched, and `src/site.fixture.json` still makes all 3,600 of them again, byte for byte.
+- The six solvers count answers with a shared engine that reasons first: a board that the rules (or one supposition) settle is proved with no search at all, and others are searched from what reasoning left. Counts are the same as before on every board the tests compare (exhaustive enumeration of small boards, and the old solvers); only the node counts, and so what a given `nodes` budget reaches, are different, and answers are found in far fewer nodes. `hint*` calls are quicker as a result.
+- If a generator cannot make a board of the level within its attempts it makes one of the next level down, and finally a plain one, rather than throw; the rating of the board shows what it is. On the 20,800 boards of `docs/LEVELS.md` (seeds 1 to 200 at every size and level) this happened on none.
+- Fillomino's number choice in the player offers only numbers a board can hold (up to the biggest given, or the biggest stretch of squares with none), not up to the square count.
+
+### Fixed
+
+- `generateKakuro(97)` threw "No uniquely solvable Kakuro board was proved within the generation budget"; no seed throws now, at any level or size.
+- `solveHitori` could count one shade pattern twice (so a board with two answers could be reported as having three, and a limit could be reached early); it counts each distinct pattern once.
+
+## [1.2.0] - 2026-10-05
+
+### Added
+
+- Hitori and Nurikabe: independent shading rules, bounded solution counting, original proof-backed puzzle families, bilingual players and package entry points.
+- Juosan: a dedicated territory model, verified small training layouts and a bilingual player for supplied boards.
+- Nine named Shikaku challenges across square, wide and tall routes.
+- Akari: a separate rule engine, bounded solution counter, seeded unique puzzle generator, immutable play, accessible bilingual player, drawing and demo.
+- Slitherlink: a dedicated edge-loop engine, bounded unique-puzzle generation, accessible bilingual player, demo and package entry points.
+- Ripple Effect: a dedicated room and spacing engine, bounded unique 9×9 generation, bilingual accessible player, demo and package entries.
+- Kakuro: a seeded uniquely proved crossword-sum family, independent bounded solver, immutable progress, SVG and accessible English/Japanese player.
+
+- Masyu and Yajilin: cell-centre loop engines, bounded proof-backed 5×5 families, drawing, bilingual players and saved progress.
+- Fillomino: connected numbered regions, bounded original rectangular generation, independent checks, hints and a bilingual player.
+- Heyawake: rectangular rooms, shading and white-path rules, bounded original small-board generation, hints and a bilingual player.
+
 ## [1.1.0] - 2026-10-04
 
 ### Added

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, 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"><strong>Grid number and logic puzzles for JavaScript and TypeScript.</strong><br>
+Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG drawing, saved progress, and English and Japanese players for touch, mouse and keyboard. No runtime 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,
   <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 a family of grid puzzles built around numbers. Sudoku and its companions fill cells with numbers; Shikaku divides cells into numbered rectangles. It is
+Kazu is a family of grid puzzles: number placement, regions, shading, lights and loops. Each puzzle has its own rules and engine. The original number puzzles are
 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.
 
@@ -48,7 +48,7 @@ And in a page, a puzzle to play, by touch, mouse and keyboard, with nothing else
 
 ## Who it is for
 
-- **Puzzle sites and apps** that want these six puzzles with the rules already right: puzzles everybody
+- **Puzzle sites and apps** that want these number puzzles with the rules already right: puzzles everybody
   plays alike from a seed, a check a server can trust in O(cells), a hint that is a reason and not just
   an answer, and runs kept as short strings.
 - **Anyone making number puzzles of their own**, who wants a solver that counts answers, generators whose
@@ -60,7 +60,9 @@ And in a page, a puzzle to play, by touch, mouse and keyboard, with nothing else
 
 ## Features
 
-- **Six puzzles, three levels.** Sudoku (4×4, 6×6, 9×9 and a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys.
+- **Seven puzzles, three levels.** Sudoku (4×4, 6×6, 9×9 and a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys.
+- **Six number puzzles, three levels.** Sudoku (4×4, 6×6, 9×9 and a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys. Shikaku and Juosan use dedicated rectangle and territory models.
+- **Four levels on the grid puzzles.** Shikaku, Akari, Slitherlink, Hitori, Fillomino and Kakuro each make `easy`, `medium`, `hard` and `extra-hard` boards, at three or more sizes each, every one with exactly one answer and rated by what a person must do to solve it: [Levels of the grid puzzles](#levels-of-the-grid-puzzles).
 - **Exactly one answer.** A generator makes puzzles from a seed, and a solver that counts answers confirms there is one. The same kind, size, level and seed make the same puzzle in every browser and every Node, for ever.
 - **A check a server can trust.** `checkKazu` reads a finished grid in O(cells), with no search, and says the first thing wrong in words.
 - **A hint that is a reason.** Which cell to fill next, with the rule that says so (a cell with one number left, a number with one place left), never built on a wrong entry.
@@ -442,17 +444,54 @@ 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.
 
+## Masyu — pearls and a single loop
+
+Masyu is a line puzzle with its own cell-centre loop model. A white pearl lies on a straight section and the loop turns in at least one of its adjacent cells. A black pearl lies at a turn, with a straight section in each adjacent cell. One closed loop must pass through every pearl.
+
+```ts
+import { generateMasyu, checkMasyu, solveMasyu } from "@johnmorrisdotca/kazu/masyu";
+import { mountMasyu } from "@johnmorrisdotca/kazu/masyu/play";
+
+const puzzle = generateMasyu(5, 42);
+checkMasyu(puzzle, puzzle.solution); // { ok: true }
+solveMasyu(puzzle);                  // count: 1, complete: true
+mountMasyu(document.querySelector("#board"), { board: puzzle });
+```
+
+The dedicated `/masyu`, `/masyu/play`, and `/masyu/draw` entry points keep the loop engine separate from number-entry state. Import them from `@johnmorrisdotca/kazu/masyu`, `@johnmorrisdotca/kazu/masyu/play`, and `@johnmorrisdotca/kazu/masyu/draw`. The solver uses bounded cell-degree search; it reports `complete: false` when its node budget stops. The seeded generator currently supports original 5×5 layouts only: four distinct loop families, with board symmetries, produce varied pearl patterns and loop lengths. It returns a puzzle only after a completed uniqueness proof. Larger boards are not advertised until they can be proved within the search budget. Hints expose a next loop edge from a proved unique solution; saved play data contains the public pearls, drawn edges, and whether a hint was used.
+
+[Nikoli describes the Masyu rules here](https://www.nikoli.co.jp/en/puzzles/masyu/). The generated layouts are original and do not use Nikoli's grids or artwork.
+
+## Yajilin — arrows, shaded cells and a loop
+
+Yajilin places black cells by arrow counts and draws one loop through every remaining empty cell. Black cells do not touch by an edge; arrow cells are not shaded and are not part of the loop. The loop uses cell centres, not Slitherlink's grid edges.
+
+```ts
+import { generateYajilin, checkYajilin, solveYajilin } from "@johnmorrisdotca/kazu/yajilin";
+import { mountYajilin } from "@johnmorrisdotca/kazu/yajilin/play";
+
+const puzzle = generateYajilin(5, 42);
+checkYajilin(puzzle, puzzle.solution.shaded, puzzle.solution.edges); // { ok: true }
+solveYajilin(puzzle); // count: 1, complete: true
+mountYajilin(document.querySelector("#board"), { board: puzzle });
+```
+
+Import the engine, player, and drawing from `@johnmorrisdotca/kazu/yajilin`, `@johnmorrisdotca/kazu/yajilin/play`, and `@johnmorrisdotca/kazu/yajilin/draw`. The solver enumerates public shade assignments, then checks the remaining cell-centre loop, with a finite node budget and an explicit incomplete result. The original seeded generator currently supports 5×5 only and keeps boards whose unique answer was proved. It varies both 3×3 and 3×4 loop families and their symmetries. Hints infer either a shade or a loop edge from the public clues and mark progress as helped. Save data contains only clues, current shades and drawn edges.
+
+[Nikoli's Yajilin rules](https://www.nikoli.co.jp/en/puzzles/yajilin/) define the arrow counts, non-touching shaded cells and single loop. These original layouts use no Nikoli puzzle grids or artwork.
+
 ## 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.
+The demo includes square boards (5, 7, 10 and 14 on a side), wide (10 × 6), tall (6 × 10) and custom rectangular boards, with width and height from 2 to 16, at four levels. The named Courtyard (square), Long Table (wide) and Narrow Garden (tall) packs each hold three uniquely proved challenges with useful titles. Shares and saved settings preserve both dimensions. It uses Kazu’s shared materials and pieces palette.
 
 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";
+import { generateShikakuChallenge } from "@johnmorrisdotca/kazu/shikaku";
 
-const puzzle = generateShikaku(7, 7, "medium", 42);
+const { puzzle } = generateShikakuChallenge("wide", 2); // Causeway, a proved 10 × 6 puzzle
 const player = mountShikaku(document.querySelector("#board"), {
   board: puzzle, material: "ivory", pieces: "ink", language: "en",
   onFinish: game => console.log(game.helped ? "Solved with help" : "Solved"),
@@ -460,13 +499,32 @@ const player = mountShikaku(document.querySelector("#board"), {
 // player.progress() saves public clues and rectangles; player.destroy() removes the player.
 ```
 
+`generateShikakuChallenge("square" | "wide" | "tall", 1..3)` selects a named challenge and checks uniqueness with the existing solver.
+
 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.
 
+## Juosan — horizontal and vertical marks
+
+Juosan gives each cell either a horizontal mark (`1`) or a vertical mark (`2`). A territory clue is the absolute difference between its horizontal and vertical mark counts; an unnumbered territory uses `difference: null`. Horizontal marks may make longer runs horizontally but never three vertically; vertical marks may make longer runs vertically but never three horizontally. See [Nikoli's English rules](https://www.nikoli.co.jp/en/puzzles/juosan/) for the original rule wording.
+
+```ts
+import { checkJuosan, generateJuosan, solveJuosan } from "@johnmorrisdotca/kazu/juosan";
+import { mountJuosan } from "@johnmorrisdotca/kazu/juosan/play";
+
+const puzzle = generateJuosan(3, 2, "easy", 42); // 3 × 2 training board; answer proved unique
+solveJuosan(puzzle, 2);                         // { count: 1, complete: true, ... }
+checkJuosan(puzzle, puzzle.solution);           // { ok: true, errors: [] }
+const game = mountJuosan(document.querySelector("#board")!, { board: puzzle });
+```
+
+Juosan has a dedicated immutable engine and package paths: `@johnmorrisdotca/kazu/juosan`, `@johnmorrisdotca/kazu/juosan/play`, and `@johnmorrisdotca/kazu/juosan/draw`. The player accepts any valid supplied board from 2×2 through 16×16. The built-in seeded generator currently supports the two small training shapes, 3×2 and 2×3. Even seeds split the board into straight three-cell territories; odd seeds use one whole-board territory. In each case, the maximum difference clue plus the directional run rule proves the single uniform orientation. Its `level` setting is reserved and does not change rule difficulty yet. The demo saves progress locally, marks hint use as assisted, and offers keyboard and touch input in English and Japanese.
+
 - `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.
+- `generateShikaku(width, height, level, seed)`: deterministic puzzle and solution; `level` is `easy`, `medium`, `hard` or `extra-hard` (`SHIKAKU_LEVELS`), and `SHIKAKU_SIZES` lists the square sides the demo offers (5, 7, 10, 14). The board is cut into interlocking rectangles by packing, not by straight cuts, each carries one number, and the answer is counted independently; every level is checked by solving the board (see [Levels](#levels-of-the-grid-puzzles)). It never returns an unproved board. If no board of a level is found within its attempts the next level down is made instead, which the rating shows.
+- `rateShikaku(board)`: how hard a board is, measured by solving it: `depth` (0 rules alone, 1 supposing one rectangle, 2 more), `rules` (how many of the three rules a depth-0 solve needed), `probes`, and the number, area and ambiguity of the rectangles.
 - `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.
@@ -479,6 +537,146 @@ The demo is `site/shikaku.html` after `pnpm site`; its generator runs in a modul
 
 [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.
 
+## Akari — light the grid
+
+Akari (美術館) places bulbs in white squares. Each bulb lights in straight lines until a black square or the edge. Every white square must be lit, bulbs cannot see each other, and a numbered black square must touch exactly that many bulbs. Boards may be square, wide, tall or custom, with each side from 2 to 16. The seeded generator scatters black squares at random (half the time in rotating pairs), lights them with random bulbs, numbers every black square that touches a white one, and then takes numbers away for as long as the board can still be solved the way the level asks, so the layouts are not a fixed motif. It returns a board only when its answer is proved single.
+
+```js
+import { generateAkari, checkAkari } from "@johnmorrisdotca/kazu/akari";
+import { mountAkari } from "@johnmorrisdotca/kazu/akari/play";
+
+const puzzle = generateAkari(7, 7, 42, "hard"); // width, height, seed, level ("medium" if left out)
+const player = mountAkari(document.querySelector("#board"), {
+  board: puzzle, material: "ivory", pieces: "ink", language: "en",
+});
+// player.progress() saves public clues and bulbs; player.destroy() removes the player.
+```
+
+Use `@johnmorrisdotca/kazu/akari`, `@johnmorrisdotca/kazu/akari/play`, or `@johnmorrisdotca/kazu/akari/draw`. The root package also re-exports the engine; the dedicated drawing and player entries keep those features optional. There are no runtime dependencies.
+
+- `AkariBoard`: width, height and row-major `cells`: `null` is white, `false` is an unnumbered black square, and `0`–`4` are numbered black squares.
+- `generateAkari(width, height, seed, level?)`: deterministic puzzle and its solution at `easy`, `medium`, `hard` or `extra-hard` (`AKARI_LEVELS`; `AKARI_SIZES` lists the square sides on offer: 5, 7, 10, 14). Easy keeps most of its numbers, medium is solved by the rules alone with as few as it can, hard needs supposing a bulb or an empty square, extra-hard needs the most of that. It returns only when an independent count proves exactly one answer; if no board of the level is found within its attempts the next level down is made, and the first generator, which cannot fail, is the last resort.
+- `rateAkari(board)`: how hard a board is, measured by solving it: `depth` (0 rules alone, 1 supposing one square, 2 more), `probes`, and the numbers, bulbs and white squares.
+- `solveAkari(board, {limit?, nodes?})`: counts placements, returns the first answer, visited nodes and `complete`; only `complete && count === 1` proves uniqueness. The default answer limit is two and the node budget is 250,000.
+- `checkAkari(board, bulbs)`: checks a complete placement from the rules, independently of the generated answer. `progressAkari` reports dark squares and immediate conflicts while permitting unfinished numbered clues.
+- `newAkari`, `toggleAkari`, `undoAkari`, `akariFinished`, `hintAkari`: immutable play operations. Hints require a proved unique answer and mark the game as helped.
+- `encodeAkari`, `decodeAkari`: versioned JSON containing only public board data and player bulbs.
+- `drawAkari(board, options)`: SVG with `ivory`, `wood` and `slate` materials, `ink` or `tiles` bulb pieces, and `en` or `ja` labels.
+- `mountAkari(host, options)`: toggle bulbs by tap, click, Enter or Space. Arrow keys move through the grid; Delete removes a bulb. Undo, Check, Hint, Restart and a modal board view are built in. The handle has `game`, `progress`, `set`, `restart` and `destroy`.
+
+The demo is `site/akari.html` after `pnpm site`. It shares Kazu's family header, footer, palette and felt board. Progress stays in local storage; share links carry board settings, not player data.
+
+[Nikoli's Akari rules](https://www.nikoli.co.jp/en/puzzles/akari/) describe the same line-of-sight and numbered-square constraints. These boards are generated here; the implementation does not copy Nikoli's grids or artwork.
+
+## Slitherlink
+
+```js
+import { generateSlitherlink } from "@johnmorrisdotca/kazu/slitherlink";
+import { mountSlitherlink } from "@johnmorrisdotca/kazu/slitherlink/play";
+
+const puzzle = generateSlitherlink(7, 7, 42, "hard"); // width, height, seed, level ("medium" if left out)
+const player = mountSlitherlink(document.querySelector("#board"), {
+  board: puzzle, material: "ivory", language: "en",
+});
+// player.progress() saves the public clues and selected edges.
+```
+
+The Slitherlink engine has its own edge model, checker, progress checker, bounded solution counter, seeded generator and immutable play state. `solveSlitherlink` distinguishes an exhausted search from a proved count; the generator returns only boards proved to have one loop. `generateSlitherlink(width, height, seed, level?)` makes `easy`, `medium`, `hard` or `extra-hard` (`SLITHERLINK_LEVELS`) boards, and `SLITHERLINK_SIZES` lists the square sides on offer (5, 7, 10). `rateSlitherlink(board)` measures a board by solving it: `depth` (0 rules alone, 1 supposing one edge, 2 more), `probes`, the numbers, how many of them say 0, and the loop's length. Boards may be 2–10 cells wide and high. The generator grows a random winding loop (a connected region without holes whose outline never touches itself), numbers every square with how many of its edges the loop uses, and takes numbers away, squares numbered 0 first, for as long as the board can still be solved the way the level asks, so boards are not a few shapes and few squares say 0. The player supports touch and mouse edge toggles, arrow-key focus, Enter/Space, undo, restart, checking, proved hints, save/restore, and ivory, wood and slate materials in English and Japanese.
+
+Use `@johnmorrisdotca/kazu/slitherlink`, `@johnmorrisdotca/kazu/slitherlink/play`, or `@johnmorrisdotca/kazu/slitherlink/draw`. The demo is `site/slitherlink.html` after `pnpm site`. The rules are described by [Nikoli](https://www.nikoli.co.jp/en/puzzles/slitherlink/). This implementation uses original generated layouts and does not copy Nikoli puzzle grids, wording or artwork.
+
+## Ripple Effect
+
+```ts
+import { generateRipple, newRipple, hintRipple } from "@johnmorrisdotca/kazu/ripple";
+import { mountRipple } from "@johnmorrisdotca/kazu/ripple/play";
+
+const puzzle = generateRipple(9, 9, 42);
+const game = newRipple(puzzle);
+const hint = hintRipple(game); // only returned after a unique completion is proved
+const player = mountRipple(document.querySelector<HTMLElement>("#board")!, {
+  board: puzzle, material: "ivory", pieces: "ink", language: "en",
+});
+```
+
+Each room contains every number from 1 through its size exactly once. Repeated N values in one row or column have at least N cells between them, so their coordinate distance must exceed N. The DOM-free engine has independent completion and progress checks and a bounded solution counter that reports when a search stopped before proof. The original seeded 9×9 generator uses 3×3 rooms, seeded row-band, column-stack and digit permutations, and uniqueness-preserving clue removal. It returns only puzzles proved to have one completion; custom sizes are not advertised until their generator family passes the same proof checks. These are original layouts and do not reproduce Nikoli puzzle grids or artwork.
+
+Use `@johnmorrisdotca/kazu/ripple`, `@johnmorrisdotca/kazu/ripple/play`, or `@johnmorrisdotca/kazu/ripple/draw`. The touch and keyboard player includes number entry, pencil notes, undo, restart, checking, unique-proof hints, accessible room boundaries, save/restore, and ivory, wood and slate materials with ink or tile pieces in English and Japanese. The demo is `site/ripple.html` after `pnpm site`. Rules: [Nikoli’s Ripple Effect page](https://www.nikoli.co.jp/en/puzzles/ripple_effect/).
+
+## Kakuro — crossword sums in Kazu
+
+Kakuro fills white cells with digits 1–9. Each across and down run must match its clue sum without repeating a digit. Run lengths are at least two, and every white cell belongs to exactly one run in each direction. [Nikoli describes the rules](https://www.nikoli.co.jp/en/puzzles/kakuro/); generated layouts here are original.
+
+```js
+import { generateKakuro, solveKakuro, checkKakuro } from "@johnmorrisdotca/kazu/kakuro";
+import { mountKakuro } from "@johnmorrisdotca/kazu/kakuro/play";
+
+const puzzle = generateKakuro(42, "hard", 8); // seed, level ("medium"), size including the totals' row and column (10)
+const proof = solveKakuro(puzzle); // uniqueness only when complete && count === 1
+const player = mountKakuro(document.querySelector("#board"), { board: puzzle, language: "en" });
+player.progress(); // public clues, entries and pencil marks; no answer
+```
+
+`@johnmorrisdotca/kazu/kakuro/draw` provides standalone SVG drawing. `generateKakuro(seed, level?, size?)` makes a board of any side from 5 to 12 (`KAKURO_SIZES` lists those on offer: 6, 8, 10, 12) at `easy`, `medium`, `hard` or `extra-hard` (`KAKURO_LEVELS`). It lays out the black squares row by row so that no run is a single square or longer than the level allows, fills random digits, and changes digits or darkens squares until the answer is single; easy and medium also ease the board until the rules they promise are enough, and hard and extra-hard ask for supposing. A board is accepted only after a bounded exact count proves one answer, and a seed never throws: if a level is not found within its attempts the next level down is made, and the first generator is the last resort on a 10×10. `rateKakuro(board)` measures a board by solving it: `depth`, `plain` (the single-run rules were enough), `probes`, the runs, the longest run and the share of totals that can be made one way only. `solveKakuro` reports `complete: false` when its node budget or answer limit stops counting. `checkKakuro` validates completed runs independently; `progressKakuro` permits blanks while marking impossible totals and repeats. The bilingual player supports touch, arrows, digits, pencil mode, Undo, Hint, Check, Restart and versioned saved progress.
+
+The Kakuro entries are `@johnmorrisdotca/kazu/kakuro`, `@johnmorrisdotca/kazu/kakuro/play` and `@johnmorrisdotca/kazu/kakuro/draw`.
+
+## Fillomino — connected regions with exact areas
+
+The dedicated package entries are `@johnmorrisdotca/kazu/fillomino`, `@johnmorrisdotca/kazu/fillomino/play`, and `@johnmorrisdotca/kazu/fillomino/draw`.
+
+Each cell holds a number. All orthogonally connected cells with the same number form a region, and the region's area must equal that number. Two regions of the same area cannot touch. A completed region does not need to contain a printed clue; the checker and solver do not require one clue per region.
+
+```ts
+import { generateFillomino, checkFillomino, solveFillomino } from "@johnmorrisdotca/kazu/fillomino";
+import { mountFillomino } from "@johnmorrisdotca/kazu/fillomino/play";
+
+const puzzle = generateFillomino(6, 6, "hard", 17);
+const result = solveFillomino(puzzle);
+if (!result.complete || result.count !== 1) throw new Error("The answer was not proved unique");
+checkFillomino(puzzle, result.solution);
+mountFillomino(document.querySelector("#board"), { board: puzzle });
+```
+
+`FillominoBoard` contains `width`, `height`, and row-major `givens`, with zero for an empty cell. Engine validation and the seeded generator both support rectangular boards from 4 to 12 cells per side (`FILLOMINO_SIZES` lists the square sides on offer: 6, 8, 10, 12). A seed reproduces its puzzle. The levels are `easy`, `medium`, `hard` and `extra-hard` (`FILLOMINO_LEVELS`), and `rateFillomino(board)` measures a board by solving it: `depth` (0 rules alone, 1 supposing one number, 2 more), `probes`, the givens and their share, the regions, how many have no given and how big they are. The generator cuts the board into connected regions with no two of one size touching, gives every square, and takes givens away while the board can still be solved the way the level asks. Search bounds report when counting stopped rather than treating a partial search as a uniqueness proof.
+
+`checkFillomino(board, entries)` checks givens, oversized connected groups and completion independently of the generated answer. An unfinished group smaller than its number can still grow. `solveFillomino(board, entries?, { limit?, nodes? })` counts filled solutions by growing connected regions, including regions with no given. Only `complete && count === 1` proves uniqueness. `newFillomino`, `setFillominoCell`, `undoFillomino`, `restartFillomino`, `hintFillomino`, and `fillominoFinished` are immutable game helpers. Progress codes contain public clues, entries, and the persistent assisted flag; they contain no stored answer.
+
+The player accepts touch, mouse, and keyboard input, with undo, check, a proved hint, restart, and local progress codes. Hints persistently mark a run as assisted. The English and Japanese player uses the same board materials and number styles as Shikaku. The demo offers 4×4 through 12×12 settings at four levels. It is at [fillomino.html](https://johnmorrisdotca.github.io/kazu/fillomino.html).
+
+[Nikoli's Fillomino rules](https://www.nikoli.co.jp/en/puzzles/fillomino/) describe numbered connected regions, exact area, and separation between equal-area regions. This implementation generates original puzzles and does not reuse published grids or artwork.
+
+## Levels of the grid puzzles
+
+Shikaku, Akari, Slitherlink, Hitori, Fillomino and Kakuro make boards at `easy`, `medium`, `hard` and `extra-hard`. Every board has exactly one answer, and a level says what a person has to do to solve it, measured by solving the board with the package's own rules: easy and medium need only the rules (easy keeps more numbers, medium as few as the rules allow), hard needs supposing something and watching it break, and extra-hard needs the most of that. `rateShikaku`, `rateAkari`, `rateSlitherlink`, `rateHitori`, `rateFillomino` and `rateKakuro` return the measure of a board (`depth`, `probes` and what it is made of), so a site can show it or pick boards by it.
+
+| Kind | Call | Sizes on offer | Largest size, extra-hard: median / slowest to make |
+| --- | --- | --- | --- |
+| Shikaku | `generateShikaku(width, height, level, seed)` | 5, 7, 10, 14 (any side 2–16) | 14 × 14: 89 ms / 302 ms |
+| Akari | `generateAkari(width, height, seed, level?)` | 5, 7, 10, 14 (any side 2–16) | 14 × 14: 212 ms / 366 ms |
+| Slitherlink | `generateSlitherlink(width, height, seed, level?)` | 5, 7, 10 (any side 2–10) | 10 × 10: 231 ms / 286 ms |
+| Hitori | `generateHitori(size, seed, level?)` | 5, 6, 7, 8, 9, 10, 12 (any side 4–12) | 12 × 12: 157 ms / 511 ms |
+| Fillomino | `generateFillomino(width, height, level, seed)` | 6, 8, 10, 12 (any side 4–12) | 12 × 12: 187 ms / 422 ms |
+| Kakuro | `generateKakuro(seed, level?, size?)` | 6, 8, 10, 12 (any side 5–12) | 12 × 12: 273 ms / 1,254 ms |
+
+[docs/LEVELS.md](docs/LEVELS.md) defines each level for each kind, defines the measure, and tables it by size and level over 200 seeds, with the median, 95th percentile and slowest time to make a board; `node scripts/measure-levels.mjs` makes the tables again. These are the same boards in every browser and every Node for a given kind, size, level and seed, but they are **not** the boards 1.2.0 made for that seed.
+
+## Heyawake — rooms and white paths
+
+The Heyawake demo supports rectangular room boards, black/white/blank marking, keyboard and touch play, undo, a contradiction check, unique-solution hints, restart, local progress, and English/Japanese labels. Use `@johnmorrisdotca/kazu/heyawake`, `@johnmorrisdotca/kazu/heyawake/play`, or `@johnmorrisdotca/kazu/heyawake/draw`; generated answers are never included in progress data.
+
+```js
+import { generateHeyawake, checkHeyawake, solveHeyawake } from "@johnmorrisdotca/kazu/heyawake";
+
+const puzzle = generateHeyawake(5, 4, "easy", 17);
+checkHeyawake(puzzle, puzzle.solution); // checks room counts and all three global rules
+solveHeyawake(puzzle); // { count: 1, complete: true, ... }
+```
+
+The engine accepts boards up to 12×12. The original seeded generator supports rectangles from 4 to 8 cells per side, capped at 25 total cells to keep uniqueness proofs bounded. Its easy, medium and hard profiles start with different room-clue densities, then retain more room clues and may split rooms more finely when needed for a uniqueness proof. These are clue profiles, not measured human difficulty. See [the Heyawake rules and API guide](docs/HEYAWAKE.md).
+
+[Nikoli's Heyawake rules](https://www.nikoli.co.jp/en/puzzles/heyawake/) describe numbered room counts, non-touching black cells, connected whites, and a maximum of two rooms in a straight uninterrupted white run. The package generates original grids and uses no published puzzle boards or artwork.
+
 ## Architecture
 
 The generators, the solvers, the check, the hint and the game are plain functions over short codes, with no
@@ -486,25 +684,203 @@ 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
+├── hitori-draw-entry.ts
+├── hitori-entry.ts
+├── hitori-play-entry.ts
+├── hitori.constants.ts
+├── hitori.types.ts
+├── hitoriBoard.ts
+├── hitoriDraw.ts
+├── hitoriGame.ts
+├── hitoriGenerate.ts
+├── hitoriBuild.ts
+├── hitoriLogic.ts
+├── hitoriRate.ts
+├── hitoriMount.ts
+├── hitoriPlay.types.ts
+├── hitoriSolve.ts
+├── hitoriStrings.ts
+├── hitoriStyle.ts
+├── nurikabe-draw-entry.ts
+├── nurikabe-entry.ts
+├── nurikabe-play-entry.ts
+├── nurikabe.constants.ts
+├── nurikabe.types.ts
+├── nurikabeBoard.ts
+├── nurikabeDraw.ts
+├── nurikabeGame.ts
+├── nurikabeGenerate.ts
+├── nurikabeMount.ts
+├── nurikabePlay.types.ts
+├── nurikabeSolve.ts
+├── nurikabeStrings.ts
+├── nurikabeStyle.ts
+├── juosan-draw-entry.ts
+├── juosan-entry.ts
+├── juosan-play-entry.ts
+├── juosan.constants.ts
+├── juosan.types.ts
+├── juosanBoard.ts
+├── juosanDraw.ts
+├── juosanGame.ts
+├── juosanGenerate.ts
+├── juosanMount.ts
+├── juosanPlay.types.ts
+├── juosanSolve.ts
+├── juosanStrings.ts
+├── juosanStyle.ts
+├── masyu-draw-entry.ts
+├── masyu-entry.ts
+├── masyu-play-entry.ts
+├── masyu.constants.ts
+├── masyu.types.ts
+├── masyuBoard.ts
+├── masyuDraw.ts
+├── masyuGame.ts
+├── masyuGenerate.ts
+├── masyuMount.ts
+├── masyuPlay.types.ts
+├── masyuSolve.ts
+├── masyuStrings.ts
+├── masyuStyle.ts
+├── yajilin-draw-entry.ts
+├── yajilin-entry.ts
+├── yajilin-play-entry.ts
+├── yajilin.constants.ts
+├── yajilin.types.ts
+├── yajilinBoard.ts
+├── yajilinDraw.ts
+├── yajilinGame.ts
+├── yajilinGenerate.ts
+├── yajilinMount.ts
+├── yajilinPlay.types.ts
+├── yajilinSolve.ts
+├── yajilinStrings.ts
+├── yajilinStyle.ts
+├── fillomino-draw-entry.ts
+├── fillomino-entry.ts
+├── fillomino-play-entry.ts
+├── fillomino.constants.ts
+├── fillomino.types.ts
+├── fillominoBoard.ts
+├── fillominoDraw.ts
+├── fillominoGame.ts
+├── fillominoGenerate.ts
+├── fillominoBuild.ts
+├── fillominoLogic.ts
+├── fillominoRate.ts
+├── fillominoMount.ts
+├── fillominoPlay.types.ts
+├── fillominoSolve.ts
+├── fillominoStrings.ts
+├── fillominoStyle.ts
+├── fillominoWorker.ts
 ├── shikaku-draw-entry.ts
 ├── shikaku-entry.ts
 ├── shikaku-play-entry.ts
+├── kakuro-draw-entry.ts
+├── kakuro-entry.ts
+├── kakuro-play-entry.ts
+├── kakuro.constants.ts
+├── kakuro.types.ts
+├── kakuroBoard.ts
+├── kakuroDraw.ts
+├── kakuroGame.ts
+├── kakuroGenerate.ts
+├── kakuroBuild.ts
+├── kakuroLogic.ts
+├── kakuroRate.ts
+├── kakuroTemplate.ts
+├── kakuroMount.ts
+├── kakuroPlay.types.ts
+├── kakuroSolve.ts
+├── kakuroStrings.ts
+├── kakuroStyle.ts
 ├── shikaku.constants.ts
 ├── shikaku.types.ts
 ├── shikakuBoard.ts
 ├── shikakuDraw.ts
 ├── shikakuGame.ts
 ├── shikakuGenerate.ts
+├── shikakuBuild.ts
+├── shikakuLogic.ts
+├── shikakuRate.ts
+├── shikakuTemplate.ts
 ├── shikakuMount.ts
+├── shikakuPacks.ts
 ├── shikakuPlay.types.ts
 ├── shikakuSolve.ts
 ├── shikakuStrings.ts
 ├── shikakuStyle.ts
 ├── shikakuWorker.ts
+├── akari-draw-entry.ts
+├── akari-entry.ts
+├── akari-play-entry.ts
+├── akari.constants.ts
+├── akari.types.ts
+├── akariBoard.ts
+├── akariDraw.ts
+├── akariGame.ts
+├── akariGenerate.ts
+├── akariLogic.ts
+├── akariRate.ts
+├── akariTemplate.ts
+├── akariMount.ts
+├── akariPlay.types.ts
+├── akariSolve.ts
+├── akariStrings.ts
+├── akariStyle.ts
+├── slitherlink-draw-entry.ts
+├── slitherlink-entry.ts
+├── slitherlink-play-entry.ts
+├── slitherlink.constants.ts
+├── slitherlink.types.ts
+├── slitherlinkBoard.ts
+├── slitherlinkDraw.ts
+├── slitherlinkGame.ts
+├── slitherlinkGenerate.ts
+├── slitherlinkLogic.ts
+├── slitherlinkRate.ts
+├── slitherlinkTemplate.ts
+├── slitherlinkMount.ts
+├── slitherlinkPlay.types.ts
+├── slitherlinkSolve.ts
+├── slitherlinkStrings.ts
+├── slitherlinkStyle.ts
+├── ripple-draw-entry.ts
+├── ripple-entry.ts
+├── ripple-play-entry.ts
+├── ripple.constants.ts
+├── ripple.types.ts
+├── rippleBoard.ts
+├── rippleDraw.ts
+├── rippleGame.ts
+├── rippleGenerate.ts
+├── rippleMount.ts
+├── ripplePlay.types.ts
+├── rippleSolve.ts
+├── rippleStrings.ts
+├── rippleStyle.ts
+├── heyawake-draw-entry.ts
+├── heyawake-entry.ts
+├── heyawake-play-entry.ts
+├── heyawake.constants.ts
+├── heyawake.types.ts
+├── heyawakeBoard.ts
+├── heyawakeDraw.ts
+├── heyawakeGame.ts
+├── heyawakeGenerate.ts
+├── heyawakeMount.ts
+├── heyawakePlay.types.ts
+├── heyawakeSolve.ts
+├── heyawakeStrings.ts
+├── heyawakeStyle.ts
+├── heyawakeWorker.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
 ├── random.ts           the seeded random numbers every puzzle is made from
+├── csp.ts              the one small engine under the six grid kinds: counting answers, and reasoning with and without supposing
 ├── cells.ts            a grid of numbers as a string, 1 to 9 and A to G
 ├── layout.ts           the groups that must each hold every number once: rows, columns, boxes, regions, diagonals, cages
 ├── groupSolve.ts       the solver for puzzles made of groups: counting, singles, depth
@@ -568,7 +944,7 @@ Using Kazu in something? Open an *Add my project* issue and we will add you.
 ### The family
 
 <!-- family:start (made by scripts/family-readme.mjs from scripts/family-template.mjs; change those, not this) -->
-Kazu is one of nineteen packages, each made for the same site, each at
+Kazu is one of twenty-two packages, each made for the same site, each at
 [github.com/johnmorrisdotca](https://github.com/johnmorrisdotca). The code of every one is MIT.
 
 - [Korokoro](https://github.com/johnmorrisdotca/korokoro) (コロコロ): dice, with notation, exact odds, real sounds and the dice of many games. [Demo](https://johnmorrisdotca.github.io/korokoro/).
@@ -590,8 +966,11 @@ Kazu is one of nineteen packages, each made for the same site, each at
 - [Hikidashi](https://github.com/johnmorrisdotca/hikidashi) (引き出し): a drawer of small Japanese text tools: era dates, kanji numerals, readings and sentence difficulty. [Demo](https://johnmorrisdotca.github.io/hikidashi/).
 - [Chizu](https://github.com/johnmorrisdotca/chizu) (地図): maps of the world and of countries' regions, in English and Japanese, with a quiz and callouts. [Demo](https://johnmorrisdotca.github.io/chizu/).
 - [Bushu](https://github.com/johnmorrisdotca/bushu) (部首): find a kanji by the parts it is made of. [Demo](https://johnmorrisdotca.github.io/bushu/).
+- [Tobiishi](https://github.com/johnmorrisdotca/tobiishi) (飛び石): peg solitaire with nine boards and seeded solvable challenges. [Demo](https://johnmorrisdotca.github.io/tobiishi/).
+- [Jirai](https://github.com/johnmorrisdotca/jirai) (地雷): minesweeper on shaped grids with verified no-guess boards. [Demo](https://johnmorrisdotca.github.io/jirai/).
+- [Gunjin](https://github.com/johnmorrisdotca/gunjin) (軍人): five hidden-rank strategy games with pass-the-device play. [Demo](https://johnmorrisdotca.github.io/gunjin/).
 
-**This package is Kazu.** The demos of all nineteen share one header and footer, so each links the rest.
+**This package is Kazu.** The demos of all twenty-two share one header and footer, so each links the rest.
 <!-- family:end -->
 
 ## Development
@@ -618,3 +997,38 @@ See [CHANGELOG.md](./CHANGELOG.md).
 ## Licence
 
 MIT, © John Morris. The puzzles are made in code and the drawing is SVG; there is no sound and no data file but the record of what the site made.
+
+## Hitori
+
+Hitori is included as a small standalone rules engine, drawing and player. Its public board has a `size` from 4 to 12 (`HITORI_SIZES` lists those on offer: 5, 6, 7, 8, 9, 10, 12) and a flat row-major `numbers` array. A solution is a Boolean shade mask: `true` means black. The solver counts minimal shade patterns, excluding redundant extra black cells; `complete: true` means the search finished, while a node-budget stop never claims uniqueness. `generateHitori(size, seed, level?)` makes `easy`, `medium`, `hard` or `extra-hard` (`HITORI_LEVELS`) puzzles: a random set of shaded squares that never touch and leave the rest in one piece, white squares numbered from a random Latin square so nothing repeats among them, and every shaded square numbered like a white one in its row or column, repaired until the answer is single. Easy is solved by the duplicates, pairs and sandwiches alone, medium once the whites must stay connected, hard by supposing, extra-hard needs the most supposing of several boards. The generator returns only puzzles proved to have one minimal answer, and `rateHitori(board)` measures a board by solving it: `depth`, `reach`, `probes` and how much is shaded and repeated.
+
+```ts
+import { generateHitori, checkHitori, solveHitori } from "@johnmorrisdotca/kazu/hitori";
+import { drawHitori } from "@johnmorrisdotca/kazu/hitori/draw";
+import { mountHitori } from "@johnmorrisdotca/kazu/hitori/play";
+
+const puzzle = generateHitori(9, 42, "hard"); // size, seed, level ("medium" if left out)
+checkHitori(puzzle, puzzle.solution); // { ok: true, errors: [] }
+solveHitori(puzzle);                 // count: 1, complete: true
+```
+
+`newHitori`, `shadeHitori`, `undoHitori`, `hintHitori`, `encodeHitori` and `decodeHitori` keep play state immutable and progress codes free of the answer. Hints are assistance and set `helped`; generated answers are never put into the player state. The demo is `site/hitori.html` after `pnpm site`, and stores progress in this browser only. The implementation follows [Nikoli's Hitori rules](https://www.nikoli.co.jp/en/puzzles/hitori/) and makes its own boards.
+
+Use `@johnmorrisdotca/kazu/hitori`, `@johnmorrisdotca/kazu/hitori/play`, or `@johnmorrisdotca/kazu/hitori/draw`.
+## Nurikabe
+
+Nurikabe is available through its own rules, drawing and player entries. This compact edition makes original 5×5 puzzles from seeded symmetric layouts; it returns a puzzle only after the bounded solver proves exactly one solution. The supported board size is intentionally limited to 5×5 so generation remains quick and dependable.
+
+```ts
+import { generateNurikabe, checkNurikabe, solveNurikabe } from "@johnmorrisdotca/kazu/nurikabe";
+import { drawNurikabe } from "@johnmorrisdotca/kazu/nurikabe/draw";
+import { mountNurikabe } from "@johnmorrisdotca/kazu/nurikabe/play";
+
+const puzzle = generateNurikabe(42);
+checkNurikabe(puzzle, puzzle.solution); // { ok: true, errors: [] }
+solveNurikabe(puzzle);                 // count: 1, complete: true
+```
+
+A clue gives the exact size of its white island; each island has one clue, the remaining black sea is connected, and no 2×2 square is entirely black. `newNurikabe`, `markNurikabeSea`, `undoNurikabe`, `hintNurikabe`, `encodeNurikabe` and `decodeNurikabe` keep the player's state separate from the answer. The demo stores progress locally. The implementation follows [Nikoli's Nurikabe rules](https://www.nikoli.co.jp/en/puzzles/nurikabe/) and uses its own puzzle layouts.
+
+Use `@johnmorrisdotca/kazu/nurikabe`, `@johnmorrisdotca/kazu/nurikabe/play`, or `@johnmorrisdotca/kazu/nurikabe/draw`.

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

@@ -0,0 +1,2 @@
+export { drawAkari } from "./akariDraw.ts";
+export type { AkariDrawOptions } from "./akariPlay.types.ts";

package/dist/akari-draw-entry.js

@@ -0,0 +1 @@
+export { drawAkari } from "./akariDraw.js";

package/dist/akari-entry.d.ts

@@ -0,0 +1,13 @@
+export * from "./akari.types.ts";
+export * from "./akari.constants.ts";
+export * from "./akariBoard.ts";
+export * from "./akariSolve.ts";
+export * from "./akariGenerate.ts";
+export * from "./akariRate.ts";
+export * from "./akariGame.ts";
+export { drawAkari } from "./akariDraw.ts";
+export type { AkariDrawOptions } from "./akariPlay.types.ts";
+export { mountAkari } from "./akariMount.ts";
+export { AKARI_PLAY_STYLE } from "./akariStyle.ts";
+export { AKARI_STRINGS } from "./akariStrings.ts";
+export type * from "./akariPlay.types.ts";