@johnmorrisdotca/kazu 1.1.0 → 1.3.0

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,10 @@
+import type { HitoriLevel, HitoriPuzzle } from "./hitori.types.ts";
+/**
+ * Makes a seeded puzzle and proves its answer is the only one. The shaded squares are chosen first (never touching,
+ * the rest in one piece), the white squares get numbers that repeat nowhere in their row or column, and every shaded
+ * square takes a number that a white square in its row or column already has. Boards with more than one answer are
+ * repaired by renumbering a shaded square so that the other answer repeats a number, and the result is rated:
+ * easy by the plain rules, medium once the whites must stay in one piece, hard by supposing, and extra-hard the
+ * most-supposing of several boards.
+ */
+export declare function generateHitori(size?: number, seed?: number, level?: HitoriLevel): HitoriPuzzle;

package/dist/hitoriGenerate.js

@@ -0,0 +1,65 @@
+import { HITORI_LEAST_SIDE, HITORI_LEVELS, HITORI_MOST_ATTEMPTS, HITORI_MOST_SIDE } from "./hitori.constants.js";
+import { checkHitori } from "./hitoriBoard.js";
+import { candidateHitori, latinSquare } from "./hitoriBuild.js";
+import { hitoriModel } from "./hitoriLogic.js";
+import { solveHitori } from "./hitoriSolve.js";
+import { logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * Makes a seeded puzzle and proves its answer is the only one. The shaded squares are chosen first (never touching,
+ * the rest in one piece), the white squares get numbers that repeat nowhere in their row or column, and every shaded
+ * square takes a number that a white square in its row or column already has. Boards with more than one answer are
+ * repaired by renumbering a shaded square so that the other answer repeats a number, and the result is rated:
+ * easy by the plain rules, medium once the whites must stay in one piece, hard by supposing, and extra-hard the
+ * most-supposing of several boards.
+ */
+export function generateHitori(size = 5, seed = 1, level = "medium") {
+    if (!Number.isInteger(size) || size < HITORI_LEAST_SIDE || size > HITORI_MOST_SIDE || !isKazuSeed(seed) || !HITORI_LEVELS.includes(level)) {
+        throw new RangeError("Invalid Hitori settings");
+    }
+    const random = seededRandom(seed);
+    const base = latinSquare(size, random);
+    if (!base)
+        throw new Error("No Hitori found within the generation budget; try another seed");
+    for (let aim = HITORI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = HITORI_LEVELS[aim];
+        const wanted = aimed === "extra-hard" ? 4 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < HITORI_MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const built = candidateHitori(size, aimed, random, base);
+            const made = built && rated(built.board, built.shaded, aimed);
+            if (!made)
+                continue;
+            found += 1;
+            if (!best || made.score > best.score)
+                best = made;
+        }
+        if (best) {
+            const proof = solveHitori(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkHitori(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
+            }
+        }
+    }
+    throw new Error("No uniquely solvable Hitori found within the generation budget; try another seed");
+}
+function rated(board, shaded, level) {
+    const total = board.size * board.size;
+    const solved = (strength, depth) => {
+        const { csp } = hitoriModel(board, strength);
+        const run = logicCsp(csp, openSlots(csp), depth);
+        return run.solved && checkHitori(board, Array.from({ length: total }, (_, cell) => run.alive[2 * cell + 1] === 1)).ok ? run : null;
+    };
+    if (level === "easy")
+        return solved(0, 0) ? { board, shaded, score: 0 } : null;
+    if (solved(0, 0))
+        return null;
+    if (level === "medium")
+        return solved(2, 0) ? { board, shaded, score: 0 } : null;
+    if (solved(2, 0))
+        return null;
+    const probing = solved(2, 1);
+    if (!probing)
+        return level === "extra-hard" ? { board, shaded, score: 1000 } : null;
+    return { board, shaded, score: probing.probes };
+}

package/dist/hitoriLogic.d.ts

@@ -0,0 +1,12 @@
+import type { Csp } from "./csp.ts";
+import type { HitoriBoard } from "./hitori.types.ts";
+/**
+ * Hitori as variables: one per square, slot 0 for left white and slot 1 for shaded.
+ * `strength` is how much of the rules the pruning uses: 0 has the duplicates, the ban on touching shades, the
+ * pair and the sandwich; 1 adds that every white square must stay in reach of the others; 2 adds that a square
+ * whose shading would cut the whites in two must stay white. A finished answer must be one piece, which the
+ * search checks whatever the strength.
+ */
+export declare function hitoriModel(board: HitoriBoard, strength?: 0 | 1 | 2): {
+    csp: Csp;
+};

package/dist/hitoriLogic.js

@@ -0,0 +1,189 @@
+import { hitoriNeighbors } from "./hitoriBoard.js";
+/**
+ * Hitori as variables: one per square, slot 0 for left white and slot 1 for shaded.
+ * `strength` is how much of the rules the pruning uses: 0 has the duplicates, the ban on touching shades, the
+ * pair and the sandwich; 1 adds that every white square must stay in reach of the others; 2 adds that a square
+ * whose shading would cut the whites in two must stay white. A finished answer must be one piece, which the
+ * search checks whatever the strength.
+ */
+export function hitoriModel(board, strength = 2) {
+    const size = board.size, total = size * size;
+    const neighbours = Array.from({ length: total }, (_, cell) => Int32Array.from(hitoriNeighbors(size, cell)));
+    const partners = Array.from({ length: total }, (_, cell) => {
+        const x = cell % size, y = Math.floor(cell / size), found = [];
+        for (let k = 0; k < size; k += 1) {
+            if (k !== x && board.numbers[y * size + k] === board.numbers[cell])
+                found.push(y * size + k);
+            if (k !== y && board.numbers[k * size + x] === board.numbers[cell])
+                found.push(k * size + x);
+        }
+        return Int32Array.from(found);
+    });
+    // A pair of equal numbers side by side shades every other equal number of that line; a number on both sides of a square keeps it white.
+    const pairs = [];
+    const sandwiches = [];
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1) {
+            const cell = y * size + x;
+            for (const [dx, dy] of [[1, 0], [0, 1]]) {
+                const nx = x + dx, ny = y + dy;
+                if (nx >= size || ny >= size)
+                    continue;
+                const next = ny * size + nx;
+                if (board.numbers[cell] === board.numbers[next]) {
+                    const others = partners[cell].filter(other => other !== next && (dx ? Math.floor(other / size) === y : other % size === x));
+                    if (others.length)
+                        pairs.push({ a: cell, b: next, others });
+                }
+                const fx = x + 2 * dx, fy = y + 2 * dy;
+                if (fx < size && fy < size && board.numbers[cell] === board.numbers[fy * size + fx])
+                    sandwiches.push(next);
+            }
+        }
+    const starts = Int32Array.from({ length: total + 1 }, (_, i) => i * 2);
+    const disc = new Int32Array(total), low = new Int32Array(total), whitesBelow = new Int32Array(total);
+    const propagate = (alive) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let c = 0; c < total; c += 1) {
+                const white = alive[2 * c], shaded = alive[2 * c + 1];
+                if (!white && !shaded)
+                    return false;
+                if (shaded && !white) {
+                    const around = neighbours[c];
+                    for (let k = 0; k < around.length; k += 1) {
+                        const n = around[k];
+                        if (alive[2 * n + 1]) {
+                            alive[2 * n + 1] = 0;
+                            changed = true;
+                            if (!alive[2 * n])
+                                return false;
+                        }
+                    }
+                }
+                if (white && !shaded) {
+                    const same = partners[c];
+                    for (let k = 0; k < same.length; k += 1) {
+                        const p = same[k];
+                        if (alive[2 * p]) {
+                            alive[2 * p] = 0;
+                            changed = true;
+                            if (!alive[2 * p + 1])
+                                return false;
+                        }
+                    }
+                }
+                if (shaded) {
+                    // A square is shaded only to settle a duplicate, so some equal number in its row or column must stay white.
+                    const same = partners[c];
+                    let free = 0, last = -1;
+                    for (let k = 0; k < same.length; k += 1)
+                        if (alive[2 * same[k]]) {
+                            free += 1;
+                            last = same[k];
+                        }
+                    if (free === 0) {
+                        if (!white)
+                            return false;
+                        alive[2 * c + 1] = 0;
+                        changed = true;
+                    }
+                    else if (free === 1 && !white && alive[2 * last + 1]) {
+                        alive[2 * last + 1] = 0;
+                        changed = true;
+                    }
+                }
+            }
+            for (const { a, b, others } of pairs) {
+                if (!alive[2 * a] && !alive[2 * b])
+                    continue;
+                for (let k = 0; k < others.length; k += 1) {
+                    const o = others[k];
+                    if (alive[2 * o]) {
+                        alive[2 * o] = 0;
+                        changed = true;
+                        if (!alive[2 * o + 1])
+                            return false;
+                    }
+                }
+            }
+            for (let k = 0; k < sandwiches.length; k += 1) {
+                const m = sandwiches[k];
+                if (alive[2 * m + 1]) {
+                    alive[2 * m + 1] = 0;
+                    changed = true;
+                    if (!alive[2 * m])
+                        return false;
+                }
+            }
+            if (strength > 0) {
+                const verdict = reach(alive);
+                if (verdict < 0)
+                    return false;
+                if (verdict > 0)
+                    changed = true;
+            }
+        }
+        return true;
+    };
+    const cutList = new Int32Array(total);
+    let clock = 0, cutCount = 0, whiteTotal = 0, current = new Uint8Array(0), power = 0;
+    const visit = (u, parent) => {
+        disc[u] = low[u] = ++clock;
+        let below = current[2 * u + 1] ? 0 : 1, cutWhites = 0, cutParts = 0;
+        const around = neighbours[u];
+        for (let k = 0; k < around.length; k += 1) {
+            const n = around[k];
+            if (!current[2 * n] || n === parent)
+                continue;
+            if (disc[n]) {
+                if (disc[n] < low[u])
+                    low[u] = disc[n];
+                continue;
+            }
+            visit(n, u);
+            if (low[n] < low[u])
+                low[u] = low[n];
+            below += whitesBelow[n];
+            if (low[n] >= disc[u] && whitesBelow[n] > 0) {
+                cutParts += 1;
+                cutWhites += whitesBelow[n];
+            }
+        }
+        whitesBelow[u] = below;
+        if (power > 1 && current[2 * u] && current[2 * u + 1] && cutParts + (whiteTotal - cutWhites > 0 ? 1 : 0) >= 2)
+            cutList[cutCount++] = u;
+    };
+    /** -1 when the white squares cannot be one piece, 1 when a square was forced white, 0 when nothing moved. */
+    const reach = (alive) => {
+        let root = -1;
+        whiteTotal = 0;
+        for (let c = 0; c < total; c += 1)
+            if (!alive[2 * c + 1]) {
+                whiteTotal += 1;
+                if (root < 0)
+                    root = c;
+            }
+        if (root < 0)
+            return 0;
+        if (!alive[2 * root])
+            return -1;
+        disc.fill(0);
+        clock = 0;
+        cutCount = 0;
+        current = alive;
+        power = strength;
+        visit(root, -1);
+        let seenWhites = 0;
+        for (let c = 0; c < total; c += 1)
+            if (!alive[2 * c + 1] && disc[c])
+                seenWhites += 1;
+        if (seenWhites !== whiteTotal)
+            return -1;
+        for (let k = 0; k < cutCount; k += 1)
+            alive[2 * cutList[k] + 1] = 0;
+        return cutCount ? 1 : 0;
+    };
+    return { csp: { starts, propagate } };
+}

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/hitoriRate.d.ts

