@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/slitherlinkSolve.d.ts

@@ -0,0 +1,6 @@
+import type { SlitherlinkBoard, SlitherlinkSolve } from "./slitherlink.types.ts";
+/** Counts loop solutions with clue and vertex propagation under explicit work bounds. */
+export declare function solveSlitherlink(board: SlitherlinkBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): SlitherlinkSolve;

package/dist/slitherlinkSolve.js

@@ -0,0 +1,127 @@
+import { SLITHERLINK_MOST_NODES } from "./slitherlink.constants.js";
+import { checkSlitherlink, edgeVertices, isSlitherlinkBoard, slitherlinkCellEdges, slitherlinkEdgeCount, slitherlinkVertexEdges, } from "./slitherlinkBoard.js";
+/** Counts loop solutions with clue and vertex propagation under explicit work bounds. */
+export function solveSlitherlink(board, options = {}) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    const limit = options.limit ?? 2;
+    const budget = options.nodes ?? SLITHERLINK_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
+        throw new RangeError("Invalid search bounds");
+    }
+    const edgeCount = slitherlinkEdgeCount(board);
+    const vertices = Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => slitherlinkVertexEdges(board, vertex));
+    const cells = board.clues.flatMap((clue, cell) => clue === null ? [] : [slitherlinkCellEdges(board, cell)]);
+    let count = 0;
+    let nodes = 0;
+    let complete = true;
+    let solution = null;
+    const search = (start) => {
+        if (!complete)
+            return;
+        nodes += 1;
+        if (nodes > budget) {
+            complete = false;
+            return;
+        }
+        const state = start.slice();
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const group of vertices) {
+                const on = group.filter(edge => state[edge] === 1).length;
+                const unknown = group.filter(edge => state[edge] < 0);
+                if (on > 2 || on === 1 && !unknown.length)
+                    return;
+                if (on === 2) {
+                    for (const edge of unknown) {
+                        state[edge] = 0;
+                        changed = true;
+                    }
+                }
+                else if (on === 1 && unknown.length === 1) {
+                    state[unknown[0]] = 1;
+                    changed = true;
+                }
+                else if (on === 0 && unknown.length === 1) {
+                    state[unknown[0]] = 0;
+                    changed = true;
+                }
+            }
+            let clueIndex = 0;
+            for (const clue of board.clues) {
+                if (clue === null)
+                    continue;
+                const group = cells[clueIndex++];
+                const on = group.filter(edge => state[edge] === 1).length;
+                const unknown = group.filter(edge => state[edge] < 0);
+                if (on > clue || on + unknown.length < clue)
+                    return;
+                if (on === clue) {
+                    for (const edge of unknown) {
+                        state[edge] = 0;
+                        changed = true;
+                    }
+                }
+                else if (on + unknown.length === clue) {
+                    for (const edge of unknown) {
+                        state[edge] = 1;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        const selected = Array.from(state).flatMap((value, edge) => value === 1 ? [edge] : []);
+        const closed = closedComponents(board, selected);
+        if (closed.length > 1)
+            return;
+        if (closed.length === 1 && closed[0].length !== selected.length)
+            return;
+        const branch = state.findIndex(value => value < 0);
+        if (branch < 0) {
+            if (!checkSlitherlink(board, selected).ok)
+                return;
+            count += 1;
+            solution ?? (solution = selected);
+            if (count >= limit)
+                complete = false;
+            return;
+        }
+        for (const value of [1, 0]) {
+            const next = state.slice();
+            next[branch] = value;
+            search(next);
+            if (!complete)
+                return;
+        }
+    };
+    search(new Int8Array(edgeCount).fill(-1));
+    return { count, solution, complete, nodes };
+}
+function closedComponents(board, selected) {
+    const unseen = new Set(selected);
+    const components = [];
+    while (unseen.size) {
+        const first = unseen.values().next().value;
+        const component = [first];
+        const queue = [first];
+        unseen.delete(first);
+        while (queue.length) {
+            const edge = queue.pop();
+            for (const vertex of edgeVertices(board, edge)) {
+                for (const adjacent of slitherlinkVertexEdges(board, vertex)) {
+                    if (!unseen.has(adjacent))
+                        continue;
+                    unseen.delete(adjacent);
+                    component.push(adjacent);
+                    queue.push(adjacent);
+                }
+            }
+        }
+        const vertices = new Set(component.flatMap(edge => edgeVertices(board, edge)));
+        if ([...vertices].every(vertex => slitherlinkVertexEdges(board, vertex)
+            .filter(edge => component.includes(edge)).length === 2))
+            components.push(component);
+    }
+    return components;
+}

package/dist/slitherlinkStrings.d.ts

@@ -0,0 +1,86 @@
+import type { SlitherlinkLanguage } from "./slitherlinkPlay.types.ts";
+export declare const SLITHERLINK_STRINGS: {
+    readonly en: {
+        readonly title: "Slitherlink";
+        readonly help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly expand: "Just the board";
+        readonly close: "Close";
+        readonly won: "One closed loop. Solved!";
+        readonly helped: "Solved with help.";
+        readonly checked: "No rule conflicts so far. Keep drawing the loop.";
+        readonly wrong: "Check the numbered cells, branches and loop connections.";
+        readonly hintWhy: "This edge is part of the only proved loop.";
+        readonly noHint: "No proved hint is available.";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly clue: "number";
+        readonly blank: "no number";
+        readonly edge: "edge";
+    };
+    readonly ja: {
+        readonly title: "スリザーリンク";
+        readonly help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly expand: "盤だけ";
+        readonly close: "閉じる";
+        readonly won: "一つの輪ができました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly checked: "ここまでルールに合っています。輪を続けましょう。";
+        readonly wrong: "数字のマス、分岐、輪のつながりを確かめましょう。";
+        readonly hintWhy: "唯一の解答に含まれる辺です。";
+        readonly noHint: "確かなヒントがありません。";
+        readonly row: "行";
+        readonly column: "列";
+        readonly clue: "数字";
+        readonly blank: "数字なし";
+        readonly edge: "辺";
+    };
+};
+export declare function slitherlinkWords(language?: SlitherlinkLanguage): {
+    readonly title: "Slitherlink";
+    readonly help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly expand: "Just the board";
+    readonly close: "Close";
+    readonly won: "One closed loop. Solved!";
+    readonly helped: "Solved with help.";
+    readonly checked: "No rule conflicts so far. Keep drawing the loop.";
+    readonly wrong: "Check the numbered cells, branches and loop connections.";
+    readonly hintWhy: "This edge is part of the only proved loop.";
+    readonly noHint: "No proved hint is available.";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly clue: "number";
+    readonly blank: "no number";
+    readonly edge: "edge";
+} | {
+    readonly title: "スリザーリンク";
+    readonly help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly expand: "盤だけ";
+    readonly close: "閉じる";
+    readonly won: "一つの輪ができました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly checked: "ここまでルールに合っています。輪を続けましょう。";
+    readonly wrong: "数字のマス、分岐、輪のつながりを確かめましょう。";
+    readonly hintWhy: "唯一の解答に含まれる辺です。";
+    readonly noHint: "確かなヒントがありません。";
+    readonly row: "行";
+    readonly column: "列";
+    readonly clue: "数字";
+    readonly blank: "数字なし";
+    readonly edge: "辺";
+};

package/dist/slitherlinkStrings.js

@@ -0,0 +1,47 @@
+export const SLITHERLINK_STRINGS = {
+    en: {
+        title: "Slitherlink",
+        help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.",
+        undo: "Undo",
+        hint: "Hint",
+        check: "Check",
+        restart: "Restart",
+        expand: "Just the board",
+        close: "Close",
+        won: "One closed loop. Solved!",
+        helped: "Solved with help.",
+        checked: "No rule conflicts so far. Keep drawing the loop.",
+        wrong: "Check the numbered cells, branches and loop connections.",
+        hintWhy: "This edge is part of the only proved loop.",
+        noHint: "No proved hint is available.",
+        row: "Row",
+        column: "column",
+        clue: "number",
+        blank: "no number",
+        edge: "edge",
+    },
+    ja: {
+        title: "スリザーリンク",
+        help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。",
+        undo: "戻す",
+        hint: "ヒント",
+        check: "確かめる",
+        restart: "やり直す",
+        expand: "盤だけ",
+        close: "閉じる",
+        won: "一つの輪ができました。完成！",
+        helped: "ヒントを使って完成！",
+        checked: "ここまでルールに合っています。輪を続けましょう。",
+        wrong: "数字のマス、分岐、輪のつながりを確かめましょう。",
+        hintWhy: "唯一の解答に含まれる辺です。",
+        noHint: "確かなヒントがありません。",
+        row: "行",
+        column: "列",
+        clue: "数字",
+        blank: "数字なし",
+        edge: "辺",
+    },
+};
+export function slitherlinkWords(language = "en") {
+    return SLITHERLINK_STRINGS[language];
+}

package/dist/slitherlinkStyle.d.ts

@@ -0,0 +1 @@
+export declare const SLITHERLINK_PLAY_STYLE = "\n.sl-root{color:var(--sl-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:760px;margin:auto}\n.sl-board{display:grid;position:relative;gap:0;width:100%;min-width:240px;touch-action:manipulation;user-select:none}\n.sl-cell{position:relative;grid-column:span 2;grid-row:span 2;display:grid;place-items:center;min-width:0;min-height:0;border:0;background:transparent;padding:0;color:var(--sl-ink,#1f2320);font:700 clamp(14px,2vw,22px)/1 system-ui,sans-serif}\n.sl-dot{z-index:2;grid-column:span 1;grid-row:span 1;justify-self:center;align-self:center;width:8px;height:8px;border-radius:50%;background:var(--sl-ink,#1f2320);pointer-events:none}\n.sl-edge{position:relative;z-index:1;grid-column:span 2;grid-row:span 1;min-width:0;min-height:0;border:0;padding:0;background:transparent;cursor:pointer;touch-action:manipulation}\n.sl-edge.vertical{grid-column:span 1;grid-row:span 2}\n.sl-edge::after{content:\"\";position:absolute;background:var(--kz-grid,#cfc6b2);transition:background .12s ease}\n.sl-edge.horizontal::after{left:0;right:0;top:50%;height:5px;transform:translateY(-50%)}\n.sl-edge.vertical::after{top:0;bottom:0;left:50%;width:5px;transform:translateX(-50%)}\n.sl-edge.on::after{background:var(--sl-ink,#1f2320)}\n.sl-edge.error::after{background:var(--kz-bad,#b5452c)}\n.sl-edge:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-2px;border-radius:4px}\n.sl-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}\n.sl-tools button,.sl-close{font:inherit;border:1px solid var(--sl-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--sl-surface,#fbf8f1);color:var(--sl-ink,#1f2320);cursor:pointer}\n.sl-tools button:disabled{opacity:.45;cursor:default}.sl-status{min-height:1.5em}.sl-help{font-size:14px;opacity:.8}\n.sl-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,820px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--sl-ink:var(--ink,#1f2320);--sl-surface:var(--surface,#fbf8f1);--sl-rule:var(--rule,#ddd6c6)}.sl-dialog::backdrop{background:#172c28bb}.sl-close{float:right;margin-bottom:10px}.sl-dialog .sl-root{clear:both}\n";

package/dist/slitherlinkStyle.js

@@ -0,0 +1,18 @@
+export const SLITHERLINK_PLAY_STYLE = `
+.sl-root{color:var(--sl-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:760px;margin:auto}
+.sl-board{display:grid;position:relative;gap:0;width:100%;min-width:240px;touch-action:manipulation;user-select:none}
+.sl-cell{position:relative;grid-column:span 2;grid-row:span 2;display:grid;place-items:center;min-width:0;min-height:0;border:0;background:transparent;padding:0;color:var(--sl-ink,#1f2320);font:700 clamp(14px,2vw,22px)/1 system-ui,sans-serif}
+.sl-dot{z-index:2;grid-column:span 1;grid-row:span 1;justify-self:center;align-self:center;width:8px;height:8px;border-radius:50%;background:var(--sl-ink,#1f2320);pointer-events:none}
+.sl-edge{position:relative;z-index:1;grid-column:span 2;grid-row:span 1;min-width:0;min-height:0;border:0;padding:0;background:transparent;cursor:pointer;touch-action:manipulation}
+.sl-edge.vertical{grid-column:span 1;grid-row:span 2}
+.sl-edge::after{content:"";position:absolute;background:var(--kz-grid,#cfc6b2);transition:background .12s ease}
+.sl-edge.horizontal::after{left:0;right:0;top:50%;height:5px;transform:translateY(-50%)}
+.sl-edge.vertical::after{top:0;bottom:0;left:50%;width:5px;transform:translateX(-50%)}
+.sl-edge.on::after{background:var(--sl-ink,#1f2320)}
+.sl-edge.error::after{background:var(--kz-bad,#b5452c)}
+.sl-edge:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-2px;border-radius:4px}
+.sl-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.sl-tools button,.sl-close{font:inherit;border:1px solid var(--sl-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--sl-surface,#fbf8f1);color:var(--sl-ink,#1f2320);cursor:pointer}
+.sl-tools button:disabled{opacity:.45;cursor:default}.sl-status{min-height:1.5em}.sl-help{font-size:14px;opacity:.8}
+.sl-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,820px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--sl-ink:var(--ink,#1f2320);--sl-surface:var(--surface,#fbf8f1);--sl-rule:var(--rule,#ddd6c6)}.sl-dialog::backdrop{background:#172c28bb}.sl-close{float:right;margin-bottom:10px}.sl-dialog .sl-root{clear:both}
+`;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.1.0";
+export declare const VERSION = "1.2.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.1.0";
+export const VERSION = "1.2.0";

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

@@ -0,0 +1,2 @@
+export { drawYajilin } from "./yajilinDraw.ts";
+export type { YajilinDrawOptions } from "./yajilin.types.ts";

package/dist/yajilin-draw-entry.js

@@ -0,0 +1 @@
+export { drawYajilin } from "./yajilinDraw.js";

package/dist/yajilin-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./yajilin.types.ts";
+export * from "./yajilin.constants.ts";
+export * from "./yajilinBoard.ts";
+export * from "./yajilinSolve.ts";
+export * from "./yajilinGenerate.ts";
+export * from "./yajilinGame.ts";

package/dist/yajilin-entry.js

@@ -0,0 +1,6 @@
+export * from "./yajilin.types.js";
+export * from "./yajilin.constants.js";
+export * from "./yajilinBoard.js";
+export * from "./yajilinSolve.js";
+export * from "./yajilinGenerate.js";
+export * from "./yajilinGame.js";

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

@@ -0,0 +1,4 @@
+export { mountYajilin } from "./yajilinMount.ts";
+export { YAJILIN_PLAY_STYLE } from "./yajilinStyle.ts";
+export { YAJILIN_STRINGS } from "./yajilinStrings.ts";
+export type * from "./yajilinPlay.types.ts";

package/dist/yajilin-play-entry.js

@@ -0,0 +1,3 @@
+export { mountYajilin } from "./yajilinMount.js";
+export { YAJILIN_PLAY_STYLE } from "./yajilinStyle.js";
+export { YAJILIN_STRINGS } from "./yajilinStrings.js";

package/dist/yajilin.constants.d.ts

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

package/dist/yajilin.constants.js

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

package/dist/yajilin.types.d.ts

@@ -0,0 +1,63 @@
+export type YajilinDirection = "up" | "right" | "down" | "left";
+export type YajilinClue = {
+    direction: YajilinDirection;
+    count: number;
+};
+export type YajilinBoard = {
+    width: number;
+    height: number;
+    clues: readonly (YajilinClue | null)[];
+};
+export type YajilinPuzzle = YajilinBoard & {
+    seed: number;
+    solution: {
+        shaded: readonly boolean[];
+        edges: readonly number[];
+    };
+};
+export type YajilinCheck = {
+    ok: boolean;
+    errors: readonly number[];
+};
+export type YajilinSolution = {
+    shaded: readonly boolean[];
+    edges: readonly number[];
+};
+export type YajilinSolve = {
+    count: number;
+    solution: YajilinSolution | null;
+    complete: boolean;
+    nodes: number;
+};
+export type YajilinGame = {
+    board: YajilinBoard;
+    shaded: readonly boolean[];
+    edges: readonly number[];
+    history: readonly {
+        shaded: readonly boolean[];
+        edges: readonly number[];
+    }[];
+    helped: boolean;
+};
+export type YajilinDrawOptions = {
+    shaded?: readonly boolean[];
+    edges?: readonly number[];
+    selected?: number;
+    errors?: readonly number[];
+    material?: "ivory" | "wood" | "slate";
+    pieces?: "plain" | "tiles";
+    language?: "en" | "ja";
+};
+export type YajilinMountOptions = YajilinDrawOptions & {
+    board: YajilinBoard;
+    progress?: string;
+    onChange?: (game: YajilinGame) => void;
+    onFinish?: (game: YajilinGame) => void;
+};
+export type YajilinMount = {
+    game: () => YajilinGame;
+    progress: () => string;
+    set: (options: YajilinDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/yajilin.types.js

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

package/dist/yajilinBoard.d.ts

@@ -0,0 +1,9 @@
+import type { YajilinBoard, YajilinCheck, YajilinDirection } from "./yajilin.types.ts";
+export declare const yajilinEdgeCount: (board: YajilinBoard) => number;
+export declare function isYajilinBoard(value: unknown): value is YajilinBoard;
+export declare function yajilinNeighbors(board: YajilinBoard, cell: number): {
+    cell: number;
+    edge: number;
+}[];
+export declare function checkYajilin(board: YajilinBoard, shaded: readonly boolean[], lines: readonly number[]): YajilinCheck;
+export declare function yajilinRay(board: YajilinBoard, cell: number, direction: YajilinDirection): number[];

package/dist/yajilinBoard.js

@@ -0,0 +1,91 @@
+import { YAJILIN_SIZES } from "./yajilin.constants.js";
+const directionDelta = { up: [0, -1], right: [1, 0], down: [0, 1], left: [-1, 0] };
+export const yajilinEdgeCount = (board) => board.height * (board.width - 1) + board.width * (board.height - 1);
+export function isYajilinBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!YAJILIN_SIZES.includes(board.width) || board.width !== board.height
+        || !Array.isArray(board.clues) || board.clues.length !== board.width * board.height)
+        return false;
+    return board.clues.every(clue => clue === null || (!!clue && typeof clue === "object"
+        && Object.hasOwn(directionDelta, clue.direction) && Number.isInteger(clue.count) && clue.count >= 0 && clue.count < board.width));
+}
+export function yajilinNeighbors(board, cell) {
+    const x = cell % board.width, y = Math.floor(cell / board.width), horizontal = board.height * (board.width - 1), result = [];
+    if (y > 0)
+        result.push({ cell: cell - board.width, edge: horizontal + (y - 1) * board.width + x });
+    if (x < board.width - 1)
+        result.push({ cell: cell + 1, edge: y * (board.width - 1) + x });
+    if (y < board.height - 1)
+        result.push({ cell: cell + board.width, edge: horizontal + y * board.width + x });
+    if (x > 0)
+        result.push({ cell: cell - 1, edge: y * (board.width - 1) + x - 1 });
+    return result;
+}
+function ray(board, cell, direction) {
+    const [dx, dy] = directionDelta[direction], cells = [];
+    let x = cell % board.width + dx, y = Math.floor(cell / board.width) + dy;
+    while (x >= 0 && x < board.width && y >= 0 && y < board.height) {
+        cells.push(y * board.width + x);
+        x += dx;
+        y += dy;
+    }
+    return cells;
+}
+export function checkYajilin(board, shaded, lines) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    const size = board.width, total = size * size, edges = new Set(lines), errors = new Set();
+    if (shaded.length !== total || !shaded.every(value => typeof value === "boolean"))
+        return { ok: false, errors: [] };
+    if (edges.size !== lines.length || lines.some(edge => !Number.isInteger(edge) || edge < 0 || edge >= yajilinEdgeCount(board)))
+        return { ok: false, errors: [] };
+    for (let cell = 0; cell < total; cell += 1) {
+        const clue = board.clues[cell];
+        if (clue && shaded[cell])
+            errors.add(cell);
+        if (shaded[cell]) {
+            if (cell % size < size - 1 && shaded[cell + 1]) {
+                errors.add(cell);
+                errors.add(cell + 1);
+            }
+            if (cell + size < total && shaded[cell + size]) {
+                errors.add(cell);
+                errors.add(cell + size);
+            }
+        }
+        if (clue && ray(board, cell, clue.direction).filter(next => shaded[next]).length !== clue.count)
+            errors.add(cell);
+    }
+    const degrees = board.clues.map((clue, cell) => {
+        const degree = yajilinNeighbors(board, cell).filter(next => edges.has(next.edge)).length;
+        if ((clue || shaded[cell]) && degree > 0)
+            errors.add(cell);
+        if (!clue && !shaded[cell] && degree !== 2)
+            errors.add(cell);
+        return degree;
+    });
+    if (edges.size) {
+        const first = degrees.findIndex(degree => degree > 0), reached = new Set([first]), stack = [first];
+        while (stack.length) {
+            const cell = stack.pop();
+            for (const next of yajilinNeighbors(board, cell))
+                if (edges.has(next.edge) && !reached.has(next.cell)) {
+                    reached.add(next.cell);
+                    stack.push(next.cell);
+                }
+        }
+        const loopCells = degrees.filter(degree => degree > 0).length;
+        if (reached.size !== loopCells || edges.size !== loopCells)
+            for (const cell of reached)
+                errors.add(cell);
+    }
+    const playable = board.clues.filter((clue, cell) => !clue && !shaded[cell]).length;
+    const ok = playable >= 4 && edges.size === playable && errors.size === 0
+        && degrees.every((degree, cell) => board.clues[cell] || shaded[cell] ? degree === 0 : degree === 2);
+    return { ok, errors: [...errors] };
+}
+export function yajilinRay(board, cell, direction) {
+    return ray(board, cell, direction);
+}

