@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/masyu.constants.js

@@ -0,0 +1,2 @@
+export const MASYU_SIZES = [5, 7];
+export const MASYU_NODE_BUDGET = 250000;

package/dist/masyu.types.d.ts

@@ -0,0 +1,46 @@
+export type MasyuBoard = {
+    width: number;
+    height: number;
+    pearls: readonly number[];
+};
+export type MasyuPuzzle = MasyuBoard & {
+    seed: number;
+    solution: readonly number[];
+};
+export type MasyuCheck = {
+    ok: boolean;
+    errors: readonly number[];
+};
+export type MasyuSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type MasyuGame = {
+    board: MasyuBoard;
+    edges: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};
+export type MasyuDrawOptions = {
+    edges?: readonly number[];
+    selected?: number;
+    errors?: readonly number[];
+    material?: "ivory" | "wood" | "slate";
+    pieces?: "plain" | "tiles";
+    language?: "en" | "ja";
+};
+export type MasyuMountOptions = MasyuDrawOptions & {
+    board: MasyuBoard;
+    progress?: string;
+    onChange?: (game: MasyuGame) => void;
+    onFinish?: (game: MasyuGame) => void;
+};
+export type MasyuMount = {
+    game: () => MasyuGame;
+    progress: () => string;
+    set: (options: MasyuDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/masyu.types.js

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

package/dist/masyuBoard.d.ts

@@ -0,0 +1,10 @@
+import type { MasyuBoard, MasyuCheck } from "./masyu.types.ts";
+export declare const masyuCellCount: (board: MasyuBoard) => number;
+export declare const masyuEdgeCount: (board: MasyuBoard) => number;
+export declare function isMasyuBoard(value: unknown): value is MasyuBoard;
+export declare function masyuNeighbors(board: MasyuBoard, cell: number): {
+    cell: number;
+    edge: number;
+    direction: number;
+}[];
+export declare function checkMasyu(board: MasyuBoard, lines: readonly number[]): MasyuCheck;

package/dist/masyuBoard.js

@@ -0,0 +1,88 @@
+import { MASYU_SIZES } from "./masyu.constants.js";
+export const masyuCellCount = (board) => board.width * board.height;
+export const masyuEdgeCount = (board) => board.height * (board.width - 1) + board.width * (board.height - 1);
+export function isMasyuBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    return MASYU_SIZES.includes(board.width) && board.width === board.height
+        && Array.isArray(board.pearls) && board.pearls.length === masyuCellCount(board)
+        && board.pearls.every(pearl => pearl === 0 || pearl === 1 || pearl === 2)
+        && board.pearls.some(Boolean);
+}
+export function masyuNeighbors(board, cell) {
+    const x = cell % board.width, y = Math.floor(cell / board.width), horizontal = board.height * (board.width - 1);
+    const result = [];
+    if (y > 0)
+        result.push({ cell: cell - board.width, edge: horizontal + (y - 1) * board.width + x, direction: 0 });
+    if (x < board.width - 1)
+        result.push({ cell: cell + 1, edge: y * (board.width - 1) + x, direction: 1 });
+    if (y < board.height - 1)
+        result.push({ cell: cell + board.width, edge: horizontal + y * board.width + x, direction: 2 });
+    if (x > 0)
+        result.push({ cell: cell - 1, edge: y * (board.width - 1) + x - 1, direction: 3 });
+    return result;
+}
+function pearlRule(board, edges, cell) {
+    const directions = masyuNeighbors(board, cell).filter(next => edges.has(next.edge)).map(next => next.direction);
+    if (directions.length !== 2)
+        return false;
+    const pearl = board.pearls[cell];
+    if (pearl === 1) {
+        if ((directions[0] + 2) % 4 !== directions[1])
+            return false;
+        return directions.some(direction => {
+            const next = masyuNeighbors(board, cell).find(item => item.direction === direction);
+            const nextDirections = masyuNeighbors(board, next.cell).filter(item => edges.has(item.edge)).map(item => item.direction);
+            return nextDirections.length === 2 && (nextDirections[0] + 2) % 4 !== nextDirections[1];
+        });
+    }
+    if (pearl === 2) {
+        if ((directions[0] + 2) % 4 === directions[1])
+            return false;
+        return directions.every(direction => {
+            const next = masyuNeighbors(board, cell).find(item => item.direction === direction);
+            const nextDirections = masyuNeighbors(board, next.cell).filter(item => edges.has(item.edge)).map(item => item.direction);
+            return nextDirections.length === 2 && (nextDirections[0] + 2) % 4 === nextDirections[1];
+        });
+    }
+    return true;
+}
+export function checkMasyu(board, lines) {
+    if (!isMasyuBoard(board))
+        throw new RangeError("Invalid Masyu board");
+    const edgeCount = masyuEdgeCount(board), edges = new Set(lines), errors = new Set();
+    if (edges.size !== lines.length || lines.some(edge => !Number.isInteger(edge) || edge < 0 || edge >= edgeCount)) {
+        return { ok: false, errors: [] };
+    }
+    const degrees = board.pearls.map((_, cell) => masyuNeighbors(board, cell).filter(next => edges.has(next.edge)).length);
+    for (let cell = 0; cell < degrees.length; cell += 1) {
+        if (degrees[cell] !== 0 && degrees[cell] !== 2 || (board.pearls[cell] > 0 && degrees[cell] !== 2))
+            errors.add(cell);
+    }
+    if (edges.size) {
+        const start = degrees.findIndex(degree => degree === 2), reached = new Set([start]), stack = [start];
+        while (stack.length) {
+            const cell = stack.pop();
+            for (const next of masyuNeighbors(board, cell))
+                if (edges.has(next.edge) && !reached.has(next.cell)) {
+                    reached.add(next.cell);
+                    stack.push(next.cell);
+                }
+        }
+        for (let cell = 0; cell < degrees.length; cell += 1)
+            if (degrees[cell] === 2 && !reached.has(cell))
+                errors.add(cell);
+        if (reached.size !== edges.size)
+            for (const cell of reached)
+                errors.add(cell);
+    }
+    for (let cell = 0; cell < degrees.length; cell += 1) {
+        if (degrees[cell] === 2 && !pearlRule(board, edges, cell))
+            errors.add(cell);
+    }
+    const complete = edges.size > 0 && degrees.every(degree => degree === 0 || degree === 2)
+        && degrees.every((degree, cell) => board.pearls[cell] === 0 || degree === 2)
+        && degrees.filter(degree => degree === 2).length === edges.size;
+    return { ok: complete && errors.size === 0, errors: [...errors] };
+}

package/dist/masyuDraw.d.ts

@@ -0,0 +1,2 @@
+import type { MasyuBoard, MasyuDrawOptions } from "./masyu.types.ts";
+export declare function drawMasyu(board: MasyuBoard, options?: MasyuDrawOptions): string;

package/dist/masyuDraw.js

@@ -0,0 +1,33 @@
+import { isMasyuBoard, masyuNeighbors } from "./masyuBoard.js";
+import { MASYU_STRINGS } from "./masyuStrings.js";
+export function drawMasyu(board, options = {}) {
+    if (!isMasyuBoard(board))
+        throw new RangeError("Invalid Masyu board");
+    const words = MASYU_STRINGS[options.language ?? "en"], step = 52, pad = 14;
+    const palette = { 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] = palette[options.material ?? "ivory"];
+    const edges = new Set(options.edges ?? []), parts = [];
+    for (let cell = 0; cell < board.pearls.length; cell += 1) {
+        const x = pad + (cell % board.width) * step, y = pad + Math.floor(cell / board.width) * step;
+        const active = options.selected === cell;
+        parts.push(`<rect x="${x - step / 2}" y="${y - step / 2}" width="${step}" height="${step}" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".08" : "1"}"/>`);
+        for (const next of masyuNeighbors(board, cell))
+            if (cell < next.cell && edges.has(next.edge)) {
+                const nx = pad + (next.cell % board.width) * step, ny = pad + Math.floor(next.cell / board.width) * step;
+                parts.push(`<line x1="${x}" y1="${y}" x2="${nx}" y2="${ny}" stroke="${options.errors?.includes(cell) ? "var(--kz-bad,#b5452c)" : ink}" stroke-width="5" stroke-linecap="round"/>`);
+            }
+    }
+    for (let cell = 0; cell < board.pearls.length; cell += 1) {
+        const pearl = board.pearls[cell];
+        if (!pearl)
+            continue;
+        const x = pad + (cell % board.width) * step, y = pad + Math.floor(cell / board.width) * step;
+        const radius = options.pieces === "tiles" ? 12 : 10;
+        parts.push(`<circle cx="${x}" cy="${y}" r="${radius}" fill="${pearl === 1 ? paper : ink}" stroke="${ink}" stroke-width="3" aria-label="${words.pearl[pearl]}"/>`);
+    }
+    for (let y = 0; y < board.height; y += 1)
+        for (let x = 0; x < board.width; x += 1) {
+            parts.push(`<circle cx="${pad + x * step}" cy="${pad + y * step}" r="2" fill="${grid}"/>`);
+        }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pad * 2 + (board.width - 1) * step} ${pad * 2 + (board.height - 1) * step}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${parts.join("")}</svg>`;
+}

package/dist/masyuGame.d.ts

@@ -0,0 +1,9 @@
+import type { MasyuBoard, MasyuGame } from "./masyu.types.ts";
+export declare function newMasyu(board: MasyuBoard): MasyuGame;
+export declare function toggleMasyuEdge(game: MasyuGame, edge: number): MasyuGame;
+export declare function undoMasyu(game: MasyuGame): MasyuGame;
+export declare function restartMasyu(game: MasyuGame): MasyuGame;
+export declare function hintMasyu(game: MasyuGame): number | null;
+export declare function masyuFinished(game: MasyuGame): boolean;
+export declare function encodeMasyu(game: MasyuGame): string;
+export declare function decodeMasyu(code: string): MasyuGame | null;

package/dist/masyuGame.js

@@ -0,0 +1,46 @@
+import { checkMasyu, isMasyuBoard, masyuEdgeCount } from "./masyuBoard.js";
+import { solveMasyu } from "./masyuSolve.js";
+export function newMasyu(board) {
+    if (!isMasyuBoard(board))
+        throw new RangeError("Invalid Masyu board");
+    return { board: { width: board.width, height: board.height, pearls: [...board.pearls] }, edges: [], history: [], helped: false };
+}
+export function toggleMasyuEdge(game, edge) {
+    if (!Number.isInteger(edge) || edge < 0 || edge >= masyuEdgeCount(game.board))
+        return game;
+    const edges = game.edges.includes(edge) ? game.edges.filter(value => value !== edge) : [...game.edges, edge].sort((a, b) => a - b);
+    return { ...game, edges, history: [...game.history, [...game.edges]] };
+}
+export function undoMasyu(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, edges: [...previous], history: game.history.slice(0, -1) } : game;
+}
+export function restartMasyu(game) { return { ...newMasyu(game.board), helped: false }; }
+export function hintMasyu(game) {
+    const result = solveMasyu(game.board);
+    if (!result.complete || result.count !== 1)
+        return null;
+    return result.solution.find(edge => !game.edges.includes(edge)) ?? null;
+}
+export function masyuFinished(game) { return checkMasyu(game.board, game.edges).ok; }
+export function encodeMasyu(game) {
+    return JSON.stringify({ version: 1, board: game.board, edges: game.edges, helped: game.helped });
+}
+export function decodeMasyu(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isMasyuBoard(value.board) || !Array.isArray(value.edges)
+            || typeof value.helped !== "boolean" || !value.edges.every((edge) => Number.isInteger(edge)))
+            return null;
+        const rawEdges = value.edges;
+        const edges = [...new Set(rawEdges)].sort((a, b) => a - b);
+        if (edges.length !== rawEdges.length || edges.some(edge => edge < 0 || edge >= masyuEdgeCount(value.board)))
+            return null;
+        return { ...newMasyu(value.board), edges, helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/masyuGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { MasyuPuzzle } from "./masyu.types.ts";
+/** Seeded original loop layouts; every output is accepted only after a completed uniqueness proof. */
+export declare function generateMasyu(size?: 5, seed?: number): MasyuPuzzle;

package/dist/masyuGenerate.js

@@ -0,0 +1,56 @@
+import { isKazuSeed, seededRandom } from "./random.js";
+import { checkMasyu, isMasyuBoard, masyuNeighbors } from "./masyuBoard.js";
+import { solveMasyu } from "./masyuSolve.js";
+const loops = [
+    [12, 17, 18, 19, 14, 9, 8, 7],
+    [14, 9, 4, 3, 2, 1, 6, 11, 12, 13],
+    [21, 20, 15, 10, 5, 0, 1, 2, 7, 12, 17, 22],
+    [19, 24, 23, 22, 17, 12, 7, 8, 9, 14],
+];
+function turnAt(path, index) {
+    const before = path[(index + path.length - 1) % path.length];
+    const cell = path[index];
+    const after = path[(index + 1) % path.length];
+    return Math.abs(cell - before) !== Math.abs(after - cell);
+}
+function makePearls(path) {
+    const pearls = Array(25).fill(0);
+    for (let index = 0; index < path.length; index += 1) {
+        if (turnAt(path, index))
+            pearls[path[index]] = 2;
+        else if (turnAt(path, (index + path.length - 1) % path.length)
+            || turnAt(path, (index + 1) % path.length))
+            pearls[path[index]] = 1;
+    }
+    return pearls;
+}
+function makeEdges(board, path) {
+    const edges = path.map((cell, index) => {
+        const nextCell = path[(index + 1) % path.length];
+        return masyuNeighbors(board, cell).find(next => next.cell === nextCell)?.edge;
+    });
+    return edges.every((edge) => edge !== undefined) ? edges.sort((a, b) => a - b) : null;
+}
+/** Seeded original loop layouts; every output is accepted only after a completed uniqueness proof. */
+export function generateMasyu(size = 5, seed = 1) {
+    if (size !== 5 || !isKazuSeed(seed))
+        throw new RangeError("Invalid Masyu settings");
+    const random = seededRandom(seed), base = loops[Math.floor(random() * loops.length)];
+    const turns = Math.floor(random() * 4), reflect = random() < 0.5;
+    const path = base.map(cell => {
+        let x = cell % 5, y = Math.floor(cell / 5);
+        if (reflect)
+            x = 4 - x;
+        for (let turn = 0; turn < turns; turn += 1)
+            [x, y] = [4 - y, x];
+        return y * 5 + x;
+    });
+    const board = { width: 5, height: 5, pearls: makePearls(path) };
+    const expected = makeEdges(board, path);
+    if (!expected || !isMasyuBoard(board) || !checkMasyu(board, expected).ok)
+        throw new Error("Invalid Masyu layout");
+    const proof = solveMasyu(board);
+    if (!proof.complete || proof.count !== 1)
+        throw new Error("No uniquely proved Masyu found within the generation budget; try another seed");
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/masyuMount.d.ts

@@ -0,0 +1,2 @@
+import type { MasyuMount, MasyuMountOptions } from "./masyu.types.ts";
+export declare function mountMasyu(element: HTMLElement, initial: MasyuMountOptions): MasyuMount;

package/dist/masyuMount.js

@@ -0,0 +1,118 @@
+import { checkMasyu, masyuNeighbors } from "./masyuBoard.js";
+import { decodeMasyu, encodeMasyu, hintMasyu, newMasyu, restartMasyu, toggleMasyuEdge, undoMasyu } from "./masyuGame.js";
+import { drawMasyu } from "./masyuDraw.js";
+import { MASYU_PLAY_STYLE } from "./masyuStyle.js";
+import { MASYU_STRINGS } from "./masyuStrings.js";
+export function mountMasyu(element, initial) {
+    const document = element.ownerDocument, style = document.createElement("style");
+    style.textContent = MASYU_PLAY_STYLE;
+    const root = document.createElement("section");
+    root.className = "kazu-masyu";
+    const help = document.createElement("p"), board = document.createElement("div");
+    board.className = "km-board";
+    const tools = document.createElement("div");
+    tools.className = "km-tools";
+    const status = document.createElement("p");
+    status.className = "km-status";
+    status.setAttribute("aria-live", "polite");
+    root.append(help, board, tools, status);
+    element.replaceChildren(style, root);
+    let options = { ...initial };
+    let game = initial.progress ? decodeMasyu(initial.progress) : null;
+    if (!game || game.board.width !== initial.board.width || game.board.height !== initial.board.height
+        || game.board.pearls.some((pearl, cell) => pearl !== initial.board.pearls[cell]))
+        game = newMasyu(initial.board);
+    let selected = 0, anchor = null, errors = [], message = "", dead = false;
+    const words = () => MASYU_STRINGS[options.language ?? "en"];
+    const copy = () => ({ ...game, board: { ...game.board, pearls: [...game.board.pearls] }, edges: [...game.edges], history: game.history.map(turn => [...turn]) });
+    const changed = () => { options.onChange?.(copy()); if (checkMasyu(game.board, game.edges).ok)
+        options.onFinish?.(copy()); };
+    const toggleBetween = (first, second) => {
+        const edge = masyuNeighbors(game.board, first).find(next => next.cell === second)?.edge;
+        if (edge === undefined)
+            return;
+        game = toggleMasyuEdge(game, edge);
+        anchor = second;
+        selected = second;
+        errors = [];
+        message = "";
+        render();
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words();
+        help.textContent = w.help;
+        board.innerHTML = drawMasyu(game.board, { ...options, edges: game.edges, selected, errors });
+        const controls = document.createElement("div");
+        controls.className = "km-cells";
+        controls.style.gridTemplateColumns = `repeat(${game.board.width}, 1fr)`;
+        controls.style.gridTemplateRows = `repeat(${game.board.height}, 1fr)`;
+        game.board.pearls.forEach((pearl, cell) => {
+            const button = document.createElement("button");
+            button.type = "button";
+            button.className = "km-cell";
+            button.dataset.cell = String(cell);
+            button.textContent = String(cell + 1);
+            button.setAttribute("aria-label", `${w.pearl[pearl]}, row ${Math.floor(cell / game.board.width) + 1}, column ${cell % game.board.width + 1}`);
+            button.setAttribute("aria-pressed", String(selected === cell));
+            button.tabIndex = selected === cell ? 0 : -1;
+            button.onclick = () => {
+                selected = cell;
+                if (anchor === null)
+                    anchor = cell;
+                else if (anchor !== cell)
+                    toggleBetween(anchor, cell);
+                render();
+            };
+            button.onkeydown = event => {
+                const x = cell % game.board.width, y = Math.floor(cell / game.board.width);
+                const moves = { ArrowUp: [0, -1], ArrowDown: [0, 1], ArrowLeft: [-1, 0], ArrowRight: [1, 0] };
+                if (event.key in moves) {
+                    event.preventDefault();
+                    const [dx, dy] = moves[event.key];
+                    const nextX = x + dx, nextY = y + dy;
+                    if (nextX >= 0 && nextX < game.board.width && nextY >= 0 && nextY < game.board.height) {
+                        selected = nextY * game.board.width + nextX;
+                        render();
+                        board.querySelectorAll(".km-cell")[selected]?.focus();
+                    }
+                }
+                else if (event.key === "Enter" || event.key === " ") {
+                    event.preventDefault();
+                    if (anchor === null)
+                        anchor = cell;
+                    else if (anchor !== cell)
+                        toggleBetween(anchor, cell);
+                    render();
+                    board.querySelectorAll(".km-cell")[selected]?.focus();
+                }
+            };
+            controls.append(button);
+        });
+        board.append(controls);
+        tools.replaceChildren();
+        const add = (label, action) => { const button = document.createElement("button"); button.type = "button"; button.textContent = label; button.onclick = action; tools.append(button); };
+        add(w.undo, () => { game = undoMasyu(game); errors = []; render(); changed(); });
+        add(w.hint, () => { const edge = hintMasyu(game); if (edge === null)
+            message = w.bad;
+        else {
+            game = toggleMasyuEdge(game, edge);
+            game = { ...game, helped: true };
+            message = w.good;
+            changed();
+        } render(); });
+        add(w.check, () => { errors = checkMasyu(game.board, game.edges).errors; message = errors.length ? w.bad : w.good; render(); });
+        add(w.restart, () => { game = restartMasyu(game); anchor = null; errors = []; message = ""; render(); changed(); });
+        status.textContent = checkMasyu(game.board, game.edges).ok ? (game.helped ? w.helped : w.won) : message;
+    };
+    render();
+    return {
+        game: copy,
+        progress: () => encodeMasyu(game),
+        set: next => { options = { ...options, ...next }; render(); },
+        restart: () => { game = restartMasyu(game); anchor = null; render(); changed(); },
+        destroy: () => { dead = true; element.replaceChildren(); },
+    };
+}

package/dist/masyuPlay.types.d.ts

@@ -0,0 +1 @@
+export type { MasyuDrawOptions as MasyuDrawOptions, MasyuMount as MasyuMount, MasyuMountOptions as MasyuMountOptions } from "./masyu.types.ts";

package/dist/masyuPlay.types.js

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

package/dist/masyuSolve.d.ts

@@ -0,0 +1,6 @@
+import type { MasyuBoard, MasyuSolve } from "./masyu.types.ts";
+/** Counts distinct single loops with local pearl rules; budget stops never claim a proof. */
+export declare function solveMasyu(board: MasyuBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): MasyuSolve;

package/dist/masyuSolve.js

@@ -0,0 +1,88 @@
+import { MASYU_NODE_BUDGET } from "./masyu.constants.js";
+import { checkMasyu, isMasyuBoard, masyuEdgeCount, masyuNeighbors } from "./masyuBoard.js";
+/** Counts distinct single loops with local pearl rules; budget stops never claim a proof. */
+export function solveMasyu(board, options = {}) {
+    if (!isMasyuBoard(board))
+        throw new RangeError("Invalid Masyu board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? MASYU_NODE_BUDGET;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const edgeState = Array(masyuEdgeCount(board)).fill(-1);
+    const configs = board.pearls.map((pearl, cell) => {
+        const validDirections = masyuNeighbors(board, cell).map(next => next.direction);
+        const choices = [];
+        for (let mask = 0; mask < 16; mask += 1) {
+            const bits = [0, 1, 2, 3].filter(direction => mask & (1 << direction));
+            if (bits.length !== 0 && bits.length !== 2)
+                continue;
+            if (bits.some(direction => !validDirections.includes(direction)))
+                continue;
+            if (pearl && bits.length !== 2)
+                continue;
+            const straight = bits.length === 2 && (bits[0] + 2) % 4 === bits[1];
+            if (pearl === 1 && !straight || pearl === 2 && straight)
+                continue;
+            choices.push(mask);
+        }
+        return choices;
+    });
+    let count = 0, nodes = 0, complete = true, answer = null;
+    const assigned = Array(board.pearls.length).fill(false);
+    const visit = (depth) => {
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        if (depth === board.pearls.length) {
+            const edges = edgeState.flatMap((value, edge) => value === 1 ? [edge] : []);
+            if (!checkMasyu(board, edges).ok)
+                return;
+            count += 1;
+            answer ?? (answer = edges);
+            if (count >= limit)
+                complete = false;
+            return;
+        }
+        let chosen = -1, available = null;
+        for (let cell = 0; cell < board.pearls.length; cell += 1) {
+            if (assigned[cell])
+                continue;
+            const neighbors = masyuNeighbors(board, cell);
+            const candidates = configs[cell].filter(mask => neighbors.every(next => edgeState[next.edge] < 0 || edgeState[next.edge] === (mask & (1 << next.direction) ? 1 : 0)));
+            if (!candidates.length)
+                return;
+            if (!available || candidates.length < available.length) {
+                chosen = cell;
+                available = candidates;
+                if (candidates.length === 1)
+                    break;
+            }
+        }
+        const neighbors = masyuNeighbors(board, chosen);
+        assigned[chosen] = true;
+        for (const mask of available ?? []) {
+            const changes = [];
+            let valid = true;
+            for (const next of neighbors) {
+                const value = mask & (1 << next.direction) ? 1 : 0;
+                if (edgeState[next.edge] >= 0 && edgeState[next.edge] !== value) {
+                    valid = false;
+                    break;
+                }
+                if (edgeState[next.edge] < 0) {
+                    edgeState[next.edge] = value;
+                    changes.push(next.edge);
+                }
+            }
+            if (valid)
+                visit(depth + 1);
+            for (const edge of changes)
+                edgeState[edge] = -1;
+            if (!complete)
+                return;
+        }
+        assigned[chosen] = false;
+    };
+    visit(0);
+    return { count, solution: answer, complete, nodes };
+}

package/dist/masyuStrings.d.ts

@@ -0,0 +1,28 @@
+export declare const MASYU_STRINGS: {
+    readonly en: {
+        readonly title: "Masyu";
+        readonly help: "Draw one loop through every pearl. White pearls go straight and turn at a neighboring cell; black pearls turn and go straight through the neighboring cell on each side.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly won: "Solved!";
+        readonly helped: "Solved with help.";
+        readonly good: "The loop is still open. Keep going.";
+        readonly bad: "Check the marked line ends and pearls.";
+        readonly pearl: readonly ["empty", "white pearl", "black pearl"];
+    };
+    readonly ja: {
+        readonly title: "ましゅ";
+        readonly help: "すべての真珠を通る一つの輪を描きます。白真珠では直進して隣のマスで曲がり、黒真珠では曲がって両隣のマスで直進します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly won: "完成！";
+        readonly helped: "ヒントを使って完成。";
+        readonly good: "輪はまだ閉じていません。続けましょう。";
+        readonly bad: "線の端や真珠の周りを確認してください。";
+        readonly pearl: readonly ["なし", "白真珠", "黒真珠"];
+    };
+};

package/dist/masyuStrings.js

@@ -0,0 +1,4 @@
+export const MASYU_STRINGS = {
+    en: { title: "Masyu", help: "Draw one loop through every pearl. White pearls go straight and turn at a neighboring cell; black pearls turn and go straight through the neighboring cell on each side.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", won: "Solved!", helped: "Solved with help.", good: "The loop is still open. Keep going.", bad: "Check the marked line ends and pearls.", pearl: ["empty", "white pearl", "black pearl"] },
+    ja: { title: "ましゅ", help: "すべての真珠を通る一つの輪を描きます。白真珠では直進して隣のマスで曲がり、黒真珠では曲がって両隣のマスで直進します。", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", won: "完成！", helped: "ヒントを使って完成。", good: "輪はまだ閉じていません。続けましょう。", bad: "線の端や真珠の周りを確認してください。", pearl: ["なし", "白真珠", "黒真珠"] },
+};

package/dist/masyuStyle.d.ts

@@ -0,0 +1 @@
+export declare const MASYU_PLAY_STYLE = "\n.kazu-masyu { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }\n.kazu-masyu .km-board { position:relative; max-width:440px; margin:auto; }\n.kazu-masyu svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }\n.kazu-masyu .km-cells { position:absolute; inset:6%; display:grid; }\n.kazu-masyu .km-cell { border:0; background:transparent; border-radius:50%; color:transparent; cursor:pointer; }\n.kazu-masyu .km-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }\n.kazu-masyu .km-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }\n.kazu-masyu button { font:inherit; padding:.45rem .8rem; }\n.kazu-masyu .km-status { min-height:1.5em; text-align:center; }\n";

package/dist/masyuStyle.js

@@ -0,0 +1,11 @@
+export const MASYU_PLAY_STYLE = `
+.kazu-masyu { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }
+.kazu-masyu .km-board { position:relative; max-width:440px; margin:auto; }
+.kazu-masyu svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }
+.kazu-masyu .km-cells { position:absolute; inset:6%; display:grid; }
+.kazu-masyu .km-cell { border:0; background:transparent; border-radius:50%; color:transparent; cursor:pointer; }
+.kazu-masyu .km-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }
+.kazu-masyu .km-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }
+.kazu-masyu button { font:inherit; padding:.45rem .8rem; }
+.kazu-masyu .km-status { min-height:1.5em; text-align:center; }
+`;

package/dist/nurikabe-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawNurikabe } from "./nurikabeDraw.ts";
+export type { NurikabeDrawOptions } from "./nurikabePlay.types.ts";

package/dist/nurikabe-draw-entry.js

@@ -0,0 +1 @@
+export { drawNurikabe } from "./nurikabeDraw.js";

package/dist/nurikabe-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./nurikabe.types.ts";
+export * from "./nurikabe.constants.ts";
+export * from "./nurikabeBoard.ts";
+export * from "./nurikabeSolve.ts";
+export * from "./nurikabeGenerate.ts";
+export * from "./nurikabeGame.ts";

package/dist/nurikabe-entry.js

@@ -0,0 +1,6 @@
+export * from "./nurikabe.types.js";
+export * from "./nurikabe.constants.js";
+export * from "./nurikabeBoard.js";
+export * from "./nurikabeSolve.js";
+export * from "./nurikabeGenerate.js";
+export * from "./nurikabeGame.js";

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

@@ -0,0 +1,4 @@
+export { mountNurikabe } from "./nurikabeMount.ts";
+export { NURIKABE_PLAY_STYLE } from "./nurikabeStyle.ts";
+export { NURIKABE_STRINGS } from "./nurikabeStrings.ts";
+export type * from "./nurikabePlay.types.ts";

package/dist/nurikabe-play-entry.js

@@ -0,0 +1,3 @@
+export { mountNurikabe } from "./nurikabeMount.js";
+export { NURIKABE_PLAY_STYLE } from "./nurikabeStyle.js";
+export { NURIKABE_STRINGS } from "./nurikabeStrings.js";

package/dist/nurikabe.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NURIKABE_MAX_NODES = 250000;
+export declare const NURIKABE_SIZES: readonly [5];

package/dist/nurikabe.constants.js

@@ -0,0 +1,2 @@
+export const NURIKABE_MAX_NODES = 250000;
+export const NURIKABE_SIZES = [5];