@johnmorrisdotca/jirai 0.0.0-stage → 0.1.0

package/dist/grid.js

@@ -0,0 +1,46 @@
+import { GRID_SPECS, MAX_CELLS, MAX_SIDE } from "./jirai.constants.js";
+import { activeCell, activeCells, SHAPES } from "./shape.js";
+/** Reject a setting before it reaches a board allocation or a shuffle. */
+export function validSettings(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const s = value;
+    return Number.isInteger(s.width) && s.width >= 3 && s.width <= MAX_SIDE
+        && Number.isInteger(s.height) && s.height >= 3 && s.height <= MAX_SIDE
+        && s.width * s.height <= MAX_CELLS
+        && Number.isInteger(s.mines) && s.mines >= 1 && s.mines < s.width * s.height
+        && (s.shape === undefined || SHAPES.includes(s.shape))
+        && ((s.shape ?? "rectangle") === "rectangle" || (s.width >= 9 && s.height >= 9 && s.grid !== "wrap"))
+        && s.mines < activeCells(s).length
+        && Object.hasOwn(GRID_SPECS, s.grid) && typeof s.noGuess === "boolean"
+        && (s.opening === "safe" || s.opening === "clear")
+        && Number.isInteger(s.seed) && s.seed >= 0 && s.seed <= 0xffffffff;
+}
+export function validCell(settings, cell) {
+    return Number.isInteger(cell) && cell >= 0 && cell < settings.width * settings.height && activeCell(settings, cell);
+}
+/** Every neighbour once. Wrap joins both pairs of opposite edges. */
+export function neighbours(settings, cell) {
+    if (!validCell(settings, cell))
+        return [];
+    const spec = GRID_SPECS[settings.grid];
+    const x = cell % settings.width;
+    const y = Math.floor(cell / settings.width);
+    const out = new Set();
+    for (const [dx, dy] of spec.offsets) {
+        let nx = x + dx, ny = y + dy;
+        if (spec.wrap) {
+            nx = (nx + settings.width) % settings.width;
+            ny = (ny + settings.height) % settings.height;
+        }
+        if (nx >= 0 && nx < settings.width && ny >= 0 && ny < settings.height) {
+            const next = ny * settings.width + nx;
+            if (validCell(settings, next))
+                out.add(next);
+        }
+    }
+    return [...out].sort((a, b) => a - b);
+}
+export function neighboursOf(settings) {
+    return Array.from({ length: settings.width * settings.height }, (_, cell) => neighbours(settings, cell));
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/** Jirai 地雷: the rules and deductions, plain functions over plain data. No DOM and no dependencies. */
+export * from "./jirai.types.ts";
+export * from "./jirai.constants.ts";
+export * from "./grid.ts";
+export * from "./generate.ts";
+export * from "./game.ts";
+export * from "./deduce.ts";
+export * from "./keep.ts";
+export { seededRandom } from "./random.ts";
+export declare const VERSION = "0.1.0";
+export { SHAPES, activeCell, activeCells } from "./shape.ts";

package/dist/index.js

@@ -0,0 +1,11 @@
+/** Jirai 地雷: the rules and deductions, plain functions over plain data. No DOM and no dependencies. */
+export * from "./jirai.types.js";
+export * from "./jirai.constants.js";
+export * from "./grid.js";
+export * from "./generate.js";
+export * from "./game.js";
+export * from "./deduce.js";
+export * from "./keep.js";
+export { seededRandom } from "./random.js";
+export const VERSION = "0.1.0";
+export { SHAPES, activeCell, activeCells } from "./shape.js";

package/dist/jirai.constants.d.ts

@@ -0,0 +1,61 @@
+import type { Grid, Settings } from "./jirai.types.ts";
+export declare const GRIDS: {
+    readonly square: "square";
+    readonly hex: "hex";
+    readonly wrap: "wrap";
+};
+export declare const STATUSES: {
+    readonly ready: "ready";
+    readonly playing: "playing";
+    readonly won: "won";
+    readonly lost: "lost";
+};
+export declare const MARKS: {
+    readonly covered: "covered";
+    readonly flag: "flag";
+    readonly question: "question";
+    readonly open: "open";
+};
+export declare const MOVES: {
+    readonly reveal: "reveal";
+    readonly mark: "mark";
+    readonly chord: "chord";
+};
+/** Hex coordinates are axial: a row is displaced half a cell to the right. */
+export declare const GRID_SPECS: Record<Grid, {
+    offsets: readonly (readonly [number, number])[];
+    wrap: boolean;
+}>;
+export declare const PRESETS: {
+    readonly beginner: {
+        readonly width: 9;
+        readonly height: 9;
+        readonly mines: 10;
+    };
+    readonly intermediate: {
+        readonly width: 16;
+        readonly height: 16;
+        readonly mines: 40;
+    };
+    readonly expert: {
+        readonly width: 30;
+        readonly height: 16;
+        readonly mines: 99;
+    };
+    readonly wide: {
+        readonly width: 21;
+        readonly height: 9;
+        readonly mines: 24;
+    };
+    readonly tall: {
+        readonly width: 9;
+        readonly height: 21;
+        readonly mines: 24;
+    };
+};
+export declare const DEFAULT_SETTINGS: Settings;
+export declare const MAX_SIDE = 60;
+export declare const MAX_CELLS = 2400;
+export declare const GENERATION_ATTEMPTS = 128;
+export declare const ENUMERATION_CELLS = 18;
+export declare const ENUMERATION_NODES = 100000;

package/dist/jirai.constants.js

@@ -0,0 +1,23 @@
+export const GRIDS = { square: "square", hex: "hex", wrap: "wrap" };
+export const STATUSES = { ready: "ready", playing: "playing", won: "won", lost: "lost" };
+export const MARKS = { covered: "covered", flag: "flag", question: "question", open: "open" };
+export const MOVES = { reveal: "reveal", mark: "mark", chord: "chord" };
+/** Hex coordinates are axial: a row is displaced half a cell to the right. */
+export const GRID_SPECS = {
+    square: { offsets: [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]], wrap: false },
+    hex: { offsets: [[-1, 0], [1, 0], [0, -1], [1, -1], [-1, 1], [0, 1]], wrap: false },
+    wrap: { offsets: [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]], wrap: true },
+};
+export const PRESETS = {
+    beginner: { width: 9, height: 9, mines: 10 },
+    intermediate: { width: 16, height: 16, mines: 40 },
+    expert: { width: 30, height: 16, mines: 99 },
+    wide: { width: 21, height: 9, mines: 24 },
+    tall: { width: 9, height: 21, mines: 24 },
+};
+export const DEFAULT_SETTINGS = { ...PRESETS.beginner, grid: GRIDS.square, noGuess: true, opening: "clear", seed: 1 };
+export const MAX_SIDE = 60;
+export const MAX_CELLS = 2400;
+export const GENERATION_ATTEMPTS = 128;
+export const ENUMERATION_CELLS = 18;
+export const ENUMERATION_NODES = 100_000;

