@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/akari-entry.js

@@ -0,0 +1,11 @@
+export * from "./akari.types.js";
+export * from "./akari.constants.js";
+export * from "./akariBoard.js";
+export * from "./akariSolve.js";
+export * from "./akariGenerate.js";
+export * from "./akariRate.js";
+export * from "./akariGame.js";
+export { drawAkari } from "./akariDraw.js";
+export { mountAkari } from "./akariMount.js";
+export { AKARI_PLAY_STYLE } from "./akariStyle.js";
+export { AKARI_STRINGS } from "./akariStrings.js";

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

@@ -0,0 +1,2 @@
+export { mountAkari } from "./akariMount.ts";
+export type { AkariMount, AkariMountOptions, AkariDrawOptions, AkariLanguage, AkariMaterial, AkariPieces } from "./akariPlay.types.ts";

package/dist/akari-play-entry.js

@@ -0,0 +1 @@
+export { mountAkari } from "./akariMount.js";

package/dist/akari.constants.d.ts

@@ -0,0 +1,7 @@
+export declare const AKARI_MOST_SIDE = 16;
+export declare const AKARI_MOST_NODES = 250000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateAkari`. */
+export declare const AKARI_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+/** The sides the demo and the site offer for a square board; any side from 2 to `AKARI_MOST_SIDE` can be made. */
+export declare const AKARI_SIZES: readonly [5, 7, 10, 14];
+export declare const AKARI_MOST_ATTEMPTS = 60;

package/dist/akari.constants.js

@@ -0,0 +1,7 @@
+export const AKARI_MOST_SIDE = 16;
+export const AKARI_MOST_NODES = 250000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateAkari`. */
+export const AKARI_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+/** The sides the demo and the site offer for a square board; any side from 2 to `AKARI_MOST_SIDE` can be made. */
+export const AKARI_SIZES = [5, 7, 10, 14];
+export const AKARI_MOST_ATTEMPTS = 60;

package/dist/akari.types.d.ts

@@ -0,0 +1,52 @@
+/** A board is row-major. null is white, false is a plain black square, and 0–4 are numbered black squares. */
+export type AkariBoard = {
+    width: number;
+    height: number;
+    cells: readonly (number | null | false)[];
+};
+export type AkariLevel = "easy" | "medium" | "hard" | "extra-hard";
+export type AkariPuzzle = AkariBoard & {
+    seed: number;
+    level: AkariLevel;
+    solution: readonly number[];
+};
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the plain rules solve it, 1 means somebody has to
+ * suppose a bulb or an empty square and see it break, 2 means more than that. `probes` is how many suppositions
+ * the depth-1 reasoning needed. The rest describes the board.
+ */
+export type AkariRating = {
+    depth: 0 | 1 | 2;
+    probes: number;
+    whites: number;
+    blacks: number;
+    clues: number;
+    bulbs: number;
+    /** Numbered squares as a share of the black squares that touch a white one. */
+    clueShare: number;
+    /** White squares as a share of the board. */
+    openShare: number;
+};
+export type AkariCheck = {
+    ok: boolean;
+    illuminated: number;
+    errors: readonly number[];
+    dark: readonly number[];
+    numbered: readonly number[];
+    conflicts: readonly number[];
+};
+export type AkariProgress = Omit<AkariCheck, "ok"> & {
+    ok: boolean;
+};
+export type AkariSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type AkariGame = {
+    board: AkariBoard;
+    bulbs: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};

package/dist/akari.types.js

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

package/dist/akariBoard.d.ts

