@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/heyawake-entry.js

@@ -0,0 +1,11 @@
+/** Heyawake has its own room model alongside Kazu's number puzzles. */
+export * from "./heyawake.types.js";
+export * from "./heyawake.constants.js";
+export * from "./heyawakeBoard.js";
+export * from "./heyawakeSolve.js";
+export * from "./heyawakeGenerate.js";
+export * from "./heyawakeGame.js";
+export { drawHeyawake } from "./heyawakeDraw.js";
+export { mountHeyawake } from "./heyawakeMount.js";
+export { HEYAWAKE_PLAY_STYLE } from "./heyawakeStyle.js";
+export { heyawakeWords } from "./heyawakeStrings.js";

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

@@ -0,0 +1,2 @@
+export { mountHeyawake } from "./heyawakeMount.ts";
+export type { HeyawakeMount, HeyawakeMountOptions, HeyawakeAppearance } from "./heyawakePlay.types.ts";

package/dist/heyawake-play-entry.js

@@ -0,0 +1 @@
+export { mountHeyawake } from "./heyawakeMount.js";

package/dist/heyawake.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HEYAWAKE_MOST_SIDE = 12;
+export declare const HEYAWAKE_GENERATOR_MOST_CELLS = 25;
+export declare const HEYAWAKE_MOST_NODES = 250000;
+export declare const HEYAWAKE_MOST_ATTEMPTS = 500;
+export declare const HEYAWAKE_LEVELS: readonly ["easy", "medium", "hard"];

package/dist/heyawake.constants.js

@@ -0,0 +1,5 @@
+export const HEYAWAKE_MOST_SIDE = 12;
+export const HEYAWAKE_GENERATOR_MOST_CELLS = 25;
+export const HEYAWAKE_MOST_NODES = 250000;
+export const HEYAWAKE_MOST_ATTEMPTS = 500;
+export const HEYAWAKE_LEVELS = ["easy", "medium", "hard"];

package/dist/heyawake.types.d.ts

