@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/heyawakeMount.js

@@ -0,0 +1,106 @@
+import { checkHeyawake, isHeyawakeBoard } from "./heyawakeBoard.js";
+import { decodeHeyawake, encodeHeyawake, hintHeyawake, newHeyawake, restartHeyawake, setHeyawakeCell, undoHeyawake, heyawakeFinished } from "./heyawakeGame.js";
+import { drawHeyawake } from "./heyawakeDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { HEYAWAKE_PLAY_STYLE } from "./heyawakeStyle.js";
+import { heyawakeWords } from "./heyawakeStrings.js";
+export function mountHeyawake(host, initial) {
+    if (!isHeyawakeBoard(initial.board))
+        throw new RangeError("Invalid Heyawake board");
+    const doc = host.ownerDocument;
+    let options = { ...initial }, game = initial.progress ? decodeHeyawake(initial.progress) : null;
+    if (!game || JSON.stringify(game.board) !== JSON.stringify(initial.board))
+        game = newHeyawake(initial.board);
+    let selected = 0, errors = [], message = "", dead = false, finished = heyawakeFinished(game);
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div"), grid = doc.createElement("div"), status = doc.createElement("p"), tools = doc.createElement("div"), help = doc.createElement("p");
+    root.className = "kh-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".kh-palette") + HEYAWAKE_PLAY_STYLE;
+    board.className = "kh-board";
+    grid.className = "kh-grid";
+    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: { width: game.board.width, height: game.board.height, rooms: game.board.rooms.map(room => ({ ...room })) }, entries: [...game.entries], history: game.history.map(turn => [...turn]) });
+    const words = () => heyawakeWords(options.language);
+    const button = (label, action, disabled = false) => { const item = doc.createElement("button"); item.type = "button"; item.textContent = label; item.disabled = disabled; item.onclick = action; tools.append(item); };
+    const changed = () => {
+        errors = [];
+        message = "";
+        const won = heyawakeFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("heyawake-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("heyawake-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const choose = (cell) => {
+        if (finished)
+            return;
+        selected = cell;
+        const value = game.entries[cell] === null ? true : game.entries[cell] === true ? false : null;
+        game = setHeyawakeCell(game, cell, value);
+        changed();
+    };
+    const restart = () => { game = restartHeyawake(game); finished = false; changed(); };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words(), b = game.board, focused = grid.contains(doc.activeElement);
+        board.classList.toggle("kh-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawHeyawake(b, { ...options, entries: game.entries, selected, errors });
+        grid.replaceChildren();
+        grid.style.gridTemplateColumns = `repeat(${b.width},1fr)`;
+        game.entries.forEach((entry, cellIndex) => {
+            const cell = doc.createElement("button");
+            cell.type = "button";
+            cell.className = "kh-cell";
+            cell.dataset.cell = String(cellIndex);
+            cell.tabIndex = cellIndex === selected ? 0 : -1;
+            cell.setAttribute("aria-label", `${w.row} ${Math.floor(cellIndex / b.width) + 1}, ${w.column} ${cellIndex % b.width + 1}: ${entry === true ? w.black : entry === false ? w.white : w.blank}`);
+            cell.setAttribute("aria-pressed", String(entry !== null));
+            cell.onclick = () => choose(cellIndex);
+            cell.onkeydown = event => {
+                const moves = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -b.width, ArrowDown: b.width };
+                if (event.key in moves) {
+                    event.preventDefault();
+                    selected = Math.max(0, Math.min(game.entries.length - 1, cellIndex + moves[event.key]));
+                    render();
+                }
+                else if (event.key === " " || event.key === "Enter") {
+                    event.preventDefault();
+                    choose(cellIndex);
+                }
+            };
+            grid.append(cell);
+        });
+        board.append(grid);
+        if (focused)
+            grid.querySelector(`[data-cell="${selected}"]`)?.focus();
+        const checked = checkHeyawake(b, game.entries);
+        status.textContent = heyawakeFinished(game) ? game.helped ? w.helped : w.won : message || (errors.length ? w.wrong : "");
+        status.classList.toggle("kh-errors", errors.length > 0);
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => { game = undoHeyawake(game); finished = heyawakeFinished(game); changed(); }, !game.history.length);
+        button(w.check, () => { errors = checked.errors; message = checked.errors.length === 0 ? w.checked : w.wrong; render(); });
+        button(w.hint, () => {
+            const hint = hintHeyawake(game);
+            if (!hint) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...setHeyawakeCell(game, hint.cell, hint.value), helped: true };
+            changed();
+        }, finished);
+        button(w.restart, restart);
+    };
+    render();
+    return { game: copy, progress: () => encodeHeyawake(game), restart, set: (next) => { options = { ...options, ...next }; render(); }, destroy: () => { dead = true; root.remove(); } };
+}