package/dist/jirai.types.d.ts

@@ -0,0 +1,66 @@
+/** A cell's number is its row-major place on the board, starting at zero. */
+export type Grid = "square" | "hex" | "wrap";
+export type Status = "ready" | "playing" | "won" | "lost";
+export type Mark = "covered" | "flag" | "question" | "open";
+export type Settings = {
+    /** Shape omits cells; rectangle is the compatible default. Wrap requires rectangle. */
+    shape?: "rectangle" | "heart" | "star" | "hexagon";
+    width: number;
+    height: number;
+    mines: number;
+    grid: Grid;
+    /** Only accept boards the deduction solver finishes from the opening. */
+    noGuess: boolean;
+    /** The opening and every neighbour are safe, not only the first cell. */
+    opening: "safe" | "clear";
+    seed: number;
+};
+export type Move = {
+    kind: "reveal" | "mark" | "chord";
+    cell: number;
+};
+export type Board = {
+    settings: Settings;
+    mines: readonly boolean[];
+    clues: readonly number[];
+    first: number;
+    attempt: number;
+};
+/** Rules data includes the answer; never send it to a competitive client. Use visibleGame for hints and drawing. */
+export type Game = {
+    settings: Settings;
+    board: Board | null;
+    marks: readonly Mark[];
+    status: Status;
+    exploded: number | null;
+    moves: readonly Move[];
+    /** A proved hint has been shown during this run. */
+    helped: boolean;
+};
+export type VisibleGame = {
+    settings: Settings;
+    /** Null is hidden, including flags. Only opened cells give a clue. */
+    clues: readonly (number | null)[];
+    marks: readonly Mark[];
+    status: Status;
+};
+export type Constraint = {
+    cells: readonly number[];
+    mines: number;
+    sources: readonly number[];
+};
+export type Deduction = {
+    safe: readonly number[];
+    mines: readonly number[];
+    reason: "count" | "overlap" | "total" | "enumeration" | "none";
+    sources: readonly number[];
+    /** A conflicting clue, or a board with no consistent mine placement. */
+    contradiction: boolean;
+};
+export type GenerationOptions = {
+    attempts?: number;
+    enumerate?: boolean;
+};
+export type Language = "en" | "ja";
+export type Material = "ivory" | "wood" | "slate";
+export type Pieces = "flags" | "stones" | "flowers";