@@ -0,0 +1,35 @@
+export type HeyawakeRoom = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    blacks: number | null;
+};
+export type HeyawakeBoard = {
+    width: number;
+    height: number;
+    rooms: readonly HeyawakeRoom[];
+};
+export type HeyawakeLevel = "easy" | "medium" | "hard";
+export type HeyawakePuzzle = HeyawakeBoard & {
+    seed: number;
+    level: HeyawakeLevel;
+    solution: readonly boolean[];
+};
+export type HeyawakeCheck = {
+    ok: boolean;
+    complete: boolean;
+    errors: readonly number[];
+};
+export type HeyawakeSolve = {
+    count: number;
+    solution: readonly boolean[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type HeyawakeGame = {
+    board: HeyawakeBoard;
+    entries: readonly (boolean | null)[];
+    history: readonly (readonly (boolean | null)[])[];
+    helped: boolean;
+};

package/dist/heyawake.types.js

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

package/dist/heyawakeBoard.d.ts

@@ -0,0 +1,7 @@
+import type { HeyawakeBoard, HeyawakeCheck, HeyawakeRoom } from "./heyawake.types.ts";
+export declare function heyawakeCells(board: HeyawakeBoard, room: HeyawakeRoom): number[] | null;
+export declare function isHeyawakeBoard(value: unknown): value is HeyawakeBoard;
+export declare function heyawakeNeighbours(board: HeyawakeBoard, cell: number): number[];
+export declare function roomForCell(board: HeyawakeBoard): number[];
+export declare function checkHeyawake(board: HeyawakeBoard, entries: readonly (boolean | null)[]): HeyawakeCheck;
+export declare function checkRoomSpans(board: HeyawakeBoard, entries: readonly (boolean | null)[], roomIds?: number[], errors?: Set<number>): void;

package/dist/heyawakeBoard.js

@@ -0,0 +1,116 @@
+import { HEYAWAKE_MOST_SIDE } from "./heyawake.constants.js";
+export function heyawakeCells(board, room) {
+    if (!room || ![room.x, room.y, room.width, room.height].every(Number.isInteger)
+        || room.x < 0 || room.y < 0 || room.width < 1 || room.height < 1
+        || room.x + room.width > board.width || room.y + room.height > board.height)
+        return null;
+    return Array.from({ length: room.width * room.height }, (_, index) => (room.y + Math.floor(index / room.width)) * board.width + room.x + index % room.width);
+}
+export function isHeyawakeBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!Number.isInteger(board.width) || board.width < 2 || board.width > HEYAWAKE_MOST_SIDE
+        || !Number.isInteger(board.height) || board.height < 2 || board.height > HEYAWAKE_MOST_SIDE
+        || !Array.isArray(board.rooms) || board.rooms.length === 0)
+        return false;
+    const occupied = new Set();
+    for (const room of board.rooms) {
+        if (!room || typeof room !== "object"
+            || ![room.x, room.y, room.width, room.height].every(Number.isInteger)
+            || !(room.blacks === null || Number.isInteger(room.blacks) && room.blacks >= 0 && room.blacks <= room.width * room.height))
+            return false;
+        const cells = heyawakeCells(board, room);
+        if (!cells || cells.some(cell => occupied.has(cell)))
+            return false;
+        cells.forEach(cell => occupied.add(cell));
+    }
+    return occupied.size === board.width * board.height;
+}
+export function heyawakeNeighbours(board, cell) {
+    const x = cell % board.width, y = Math.floor(cell / board.width);
+    return [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]]
+        .filter(([nx, ny]) => nx >= 0 && nx < board.width && ny >= 0 && ny < board.height)
+        .map(([nx, ny]) => ny * board.width + nx);
+}
+export function roomForCell(board) {
+    const lookup = Array(board.width * board.height).fill(-1);
+    board.rooms.forEach((room, index) => heyawakeCells(board, room)?.forEach(cell => { lookup[cell] = index; }));
+    return lookup;
+}
+export function checkHeyawake(board, entries) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    if (!Array.isArray(entries) || entries.length !== board.width * board.height
+        || entries.some(value => value !== true && value !== false && value !== null))
+        throw new RangeError("Invalid Heyawake entries");
+    const errors = new Set(), complete = entries.every(value => value !== null), ids = roomForCell(board);
+    for (let cell = 0; cell < entries.length; cell += 1) {
+        if (entries[cell] !== true)
+            continue;
+        if (heyawakeNeighbours(board, cell).some(next => entries[next] === true)) {
+            errors.add(cell);
+            heyawakeNeighbours(board, cell).filter(next => entries[next] === true).forEach(next => errors.add(next));
+        }
+    }
+    for (let index = 0; index < board.rooms.length; index += 1) {
+        const room = board.rooms[index];
+        const cells = heyawakeCells(board, room);
+        const marked = cells.filter(cell => entries[cell] === true).length;
+        if (room.blacks !== null && (marked > room.blacks || complete && marked !== room.blacks))
+            cells.forEach(cell => errors.add(cell));
+    }
+    if (complete) {
+        const white = entries.flatMap((value, cell) => value === false ? [cell] : []);
+        const reached = new Set();
+        if (white.length) {
+            const pending = [white[0]];
+            reached.add(white[0]);
+            while (pending.length)
+                for (const next of heyawakeNeighbours(board, pending.pop())) {
+                    if (entries[next] === false && !reached.has(next)) {
+                        reached.add(next);
+                        pending.push(next);
+                    }
+                }
+        }
+        if (reached.size !== white.length)
+            white.filter(cell => !reached.has(cell)).forEach(cell => errors.add(cell));
+        checkRoomSpans(board, entries, ids, errors);
+    }
+    return { ok: errors.size === 0 && complete, complete, errors: [...errors].sort((a, b) => a - b) };
+}
+export function checkRoomSpans(board, entries, roomIds = roomForCell(board), errors = new Set()) {
+    for (let y = 0; y < board.height; y += 1) {
+        let rooms = new Set(), cells = [];
+        for (let x = 0; x <= board.width; x += 1) {
+            const cell = y * board.width + x;
+            if (x < board.width && entries[cell] === false) {
+                cells.push(cell);
+                rooms.add(roomIds[cell]);
+            }
+            else {
+                if (rooms.size > 2)
+                    cells.forEach(value => errors.add(value));
+                rooms = new Set();
+                cells = [];
+            }
+        }
+    }
+    for (let x = 0; x < board.width; x += 1) {
+        let rooms = new Set(), cells = [];
+        for (let y = 0; y <= board.height; y += 1) {
+            const cell = y * board.width + x;
+            if (y < board.height && entries[cell] === false) {
+                cells.push(cell);
+                rooms.add(roomIds[cell]);
+            }
+            else {
+                if (rooms.size > 2)
+                    cells.forEach(value => errors.add(value));
+                rooms = new Set();
+                cells = [];
+            }
+        }
+    }
+}