package/dist/heyawakePlay.types.d.ts

@@ -0,0 +1,24 @@
+import type { HeyawakeGame, HeyawakeBoard } from "./heyawake.types.ts";
+export type HeyawakeAppearance = {
+    language?: "en" | "ja";
+    material?: "ivory" | "wood" | "slate";
+    pieces?: "ink" | "tiles";
+};
+export type HeyawakeMountOptions = HeyawakeAppearance & {
+    board: HeyawakeBoard;
+    progress?: string;
+    onChange?: (game: HeyawakeGame) => void;
+    onFinish?: (game: HeyawakeGame) => void;
+};
+export type HeyawakeDrawOptions = HeyawakeAppearance & {
+    entries?: readonly (boolean | null)[];
+    selected?: number;
+    errors?: readonly number[];
+};
+export type HeyawakeMount = {
+    game: () => HeyawakeGame;
+    progress: () => string;
+    restart: () => void;
+    set: (options: HeyawakeAppearance) => void;
+    destroy: () => void;
+};

package/dist/heyawakePlay.types.js

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

package/dist/heyawakeSolve.d.ts

@@ -0,0 +1,5 @@
+import type { HeyawakeBoard, HeyawakeSolve } from "./heyawake.types.ts";
+export declare function solveHeyawake(board: HeyawakeBoard, entries?: readonly (boolean | null)[], options?: {
+    limit?: number;
+    nodes?: number;
+}): HeyawakeSolve;

package/dist/heyawakeSolve.js

@@ -0,0 +1,52 @@
+import { HEYAWAKE_MOST_NODES } from "./heyawake.constants.js";
+import { checkHeyawake, heyawakeCells, heyawakeNeighbours, isHeyawakeBoard, roomForCell } from "./heyawakeBoard.js";
+export function solveHeyawake(board, entries = Array(board.width * board.height).fill(null), options = {}) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    const limit = Math.max(1, Math.floor(options.limit ?? 2)), maxNodes = Math.max(1, Math.floor(options.nodes ?? HEYAWAKE_MOST_NODES));
+    const work = [...entries], ids = roomForCell(board), roomCells = board.rooms.map(room => heyawakeCells(board, room));
+    if (work.length !== board.width * board.height || work.some(value => value !== true && value !== false && value !== null))
+        throw new RangeError("Invalid Heyawake entries");
+    let count = 0, nodes = 0, solution = null, stopped = false;
+    const visit = (index) => {
+        if (count >= limit || stopped)
+            return;
+        if (++nodes > maxNodes) {
+            stopped = true;
+            return;
+        }
+        if (index === work.length) {
+            const checked = checkHeyawake(board, work);
+            if (checked.ok) {
+                count += 1;
+                solution ?? (solution = work.map(value => value === true));
+            }
+            return;
+        }
+        if (work[index] !== null) {
+            visit(index + 1);
+            return;
+        }
+        const optionsAtCell = [false, true];
+        for (const black of optionsAtCell) {
+            if (black && heyawakeNeighbours(board, index).some(next => work[next] === true))
+                continue;
+            work[index] = black;
+            const room = board.rooms[ids[index]], cells = roomCells[ids[index]];
+            if (room.blacks !== null) {
+                const marked = cells.filter(cell => work[cell] === true).length;
+                const unknown = cells.filter(cell => work[cell] === null).length;
+                if (marked > room.blacks || marked + unknown < room.blacks) {
+                    work[index] = null;
+                    continue;
+                }
+            }
+            visit(index + 1);
+            work[index] = null;
+            if (count >= limit || stopped)
+                break;
+        }
+    };
+    visit(0);
+    return { count, solution, nodes: Math.min(nodes, maxNodes), complete: !stopped && count < limit };
+}

package/dist/heyawakeStrings.d.ts

@@ -0,0 +1,19 @@
+export declare function heyawakeWords(language?: "en" | "ja"): {
+    title: string;
+    ready: string;
+    wrong: string;
+    checked: string;
+    won: string;
+    helped: string;
+    undo: string;
+    check: string;
+    hint: string;
+    restart: string;
+    help: string;
+    black: string;
+    white: string;
+    blank: string;
+    row: string;
+    column: string;
+    noHint: string;
+};

package/dist/heyawakeStrings.js