package/dist/jirai.types.js

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

package/dist/keep.d.ts

@@ -0,0 +1,7 @@
+import type { Game } from "./jirai.types.ts";
+/** Keep settings and moves, never an unchecked answer array. Version the deal before changing it. */
+export declare function gameProgress(game: Game): string;
+/** A saved game is rebuilt under the rules. Malformed or unavailable boards return null. */
+export declare function gameFromProgress(progress: string): Game | null;
+/** UTC by definition, so two people sharing a daily seed get the same board. */
+export declare function dailySeed(day: string, grid?: string): number;

package/dist/keep.js

@@ -0,0 +1,40 @@
+import { newGame, play } from "./game.js";
+import { validSettings } from "./grid.js";
+/** Keep settings and moves, never an unchecked answer array. Version the deal before changing it. */
+export function gameProgress(game) {
+    return JSON.stringify({ version: 1, settings: game.settings, moves: game.moves, helped: game.helped });
+}
+/** A saved game is rebuilt under the rules. Malformed or unavailable boards return null. */
+export function gameFromProgress(progress) {
+    if (progress.length > 1_000_000)
+        return null;
+    try {
+        const data = JSON.parse(progress);
+        if (data.version !== 1 || !validSettings(data.settings) || !Array.isArray(data.moves) || data.moves.length > 20_000)
+            return null;
+        if (data.helped !== undefined && typeof data.helped !== "boolean")
+            return null;
+        let game = newGame(data.settings);
+        for (const move of data.moves) {
+            if (move === null || typeof move !== "object" || !["reveal", "mark", "chord"].includes(move.kind) || !Number.isInteger(move.cell))
+                return null;
+            const next = play(game, move);
+            if (next === game)
+                return null;
+            game = next;
+        }
+        return { ...game, helped: data.helped ?? false };
+    }
+    catch {
+        return null;
+    }
+}
+/** UTC by definition, so two people sharing a daily seed get the same board. */
+export function dailySeed(day, grid = "square") {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) !== day)
+        throw new RangeError("Use a real day as YYYY-MM-DD.");
+    let hash = 2166136261;
+    for (const letter of `jirai:1:${day}:${grid}`)
+        hash = Math.imul(hash ^ letter.charCodeAt(0), 16777619) >>> 0;
+    return hash;
+}

package/dist/mount.d.ts

@@ -0,0 +1,7 @@
+import type { JiraiMount, MountOptions } from "./ui.types.ts";
+/**
+ * One playable board in any element. The engine owns the rules, this module
+ * owns presses, focus, the clock and the worker. Destroy removes only its own
+ * root, so two mounted boards never take each other's listeners or children.
+ */
+export declare function mountJirai(host: HTMLElement, options?: MountOptions): JiraiMount;