package/dist/yajilinDraw.d.ts

@@ -0,0 +1,2 @@
+import type { YajilinBoard, YajilinDrawOptions } from "./yajilin.types.ts";
+export declare function drawYajilin(board: YajilinBoard, options?: YajilinDrawOptions): string;

package/dist/yajilinDraw.js

@@ -0,0 +1,33 @@
+import { isYajilinBoard, yajilinNeighbors } from "./yajilinBoard.js";
+import { YAJILIN_STRINGS } from "./yajilinStrings.js";
+const arrows = { up: "↑", right: "→", down: "↓", left: "←" };
+export function drawYajilin(board, options = {}) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    const words = YAJILIN_STRINGS[options.language ?? "en"], size = 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"], edges = new Set(options.edges ?? []), parts = [];
+    for (let cell = 0; cell < board.clues.length; cell += 1) {
+        const x = pad + cell % board.width * size, y = pad + Math.floor(cell / board.width) * size, clue = board.clues[cell];
+        const bad = options.errors?.includes(cell), active = options.selected === cell;
+        parts.push(`<rect x="${x - size / 2}" y="${y - size / 2}" width="${size}" height="${size}" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".08" : "1"}" stroke="${grid}" stroke-width="1"/>`);
+        if (options.shaded?.[cell])
+            parts.push(`<rect x="${x - 17}" y="${y - 17}" width="34" height="34" rx="2" fill="${bad ? "var(--kz-bad,#b5452c)" : ink}"/>`);
+        if (clue) {
+            if (options.pieces === "tiles")
+                parts.push(`<rect x="${x - 19}" y="${y - 19}" width="38" height="38" rx="5" fill="${paper}" stroke="${grid}"/>`);
+            parts.push(`<text x="${x - 2}" y="${y + 1}" text-anchor="middle" dominant-baseline="middle" fill="${bad ? "var(--kz-bad,#b5452c)" : ink}" font-size="20" font-weight="700" font-family="system-ui,sans-serif">${arrows[clue.direction]}</text>`);
+            parts.push(`<text x="${x + 11}" y="${y + 14}" text-anchor="middle" dominant-baseline="middle" fill="${ink}" font-size="12" font-weight="700" font-family="system-ui,sans-serif">${clue.count}</text>`);
+        }
+        for (const next of yajilinNeighbors(board, cell))
+            if (cell < next.cell && edges.has(next.edge)) {
+                const nx = pad + next.cell % board.width * size, ny = pad + Math.floor(next.cell / board.width) * size;
+                parts.push(`<line x1="${x}" y1="${y}" x2="${nx}" y2="${ny}" stroke="${bad ? "var(--kz-bad,#b5452c)" : ink}" stroke-width="5" stroke-linecap="round"/>`);
+            }
+    }
+    for (let y = 0; y < board.height; y += 1)
+        for (let x = 0; x < board.width; x += 1) {
+            parts.push(`<circle cx="${pad + x * size}" cy="${pad + y * size}" r="2" fill="${grid}"/>`);
+        }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${pad * 2 + (board.width - 1) * size} ${pad * 2 + (board.height - 1) * size}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${parts.join("")}</svg>`;
+}

package/dist/yajilinGame.d.ts

@@ -0,0 +1,15 @@
+import type { YajilinBoard, YajilinGame } from "./yajilin.types.ts";
+export declare function newYajilin(board: YajilinBoard): YajilinGame;
+export declare function toggleYajilinShade(game: YajilinGame, cell: number): YajilinGame;
+export declare function toggleYajilinEdge(game: YajilinGame, edge: number): YajilinGame;
+export declare function undoYajilin(game: YajilinGame): YajilinGame;
+export declare function restartYajilin(game: YajilinGame): YajilinGame;
+export declare function hintYajilin(game: YajilinGame): {
+    type: "shade";
+    cell: number;
+} | {
+    type: "edge";
+    edge: number;
+} | null;
+export declare function encodeYajilin(game: YajilinGame): string;
+export declare function decodeYajilin(code: string): YajilinGame | null;

package/dist/yajilinGame.js

@@ -0,0 +1,58 @@
+import { isYajilinBoard, yajilinEdgeCount } from "./yajilinBoard.js";
+import { solveYajilin } from "./yajilinSolve.js";
+export function newYajilin(board) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    return { board: { width: board.width, height: board.height, clues: board.clues.map(clue => clue ? { ...clue } : null) }, shaded: Array(board.width * board.height).fill(false), edges: [], history: [], helped: false };
+}
+function snapshot(game) { return { shaded: [...game.shaded], edges: [...game.edges] }; }
+export function toggleYajilinShade(game, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= game.shaded.length || game.board.clues[cell])
+        return game;
+    const shaded = [...game.shaded];
+    shaded[cell] = !shaded[cell];
+    return { ...game, shaded, history: [...game.history, snapshot(game)] };
+}
+export function toggleYajilinEdge(game, edge) {
+    if (!Number.isInteger(edge) || edge < 0 || edge >= yajilinEdgeCount(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, snapshot(game)] };
+}
+export function undoYajilin(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, shaded: [...previous.shaded], edges: [...previous.edges], history: game.history.slice(0, -1) } : game;
+}
+export function restartYajilin(game) { return { ...newYajilin(game.board), helped: false }; }
+export function hintYajilin(game) {
+    const result = solveYajilin(game.board);
+    if (!result.complete || result.count !== 1)
+        return null;
+    const cell = result.solution.shaded.findIndex((value, index) => value !== game.shaded[index]);
+    if (cell >= 0)
+        return { type: "shade", cell };
+    const edge = result.solution.edges.find(value => !game.edges.includes(value));
+    return edge === undefined ? null : { type: "edge", edge };
+}
+export function encodeYajilin(game) {
+    return JSON.stringify({ version: 1, board: game.board, shaded: game.shaded, edges: game.edges, helped: game.helped });
+}
+export function decodeYajilin(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isYajilinBoard(value.board) || !Array.isArray(value.shaded)
+            || value.shaded.length !== value.board.width * value.board.height || !value.shaded.every((cell) => typeof cell === "boolean")
+            || !Array.isArray(value.edges) || !value.edges.every((edge) => Number.isInteger(edge))
+            || typeof value.helped !== "boolean")
+            return null;
+        const edges = [...new Set(value.edges)].sort((a, b) => a - b);
+        if (edges.length !== value.edges.length || edges.some(edge => edge < 0 || edge >= yajilinEdgeCount(value.board)))
+            return null;
+        return { ...newYajilin(value.board), shaded: [...value.shaded], edges, helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/yajilinGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { YajilinPuzzle } from "./yajilin.types.ts";
+/** Seeded original 5×5 families, accepted only after a completed uniqueness proof. */
+export declare function generateYajilin(size?: 5, seed?: number): YajilinPuzzle;