@@ -0,0 +1,11 @@
+import type { AkariBoard, AkariCheck, AkariProgress } from "./akari.types.ts";
+/** Validates dimensions and the three public square kinds. */
+export declare function isAkariBoard(value: unknown): value is AkariBoard;
+/** Returns the orthogonally adjacent cells to a board position. */
+export declare function akariNeighbours(board: AkariBoard, cell: number): number[];
+/** White squares visible from a cell, including itself, stopping at black squares and edges. */
+export declare function akariVisible(board: AkariBoard, cell: number): number[];
+/** Checks a complete placement from the public rules, without consulting a stored answer. */
+export declare function checkAkari(board: AkariBoard, bulbs: readonly number[]): AkariCheck;
+/** Reports immediate contradictions while allowing required clues to remain unsatisfied during play. */
+export declare function progressAkari(board: AkariBoard, bulbs: readonly number[]): AkariProgress;

package/dist/akariBoard.js

@@ -0,0 +1,96 @@
+import { AKARI_MOST_SIDE } from "./akari.constants.js";
+/** Validates dimensions and the three public square kinds. */
+export function isAkariBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    return Number.isInteger(board.width) && board.width >= 2 && board.width <= AKARI_MOST_SIDE
+        && Number.isInteger(board.height) && board.height >= 2 && board.height <= AKARI_MOST_SIDE
+        && Array.isArray(board.cells) && board.cells.length === board.width * board.height
+        && board.cells.every(cell => cell === null || cell === false
+            || Number.isInteger(cell) && cell >= 0 && cell <= 4)
+        && board.cells.some(cell => cell === null);
+}
+/** Returns the orthogonally adjacent cells to a board position. */
+export function akariNeighbours(board, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length)
+        return [];
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const coordinates = [[x, y - 1], [x + 1, y], [x, y + 1], [x - 1, y]];
+    return coordinates
+        .filter(([cx, cy]) => cx >= 0 && cx < board.width && cy >= 0 && cy < board.height)
+        .map(([cx, cy]) => cy * board.width + cx);
+}
+/** White squares visible from a cell, including itself, stopping at black squares and edges. */
+export function akariVisible(board, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length || board.cells[cell] !== null)
+        return [];
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const visible = [cell];
+    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+        let cx = x + dx;
+        let cy = y + dy;
+        while (cx >= 0 && cx < board.width && cy >= 0 && cy < board.height) {
+            const next = cy * board.width + cx;
+            if (board.cells[next] !== null)
+                break;
+            visible.push(next);
+            cx += dx;
+            cy += dy;
+        }
+    }
+    return visible;
+}
+function evaluate(board, bulbs, complete) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const errors = [];
+    const conflicts = [];
+    const numbered = [];
+    const dark = [];
+    const unique = new Set();
+    bulbs.forEach((cell, index) => {
+        if (!Number.isInteger(cell) || cell < 0 || cell >= board.cells.length
+            || board.cells[cell] !== null || unique.has(cell)) {
+            errors.push(index);
+        }
+        else {
+            unique.add(cell);
+        }
+    });
+    const lit = new Set();
+    for (const bulb of unique) {
+        const ray = akariVisible(board, bulb);
+        ray.forEach(cell => lit.add(cell));
+        if (ray.some(cell => cell !== bulb && unique.has(cell)))
+            conflicts.push(bulb);
+    }
+    for (let cell = 0; cell < board.cells.length; cell += 1) {
+        if (board.cells[cell] === null && !lit.has(cell))
+            dark.push(cell);
+        const clue = board.cells[cell];
+        if (typeof clue !== "number")
+            continue;
+        const adjacent = akariNeighbours(board, cell).filter(neighbour => unique.has(neighbour)).length;
+        if (complete ? adjacent !== clue : adjacent > clue)
+            numbered.push(cell);
+    }
+    return {
+        ok: !errors.length && !conflicts.length && !numbered.length && (!complete || !dark.length),
+        illuminated: lit.size,
+        errors,
+        dark,
+        numbered,
+        conflicts,
+    };
+}
+/** Checks a complete placement from the public rules, without consulting a stored answer. */
+export function checkAkari(board, bulbs) {
+    return evaluate(board, bulbs, true);
+}
+/** Reports immediate contradictions while allowing required clues to remain unsatisfied during play. */
+export function progressAkari(board, bulbs) {
+    return evaluate(board, bulbs, false);
+}