package/dist/mount.js

@@ -0,0 +1,295 @@
+import { activeCells } from "./shape.js";
+import { hintFor } from "./deduce.js";
+import { boardModel } from "./draw.js";
+import { newGame, play, visibleGame, withBoard } from "./game.js";
+import { MARKS, MOVES, STATUSES } from "./jirai.constants.js";
+import { validCell } from "./grid.js";
+import { gameFromProgress, gameProgress } from "./keep.js";
+import { JIRAI_STYLE } from "./style.js";
+import { words } from "./strings.js";
+/**
+ * One playable board in any element. The engine owns the rules, this module
+ * owns presses, focus, the clock and the worker. Destroy removes only its own
+ * root, so two mounted boards never take each other's listeners or children.
+ */
+export function mountJirai(host, options = {}) {
+    const doc = host.ownerDocument;
+    let draw = { material: "ivory", pieces: "flags", language: "en", ...options };
+    const game = options.progress === undefined ? newGame(options.settings) : gameFromProgress(options.progress);
+    if (game === null)
+        throw new Error("Invalid saved Minesweeper game.");
+    let current = game;
+    let focus = activeCells(game.settings)[0], marking = false, hint = null;
+    let worker = null, pending = false, disposed = false;
+    let started = null, elapsed = 0;
+    const root = doc.createElement("div");
+    root.className = "jr-root";
+    const style = doc.createElement("style");
+    style.textContent = JIRAI_STYLE;
+    const stats = doc.createElement("div");
+    stats.className = "jr-stats";
+    const scroll = doc.createElement("div");
+    scroll.className = "jr-scroll";
+    const board = doc.createElement("div");
+    board.className = "jr-board";
+    board.setAttribute("role", "group");
+    const status = doc.createElement("p");
+    status.className = "jr-status";
+    status.setAttribute("role", "status");
+    const controls = doc.createElement("div");
+    controls.className = "jr-controls";
+    const help = doc.createElement("p");
+    help.className = "jr-help";
+    const dialog = doc.createElement("dialog");
+    dialog.className = "jr-dialog";
+    const close = doc.createElement("button");
+    close.className = "jr-button jr-close";
+    close.type = "button";
+    dialog.append(close);
+    scroll.append(board);
+    root.append(style, stats, scroll, status, controls, help);
+    host.append(root, dialog);
+    let lastOpener = null;
+    const leaveDialog = () => { root.append(stats, scroll, status, controls, help); lastOpener?.focus(); };
+    dialog.addEventListener("close", leaveDialog);
+    close.addEventListener("click", () => dialog.close());
+    function stopWorker() { worker?.terminate(); worker = null; pending = false; }
+    function clock() { return elapsed + (started === null ? 0 : Math.floor((Date.now() - started) / 1000)); }
+    function report(next) {
+        const before = current.status;
+        current = next;
+        hint = null;
+        if (started === null && current.board !== null && current.status === STATUSES.playing)
+            started = Date.now();
+        if (current.status === STATUSES.won || current.status === STATUSES.lost) {
+            elapsed = clock();
+            started = null;
+        }
+        const detail = structuredClone(current);
+        host.dispatchEvent(new CustomEvent("jirai-change", { detail }));
+        options.onChange?.(detail);
+        if (before !== current.status && (current.status === STATUSES.won || current.status === STATUSES.lost)) {
+            host.dispatchEvent(new CustomEvent("jirai-finish", { detail }));
+            options.onFinish?.(detail);
+        }
+        render();
+    }
+    function failed(error) { stopWorker(); render(); status.textContent = words(draw.language).error; options.onError?.(error); }
+    function make(move) {
+        if (disposed || pending)
+            return;
+        if (move.kind === MOVES.reveal && current.board === null && current.marks[move.cell] !== MARKS.flag && validCell(current.settings, move.cell)) {
+            pending = true;
+            render();
+            try {
+                worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+                worker.onmessage = (event) => {
+                    if (disposed)
+                        return;
+                    stopWorker();
+                    if (event.data.board === undefined) {
+                        failed(new Error(event.data.error ?? "Generation failed."));
+                        return;
+                    }
+                    try {
+                        report(play(withBoard(current, event.data.board), move));
+                    }
+                    catch (error) {
+                        failed(error);
+                    }
+                };
+                worker.onerror = () => failed(new Error("The board worker could not load. Serve the package over HTTP, and allow workers in your content security policy."));
+                worker.postMessage({ settings: current.settings, first: move.cell });
+            }
+            catch (error) {
+                failed(error);
+            }
+            return;
+        }
+        try {
+            const next = play(current, move);
+            if (next !== current)
+                report(next);
+        }
+        catch (error) {
+            failed(error);
+        }
+    }
+    function showHint() {
+        if (pending || current.status !== STATUSES.playing)
+            return;
+        const result = hintFor(visibleGame(current));
+        const safe = result.safe.find((cell) => current.marks[cell] !== MARKS.open);
+        const mine = result.mines.find((cell) => current.marks[cell] !== MARKS.flag);
+        const highlighted = safe ?? mine ?? null;
+        if (highlighted !== null && !current.helped)
+            report({ ...current, helped: true });
+        hint = highlighted;
+        render();
+        const say = words(draw.language);
+        status.textContent = hint === null ? say.hintNone : `${safe !== undefined ? say.hintSafe : say.hintMine} ${result.reason === "none" ? "" : say[result.reason]}`;
+    }
+    function renderStats() {
+        const say = words(draw.language);
+        const values = [[say.mines, current.settings.mines - current.marks.filter((m) => m === MARKS.flag).length], [say.time, `${Math.floor(clock() / 60)}:${String(clock() % 60).padStart(2, "0")}`], [say.moves, current.moves.length]];
+        stats.replaceChildren(...values.map(([label, value]) => {
+            const part = doc.createElement("span");
+            part.className = "jr-stat";
+            const name = doc.createElement("small");
+            name.textContent = String(label);
+            const number = doc.createElement("strong");
+            number.textContent = String(value);
+            part.append(name, number);
+            return part;
+        }));
+    }
+    function render() {
+        if (disposed)
+            return;
+        const say = words(draw.language);
+        root.dataset.material = draw.material;
+        root.dataset.grid = current.settings.grid;
+        root.dataset.shape = current.settings.shape ?? "rectangle";
+        root.lang = draw.language ?? "en";
+        board.setAttribute("aria-label", say.board);
+        board.setAttribute("aria-busy", String(pending));
+        const model = boardModel(current, { ...draw, hint });
+        const active = doc.activeElement instanceof HTMLElement && board.contains(doc.activeElement);
+        board.style.aspectRatio = `${model.width} / ${model.height}`;
+        board.style.minWidth = `${model.width * 27}px`;
+        board.replaceChildren(...model.cells.map((cell) => {
+            const button = doc.createElement("button");
+            button.type = "button";
+            button.className = "jr-cell";
+            button.dataset.cell = String(cell.cell);
+            button.dataset.kind = cell.kind;
+            button.dataset.hint = String(cell.hint);
+            button.dataset.number = cell.kind === MARKS.open ? cell.text : "";
+            button.setAttribute("aria-label", cell.label);
+            button.tabIndex = cell.cell === focus ? 0 : -1;
+            button.disabled = pending;
+            button.textContent = cell.text;
+            button.style.left = `${cell.x / model.width * 100}%`;
+            button.style.top = `${cell.y / model.height * 100}%`;
+            button.style.width = `${cell.width / model.width * 100}%`;
+            button.style.height = `${cell.height / model.height * 100}%`;
+            return button;
+        }));
+        if (active)
+            board.querySelector(`[data-cell="${focus}"]`)?.focus({ preventScroll: true });
+        renderStats();
+        status.textContent = pending ? say.checking : say[current.status];
+        help.textContent = say.help;
+        close.textContent = say.close;
+        controls.replaceChildren();
+        if (options.controls === false) {
+            stats.hidden = true;
+            status.hidden = true;
+            help.hidden = true;
+            return;
+        }
+        const button = (text, action) => {
+            const made = doc.createElement("button");
+            made.type = "button";
+            made.className = "jr-button";
+            made.textContent = text;
+            made.addEventListener("click", action);
+            controls.append(made);
+            return made;
+        };
+        button(say.restart, () => handle.restart());
+        const mark = button(marking ? say.mark : say.reveal, () => { marking = !marking; render(); });
+        mark.setAttribute("aria-pressed", String(marking));
+        const hinted = button(say.hint, showHint);
+        hinted.disabled = pending || current.status !== STATUSES.playing;
+        if (!dialog.open)
+            button(say.view, () => { lastOpener = doc.activeElement; dialog.append(stats, scroll, status, controls); dialog.showModal(); render(); });
+    }
+    function cellOf(event) {
+        const target = event.target instanceof Element ? event.target.closest("[data-cell]") : null;
+        return target === null ? null : Number(target.dataset.cell);
+    }
+    let hold = null, held = false, origin = { x: 0, y: 0 };
+    const cancelHold = () => { if (hold !== null)
+        clearTimeout(hold); hold = null; };
+    board.addEventListener("pointerdown", (event) => {
+        held = false;
+        cancelHold();
+        const cell = cellOf(event);
+        if (cell === null)
+            return;
+        focus = cell;
+        origin = { x: event.clientX, y: event.clientY };
+        if (event.pointerType !== "mouse")
+            hold = setTimeout(() => { held = true; make({ kind: MOVES.mark, cell }); }, 450);
+    });
+    board.addEventListener("pointermove", (event) => { if (Math.hypot(event.clientX - origin.x, event.clientY - origin.y) > 8)
+        cancelHold(); });
+    board.addEventListener("pointerup", cancelHold);
+    board.addEventListener("pointercancel", cancelHold);
+    board.addEventListener("click", (event) => { const cell = cellOf(event); if (cell !== null && !held) {
+        focus = cell;
+        make({ kind: marking ? MOVES.mark : MOVES.reveal, cell });
+    } held = false; });
+    board.addEventListener("contextmenu", (event) => { event.preventDefault(); cancelHold(); const cell = cellOf(event); if (cell !== null && !held) {
+        focus = cell;
+        make({ kind: MOVES.mark, cell });
+    } held = false; });
+    board.addEventListener("keydown", (event) => {
+        const cell = cellOf(event);
+        if (cell === null)
+            return;
+        const x = cell % current.settings.width, y = Math.floor(cell / current.settings.width);
+        const shifts = { ArrowLeft: x > 0 ? -1 : 0, ArrowRight: x < current.settings.width - 1 ? 1 : 0, ArrowUp: y > 0 ? -current.settings.width : 0, ArrowDown: y < current.settings.height - 1 ? current.settings.width : 0 };
+        if (event.key in shifts) {
+            event.preventDefault();
+            const step = shifts[event.key];
+            let next = cell + step;
+            while (step !== 0 && next >= 0 && next < current.marks.length && !validCell(current.settings, next)) {
+                if (Math.abs(step) === 1 && Math.floor(next / current.settings.width) !== y)
+                    break;
+                next += step;
+            }
+            if (validCell(current.settings, next) && (Math.abs(step) !== 1 || Math.floor(next / current.settings.width) === y))
+                focus = next;
+            render();
+            board.querySelector(`[data-cell="${focus}"]`)?.focus();
+        }
+        else if (event.key === " " || event.key.toLowerCase() === "f") {
+            event.preventDefault();
+            focus = cell;
+            make({ kind: MOVES.mark, cell });
+        }
+        else if (event.key === "Enter") {
+            event.preventDefault();
+            focus = cell;
+            make({ kind: MOVES.reveal, cell });
+        }
+    });
+    const timer = setInterval(() => { if (started !== null && !disposed)
+        renderStats(); }, 1000);
+    const handle = {
+        game: () => structuredClone(current), progress: () => gameProgress(current), play: (cell, mark = false) => make({ kind: mark ? MOVES.mark : MOVES.reveal, cell }), hint: showHint,
+        restart: () => { if (disposed)
+            return; stopWorker(); elapsed = 0; started = null; report(newGame(current.settings)); },
+        load: (settings, progress) => {
+            if (disposed)
+                return;
+            const restored = progress === undefined ? newGame(settings) : gameFromProgress(progress);
+            if (restored === null)
+                throw new Error("Invalid saved Minesweeper game.");
+            stopWorker();
+            elapsed = 0;
+            started = null;
+            focus = activeCells(restored.settings)[0];
+            report(restored);
+        },
+        set: (changes) => { draw = { ...draw, ...changes }; render(); },
+        destroy: () => { disposed = true; stopWorker(); cancelHold(); clearInterval(timer); if (dialog.open)
+            dialog.close(); root.remove(); dialog.remove(); },
+    };
+    if (current.status === STATUSES.playing)
+        started = Date.now();
+    render();
+    return handle;
+}