@@ -0,0 +1,3 @@
+import type { HitoriBoard, HitoriRating } from "./hitori.types.ts";
+/** Rates a board with one answer by solving it: with the plain rules, with the whites-stay-together rule, then by supposing. */
+export declare function rateHitori(board: HitoriBoard): HitoriRating;

package/dist/hitoriRate.js

@@ -0,0 +1,32 @@
+import { checkHitori, isHitoriBoard } from "./hitoriBoard.js";
+import { hitoriModel } from "./hitoriLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it: with the plain rules, with the whites-stay-together rule, then by supposing. */
+export function rateHitori(board) {
+    if (!isHitoriBoard(board))
+        throw new RangeError("Invalid Hitori board");
+    const strong = hitoriModel(board, 2).csp;
+    const proof = solveCsp(strong, openSlots(strong), 2, 300000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Hitori rating needs a board with one answer");
+    const shaded = Array.from({ length: board.size ** 2 }, (_, cell) => proof.solution[2 * cell + 1] === 1);
+    const solvedBy = (strength, depth) => {
+        const { csp } = hitoriModel(board, strength);
+        const run = logicCsp(csp, openSlots(csp), depth);
+        return { ...run, solved: run.solved && checkHitori(board, Array.from({ length: board.size ** 2 }, (_, cell) => run.alive[2 * cell + 1] === 1)).ok };
+    };
+    const plain = solvedBy(0, 0), reach = plain.solved ? plain : solvedBy(2, 0);
+    const probing = reach.solved ? reach : solvedBy(2, 1);
+    const repeats = board.numbers.filter((_, cell) => {
+        const x = cell % board.size, y = Math.floor(cell / board.size);
+        return board.numbers.some((other, at) => at !== cell && other === board.numbers[cell] && (at % board.size === x || Math.floor(at / board.size) === y));
+    }).length;
+    return {
+        depth: reach.solved ? 0 : probing.solved ? 1 : 2,
+        reach: !plain.solved && reach.solved,
+        probes: reach.solved ? 0 : probing.probes,
+        shaded: shaded.filter(Boolean).length,
+        shadedShare: shaded.filter(Boolean).length / shaded.length,
+        repeatShare: repeats / shaded.length,
+    };
+}

package/dist/hitoriSolve.d.ts

@@ -0,0 +1,9 @@
+import type { HitoriBoard, HitoriSolve } from "./hitori.types.ts";
+/**
+ * Counts distinct minimal shade patterns: an answer shades only squares that settle a duplicate, so extra shades
+ * are never a second answer. 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,18 @@
+import { HITORI_MAX_NODES } from "./hitori.constants.js";
+import { isHitoriBoard } from "./hitoriBoard.js";
+import { hitoriModel } from "./hitoriLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/**
+ * Counts distinct minimal shade patterns: an answer shades only squares that settle a duplicate, so extra shades
+ * are never a second answer. 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));
+    const { csp } = hitoriModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const solution = found.solution ? Array.from({ length: board.size ** 2 }, (_, cell) => found.solution[2 * cell + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
+}

package/dist/hitoriStrings.d.ts

@@ -0,0 +1,70 @@
+import type { HitoriLanguage } from "./hitoriPlay.types.ts";
+export declare const HITORI_STRINGS: {
+    readonly en: {
+        readonly title: "Hitori";
+        readonly help: "Tap a cell or press Space to shade it. Shaded cells cannot touch; the remaining numbers must be unique in every row and column, and the unshaded cells must stay connected. Arrow keys move.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly won: "Solved!";
+        readonly helped: "Solved with help.";
+        readonly bad: "Some rules are broken.";
+        readonly good: "No rule errors yet. Keep going.";
+        readonly noHint: "No proved hint is available.";
+        readonly cell: "Row";
+        readonly column: "column";
+        readonly shaded: "shaded";
+        readonly white: "unshaded";
+    };
+    readonly ja: {
+        readonly title: "ひとりにしてくれ";
+        readonly help: "マスを押すかスペースキーで黒くします。黒マスは辺で隣り合えません。白マスの行と列に同じ数字がなく、白マス全体がつながるようにします。矢印キーで移動します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly won: "完成！";
+        readonly helped: "ヒントを使って完成。";
+        readonly bad: "ルールに合わないところがあります。";
+        readonly good: "今のところルール違反はありません。";
+        readonly noHint: "確かなヒントはありません。";
+        readonly cell: "行";
+        readonly column: "列";
+        readonly shaded: "黒";
+        readonly white: "白";
+    };
+};
+export declare function hitoriWords(language?: HitoriLanguage): {
+    readonly title: "Hitori";
+    readonly help: "Tap a cell or press Space to shade it. Shaded cells cannot touch; the remaining numbers must be unique in every row and column, and the unshaded cells must stay connected. Arrow keys move.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly won: "Solved!";
+    readonly helped: "Solved with help.";
+    readonly bad: "Some rules are broken.";
+    readonly good: "No rule errors yet. Keep going.";
+    readonly noHint: "No proved hint is available.";
+    readonly cell: "Row";
+    readonly column: "column";
+    readonly shaded: "shaded";
+    readonly white: "unshaded";
+} | {
+    readonly title: "ひとりにしてくれ";
+    readonly help: "マスを押すかスペースキーで黒くします。黒マスは辺で隣り合えません。白マスの行と列に同じ数字がなく、白マス全体がつながるようにします。矢印キーで移動します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確認";
+    readonly restart: "やり直す";
+    readonly won: "完成！";
+    readonly helped: "ヒントを使って完成。";
+    readonly bad: "ルールに合わないところがあります。";
+    readonly good: "今のところルール違反はありません。";
+    readonly noHint: "確かなヒントはありません。";
+    readonly cell: "行";
+    readonly column: "列";
+    readonly shaded: "黒";
+    readonly white: "白";
+};

package/dist/hitoriStrings.js

@@ -0,0 +1,17 @@
+export const HITORI_STRINGS = {
+    en: {
+        title: "Hitori",
+        help: "Tap a cell or press Space to shade it. Shaded cells cannot touch; the remaining numbers must be unique in every row and column, and the unshaded cells must stay connected. Arrow keys move.",
+        undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", won: "Solved!", helped: "Solved with help.",
+        bad: "Some rules are broken.", good: "No rule errors yet. Keep going.", noHint: "No proved hint is available.",
+        cell: "Row", column: "column", shaded: "shaded", white: "unshaded",
+    },
+    ja: {
+        title: "ひとりにしてくれ",
+        help: "マスを押すかスペースキーで黒くします。黒マスは辺で隣り合えません。白マスの行と列に同じ数字がなく、白マス全体がつながるようにします。矢印キーで移動します。",
+        undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", won: "完成！", helped: "ヒントを使って完成。",
+        bad: "ルールに合わないところがあります。", good: "今のところルール違反はありません。", noHint: "確かなヒントはありません。",
+        cell: "行", column: "列", shaded: "黒", white: "白",
+    },
+};
+export function hitoriWords(language = "en") { return HITORI_STRINGS[language]; }

package/dist/hitoriStyle.d.ts

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

package/dist/hitoriStyle.js

@@ -0,0 +1,9 @@
+export const HITORI_PLAY_STYLE = `
+.kh-root{color:var(--ks-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}
+.kh-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}
+.kh-cells{position:absolute;inset:0;display:grid;padding:2px}
+.kh-cell{background:transparent;border:0;min-width:0;min-height:0;padding:0;cursor:pointer;touch-action:manipulation}
+.kh-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}
+.kh-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.kh-tools button{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:var(--ks-ink,#1f2320);cursor:pointer}
+.kh-tools button:disabled{opacity:.45;cursor:default}.kh-status{min-height:1.5em}.kh-help{font-size:14px;opacity:.8}`;