@@ -0,0 +1,7 @@
+export function heyawakeWords(language = "en") {
+    return language === "ja" ? {
+        title: "へやわけ", ready: "マスを選び、白・黒・空白を切り替えます", wrong: "ルールに合わないマスがあります", checked: "今のところ矛盾はありません", won: "完成しました", helped: "ヒントを使って完成しました", undo: "元に戻す", check: "確認", hint: "ヒント", restart: "やり直す", help: "黒マスは辺でつながらず、白マスは一続きです。白い直線は部屋を二つまで通ります。", black: "黒", white: "白", blank: "未入力", row: "行", column: "列", noHint: "一意に解ける状態ではありません"
+    } : {
+        title: "Heyawake", ready: "Select a cell to cycle white, black and blank", wrong: "Some cells break a rule", checked: "No contradiction found so far", won: "Puzzle complete", helped: "Solved with a hint", undo: "Undo", check: "Check", hint: "Hint", restart: "Restart", help: "Black cells do not touch; white cells stay connected. A straight white run spans at most two rooms.", black: "black", white: "white", blank: "blank", row: "row", column: "column", noHint: "A unique solution is not established"
+    };
+}

package/dist/heyawakeStyle.d.ts

@@ -0,0 +1 @@
+export declare const HEYAWAKE_PLAY_STYLE = "\n.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/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,7 @@
+export * from "./hitori.types.ts";
+export * from "./hitori.constants.ts";
+export * from "./hitoriBoard.ts";
+export * from "./hitoriSolve.ts";
+export * from "./hitoriGenerate.ts";
+export * from "./hitoriRate.ts";
+export * from "./hitoriGame.ts";

package/dist/hitori-entry.js

@@ -0,0 +1,7 @@
+export * from "./hitori.types.js";
+export * from "./hitori.constants.js";
+export * from "./hitoriBoard.js";
+export * from "./hitoriSolve.js";
+export * from "./hitoriGenerate.js";
+export * from "./hitoriRate.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,8 @@
+export declare const HITORI_MAX_NODES = 300000;
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export declare const HITORI_SIZES: readonly [5, 6, 7, 8, 9, 10, 12];
+export declare const HITORI_MOST_SIDE = 12;
+export declare const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export declare const HITORI_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+export declare const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.constants.js

@@ -0,0 +1,8 @@
+export const HITORI_MAX_NODES = 300000;
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export const HITORI_SIZES = [5, 6, 7, 8, 9, 10, 12];
+export const HITORI_MOST_SIDE = 12;
+export const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export const HITORI_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+export const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.types.d.ts