package/dist/play-entry.d.ts

@@ -0,0 +1,3 @@
+export { mountJirai } from "./mount.ts";
+export type { JiraiMount, MountOptions } from "./ui.types.ts";
+export { STRINGS } from "./strings.ts";

package/dist/play-entry.js

@@ -0,0 +1,2 @@
+export { mountJirai } from "./mount.js";
+export { STRINGS } from "./strings.js";

package/dist/random.d.ts

@@ -0,0 +1,4 @@
+/** Mulberry32, pinned by the replay tests: changing it would change every kept board. */
+export declare function seededRandom(seed: number): () => number;
+/** Fisher–Yates on a copy. A shuffle never changes the list given. */
+export declare function shuffled<T>(items: readonly T[], random: () => number): T[];

package/dist/random.js

@@ -0,0 +1,20 @@
+/** Mulberry32, pinned by the replay tests: changing it would change every kept board. */
+export function seededRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Fisher–Yates on a copy. A shuffle never changes the list given. */
+export function shuffled(items, random) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}

package/dist/react.d.ts

@@ -0,0 +1,3 @@
+import type { JiraiProps } from "./react.types.ts";
+/** The plain-DOM game as a React component. Options are read on mount; give it a new key to load a new board. */
+export declare function JiraiBoard({ settings, progress, material, pieces, language, controls, onChange, onFinish, onError, ...element }: JiraiProps): import("react").JSX.Element;

