@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [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,8 @@ 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.
 - **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 +443,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, wide (10 × 6), tall (6 × 10) and custom rectangular boards, with width and height from 2 to 16. 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,10 +498,28 @@ 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.
@@ -479,6 +535,130 @@ 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 uses original horizontal and vertical paired-room layouts, varies bulb directions, and reflects the rooms across either axis. It rejects every board whose uniqueness proof does not finish.
+
+```js
+import { generateAkari, checkAkari } from "@johnmorrisdotca/kazu/akari";
+import { mountAkari } from "@johnmorrisdotca/kazu/akari/play";
+
+const puzzle = generateAkari(7, 7, 42);
+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)`: deterministic puzzle and its solution, selected from original horizontal and vertical paired-room layouts with seed-chosen bulb directions and symmetry. It returns only when an independent bounded count proves exactly one answer.
+- `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);
+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. Boards may be 2–10 cells wide and high. The original generator uses rectangular and L-shaped loop families with seed-selected positions and reflections; its profiles describe these families, not human difficulty. 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);
+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. The 10×10 seeded family uses crossing 2×2, 2×3, 3×2 and 3×3 regions of white cells with separated runs; every returned layout is accepted only after a bounded exact count proves one answer. This is a defined family, not a general-purpose random-layout generator. `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(5, 5, "easy", 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 supports boards up to 12×12; the seeded generator supports rectangular boards from 4 to 8 cells per side, capped at 36 total cells. A seed reproduces its puzzle. Easy, medium and hard are clue-density profiles rather than measured human difficulty; the generator retains additional clues when needed to prove uniqueness. 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 6×6 settings. 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.
+
+## 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,9 +666,108 @@ 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
+├── 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
+├── 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
+├── kakuroMount.ts
+├── kakuroPlay.types.ts
+├── kakuroSolve.ts
+├── kakuroStrings.ts
+├── kakuroStyle.ts
 ├── shikaku.constants.ts
 ├── shikaku.types.ts
 ├── shikakuBoard.ts
@@ -496,11 +775,69 @@ the page's part (the mount and the element) is another.
 ├── shikakuGame.ts
 ├── shikakuGenerate.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
+├── 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
+├── 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
@@ -618,3 +955,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` of 5 or 7 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. Four original layouts per size are varied by seeded number relabeling and all board symmetries; the generator returns only puzzles proved to have one minimal answer.
+
+```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(5, 42);
+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,12 @@
+export * from "./akari.types.ts";
+export * from "./akari.constants.ts";
+export * from "./akariBoard.ts";
+export * from "./akariSolve.ts";
+export * from "./akariGenerate.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";

package/dist/akari-entry.js

@@ -0,0 +1,10 @@
+export * from "./akari.types.js";
+export * from "./akari.constants.js";
+export * from "./akariBoard.js";
+export * from "./akariSolve.js";
+export * from "./akariGenerate.js";
+export * from "./akariGame.js";
+export { drawAkari } from "./akariDraw.js";
+export { mountAkari } from "./akariMount.js";
+export { AKARI_PLAY_STYLE } from "./akariStyle.js";
+export { AKARI_STRINGS } from "./akariStrings.js";

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

@@ -0,0 +1,2 @@
+export { mountAkari } from "./akariMount.ts";
+export type { AkariMount, AkariMountOptions, AkariDrawOptions, AkariLanguage, AkariMaterial, AkariPieces } from "./akariPlay.types.ts";

package/dist/akari-play-entry.js

@@ -0,0 +1 @@
+export { mountAkari } from "./akariMount.js";

package/dist/akari.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const AKARI_MOST_SIDE = 16;
+export declare const AKARI_MOST_NODES = 250000;

package/dist/akari.constants.js

@@ -0,0 +1,2 @@
+export const AKARI_MOST_SIDE = 16;
+export const AKARI_MOST_NODES = 250000;

package/dist/akari.types.d.ts

@@ -0,0 +1,33 @@
+/** A board is row-major. null is white, false is a plain black square, and 0–4 are numbered black squares. */
+export type AkariBoard = {
+    width: number;
+    height: number;
+    cells: readonly (number | null | false)[];
+};
+export type AkariPuzzle = AkariBoard & {
+    seed: number;
+    solution: readonly number[];
+};
+export type AkariCheck = {
+    ok: boolean;
+    illuminated: number;
+    errors: readonly number[];
+    dark: readonly number[];
+    numbered: readonly number[];
+    conflicts: readonly number[];
+};
+export type AkariProgress = Omit<AkariCheck, "ok"> & {
+    ok: boolean;
+};
+export type AkariSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type AkariGame = {
+    board: AkariBoard;
+    bulbs: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};

package/dist/akari.types.js

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

package/dist/akariBoard.d.ts

@@ -0,0 +1,11 @@
+import type { AkariBoard, AkariCheck, AkariProgress } from "./akari.types.ts";
+/** Validates dimensions and the three public square kinds. */
+export declare function isAkariBoard(value: unknown): value is AkariBoard;
+/** Returns the orthogonally adjacent cells to a board position. */
+export declare function akariNeighbours(board: AkariBoard, cell: number): number[];
+/** White squares visible from a cell, including itself, stopping at black squares and edges. */
+export declare function akariVisible(board: AkariBoard, cell: number): number[];
+/** Checks a complete placement from the public rules, without consulting a stored answer. */
+export declare function checkAkari(board: AkariBoard, bulbs: readonly number[]): AkariCheck;
+/** Reports immediate contradictions while allowing required clues to remain unsatisfied during play. */
+export declare function progressAkari(board: AkariBoard, bulbs: readonly number[]): AkariProgress;