@@ -0,0 +1,37 @@
+export type HitoriBoard = {
+    size: number;
+    numbers: readonly number[];
+};
+export type HitoriLevel = "easy" | "medium" | "hard" | "extra-hard";
+export type HitoriPuzzle = HitoriBoard & {
+    seed: number;
+    level: HitoriLevel;
+    solution: readonly boolean[];
+};
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the rules solve it, 1 that somebody has to suppose a
+ * square shaded or white and watch it break, 2 that more than that is needed. `reach` says the rule that the white
+ * squares stay in one piece was needed at depth 0. `probes` is the suppositions depth 1 needed.
+ */
+export type HitoriRating = {
+    depth: 0 | 1 | 2;
+    reach: boolean;
+    probes: number;
+    shaded: number;
+    /** Shaded squares as a share of the board. */
+    shadedShare: number;
+    /** Squares whose number repeats in their row or column, as a share of the board. */
+    repeatShare: number;
+};
+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,73 @@
+import { HITORI_LEAST_SIDE, HITORI_MOST_SIDE } from "./hitori.constants.js";
+export function isHitoriBoard(board) {
+    return !!board && Number.isInteger(board.size) && board.size >= HITORI_LEAST_SIDE && board.size <= HITORI_MOST_SIDE
+        && 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/hitoriBuild.d.ts

@@ -0,0 +1,12 @@
+import type { HitoriBoard, HitoriLevel } from "./hitori.types.ts";
+import type { Random } from "./random.ts";
+export declare const SHARE: Record<HitoriLevel, number>;
+/** A board with one answer, or null when the random choices did not lead to one. How the numbers are chosen leans on the level. */
+export declare function candidateHitori(size: number, level: HitoriLevel, random: Random, base?: readonly number[]): {
+    board: HitoriBoard;
+    shaded: readonly boolean[];
+} | null;
+/** A random Latin square: every number once in each row and column, built row by row with backtracking. */
+export declare function latinSquare(size: number, random: Random): number[] | null;
+/** The same square with its rows, columns and numbers renamed at random: still one of each in every line. */
+export declare function isotope(square: readonly number[], size: number, random: Random): number[];

package/dist/hitoriBuild.js

@@ -0,0 +1,117 @@
+import { hitoriNeighbors } from "./hitoriBoard.js";
+import { hitoriModel } from "./hitoriLogic.js";
+import { countCsp, openSlots } from "./csp.js";
+import { shuffled } from "./random.js";
+export const SHARE = { easy: .26, medium: .27, hard: .28, "extra-hard": .3 };
+/** A board with one answer, or null when the random choices did not lead to one. How the numbers are chosen leans on the level. */
+export function candidateHitori(size, level, random, base = latinSquare(size, random) ?? []) {
+    const total = size * size;
+    if (base.length !== total)
+        return null;
+    const target = Math.round(total * SHARE[level] * (.9 + random() * .2));
+    const shaded = Array(total).fill(false);
+    let count = 0;
+    const around = Array.from({ length: total }, (_, cell) => hitoriNeighbors(size, cell));
+    const mark = new Int32Array(total), stack = new Int32Array(total);
+    let stamp = 0;
+    const connected = () => {
+        const first = shaded.indexOf(false);
+        stamp += 1;
+        let top = 0, reached = 1;
+        stack[top++] = first;
+        mark[first] = stamp;
+        while (top)
+            for (const next of around[stack[--top]])
+                if (!shaded[next] && mark[next] !== stamp) {
+                    mark[next] = stamp;
+                    reached += 1;
+                    stack[top++] = next;
+                }
+        return reached === total - count;
+    };
+    for (const cell of shuffled(Array.from({ length: total }, (_, i) => i), random)) {
+        if (count >= target)
+            break;
+        if (around[cell].some(next => shaded[next]))
+            continue;
+        shaded[cell] = true;
+        count += 1;
+        if (!connected()) {
+            shaded[cell] = false;
+            count -= 1;
+        }
+    }
+    if (count < Math.max(2, target - 2))
+        return null;
+    const numbers = isotope(base, size, random).map((n, cell) => shaded[cell] ? 0 : n);
+    const partnersOf = (cell) => {
+        const x = cell % size, y = Math.floor(cell / size), found = [];
+        for (let k = 0; k < size; k += 1) {
+            if (k !== x && !shaded[y * size + k])
+                found.push(y * size + k);
+            if (k !== y && !shaded[k * size + x])
+                found.push(k * size + x);
+        }
+        return found;
+    };
+    const blacks = shaded.flatMap((on, cell) => on ? [cell] : []);
+    for (const cell of blacks) {
+        const options = partnersOf(cell);
+        if (!options.length)
+            return null;
+        numbers[cell] = numbers[options[Math.floor(random() * options.length)]];
+    }
+    const board = { size, numbers };
+    const { csp } = hitoriModel(board, 2);
+    let proof = countCsp(csp, openSlots(csp), 2, 20000);
+    for (let repair = 0; repair < 60 && proof.count > 1 && !proof.exhausted; repair += 1) {
+        const other = proof.solutions[1].slice(), mine = (alive, cell) => alive[2 * cell + 1] === 1;
+        const candidates = shuffled(blacks.filter(cell => !mine(other, cell)), random);
+        let changed = false;
+        for (const cell of candidates) {
+            const keepers = partnersOf(cell).filter(p => !mine(other, p));
+            if (!keepers.length)
+                continue;
+            numbers[cell] = numbers[keepers[Math.floor(random() * keepers.length)]];
+            changed = true;
+            break;
+        }
+        if (!changed)
+            return null;
+        proof = countCsp(csp, openSlots(csp), 2, 20000);
+    }
+    if (proof.count !== 1 || proof.exhausted)
+        return null;
+    return { board, shaded };
+}
+/** A random Latin square: every number once in each row and column, built row by row with backtracking. */
+export function latinSquare(size, random) {
+    const cells = Array(size * size).fill(0);
+    let steps = 0;
+    const fill = (at) => {
+        if (at === cells.length)
+            return true;
+        if (++steps > 20000)
+            return false;
+        const x = at % size, y = Math.floor(at / size);
+        const used = new Set();
+        for (let k = 0; k < x; k += 1)
+            used.add(cells[y * size + k]);
+        for (let k = 0; k < y; k += 1)
+            used.add(cells[k * size + x]);
+        for (const n of shuffled(Array.from({ length: size }, (_, i) => i + 1).filter(i => !used.has(i)), random)) {
+            cells[at] = n;
+            if (fill(at + 1))
+                return true;
+        }
+        cells[at] = 0;
+        return false;
+    };
+    return fill(0) ? cells : null;
+}
+/** The same square with its rows, columns and numbers renamed at random: still one of each in every line. */
+export function isotope(square, size, random) {
+    const rows = shuffled(Array.from({ length: size }, (_, i) => i), random), cols = shuffled(Array.from({ length: size }, (_, i) => i), random);
+    const names = shuffled(Array.from({ length: size }, (_, i) => i + 1), random);
+    return Array.from({ length: size * size }, (_, cell) => names[square[rows[Math.floor(cell / size)] * size + cols[cell % size]] - 1]);
+}

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;