package/dist/react.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { mountJirai } from "./mount.js";
+/** The plain-DOM game as a React component. Options are read on mount; give it a new key to load a new board. */
+export function JiraiBoard({ settings, progress, material, pieces, language, controls, onChange, onFinish, onError, ...element }) {
+    const host = useRef(null);
+    const latest = useRef({ onChange, onFinish, onError });
+    useEffect(() => { latest.current = { onChange, onFinish, onError }; });
+    useEffect(() => {
+        if (host.current === null)
+            return;
+        const board = mountJirai(host.current, { settings, progress, material, pieces, language, controls,
+            onChange: (game) => latest.current.onChange?.(game), onFinish: (game) => latest.current.onFinish?.(game), onError: (error) => latest.current.onError?.(error) });
+        return () => board.destroy();
+    }, []);
+    return _jsx("div", { ref: host, ...element });
+}

package/dist/react.types.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLAttributes } from "react";
+import type { MountOptions } from "./ui.types.ts";
+export type JiraiProps = MountOptions & Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "onError">;

package/dist/react.types.js

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

package/dist/shape.d.ts

@@ -0,0 +1,5 @@
+import type { Settings } from "./jirai.types.ts";
+export declare const SHAPES: readonly ["rectangle", "heart", "star", "hexagon"];
+/** Row-major addresses stay stable; omitted cells have no clue and no neighbours. */
+export declare function activeCell(settings: Settings, cell: number): boolean;
+export declare function activeCells(settings: Settings): number[];