@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/heyawakeStyle.js

@@ -0,0 +1,2 @@
+export const HEYAWAKE_PLAY_STYLE = `
+.kh-root{max-width:40rem;margin:auto;font:inherit;color:inherit}.kh-board{position:relative;max-width:min(92vw,36rem);margin:0 auto}.kh-board svg{display:block}.kh-grid{position:absolute;inset:0;display:grid;touch-action:manipulation}.kh-cell{position:relative;aspect-ratio:1;border:0;background:transparent;color:inherit;font:inherit;padding:0;cursor:pointer}.kh-cell:focus-visible{outline:3px solid var(--kz-select,#ffd45b);outline-offset:-3px;z-index:1}.kh-cell[aria-pressed=true]{font-weight:700}.kh-tools{display:flex;flex-wrap:wrap;justify-content:center;gap:.5rem;margin:.9rem 0}.kh-tools button{min-height:2.75rem;padding:.45rem .8rem;border:1px solid currentColor;border-radius:.5rem;background:transparent;color:inherit;font:inherit}.kh-status,.kh-help{text-align:center;min-height:1.5em}.kh-errors{color:var(--kz-bad,#b5452c)}`;

package/dist/heyawakeWorker.d.ts

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

package/dist/heyawakeWorker.js

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

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

@@ -0,0 +1,2 @@
+export { drawHitori } from "./hitoriDraw.ts";
+export type { HitoriDrawOptions } from "./hitoriPlay.types.ts";

package/dist/hitori-draw-entry.js

@@ -0,0 +1 @@
+export { drawHitori } from "./hitoriDraw.js";

package/dist/hitori-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./hitori.types.ts";
+export * from "./hitori.constants.ts";
+export * from "./hitoriBoard.ts";
+export * from "./hitoriSolve.ts";
+export * from "./hitoriGenerate.ts";
+export * from "./hitoriGame.ts";

package/dist/hitori-entry.js

@@ -0,0 +1,6 @@
+export * from "./hitori.types.js";
+export * from "./hitori.constants.js";
+export * from "./hitoriBoard.js";
+export * from "./hitoriSolve.js";
+export * from "./hitoriGenerate.js";
+export * from "./hitoriGame.js";

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

@@ -0,0 +1,4 @@
+export { mountHitori } from "./hitoriMount.ts";
+export { HITORI_PLAY_STYLE } from "./hitoriStyle.ts";
+export { HITORI_STRINGS } from "./hitoriStrings.ts";
+export type * from "./hitoriPlay.types.ts";

package/dist/hitori-play-entry.js

@@ -0,0 +1,3 @@
+export { mountHitori } from "./hitoriMount.js";
+export { HITORI_PLAY_STYLE } from "./hitoriStyle.js";
+export { HITORI_STRINGS } from "./hitoriStrings.js";

package/dist/hitori.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HITORI_MAX_NODES = 300000;
+export declare const HITORI_SIZES: readonly [5, 7];

package/dist/hitori.constants.js

@@ -0,0 +1,2 @@
+export const HITORI_MAX_NODES = 300000;
+export const HITORI_SIZES = [5, 7];

package/dist/hitori.types.d.ts

