@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/kakuroStrings.d.ts

@@ -0,0 +1,82 @@
+export type KakuroLanguage = "en" | "ja";
+export declare const KAKURO_STRINGS: {
+    readonly en: {
+        readonly title: "Kakuro";
+        readonly help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly ready: "Choose a white cell.";
+        readonly won: "Every run is correct. Solved!";
+        readonly helped: "Solved with help.";
+        readonly checked: "No run errors so far. Keep filling.";
+        readonly wrong: "Some runs have a repeated digit or impossible total.";
+        readonly across: "Across";
+        readonly down: "Down";
+        readonly pencil: "Pencil marks";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly blank: "blank";
+        readonly clear: "Clear";
+    };
+    readonly ja: {
+        readonly title: "カックロ";
+        readonly help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly ready: "白マスを選んでください。";
+        readonly won: "すべての合計が合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly checked: "ここまでの合計に誤りはありません。続けてください。";
+        readonly wrong: "同じ数字または合計の誤りがあります。";
+        readonly across: "横";
+        readonly down: "縦";
+        readonly pencil: "メモ";
+        readonly row: "行";
+        readonly column: "列";
+        readonly blank: "空白";
+        readonly clear: "消す";
+    };
+};
+export declare function kakuroWords(language?: KakuroLanguage): {
+    readonly title: "Kakuro";
+    readonly help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly ready: "Choose a white cell.";
+    readonly won: "Every run is correct. Solved!";
+    readonly helped: "Solved with help.";
+    readonly checked: "No run errors so far. Keep filling.";
+    readonly wrong: "Some runs have a repeated digit or impossible total.";
+    readonly across: "Across";
+    readonly down: "Down";
+    readonly pencil: "Pencil marks";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly blank: "blank";
+    readonly clear: "Clear";
+} | {
+    readonly title: "カックロ";
+    readonly help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確認";
+    readonly restart: "やり直す";
+    readonly ready: "白マスを選んでください。";
+    readonly won: "すべての合計が合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly checked: "ここまでの合計に誤りはありません。続けてください。";
+    readonly wrong: "同じ数字または合計の誤りがあります。";
+    readonly across: "横";
+    readonly down: "縦";
+    readonly pencil: "メモ";
+    readonly row: "行";
+    readonly column: "列";
+    readonly blank: "空白";
+    readonly clear: "消す";
+};

package/dist/kakuroStrings.js

@@ -0,0 +1,5 @@
+export const KAKURO_STRINGS = {
+    en: { title: "Kakuro", help: "Fill each white cell with 1–9. Digits in each across or down run add to its clue and cannot repeat. Arrows move; type a digit or use the number pad; P toggles pencil marks.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", ready: "Choose a white cell.", won: "Every run is correct. Solved!", helped: "Solved with help.", checked: "No run errors so far. Keep filling.", wrong: "Some runs have a repeated digit or impossible total.", across: "Across", down: "Down", pencil: "Pencil marks", row: "Row", column: "column", blank: "blank", clear: "Clear" },
+    ja: { title: "カックロ", help: "白マスに1〜9を入れます。横または縦の連続した数字はヒントの合計になり、同じ数字は使えません。矢印または数字パッドで入力、Pでメモを切り替えます。", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", ready: "白マスを選んでください。", won: "すべての合計が合いました。完成！", helped: "ヒントを使って完成！", checked: "ここまでの合計に誤りはありません。続けてください。", wrong: "同じ数字または合計の誤りがあります。", across: "横", down: "縦", pencil: "メモ", row: "行", column: "列", blank: "空白", clear: "消す" }
+};
+export function kakuroWords(language = "en") { return KAKURO_STRINGS[language]; }

package/dist/kakuroStyle.d.ts

@@ -0,0 +1 @@
+export declare const KAKURO_PLAY_STYLE = ".kk-root{max-width:760px;margin:auto;color:var(--ink,#1f2320);font:16px/1.5 system-ui,sans-serif}.kk-board{position:relative;width:100%;touch-action:manipulation}.kk-cells{position:absolute;inset:2px;display:grid}.kk-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;touch-action:manipulation}.kk-cell:focus-visible,.kk-pad button:focus-visible{outline:3px solid #b5452c;outline-offset:-3px}.kk-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}.kk-tools button,.kk-pad button{font:inherit;min-height:44px;padding:0 14px;border-radius:999px;border:1px solid #ddd6c6;background:#fbf8f1;color:inherit}.kk-pad{display:grid;grid-template-columns:repeat(5,minmax(44px,1fr));gap:8px;margin:12px 0}.kk-pad button{padding:0;touch-action:manipulation}.kk-status{min-height:1.5em}.kk-help{opacity:.8;font-size:14px}";

package/dist/kakuroStyle.js

@@ -0,0 +1 @@
+export const KAKURO_PLAY_STYLE = `.kk-root{max-width:760px;margin:auto;color:var(--ink,#1f2320);font:16px/1.5 system-ui,sans-serif}.kk-board{position:relative;width:100%;touch-action:manipulation}.kk-cells{position:absolute;inset:2px;display:grid}.kk-cell{border:0;background:transparent;min-width:0;min-height:0;padding:0;touch-action:manipulation}.kk-cell:focus-visible,.kk-pad button:focus-visible{outline:3px solid #b5452c;outline-offset:-3px}.kk-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}.kk-tools button,.kk-pad button{font:inherit;min-height:44px;padding:0 14px;border-radius:999px;border:1px solid #ddd6c6;background:#fbf8f1;color:inherit}.kk-pad{display:grid;grid-template-columns:repeat(5,minmax(44px,1fr));gap:8px;margin:12px 0}.kk-pad button{padding:0;touch-action:manipulation}.kk-status{min-height:1.5em}.kk-help{opacity:.8;font-size:14px}`;

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

@@ -0,0 +1,2 @@
+export { drawMasyu } from "./masyuDraw.ts";
+export type { MasyuDrawOptions } from "./masyu.types.ts";

package/dist/masyu-draw-entry.js

@@ -0,0 +1 @@
+export { drawMasyu } from "./masyuDraw.js";

package/dist/masyu-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./masyu.types.ts";
+export * from "./masyu.constants.ts";
+export * from "./masyuBoard.ts";
+export * from "./masyuSolve.ts";
+export * from "./masyuGenerate.ts";
+export * from "./masyuGame.ts";

package/dist/masyu-entry.js

@@ -0,0 +1,6 @@
+export * from "./masyu.types.js";
+export * from "./masyu.constants.js";
+export * from "./masyuBoard.js";
+export * from "./masyuSolve.js";
+export * from "./masyuGenerate.js";
+export * from "./masyuGame.js";

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

@@ -0,0 +1,4 @@
+export { mountMasyu } from "./masyuMount.ts";
+export { MASYU_PLAY_STYLE } from "./masyuStyle.ts";
+export { MASYU_STRINGS } from "./masyuStrings.ts";
+export type * from "./masyuPlay.types.ts";

package/dist/masyu-play-entry.js

@@ -0,0 +1,3 @@
+export { mountMasyu } from "./masyuMount.js";
+export { MASYU_PLAY_STYLE } from "./masyuStyle.js";
+export { MASYU_STRINGS } from "./masyuStrings.js";

package/dist/masyu.constants.d.ts

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

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;