package/dist/heyawakeDraw.d.ts

@@ -0,0 +1,3 @@
+import type { HeyawakeBoard } from "./heyawake.types.ts";
+import type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";
+export declare function drawHeyawake(board: HeyawakeBoard, options?: HeyawakeDrawOptions): string;

package/dist/heyawakeDraw.js

@@ -0,0 +1,27 @@
+import { heyawakeCells, isHeyawakeBoard } from "./heyawakeBoard.js";
+import { heyawakeWords } from "./heyawakeStrings.js";
+export function drawHeyawake(board, options = {}) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    const words = heyawakeWords(options.language), size = 48;
+    const palettes = { ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"], wood: ["#e5cda6", "#493e2f", "#bca582"], slate: ["#262a27", "#ece8dc", "#454a44"] };
+    const [paper, ink, grid] = palettes[options.material ?? "ivory"];
+    const roomAt = Array(board.width * board.height).fill(-1);
+    board.rooms.forEach((room, index) => heyawakeCells(board, room).forEach(cell => { roomAt[cell] = index; }));
+    const cells = Array.from({ length: board.width * board.height }, (_, cell) => {
+        const x = cell % board.width * size, y = Math.floor(cell / board.width) * size;
+        const entry = options.entries?.[cell], room = board.rooms[roomAt[cell]];
+        const selected = cell === options.selected, error = options.errors?.includes(cell);
+        const color = error ? "var(--kz-bad,#b5452c)" : ink;
+        const top = Math.floor(cell / board.width) === room.y ? 3 : 1;
+        const left = cell % board.width === room.x ? 3 : 1;
+        const right = cell % board.width === room.x + room.width - 1 ? 3 : 1;
+        const bottom = Math.floor(cell / board.width) === room.y + room.height - 1 ? 3 : 1;
+        const clue = cell === room.y * board.width + room.x && room.blacks !== null
+            ? `<text x="${x + 5}" y="${y + 13}" fill="${ink}" font-size="11" font-weight="700">${room.blacks}</text>` : "";
+        const mark = entry === true ? `<rect x="${x + 1}" y="${y + 1}" width="46" height="46" fill="${color}"/>` : entry === false ? `<circle cx="${x + 24}" cy="${y + 24}" r="5" fill="${color}"/>` : "";
+        return `<g data-heyawake-cell="${cell}"><rect x="${x}" y="${y}" width="48" height="48" fill="${selected ? ink : paper}" fill-opacity="${selected ? ".12" : "1"}" stroke="${grid}" stroke-width="${Math.min(top, right, bottom, left)}"/>${clue}${mark}</g>`;
+    }).join("");
+    const roomLines = board.rooms.map(room => `<rect x="${room.x * size + 1.5}" y="${room.y * size + 1.5}" width="${room.width * size - 3}" height="${room.height * size - 3}" fill="none" stroke="${ink}" stroke-width="3" pointer-events="none"/>`).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${board.width * size} ${board.height * size}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}${roomLines}</svg>`;
+}

package/dist/heyawakeGame.d.ts

@@ -0,0 +1,12 @@
+import type { HeyawakeBoard, HeyawakeGame } from "./heyawake.types.ts";
+export declare function newHeyawake(board: HeyawakeBoard): HeyawakeGame;
+export declare function setHeyawakeCell(game: HeyawakeGame, cell: number, value: boolean | null): HeyawakeGame;
+export declare function undoHeyawake(game: HeyawakeGame): HeyawakeGame;
+export declare function restartHeyawake(game: HeyawakeGame): HeyawakeGame;
+export declare function hintHeyawake(game: HeyawakeGame): {
+    cell: number;
+    value: boolean;
+} | null;
+export declare function heyawakeFinished(game: HeyawakeGame): boolean;
+export declare function encodeHeyawake(game: HeyawakeGame): string;
+export declare function decodeHeyawake(code: string): HeyawakeGame | null;

package/dist/heyawakeGame.js

@@ -0,0 +1,51 @@
+import { checkHeyawake, isHeyawakeBoard } from "./heyawakeBoard.js";
+import { solveHeyawake } from "./heyawakeSolve.js";
+export function newHeyawake(board) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    return { board: publicBoard(board), entries: Array(board.width * board.height).fill(null), history: [], helped: false };
+}
+export function setHeyawakeCell(game, cell, value) {
+    if (value !== null && typeof value !== "boolean" || !Number.isInteger(cell) || cell < 0 || cell >= game.entries.length || game.entries[cell] === value)
+        return game;
+    const entries = [...game.entries];
+    entries[cell] = value;
+    return { ...game, entries, history: [...game.history, game.entries] };
+}
+export function undoHeyawake(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, entries: previous, history: game.history.slice(0, -1) } : game;
+}
+export function restartHeyawake(game) {
+    return { ...game, entries: Array(game.entries.length).fill(null), history: [], helped: false };
+}
+export function hintHeyawake(game) {
+    const result = solveHeyawake(game.board, game.entries);
+    if (!result.complete || result.count !== 1 || !result.solution)
+        return null;
+    const cell = game.entries.findIndex(value => value === null);
+    return cell < 0 ? null : { cell, value: result.solution[cell] };
+}
+export function heyawakeFinished(game) {
+    return checkHeyawake(game.board, game.entries).ok;
+}
+export function encodeHeyawake(game) {
+    return JSON.stringify({ version: 1, board: publicBoard(game.board), entries: game.entries.map(value => value === null ? "?" : value ? "#" : ".").join(""), helped: game.helped });
+}
+export function decodeHeyawake(code) {
+    try {
+        const data = JSON.parse(code);
+        if (data.version !== 1 || !isHeyawakeBoard(data.board) || typeof data.helped !== "boolean" || typeof data.entries !== "string")
+            return null;
+        const entries = [...data.entries].map((value) => value === "?" ? null : value === "#" ? true : value === "." ? false : undefined);
+        if (entries.length !== data.board.width * data.board.height || entries.some((value) => value === undefined))
+            return null;
+        return { board: publicBoard(data.board), entries: entries, history: [], helped: data.helped };
+    }
+    catch {
+        return null;
+    }
+}
+function publicBoard(board) {
+    return { width: board.width, height: board.height, rooms: board.rooms.map(room => ({ x: room.x, y: room.y, width: room.width, height: room.height, blacks: room.blacks })) };
+}

package/dist/heyawakeGenerate.d.ts

@@ -0,0 +1,2 @@
+import type { HeyawakeLevel, HeyawakePuzzle } from "./heyawake.types.ts";
+export declare function generateHeyawake(width?: number, height?: number, level?: HeyawakeLevel, seed?: number): HeyawakePuzzle;

package/dist/heyawakeGenerate.js

@@ -0,0 +1,114 @@
+import { HEYAWAKE_GENERATOR_MOST_CELLS, HEYAWAKE_LEVELS, HEYAWAKE_MOST_ATTEMPTS } from "./heyawake.constants.js";
+import { checkHeyawake, heyawakeNeighbours, roomForCell } from "./heyawakeBoard.js";
+import { solveHeyawake } from "./heyawakeSolve.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+export function generateHeyawake(width = 4, height = width, level = "easy", seed = 1) {
+    if (![width, height].every(value => Number.isInteger(value) && value >= 4 && value <= 8) || width * height > HEYAWAKE_GENERATOR_MOST_CELLS
+        || !HEYAWAKE_LEVELS.includes(level) || !isKazuSeed(seed))
+        throw new RangeError("Heyawake generation supports 4–8 cells per side and a valid level and seed");
+    const random = seededRandom(seed);
+    for (let attempt = 0; attempt < HEYAWAKE_MOST_ATTEMPTS; attempt += 1) {
+        const roomLimit = Math.min(10, 5 + Math.floor(attempt / 50));
+        const rooms = partitionRooms(width, height, random, roomLimit);
+        const open = { width, height, rooms: rooms.map(room => ({ ...room, blacks: null })) };
+        const solution = randomSolution(open, random);
+        if (!solution)
+            continue;
+        const order = shuffled(rooms.map((_, index) => index), random);
+        const clueCount = Math.max(2, Math.ceil(rooms.length * ({ easy: 0.95, medium: 0.75, hard: 0.55 }[level])));
+        const revealed = new Set(order.slice(0, clueCount));
+        const hidden = order.slice(clueCount);
+        for (let extra = 0; extra <= hidden.length; extra += 1) {
+            const clues = rooms.map((room, index) => ({ ...room, blacks: revealed.has(index) ? countBlacks(room, width, solution) : null }));
+            const board = { width, height, rooms: clues };
+            const proof = solveHeyawake(board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkHeyawake(board, proof.solution).ok) {
+                return { ...board, seed, level, solution: proof.solution };
+            }
+            if (extra < hidden.length)
+                revealed.add(hidden[extra]);
+        }
+    }
+    throw new Error("No unique Heyawake found within the generation budget; try another seed or smaller board");
+}
+function partitionRooms(width, height, random, maximumRooms) {
+    const pending = [{ x: 0, y: 0, width, height }];
+    const rooms = [];
+    while (pending.length) {
+        const area = pending.pop();
+        if (rooms.length + pending.length >= maximumRooms || area.width * area.height <= 3) {
+            rooms.push({ ...area, blacks: null });
+            continue;
+        }
+        const canVertical = area.width >= 4, canHorizontal = area.height >= 4;
+        if (!canVertical && !canHorizontal) {
+            rooms.push({ ...area, blacks: null });
+            continue;
+        }
+        const vertical = canVertical && (!canHorizontal || random() < 0.5);
+        if (vertical) {
+            const cut = 1 + Math.floor(random() * (area.width - 1));
+            pending.push({ x: area.x + cut, y: area.y, width: area.width - cut, height: area.height });
+            pending.push({ x: area.x, y: area.y, width: cut, height: area.height });
+        }
+        else {
+            const cut = 1 + Math.floor(random() * (area.height - 1));
+            pending.push({ x: area.x, y: area.y + cut, width: area.width, height: area.height - cut });
+            pending.push({ x: area.x, y: area.y, width: area.width, height: cut });
+        }
+    }
+    return rooms;
+}
+function randomSolution(board, random) {
+    const entries = Array(board.width * board.height).fill(null);
+    const roomIds = roomForCell(board);
+    let nodes = 0;
+    const visit = (cell) => {
+        if (++nodes > 12000)
+            return false;
+        if (cell === entries.length) {
+            const blackCount = entries.filter(value => value === true).length;
+            return blackCount >= 2 && checkHeyawake(board, entries).ok;
+        }
+        const choices = random() < 0.31 ? [true, false] : [false, true];
+        for (const black of choices) {
+            if (black && heyawakeNeighbours(board, cell).some(next => entries[next] === true))
+                continue;
+            entries[cell] = black;
+            if (partialRoomSpanIsLegal(board, entries, roomIds) && visit(cell + 1))
+                return true;
+            entries[cell] = null;
+        }
+        return false;
+    };
+    return visit(0) ? entries.map(value => value === true) : null;
+}
+function partialRoomSpanIsLegal(board, entries, roomIds) {
+    const exceeds = (cells) => {
+        let rooms = new Set();
+        for (const cell of cells) {
+            if (entries[cell] === false)
+                rooms.add(roomIds[cell]);
+            else
+                rooms = new Set();
+            if (rooms.size > 2)
+                return true;
+        }
+        return false;
+    };
+    for (let y = 0; y < board.height; y += 1)
+        if (exceeds(Array.from({ length: board.width }, (_, x) => y * board.width + x)))
+            return false;
+    for (let x = 0; x < board.width; x += 1)
+        if (exceeds(Array.from({ length: board.height }, (_, y) => y * board.width + x)))
+            return false;
+    return true;
+}
+function countBlacks(room, width, solution) {
+    let count = 0;
+    for (let y = room.y; y < room.y + room.height; y += 1)
+        for (let x = room.x; x < room.x + room.width; x += 1)
+            if (solution[y * width + x])
+                count += 1;
+    return count;
+}

package/dist/heyawakeMount.d.ts

@@ -0,0 +1,2 @@
+import type { HeyawakeMount, HeyawakeMountOptions } from "./heyawakePlay.types.ts";
+export declare function mountHeyawake(host: HTMLElement, initial: HeyawakeMountOptions): HeyawakeMount;

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)}";