@@ -0,0 +1,20 @@
+export type HitoriBoard = {
+    size: 5 | 7;
+    numbers: readonly number[];
+};
+export type HitoriPuzzle = HitoriBoard & {
+    seed: number;
+    solution: readonly boolean[];
+};
+export type HitoriSolve = {
+    count: number;
+    solution: readonly boolean[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type HitoriGame = {
+    board: HitoriBoard;
+    shaded: readonly boolean[];
+    history: readonly (readonly boolean[])[];
+    helped: boolean;
+};

package/dist/hitori.types.js

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

package/dist/hitoriBoard.d.ts

@@ -0,0 +1,8 @@
+import type { HitoriBoard } from "./hitori.types.ts";
+export declare function isHitoriBoard(board: HitoriBoard): boolean;
+export declare function hitoriNeighbors(size: number, cell: number): number[];
+/** Checks unshaded row and column duplicates, adjacent shades, and white connectivity. */
+export declare function checkHitori(board: HitoriBoard, shaded: readonly boolean[]): {
+    ok: boolean;
+    errors: readonly number[];
+};

package/dist/hitoriBoard.js

@@ -0,0 +1,72 @@
+export function isHitoriBoard(board) {
+    return !!board && (board.size === 5 || board.size === 7)
+        && Array.isArray(board.numbers)
+        && board.numbers.length === board.size * board.size
+        && board.numbers.every(value => Number.isInteger(value) && value >= 1 && value <= board.size);
+}
+export function hitoriNeighbors(size, cell) {
+    const x = cell % size, y = Math.floor(cell / size), neighbors = [];
+    if (x > 0)
+        neighbors.push(cell - 1);
+    if (x < size - 1)
+        neighbors.push(cell + 1);
+    if (y > 0)
+        neighbors.push(cell - size);
+    if (y < size - 1)
+        neighbors.push(cell + size);
+    return neighbors;
+}
+/** Checks unshaded row and column duplicates, adjacent shades, and white connectivity. */
+export function checkHitori(board, shaded) {
+    if (!isHitoriBoard(board))
+        return { ok: false, errors: [] };
+    const size = board.size, total = size * size;
+    if (shaded.length !== total || !shaded.every(value => typeof value === "boolean"))
+        return { ok: false, errors: [] };
+    const errors = new Set();
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1) {
+            const cell = y * size + x;
+            if (shaded[cell])
+                continue;
+            for (let otherX = x + 1; otherX < size; otherX += 1) {
+                const other = y * size + otherX;
+                if (!shaded[other] && board.numbers[cell] === board.numbers[other]) {
+                    errors.add(cell);
+                    errors.add(other);
+                }
+            }
+            for (let otherY = y + 1; otherY < size; otherY += 1) {
+                const other = otherY * size + x;
+                if (!shaded[other] && board.numbers[cell] === board.numbers[other]) {
+                    errors.add(cell);
+                    errors.add(other);
+                }
+            }
+        }
+    for (let cell = 0; cell < total; cell += 1)
+        if (shaded[cell]) {
+            for (const neighbor of hitoriNeighbors(size, cell))
+                if (shaded[neighbor]) {
+                    errors.add(cell);
+                    errors.add(neighbor);
+                }
+        }
+    const white = shaded.map((isShaded, cell) => isShaded ? -1 : cell).filter(cell => cell >= 0), reached = new Set();
+    if (white.length) {
+        const stack = [white[0]];
+        reached.add(white[0]);
+        while (stack.length)
+            for (const neighbor of hitoriNeighbors(size, stack.pop())) {
+                if (!shaded[neighbor] && !reached.has(neighbor)) {
+                    reached.add(neighbor);
+                    stack.push(neighbor);
+                }
+            }
+    }
+    if (reached.size !== white.length)
+        for (const cell of white)
+            if (!reached.has(cell))
+                errors.add(cell);
+    return { ok: errors.size === 0, errors: [...errors].sort((a, b) => a - b) };
+}

package/dist/hitoriDraw.d.ts

@@ -0,0 +1,4 @@
+import type { HitoriBoard } from "./hitori.types.ts";
+import type { HitoriDrawOptions } from "./hitoriPlay.types.ts";
+/** SVG text contains only the public numbers and the player's marks. */
+export declare function drawHitori(board: HitoriBoard, options?: HitoriDrawOptions): string;

package/dist/hitoriDraw.js

@@ -0,0 +1,25 @@
+import { isHitoriBoard } from "./hitoriBoard.js";
+/** SVG text contains only the public numbers and the player's marks. */
+export function drawHitori(board, options = {}) {
+    if (!isHitoriBoard(board))
+        throw new RangeError("Invalid Hitori board");
+    const size = board.size, cellSize = 52;
+    const palettes = {
+        ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"],
+        wood: ["#e5cda6", "#493e2f", "#bca582"],
+        slate: ["#333a42", "#f1eee7", "#707984"],
+    };
+    const [paper, ink, grid] = palettes[options.material ?? "ivory"], shaded = options.shaded ?? [];
+    const cells = board.numbers.map((number, cell) => {
+        const x = cell % size * cellSize, y = Math.floor(cell / size) * cellSize;
+        const black = shaded[cell], selected = options.selected === cell, error = options.errors?.includes(cell);
+        const tile = options.pieces === "tiles" && !black
+            ? `<rect x="${x + 10}" y="${y + 10}" width="32" height="32" rx="6" fill="${paper}" stroke="${grid}"/>`
+            : "";
+        const background = black ? ink : selected ? `${ink}22` : paper;
+        const foreground = black ? paper : error ? "#b5452c" : ink;
+        return `<g><rect x="${x}" y="${y}" width="${cellSize}" height="${cellSize}" fill="${background}" stroke="${grid}" stroke-width="1"/>${tile}<text x="${x + cellSize / 2}" y="${y + cellSize / 2}" text-anchor="middle" dominant-baseline="middle" fill="${foreground}" font-size="22" font-weight="${selected ? 700 : 500}" font-family="system-ui,sans-serif">${number}</text></g>`;
+    }).join("");
+    const width = size * cellSize;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${width + 4} ${width + 4}" role="img" aria-label="Hitori" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${width}" height="${width}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/hitoriGame.d.ts

@@ -0,0 +1,10 @@
+import type { HitoriBoard, HitoriGame } from "./hitori.types.ts";
+export declare function newHitori(board: HitoriBoard): HitoriGame;
+export declare function shadeHitori(game: HitoriGame, cell: number): HitoriGame;
+export declare function undoHitori(game: HitoriGame): HitoriGame;
+export declare function restartHitori(game: HitoriGame): HitoriGame;
+/** Gives one next shade in the unique minimal solution, if uniqueness was proved. */
+export declare function hintHitori(game: HitoriGame): number | null;
+/** Versioned public clue and mark data; the generated answer is not saved. */
+export declare function encodeHitori(game: HitoriGame): string;
+export declare function decodeHitori(code: string): HitoriGame | null;

package/dist/hitoriGame.js

@@ -0,0 +1,48 @@
+import { isHitoriBoard } from "./hitoriBoard.js";
+import { solveHitori } from "./hitoriSolve.js";
+export function newHitori(board) {
+    if (!isHitoriBoard(board))
+        throw new RangeError("Invalid Hitori board");
+    return { board: { size: board.size, numbers: [...board.numbers] }, shaded: Array(board.size ** 2).fill(false), history: [], helped: false };
+}
+export function shadeHitori(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.shaded.length)
+        return game;
+    const shaded = [...game.shaded];
+    shaded[cell] = !shaded[cell];
+    return { ...game, shaded, history: [...game.history, [...game.shaded]] };
+}
+export function undoHitori(game) {
+    const prior = game.history.at(-1);
+    return prior ? { ...game, shaded: [...prior], history: game.history.slice(0, -1) } : game;
+}
+export function restartHitori(game) {
+    return { ...game, shaded: Array(game.shaded.length).fill(false), history: [], helped: false };
+}
+/** Gives one next shade in the unique minimal solution, if uniqueness was proved. */
+export function hintHitori(game) {
+    const result = solveHitori(game.board);
+    if (!result.complete || result.count !== 1 || !result.solution)
+        return null;
+    const cell = result.solution.findIndex((isShaded, index) => isShaded !== game.shaded[index]);
+    return cell < 0 ? null : cell;
+}
+/** Versioned public clue and mark data; the generated answer is not saved. */
+export function encodeHitori(game) {
+    return JSON.stringify({ version: 1, board: game.board, shaded: game.shaded, helped: game.helped });
+}
+export function decodeHitori(code) {
+    try {
+        if (code.length > 10000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isHitoriBoard(value.board) || !Array.isArray(value.shaded)
+            || value.shaded.length !== value.board.size ** 2 || !value.shaded.every((cell) => typeof cell === "boolean")
+            || typeof value.helped !== "boolean")
+            return null;
+        return { ...newHitori(value.board), shaded: [...value.shaded], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/hitoriGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { HitoriPuzzle } from "./hitori.types.ts";
+/** Seeded number relabelings and board symmetries of original layouts, accepted only after a uniqueness proof. */
+export declare function generateHitori(size?: 5 | 7, seed?: number): HitoriPuzzle;

package/dist/hitoriGenerate.js

@@ -0,0 +1,163 @@
+import { HITORI_MAX_NODES, HITORI_SIZES } from "./hitori.constants.js";
+import { checkHitori } from "./hitoriBoard.js";
+import { solveHitori } from "./hitoriSolve.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+const layouts = {
+    5: [
+        {
+            numbers: [
+                1, 3, 3, 1, 5, 2, 3,
+                4, 5, 1, 3, 4, 5, 1,
+                2, 4, 5, 1, 2, 3, 5,
+                1, 2, 3, 4,
+            ],
+            shade: [
+                false, true, false, true, false, ...Array(20).fill(false),
+            ],
+        },
+        {
+            numbers: [
+                1, 2, 3, 4, 5, 2, 3,
+                4, 1, 1, 3, 4, 5, 1,
+                2, 3, 5, 1, 4, 3, 5,
+                1, 2, 3, 4,
+            ],
+            shade: [
+                false, false, false, false, false, false, false,
+                false, true, false, false, false, false, false,
+                false, true, false, false, true, false, false,
+                false, false, false, false,
+            ],
+        },
+        {
+            numbers: [
+                1, 4, 3, 4, 1, 2, 3,
+                4, 5, 1, 3, 4, 5, 1,
+                2, 4, 5, 1, 2, 3, 5,
+                1, 2, 3, 4,
+            ],
+            shade: [
+                false, true, false, false, true, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false,
+            ],
+        },
+        {
+            numbers: [
+                1, 4, 3, 4, 5, 2, 3,
+                2, 5, 1, 2, 4, 5, 1,
+                2, 4, 5, 1, 2, 3, 5,
+                5, 2, 3, 4,
+            ],
+            shade: [
+                false, true, false, false, false, false, false,
+                true, false, false, true, false, false, false,
+                false, false, false, false, false, false, false,
+                true, false, false, false,
+            ],
+        },
+    ],
+    7: [
+        {
+            numbers: [
+                1, 2, 3, 4, 2, 6, 7,
+                2, 6, 4, 5, 6, 7, 1,
+                3, 4, 5, 6, 1, 1, 1,
+                4, 5, 6, 7, 1, 2, 3,
+                5, 6, 7, 1, 2, 3, 4,
+                6, 7, 1, 2, 3, 4, 5,
+                7, 1, 2, 3, 4, 5, 6,
+            ],
+            shade: [
+                false, false, false, false, true, false, false,
+                false, true, false, false, false, false, false,
+                false, false, false, false, true, false, true,
+                ...Array(28).fill(false),
+            ],
+        },
+        {
+            numbers: [
+                1, 2, 4, 4, 5, 7, 7,
+                2, 3, 4, 5, 5, 7, 1,
+                3, 4, 5, 6, 7, 1, 2,
+                4, 5, 6, 7, 1, 2, 7,
+                5, 6, 7, 1, 2, 3, 4,
+                6, 2, 1, 2, 3, 4, 5,
+                7, 1, 2, 3, 7, 5, 6,
+            ],
+            shade: [
+                false, false, true, false, false, true, false,
+                false, false, false, false, true, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, true,
+                false, false, false, false, false, false, false,
+                false, true, false, false, false, false, false,
+                false, false, false, false, true, false, false,
+            ],
+        },
+        {
+            numbers: [
+                1, 2, 3, 4, 5, 6, 7,
+                2, 3, 4, 5, 6, 7, 1,
+                3, 4, 5, 6, 1, 1, 6,
+                4, 6, 6, 6, 1, 2, 3,
+                5, 6, 7, 1, 2, 3, 4,
+                6, 7, 1, 2, 3, 4, 5,
+                7, 1, 2, 3, 4, 5, 6,
+            ],
+            shade: [
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, true, false, true,
+                false, true, false, true, false, false, false,
+                false, false, false, false, false, false, false,
+                false, ...Array(13).fill(false),
+            ],
+        },
+        {
+            numbers: [
+                1, 2, 3, 4, 6, 6, 7,
+                2, 2, 4, 5, 6, 2, 1,
+                3, 4, 5, 6, 7, 1, 2,
+                4, 5, 6, 7, 1, 2, 3,
+                5, 6, 7, 1, 2, 3, 4,
+                6, 7, 1, 2, 3, 4, 5,
+                7, 1, 2, 3, 6, 5, 6,
+            ],
+            shade: [
+                false, false, false, false, true, false, false,
+                false, true, false, false, false, true, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, false, false, false,
+                false, false, false, false, true, false, false,
+            ],
+        },
+    ],
+};
+/** Seeded number relabelings and board symmetries of original layouts, accepted only after a uniqueness proof. */
+export function generateHitori(size = 5, seed = 1) {
+    if (!HITORI_SIZES.includes(size) || !isKazuSeed(seed))
+        throw new RangeError("Invalid Hitori settings");
+    const random = seededRandom(seed), templates = layouts[size];
+    const template = templates[Math.floor(random() * templates.length)];
+    const labels = shuffled(Array.from({ length: size }, (_, index) => index + 1), random);
+    const turns = Math.floor(random() * 4), reflected = random() < 0.5;
+    const numbers = Array(size * size), solution = Array(size * size);
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1) {
+            let tx = reflected ? size - 1 - x : x, ty = y;
+            for (let turn = 0; turn < turns; turn += 1)
+                [tx, ty] = [size - 1 - ty, tx];
+            const source = y * size + x, destination = ty * size + tx;
+            numbers[destination] = labels[template.numbers[source] - 1];
+            solution[destination] = template.shade[source];
+        }
+    const board = { size, numbers }, proof = solveHitori(board, { nodes: HITORI_MAX_NODES });
+    if (!checkHitori(board, solution).ok || !proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Hitori found within the generation budget; try another seed");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/hitoriMount.d.ts

@@ -0,0 +1,3 @@
+import type { HitoriMount, HitoriMountOptions } from "./hitoriPlay.types.ts";
+/** A keyboard- and touch-friendly Hitori player, mounted in any host element. */
+export declare function mountHitori(host: HTMLElement, initial: HitoriMountOptions): HitoriMount;

package/dist/hitoriMount.js

@@ -0,0 +1,111 @@
+import { checkHitori } from "./hitoriBoard.js";
+import { decodeHitori, encodeHitori, hintHitori, newHitori, restartHitori, shadeHitori, undoHitori } from "./hitoriGame.js";
+import { drawHitori } from "./hitoriDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { HITORI_PLAY_STYLE } from "./hitoriStyle.js";
+import { hitoriWords } from "./hitoriStrings.js";
+/** A keyboard- and touch-friendly Hitori player, mounted in any host element. */
+export function mountHitori(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial }, game = initial.progress ? decodeHitori(initial.progress) : null;
+    game ?? (game = newHitori(initial.board));
+    let selected = 0, errors = [], message = "", finished = checkHitori(game.board, game.shaded).ok, dead = false;
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div");
+    const status = doc.createElement("p"), tools = doc.createElement("div"), help = doc.createElement("p");
+    root.className = "kh-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ks-palette") + HITORI_PLAY_STYLE;
+    board.className = "kh-board";
+    status.className = "kh-status";
+    status.setAttribute("role", "status");
+    tools.className = "kh-tools";
+    help.className = "kh-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({ ...game, board: { ...game.board, numbers: [...game.board.numbers] }, shaded: [...game.shaded], history: game.history.map(turn => [...turn]) });
+    const button = (label, action, disabled = false) => {
+        const control = doc.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.onclick = action;
+        tools.append(control);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        const wasFinished = finished;
+        finished = checkHitori(game.board, game.shaded).ok;
+        render();
+        options.onChange?.(copy());
+        if (finished && !wasFinished)
+            options.onFinish?.(copy());
+    };
+    const shade = (cell) => {
+        if (finished)
+            return;
+        selected = cell;
+        game = shadeHitori(game, cell);
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const words = hitoriWords(options.language), focused = board.contains(doc.activeElement), size = game.board.size;
+        board.innerHTML = drawHitori(game.board, { ...options, shaded: game.shaded, selected, errors });
+        const cells = doc.createElement("div");
+        cells.className = "kh-cells";
+        cells.style.gridTemplateColumns = `repeat(${size},1fr)`;
+        for (let cell = 0; cell < game.shaded.length; cell += 1) {
+            const control = doc.createElement("button");
+            control.type = "button";
+            control.className = "kh-cell";
+            control.dataset.cell = String(cell);
+            control.tabIndex = cell === selected ? 0 : -1;
+            const state = game.shaded[cell] ? words.shaded : words.white;
+            control.setAttribute("aria-label", `${words.cell} ${Math.floor(cell / size) + 1}, ${words.column} ${cell % size + 1}: ${game.board.numbers[cell]}, ${state}`);
+            control.setAttribute("aria-pressed", String(game.shaded[cell]));
+            control.onclick = () => shade(cell);
+            control.onkeydown = event => {
+                const moves = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -size, ArrowDown: size };
+                if (event.key in moves) {
+                    event.preventDefault();
+                    selected = Math.max(0, Math.min(game.shaded.length - 1, cell + moves[event.key]));
+                    render();
+                }
+                else if (event.key === " " || event.key === "Enter") {
+                    event.preventDefault();
+                    shade(cell);
+                }
+            };
+            cells.append(control);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = finished ? (game.helped ? words.helped : words.won) : message;
+        help.textContent = words.help;
+        tools.replaceChildren();
+        button(words.undo, () => { game = undoHitori(game); changed(); }, !game.history.length);
+        button(words.check, () => { errors = checkHitori(game.board, game.shaded).errors; message = errors.length ? words.bad : words.good; render(); });
+        button(words.hint, () => {
+            const cell = hintHitori(game);
+            if (cell === null) {
+                message = words.noHint;
+                render();
+                return;
+            }
+            selected = cell;
+            game = { ...shadeHitori(game, cell), helped: true };
+            changed();
+        }, finished);
+        button(words.restart, () => { game = restartHitori(game); finished = false; changed(); });
+    };
+    render();
+    return {
+        game: copy,
+        progress: () => encodeHitori(game),
+        restart: () => { game = restartHitori(game); finished = false; changed(); },
+        set: (next) => { options = { ...options, ...next }; render(); },
+        destroy: () => { dead = true; root.remove(); },
+    };
+}

package/dist/hitoriPlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { HitoriBoard, HitoriGame } from "./hitori.types.ts";
+export type HitoriLanguage = "en" | "ja";
+export type HitoriMaterial = "ivory" | "wood" | "slate";
+export type HitoriPieces = "ink" | "tiles";
+export type HitoriDrawOptions = {
+    shaded?: readonly boolean[];
+    selected?: number | null;
+    errors?: readonly number[];
+    material?: HitoriMaterial;
+    pieces?: HitoriPieces;
+    language?: HitoriLanguage;
+};
+export type HitoriMountOptions = HitoriDrawOptions & {
+    board: HitoriBoard;
+    progress?: string;
+    onChange?: (game: HitoriGame) => void;
+    onFinish?: (game: HitoriGame) => void;
+};
+export type HitoriMount = {
+    game: () => HitoriGame;
+    progress: () => string;
+    restart: () => void;
+    set: (options: HitoriDrawOptions) => void;
+    destroy: () => void;
+};

package/dist/hitoriPlay.types.js

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

package/dist/hitoriSolve.d.ts

@@ -0,0 +1,6 @@
+import type { HitoriBoard, HitoriSolve } from "./hitori.types.ts";
+/** Counts distinct minimal shade patterns. A non-complete result never asserts uniqueness. */
+export declare function solveHitori(board: HitoriBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): HitoriSolve;

package/dist/hitoriSolve.js

@@ -0,0 +1,69 @@
+import { HITORI_MAX_NODES } from "./hitori.constants.js";
+import { checkHitori, hitoriNeighbors, isHitoriBoard } from "./hitoriBoard.js";
+function firstUnshadedDuplicate(board, shaded) {
+    const size = board.size;
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1) {
+            const cell = y * size + x;
+            if (shaded[cell])
+                continue;
+            for (let otherX = x + 1; otherX < size; otherX += 1) {
+                const other = y * size + otherX;
+                if (!shaded[other] && board.numbers[cell] === board.numbers[other])
+                    return [cell, other];
+            }
+            for (let otherY = y + 1; otherY < size; otherY += 1) {
+                const other = otherY * size + x;
+                if (!shaded[other] && board.numbers[cell] === board.numbers[other])
+                    return [cell, other];
+            }
+        }
+    return null;
+}
+/** A valid answer cannot contain an unnecessary shade; this avoids treating extra black cells as separate puzzle solutions. */
+function isMinimalSolution(board, shaded) {
+    if (!checkHitori(board, shaded).ok)
+        return false;
+    for (let cell = 0; cell < shaded.length; cell += 1)
+        if (shaded[cell]) {
+            const smaller = [...shaded];
+            smaller[cell] = false;
+            if (checkHitori(board, smaller).ok)
+                return false;
+        }
+    return true;
+}
+/** Counts distinct minimal shade patterns. A non-complete result never asserts uniqueness. */
+export function solveHitori(board, options = {}) {
+    if (!isHitoriBoard(board))
+        throw new RangeError("Invalid Hitori board");
+    const limit = Math.max(1, Math.floor(options.limit ?? 2));
+    const budget = Math.max(1, Math.floor(options.nodes ?? HITORI_MAX_NODES));
+    let nodes = 0, count = 0, solution = null, exhausted = false;
+    const search = (shaded) => {
+        if (count >= limit || exhausted)
+            return;
+        nodes += 1;
+        if (nodes > budget) {
+            exhausted = true;
+            return;
+        }
+        const duplicate = firstUnshadedDuplicate(board, shaded);
+        if (!duplicate) {
+            if (isMinimalSolution(board, shaded)) {
+                count += 1;
+                solution ?? (solution = [...shaded]);
+            }
+            return;
+        }
+        for (const cell of duplicate) {
+            if (hitoriNeighbors(board.size, cell).some(neighbor => shaded[neighbor]))
+                continue;
+            shaded[cell] = true;
+            search(shaded);
+            shaded[cell] = false;
+        }
+    };
+    search(Array(board.size * board.size).fill(false));
+    return { count, solution, complete: !exhausted && count < limit, nodes: Math.min(nodes, budget) };
+}