package/dist/akariDraw.d.ts

@@ -0,0 +1,4 @@
+import type { AkariBoard } from "./akari.types.ts";
+import type { AkariDrawOptions } from "./akariPlay.types.ts";
+/** Draws the public clues and current bulbs as SVG. */
+export declare function drawAkari(board: AkariBoard, options?: AkariDrawOptions): string;

package/dist/akariDraw.js

@@ -0,0 +1,38 @@
+import { akariVisible, isAkariBoard } from "./akariBoard.js";
+import { akariWords } from "./akariStrings.js";
+/** Draws the public clues and current bulbs as SVG. */
+export function drawAkari(board, options = {}) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    const words = akariWords(options.language);
+    const size = 48;
+    const palettes = {
+        ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)", "#252923"],
+        wood: ["#e5cda6", "#493e2f", "#bca582", "#493e2f"],
+        slate: ["#262a27", "#ece8dc", "#454a44", "#111412"],
+    };
+    const [paper, ink, grid, black] = palettes[options.material ?? "ivory"];
+    const bulbs = new Set(options.bulbs ?? []);
+    const lit = new Set();
+    bulbs.forEach(cell => akariVisible(board, cell).forEach(illuminated => lit.add(illuminated)));
+    const cells = board.cells.map((clue, cell) => {
+        const x = cell % board.width * size;
+        const y = Math.floor(cell / board.width) * size;
+        const active = cell === options.selected;
+        const bad = options.errors?.includes(cell);
+        const bulb = bulbs.has(cell)
+            ? `${options.pieces === "tiles" ? `<rect x="${x + 10}" y="${y + 10}" width="28" height="28" rx="6" fill="${paper}" stroke="${grid}"/>` : ""}
+          <circle cx="${x + 24}" cy="${y + 24}" r="11" fill="${ink}"/>
+          <path d="M${x + 18} ${y + 31}h12m-10 4h8" stroke="${ink}" stroke-width="2"/>`
+            : "";
+        const body = clue === null
+            ? `<rect x="${x}" y="${y}" width="48" height="48" fill="${lit.has(cell) ? paper : "var(--kz-grid,#cfc6b2)"}" fill-opacity=".95"/>${bulb}`
+            : `<rect x="${x}" y="${y}" width="48" height="48" fill="${black}"/>${typeof clue === "number"
+                ? `<text x="${x + 24}" y="${y + 25}" dominant-baseline="middle" text-anchor="middle" fill="${paper}" font-size="21" font-weight="700" font-family="system-ui,sans-serif">${clue}</text>`
+                : ""}`;
+        const stroke = bad ? "var(--kz-bad,#b5452c)" : grid;
+        const strokeWidth = bad ? 3 : 1;
+        return `<g data-akari-cell="${cell}">${body}<rect x="${x}" y="${y}" width="48" height="48" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".16" : "1"}" stroke="${stroke}" stroke-width="${strokeWidth}"/></g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${board.width * size + 4} ${board.height * size + 4}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/akariGame.d.ts

@@ -0,0 +1,15 @@
+import type { AkariBoard, AkariGame } from "./akari.types.ts";
+/** Starts a game with only its public board data. */
+export declare function newAkari(board: AkariBoard): AkariGame;
+/** Toggles a bulb on a white square and keeps one prior turn for undo. */
+export declare function toggleAkari(game: AkariGame, cell: number): AkariGame;
+/** Restores the last bulb placement. */
+export declare function undoAkari(game: AkariGame): AkariGame;
+/** A game is finished only when its bulbs satisfy every rule and light every white square. */
+export declare function akariFinished(game: AkariGame): boolean;
+/** Returns a missing bulb, or an extra bulb to remove, only after uniqueness is proved. */
+export declare function hintAkari(game: AkariGame): number | null;
+/** Encodes only public clues and player placements. */
+export declare function encodeAkari(game: AkariGame): string;
+/** Decodes a bounded save after validating the board and each placement. */
+export declare function decodeAkari(code: string): AkariGame | null;

package/dist/akariGame.js

@@ -0,0 +1,71 @@
+import { checkAkari, isAkariBoard } from "./akariBoard.js";
+import { solveAkari } from "./akariSolve.js";
+/** Starts a game with only its public board data. */
+export function newAkari(board) {
+    if (!isAkariBoard(board))
+        throw new RangeError("Invalid Akari board");
+    return {
+        board: { width: board.width, height: board.height, cells: [...board.cells] },
+        bulbs: [],
+        history: [],
+        helped: false,
+    };
+}
+/** Toggles a bulb on a white square and keeps one prior turn for undo. */
+export function toggleAkari(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.board.cells.length || game.board.cells[cell] !== null) {
+        return game;
+    }
+    const bulbs = game.bulbs.includes(cell)
+        ? game.bulbs.filter(placed => placed !== cell)
+        : [...game.bulbs, cell];
+    return { ...game, bulbs, history: [...game.history, [...game.bulbs]] };
+}
+/** Restores the last bulb placement. */
+export function undoAkari(game) {
+    const previous = game.history.at(-1);
+    return previous
+        ? { ...game, bulbs: [...previous], history: game.history.slice(0, -1) }
+        : game;
+}
+/** A game is finished only when its bulbs satisfy every rule and light every white square. */
+export function akariFinished(game) {
+    return checkAkari(game.board, game.bulbs).ok;
+}
+/** Returns a missing bulb, or an extra bulb to remove, only after uniqueness is proved. */
+export function hintAkari(game) {
+    const solved = solveAkari(game.board);
+    if (!solved.complete || solved.count !== 1 || !solved.solution)
+        return null;
+    return solved.solution.find(cell => !game.bulbs.includes(cell))
+        ?? game.bulbs.find(cell => !solved.solution.includes(cell))
+        ?? null;
+}
+/** Encodes only public clues and player placements. */
+export function encodeAkari(game) {
+    return JSON.stringify({ version: 1, board: game.board, bulbs: game.bulbs, helped: game.helped });
+}
+/** Decodes a bounded save after validating the board and each placement. */
+export function decodeAkari(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isAkariBoard(value.board) || !Array.isArray(value.bulbs)
+            || value.bulbs.length > value.board.cells.length || typeof value.helped !== "boolean")
+            return null;
+        if (new Set(value.bulbs).size !== value.bulbs.length)
+            return null;
+        let game = newAkari(value.board);
+        for (const cell of value.bulbs) {
+            const next = toggleAkari(game, cell);
+            if (next === game)
+                return null;
+            game = next;
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/akariGenerate.d.ts

@@ -0,0 +1,10 @@
+import type { AkariLevel, AkariPuzzle } from "./akari.types.ts";
+/**
+ * Makes a seeded board and proves it has one answer. A random wall of black squares is lit by randomly placed
+ * bulbs, every black square that touches a white one is numbered, and then numbers are taken away for as long as
+ * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most
+ * of its numbers), hard by supposing one square at a time, extra-hard for as long as the answer stays single,
+ * which leaves a board that needs more supposing than that. If no board of the level is found within the
+ * attempts, the next one down is tried, and the first generator, which cannot fail, is the last.
+ */
+export declare function generateAkari(width?: number, height?: number, seed?: number, level?: AkariLevel): AkariPuzzle;

package/dist/akariGenerate.js

@@ -0,0 +1,101 @@
+import { AKARI_LEVELS, AKARI_MOST_ATTEMPTS, AKARI_MOST_SIDE } from "./akari.constants.js";
+import { akariNeighbours, akariVisible, checkAkari, isAkariBoard } from "./akariBoard.js";
+import { akariModel } from "./akariLogic.js";
+import { solveAkari } from "./akariSolve.js";
+import { templateAkari } from "./akariTemplate.js";
+import { logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+/**
+ * Makes a seeded board and proves it has one answer. A random wall of black squares is lit by randomly placed
+ * bulbs, every black square that touches a white one is numbered, and then numbers are taken away for as long as
+ * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most
+ * of its numbers), hard by supposing one square at a time, extra-hard for as long as the answer stays single,
+ * which leaves a board that needs more supposing than that. If no board of the level is found within the
+ * attempts, the next one down is tried, and the first generator, which cannot fail, is the last.
+ */
+export function generateAkari(width = 7, height = width, seed = 1, level = "medium") {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
+        || !isKazuSeed(seed) || !AKARI_LEVELS.includes(level))
+        throw new RangeError("Invalid Akari settings");
+    const random = seededRandom(seed);
+    for (let aim = AKARI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = AKARI_LEVELS[aim];
+        // Extra-hard is the hardest of several boards that need supposing: the most suppositions wins.
+        const wanted = aimed === "extra-hard" ? 8 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < AKARI_MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const made = attemptAkari(width, height, aimed, random);
+            if (!made)
+                continue;
+            const proof = solveAkari(made.board, { limit: 2 });
+            if (!proof.complete || proof.count !== 1 || !proof.solution || !checkAkari(made.board, proof.solution).ok)
+                continue;
+            found += 1;
+            if (!best || made.probes > best.probes)
+                best = { board: made.board, probes: made.probes, solution: proof.solution };
+        }
+        if (best)
+            return { ...best.board, seed, level, solution: best.solution };
+    }
+    const fallback = templateAkari(width, height, seed);
+    return { ...fallback, level };
+}
+function attemptAkari(width, height, level, random) {
+    const size = width * height;
+    const density = { easy: .2, medium: .22, hard: .24, "extra-hard": .26 }[level] * (.85 + random() * .3);
+    const cells = Array.from({ length: size }, () => random() < density ? false : null);
+    if (random() < .5)
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const mirror = (height - 1 - y) * width + width - 1 - x;
+                if (y * width + x < mirror)
+                    cells[mirror] = cells[y * width + x];
+            }
+    if (!cells.includes(null))
+        return null;
+    const base = { width, height, cells };
+    // Light every white square with randomly chosen bulbs that never see one another.
+    const lit = new Set(), bulbs = new Set();
+    for (const cell of shuffled(cells.flatMap((value, at) => value === null ? [at] : []), random)) {
+        if (lit.has(cell))
+            continue;
+        bulbs.add(cell);
+        for (const seen of akariVisible(base, cell))
+            lit.add(seen);
+    }
+    const numbered = cells.flatMap((value, at) => value === false && akariNeighbours(base, at).some(n => cells[n] === null) ? [at] : []);
+    for (const at of numbered)
+        cells[at] = akariNeighbours(base, at).filter(n => bulbs.has(n)).length;
+    if (!numbered.length)
+        return null;
+    const accepts = () => {
+        const { csp } = akariModel({ width, height, cells });
+        return logicCsp(csp, openSlots(csp), level === "easy" || level === "medium" ? 0 : 1).solved;
+    };
+    if (!accepts())
+        return null;
+    const keepAtLeast = level === "easy" ? Math.ceil(numbered.length * .7) : 0;
+    let left = numbered.length;
+    for (const at of shuffled(numbered, random)) {
+        if (left <= keepAtLeast)
+            break;
+        const was = cells[at];
+        cells[at] = false;
+        if (accepts())
+            left -= 1;
+        else
+            cells[at] = was;
+    }
+    const board = { width, height, cells };
+    if (!isAkariBoard(board))
+        return null;
+    const { csp } = akariModel(board);
+    if (level === "easy" || level === "medium")
+        return { board, probes: 0 };
+    if (logicCsp(csp, openSlots(csp), 0).solved)
+        return null;
+    const probing = logicCsp(csp, openSlots(csp), 1);
+    if (!probing.solved)
+        return level === "extra-hard" ? { board, probes: 1000 } : null;
+    return probing.probes >= Math.max(2, Math.round(size * .02)) ? { board, probes: probing.probes } : null;
+}

package/dist/akariLogic.d.ts

@@ -0,0 +1,10 @@
+import type { Csp } from "./csp.ts";
+import type { AkariBoard } from "./akari.types.ts";
+/** An Akari board as variables: one per white square, slot 0 for no bulb and slot 1 for a bulb. */
+export type AkariModel = {
+    csp: Csp;
+    whites: readonly number[];
+    index: Int32Array;
+};
+/** Builds the pruning rules of Akari: a bulb shades its lines, a number counts its neighbours, every white square needs a lamp. */
+export declare function akariModel(board: AkariBoard): AkariModel;

package/dist/akariLogic.js

@@ -0,0 +1,84 @@
+import { akariNeighbours, akariVisible } from "./akariBoard.js";
+/** Builds the pruning rules of Akari: a bulb shades its lines, a number counts its neighbours, every white square needs a lamp. */
+export function akariModel(board) {
+    const whites = board.cells.flatMap((value, cell) => value === null ? [cell] : []);
+    const index = new Int32Array(board.cells.length).fill(-1);
+    whites.forEach((cell, i) => { index[cell] = i; });
+    const sees = whites.map(cell => Int32Array.from(akariVisible(board, cell).filter(other => other !== cell).map(other => index[other])));
+    const clues = board.cells.flatMap((value, cell) => typeof value === "number"
+        ? [{ need: value, near: Int32Array.from(akariNeighbours(board, cell).filter(other => index[other] >= 0).map(other => index[other])) }]
+        : []);
+    const starts = Int32Array.from({ length: whites.length + 1 }, (_, i) => i * 2);
+    const propagate = (alive) => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (let i = 0; i < whites.length; i += 1) {
+                if (!alive[2 * i] && !alive[2 * i + 1])
+                    return false;
+                if (alive[2 * i] || !alive[2 * i + 1])
+                    continue;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        alive[2 * j + 1] = 0;
+                        changed = true;
+                        if (!alive[2 * j])
+                            return false;
+                    }
+                }
+            }
+            for (const clue of clues) {
+                let on = 0, maybe = 0;
+                for (let k = 0; k < clue.near.length; k += 1) {
+                    const j = clue.near[k];
+                    if (alive[2 * j + 1]) {
+                        maybe += 1;
+                        if (!alive[2 * j])
+                            on += 1;
+                    }
+                }
+                if (on > clue.need || maybe < clue.need)
+                    return false;
+                if (on === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j + 1] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+                else if (maybe === clue.need && maybe > on) {
+                    for (let k = 0; k < clue.near.length; k += 1) {
+                        const j = clue.near[k];
+                        if (alive[2 * j + 1] && alive[2 * j]) {
+                            alive[2 * j] = 0;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < whites.length; i += 1) {
+                let lamps = alive[2 * i + 1] ? 1 : 0, only = alive[2 * i + 1] ? i : -1;
+                const ray = sees[i];
+                for (let k = 0; k < ray.length && lamps < 2; k += 1) {
+                    const j = ray[k];
+                    if (alive[2 * j + 1]) {
+                        lamps += 1;
+                        only = j;
+                    }
+                }
+                if (lamps === 0)
+                    return false;
+                if (lamps === 1 && alive[2 * only]) {
+                    alive[2 * only] = 0;
+                    changed = true;
+                }
+            }
+        }
+        return true;
+    };
+    return { csp: { starts, propagate }, whites, index };
+}

package/dist/akariMount.d.ts

@@ -0,0 +1,3 @@
+import type { AkariMount, AkariMountOptions } from "./akariPlay.types.ts";
+/** Mounts the player in a host element; call destroy when the host is removed. */
+export declare function mountAkari(host: HTMLElement, initial: AkariMountOptions): AkariMount;