@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/rippleMount.js

@@ -0,0 +1,179 @@
+import { KAZU_STYLE } from "./style.js";
+import { checkRipple, progressRipple, rippleRoomSizes } from "./rippleBoard.js";
+import { decodeRipple, encodeRipple, hintRipple, newRipple, rippleFinished, setRippleValue, toggleRippleNote, undoRipple } from "./rippleGame.js";
+import { RIPPLE_PLAY_STYLE } from "./rippleStyle.js";
+import { rippleWords } from "./rippleStrings.js";
+export function mountRipple(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeRipple(initial.progress) : null;
+    game ?? (game = newRipple(initial.board));
+    let selected = game.values.findIndex((value, cell) => game.board.clues[cell] === null);
+    if (selected < 0)
+        selected = 0;
+    let pencil = false, errors = [], message = "", dead = false;
+    const root = doc.createElement("section");
+    root.className = "rp-root";
+    const style = doc.createElement("style");
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".rp-palette") + RIPPLE_PLAY_STYLE;
+    const board = doc.createElement("div");
+    board.className = "rp-board";
+    board.setAttribute("role", "grid");
+    const status = doc.createElement("p");
+    status.className = "rp-status";
+    status.setAttribute("role", "status");
+    const help = doc.createElement("p");
+    help.className = "rp-help";
+    const controls = doc.createElement("div");
+    controls.className = "rp-controls";
+    const numpad = doc.createElement("div");
+    numpad.className = "rp-numpad";
+    numpad.setAttribute("aria-label", "Numbers");
+    root.append(style, board, status, help, numpad, controls);
+    host.append(root);
+    const words = () => rippleWords(options.language);
+    const copy = () => ({ ...game, board: { ...game.board, rooms: [...game.board.rooms], clues: [...game.board.clues] }, values: [...game.values], notes: game.notes.map(list => [...list]), history: game.history.map(turn => ({ values: [...turn.values], notes: turn.notes.map(list => [...list]) })) });
+    const changed = () => {
+        errors = [];
+        message = "";
+        render();
+        const snapshot = copy();
+        options.onChange?.(snapshot);
+        root.dispatchEvent(new CustomEvent("ripple-change", { detail: snapshot, bubbles: true }));
+        if (rippleFinished(game)) {
+            options.onFinish?.(snapshot);
+            root.dispatchEvent(new CustomEvent("ripple-finish", { detail: snapshot, bubbles: true }));
+        }
+    };
+    const enter = (value) => {
+        if (game.board.clues[selected] !== null)
+            return;
+        game = pencil ? toggleRippleNote(game, selected, value) : setRippleValue(game, selected, value);
+        changed();
+    };
+    const button = (label, action, disabled = false) => {
+        const item = doc.createElement("button");
+        item.type = "button";
+        item.className = "rp-tool";
+        item.textContent = label;
+        item.disabled = disabled;
+        item.onclick = action;
+        controls.append(item);
+        return item;
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const focused = board.contains(doc.activeElement);
+        const w = words(), current = game.board, sizes = rippleRoomSizes(current), validation = progressRipple(current, game.values);
+        root.dataset.material = options.material ?? "ivory";
+        root.dataset.pieces = options.pieces ?? "ink";
+        root.classList.toggle("rp-tiles", options.pieces === "tiles");
+        root.style.setProperty("--rp-width", String(current.width));
+        board.setAttribute("aria-label", w.title);
+        board.replaceChildren();
+        for (let cell = 0; cell < current.rooms.length; cell += 1) {
+            const x = cell % current.width, y = Math.floor(cell / current.width), room = current.rooms[cell];
+            const control = doc.createElement("button");
+            control.type = "button";
+            control.className = "rp-cell";
+            if (x + 1 < current.width && current.rooms[cell + 1] !== room)
+                control.classList.add("rp-room-right");
+            if (y + 1 < current.height && current.rooms[cell + current.width] !== room)
+                control.classList.add("rp-room-bottom");
+            const clue = current.clues[cell] !== null, value = game.values[cell];
+            control.dataset.cell = String(cell);
+            control.dataset.clue = String(clue);
+            control.dataset.error = String(errors.includes(cell));
+            control.dataset.selected = String(cell === selected);
+            control.setAttribute("aria-disabled", String(clue));
+            control.tabIndex = cell === selected ? 0 : -1;
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-label", `${w.cell.replace("{row}", String(y + 1)).replace("{column}", String(x + 1))}, ${clue ? w.clue.replace("{value}", String(current.clues[cell])) : value ? w.entry.replace("{value}", String(value)) : game.notes[cell].length ? w.note.replace("{values}", game.notes[cell].join(", ")) : w.empty}`);
+            if (clue)
+                control.textContent = String(current.clues[cell]);
+            else if (value)
+                control.textContent = String(value);
+            else if (game.notes[cell].length) {
+                const mini = doc.createElement("span");
+                mini.className = "rp-notes";
+                for (let digit = 1; digit <= sizes[room]; digit += 1) {
+                    const span = doc.createElement("span");
+                    span.textContent = game.notes[cell].includes(digit) ? String(digit) : "";
+                    mini.append(span);
+                }
+                control.append(mini);
+            }
+            control.onclick = () => { selected = cell; render(); };
+            control.onkeydown = event => {
+                if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) {
+                    event.preventDefault();
+                    move(cell, event.key);
+                }
+                else if (/^[1-9]$/.test(event.key)) {
+                    event.preventDefault();
+                    enter(Number(event.key));
+                }
+                else if (event.key === "Backspace" || event.key === "Delete") {
+                    event.preventDefault();
+                    enter(0);
+                }
+                else if (event.key.toLowerCase() === "p") {
+                    event.preventDefault();
+                    pencil = !pencil;
+                    render();
+                }
+            };
+            board.append(control);
+        }
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus({ preventScroll: true });
+        numpad.replaceChildren();
+        for (let digit = 1; digit <= Math.max(...sizes); digit += 1) {
+            const key = doc.createElement("button");
+            key.type = "button";
+            key.className = "rp-key";
+            key.textContent = String(digit);
+            key.disabled = digit > sizes[current.rooms[selected]];
+            key.onclick = () => enter(digit);
+            numpad.append(key);
+        }
+        status.textContent = rippleFinished(game) ? (game.helped ? `${w.won} · ${w.hint}` : w.won) : message || (validation.ok ? w.won : w.checked);
+        help.textContent = w.help;
+        controls.replaceChildren();
+        button(w.undo, () => { game = undoRipple(game); changed(); }, !game.history.length);
+        button(w.check, () => { errors = [...checkRipple(current, game.values).errors]; message = checkRipple(current, game.values).ok ? w.won : w.wrong; render(); });
+        button(w.hint, () => { const hint = hintRipple(game); if (!hint) {
+            message = w.noHint;
+            render();
+            return;
+        } game = { ...setRippleValue(game, hint.cell, hint.value), helped: true }; selected = hint.cell; changed(); message = w.hintWhy; render(); });
+        button(pencil ? `${w.pencil} ✓` : w.pencil, () => { pencil = !pencil; render(); });
+        button(w.restart, restart);
+        button(w.view, expand);
+    };
+    function move(cell, direction) {
+        const dx = direction === "ArrowLeft" ? -1 : direction === "ArrowRight" ? 1 : 0;
+        const dy = direction === "ArrowUp" ? -1 : direction === "ArrowDown" ? 1 : 0;
+        const x = cell % game.board.width, y = Math.floor(cell / game.board.width);
+        const nx = Math.min(game.board.width - 1, Math.max(0, x + dx)), ny = Math.min(game.board.height - 1, Math.max(0, y + dy));
+        selected = ny * game.board.width + nx;
+        render();
+        board.querySelector(`[data-cell="${selected}"]`)?.focus();
+    }
+    function restart() { game = newRipple(game.board); selected = game.values.findIndex((value, cell) => game.board.clues[cell] === null); changed(); }
+    function expand() {
+        const dialog = doc.createElement("dialog"), close = doc.createElement("button");
+        dialog.className = "rp-dialog";
+        close.type = "button";
+        close.className = "rp-tool rp-close";
+        close.textContent = words().close;
+        close.onclick = () => dialog.close();
+        dialog.append(close, root);
+        host.append(dialog);
+        dialog.onclose = () => { host.append(root); dialog.remove(); };
+        dialog.showModal();
+    }
+    render();
+    return { game: copy, progress: () => encodeRipple(game), restart, set: (next) => { options = { ...options, ...next }; render(); }, destroy: () => { dead = true; root.remove(); root.closest("dialog")?.remove(); } };
+}

package/dist/ripplePlay.types.d.ts

@@ -0,0 +1,23 @@
+import type { RippleBoard, RippleGame, RippleLanguage, RippleMaterial, RipplePieces } from "./ripple.types.ts";
+export type RippleDrawOptions = {
+    values?: readonly number[];
+    notes?: readonly (readonly number[])[];
+    errors?: readonly number[];
+    selected?: number | null;
+    material?: RippleMaterial;
+    pieces?: RipplePieces;
+    language?: RippleLanguage;
+};
+export type RippleMountOptions = RippleDrawOptions & {
+    board: RippleBoard;
+    progress?: string;
+    onChange?: (game: RippleGame) => void;
+    onFinish?: (game: RippleGame) => void;
+};
+export type RippleMount = {
+    game: () => RippleGame;
+    progress: () => string;
+    set: (options: RippleDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/ripplePlay.types.js

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

package/dist/rippleSolve.d.ts

@@ -0,0 +1,6 @@
+import type { RippleBoard, RippleSolve } from "./ripple.types.ts";
+/** Counts rule-valid fillings within an explicit node budget. */
+export declare function solveRipple(board: RippleBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): RippleSolve;

package/dist/rippleSolve.js

@@ -0,0 +1,83 @@
+import { RIPPLE_MAX_NODES } from "./ripple.constants.js";
+import { isRippleBoard, rippleRoomSizes } from "./rippleBoard.js";
+/** Counts rule-valid fillings within an explicit node budget. */
+export function solveRipple(board, options = {}) {
+    if (!isRippleBoard(board))
+        throw new RangeError("Invalid Ripple Effect board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? RIPPLE_MAX_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const sizes = rippleRoomSizes(board);
+    const values = board.clues.map(clue => clue ?? 0);
+    const roomUsed = sizes.map(() => new Set());
+    let count = 0, nodes = 0, complete = true, solution = null;
+    for (let cell = 0; cell < values.length; cell += 1) {
+        const value = values[cell];
+        if (!value)
+            continue;
+        const room = board.rooms[cell];
+        if (roomUsed[room].has(value) || conflicts(cell, value, values, board)) {
+            return { count: 0, solution: null, complete: true, nodes: 0 };
+        }
+        roomUsed[room].add(value);
+    }
+    const visit = () => {
+        if (count >= limit || !complete) {
+            complete = false;
+            return;
+        }
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        let bestCell = -1, bestValues = [];
+        for (let cell = 0; cell < values.length; cell += 1) {
+            if (values[cell])
+                continue;
+            const room = board.rooms[cell];
+            const candidates = [];
+            for (let value = 1; value <= sizes[room]; value += 1) {
+                if (!roomUsed[room].has(value) && !conflicts(cell, value, values, board))
+                    candidates.push(value);
+            }
+            if (!candidates.length)
+                return;
+            if (bestCell < 0 || candidates.length < bestValues.length) {
+                bestCell = cell;
+                bestValues = candidates;
+                if (candidates.length === 1)
+                    break;
+            }
+        }
+        if (bestCell < 0) {
+            count += 1;
+            solution ?? (solution = [...values]);
+            return;
+        }
+        const room = board.rooms[bestCell];
+        for (const value of bestValues) {
+            values[bestCell] = value;
+            roomUsed[room].add(value);
+            visit();
+            roomUsed[room].delete(value);
+            values[bestCell] = 0;
+            if (!complete || count >= limit) {
+                complete = false;
+                return;
+            }
+        }
+    };
+    visit();
+    return { count, solution, complete, nodes };
+}
+function conflicts(cell, value, values, board) {
+    const x = cell % board.width, y = Math.floor(cell / board.width);
+    for (let other = 0; other < values.length; other += 1) {
+        if (values[other] !== value || other === cell)
+            continue;
+        const ox = other % board.width, oy = Math.floor(other / board.width);
+        if ((oy === y && Math.abs(ox - x) <= value) || (ox === x && Math.abs(oy - y) <= value))
+            return true;
+    }
+    return false;
+}

package/dist/rippleStrings.d.ts

@@ -0,0 +1,86 @@
+import type { RippleLanguage } from "./ripple.types.ts";
+export declare const RIPPLE_STRINGS: {
+    readonly en: {
+        readonly title: "Ripple Effect";
+        readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+        readonly undo: "Undo";
+        readonly check: "Check";
+        readonly hint: "Hint";
+        readonly restart: "Restart";
+        readonly pencil: "Pencil";
+        readonly won: "Every room and ripple rule is correct.";
+        readonly wrong: "Some entries break a room or ripple rule.";
+        readonly checked: "Fill the rooms and check the spacing.";
+        readonly noHint: "No single proved answer is available yet.";
+        readonly hintWhy: "This value follows from the room and spacing rules.";
+        readonly view: "Just the board";
+        readonly close: "Close";
+        readonly cell: "Row {row}, column {column}";
+        readonly clue: "clue {value}";
+        readonly empty: "empty";
+        readonly entry: "{value}";
+        readonly note: "notes {values}";
+    };
+    readonly ja: {
+        readonly title: "波及効果";
+        readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+        readonly undo: "戻す";
+        readonly check: "確認";
+        readonly hint: "ヒント";
+        readonly restart: "やり直す";
+        readonly pencil: "メモ";
+        readonly won: "部屋と間隔のルールをすべて満たしました。";
+        readonly wrong: "部屋か数字の間隔に誤りがあります。";
+        readonly checked: "部屋を埋めて間隔を確認してください。";
+        readonly noHint: "確定できるヒントはまだありません。";
+        readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+        readonly view: "盤だけ";
+        readonly close: "閉じる";
+        readonly cell: "{row}行{column}列";
+        readonly clue: "手がかり {value}";
+        readonly empty: "空き";
+        readonly entry: "{value}";
+        readonly note: "メモ {values}";
+    };
+};
+export declare function rippleWords(language?: RippleLanguage): {
+    readonly title: "Ripple Effect";
+    readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+    readonly undo: "Undo";
+    readonly check: "Check";
+    readonly hint: "Hint";
+    readonly restart: "Restart";
+    readonly pencil: "Pencil";
+    readonly won: "Every room and ripple rule is correct.";
+    readonly wrong: "Some entries break a room or ripple rule.";
+    readonly checked: "Fill the rooms and check the spacing.";
+    readonly noHint: "No single proved answer is available yet.";
+    readonly hintWhy: "This value follows from the room and spacing rules.";
+    readonly view: "Just the board";
+    readonly close: "Close";
+    readonly cell: "Row {row}, column {column}";
+    readonly clue: "clue {value}";
+    readonly empty: "empty";
+    readonly entry: "{value}";
+    readonly note: "notes {values}";
+} | {
+    readonly title: "波及効果";
+    readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+    readonly undo: "戻す";
+    readonly check: "確認";
+    readonly hint: "ヒント";
+    readonly restart: "やり直す";
+    readonly pencil: "メモ";
+    readonly won: "部屋と間隔のルールをすべて満たしました。";
+    readonly wrong: "部屋か数字の間隔に誤りがあります。";
+    readonly checked: "部屋を埋めて間隔を確認してください。";
+    readonly noHint: "確定できるヒントはまだありません。";
+    readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+    readonly view: "盤だけ";
+    readonly close: "閉じる";
+    readonly cell: "{row}行{column}列";
+    readonly clue: "手がかり {value}";
+    readonly empty: "空き";
+    readonly entry: "{value}";
+    readonly note: "メモ {values}";
+};

package/dist/rippleStrings.js

@@ -0,0 +1,5 @@
+export const RIPPLE_STRINGS = {
+    en: { title: "Ripple Effect", help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.", undo: "Undo", check: "Check", hint: "Hint", restart: "Restart", pencil: "Pencil", won: "Every room and ripple rule is correct.", wrong: "Some entries break a room or ripple rule.", checked: "Fill the rooms and check the spacing.", noHint: "No single proved answer is available yet.", hintWhy: "This value follows from the room and spacing rules.", view: "Just the board", close: "Close", cell: "Row {row}, column {column}", clue: "clue {value}", empty: "empty", entry: "{value}", note: "notes {values}" },
+    ja: { title: "波及効果", help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。", undo: "戻す", check: "確認", hint: "ヒント", restart: "やり直す", pencil: "メモ", won: "部屋と間隔のルールをすべて満たしました。", wrong: "部屋か数字の間隔に誤りがあります。", checked: "部屋を埋めて間隔を確認してください。", noHint: "確定できるヒントはまだありません。", hintWhy: "部屋と間隔のルールから確定する数字です。", view: "盤だけ", close: "閉じる", cell: "{row}行{column}列", clue: "手がかり {value}", empty: "空き", entry: "{value}", note: "メモ {values}" },
+};
+export function rippleWords(language = "en") { return RIPPLE_STRINGS[language]; }

package/dist/rippleStyle.d.ts

@@ -0,0 +1 @@
+export declare const RIPPLE_PLAY_STYLE = ".rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}";

package/dist/rippleStyle.js

@@ -0,0 +1 @@
+export const RIPPLE_PLAY_STYLE = `.rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}`;

package/dist/shikaku-entry.d.ts

@@ -5,3 +5,4 @@ export * from "./shikakuBoard.ts";
 export * from "./shikakuSolve.ts";
 export * from "./shikakuGenerate.ts";
 export * from "./shikakuGame.ts";
+export * from "./shikakuPacks.ts";

package/dist/shikaku-entry.js

@@ -5,3 +5,4 @@ export * from "./shikakuBoard.js";
 export * from "./shikakuSolve.js";
 export * from "./shikakuGenerate.js";
 export * from "./shikakuGame.js";
+export * from "./shikakuPacks.js";

package/dist/shikakuPacks.d.ts

@@ -0,0 +1,27 @@
+import type { ShikakuLevel, ShikakuPuzzle } from "./shikaku.types.ts";
+export type ShikakuPackKey = "square" | "wide" | "tall";
+export type ShikakuChallenge = {
+    pack: ShikakuPackKey;
+    packTitle: string;
+    name: string;
+    level: ShikakuLevel;
+    width: number;
+    height: number;
+    seed: number;
+};
+export type ShikakuChallengePuzzle = ShikakuChallenge & {
+    puzzle: ShikakuPuzzle;
+};
+/** Three short, named challenge routes using the regular seeded unique-puzzle generator. */
+export declare const SHIKAKU_CHALLENGE_PACKS: Readonly<Record<ShikakuPackKey, {
+    title: string;
+    description: string;
+    width: number;
+    height: number;
+    challenges: readonly {
+        name: string;
+        level: ShikakuLevel;
+        seed: number;
+    }[];
+}>>;
+export declare function generateShikakuChallenge(pack: ShikakuPackKey, challenge?: number): ShikakuChallengePuzzle;

package/dist/shikakuPacks.js

@@ -0,0 +1,26 @@
+import { generateShikaku } from "./shikakuGenerate.js";
+/** Three short, named challenge routes using the regular seeded unique-puzzle generator. */
+export const SHIKAKU_CHALLENGE_PACKS = {
+    square: {
+        title: "The Courtyard", description: "A compact square route.", width: 7, height: 7,
+        challenges: [{ name: "First Cut", level: "easy", seed: 1 }, { name: "Crossing", level: "medium", seed: 2 }, { name: "Mosaic", level: "hard", seed: 3 }],
+    },
+    wide: {
+        title: "The Long Table", description: "Three puzzles across a wide board.", width: 10, height: 6,
+        challenges: [{ name: "Harbour", level: "easy", seed: 1 }, { name: "Causeway", level: "medium", seed: 2 }, { name: "Headland", level: "hard", seed: 3 }],
+    },
+    tall: {
+        title: "The Narrow Garden", description: "A tall route with long edges.", width: 6, height: 10,
+        challenges: [{ name: "Gate", level: "easy", seed: 1 }, { name: "Pavilion", level: "medium", seed: 2 }, { name: "Lantern Walk", level: "hard", seed: 3 }],
+    },
+};
+export function generateShikakuChallenge(pack, challenge = 1) {
+    const definition = SHIKAKU_CHALLENGE_PACKS[pack], entry = definition?.challenges[challenge - 1];
+    if (!definition || !entry)
+        throw new RangeError("Unknown Shikaku challenge");
+    return {
+        pack, packTitle: definition.title, name: entry.name, level: entry.level,
+        width: definition.width, height: definition.height, seed: entry.seed,
+        puzzle: generateShikaku(definition.width, definition.height, entry.level, entry.seed),
+    };
+}

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

@@ -0,0 +1,2 @@
+export { drawSlitherlink } from "./slitherlinkDraw.ts";
+export type { SlitherlinkDrawOptions } from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-draw-entry.js

@@ -0,0 +1 @@
+export { drawSlitherlink } from "./slitherlinkDraw.js";

package/dist/slitherlink-entry.d.ts

@@ -0,0 +1,11 @@
+/** Slitherlink uses a dedicated edge model and a single-loop constraint. */
+export * from "./slitherlink.types.ts";
+export * from "./slitherlink.constants.ts";
+export * from "./slitherlinkBoard.ts";
+export * from "./slitherlinkSolve.ts";
+export * from "./slitherlinkGenerate.ts";
+export * from "./slitherlinkGame.ts";
+export { drawSlitherlink } from "./slitherlinkDraw.ts";
+export type { SlitherlinkDrawOptions } from "./slitherlinkPlay.types.ts";
+export { mountSlitherlink } from "./slitherlinkMount.ts";
+export type * from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-entry.js

@@ -0,0 +1,9 @@
+/** Slitherlink uses a dedicated edge model and a single-loop constraint. */
+export * from "./slitherlink.types.js";
+export * from "./slitherlink.constants.js";
+export * from "./slitherlinkBoard.js";
+export * from "./slitherlinkSolve.js";
+export * from "./slitherlinkGenerate.js";
+export * from "./slitherlinkGame.js";
+export { drawSlitherlink } from "./slitherlinkDraw.js";
+export { mountSlitherlink } from "./slitherlinkMount.js";

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

@@ -0,0 +1,4 @@
+export { mountSlitherlink } from "./slitherlinkMount.ts";
+export { SLITHERLINK_PLAY_STYLE } from "./slitherlinkStyle.ts";
+export { SLITHERLINK_STRINGS } from "./slitherlinkStrings.ts";
+export type * from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-play-entry.js

@@ -0,0 +1,3 @@
+export { mountSlitherlink } from "./slitherlinkMount.js";
+export { SLITHERLINK_PLAY_STYLE } from "./slitherlinkStyle.js";
+export { SLITHERLINK_STRINGS } from "./slitherlinkStrings.js";

package/dist/slitherlink.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SLITHERLINK_MOST_SIDE = 10;
+export declare const SLITHERLINK_MOST_NODES = 300000;

package/dist/slitherlink.constants.js

@@ -0,0 +1,2 @@
+export const SLITHERLINK_MOST_SIDE = 10;
+export const SLITHERLINK_MOST_NODES = 300000;

package/dist/slitherlink.types.d.ts

@@ -0,0 +1,34 @@
+export type SlitherlinkBoard = {
+    width: number;
+    height: number;
+    clues: readonly (number | null)[];
+};
+export type SlitherlinkPuzzle = SlitherlinkBoard & {
+    seed: number;
+    solution: readonly number[];
+};
+export type SlitherlinkCheck = {
+    ok: boolean;
+    errors: readonly number[];
+    clues: readonly number[];
+    vertices: readonly number[];
+    loops: number;
+};
+export type SlitherlinkProgress = {
+    ok: boolean;
+    clues: readonly number[];
+    vertices: readonly number[];
+    loops: number;
+};
+export type SlitherlinkSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type SlitherlinkGame = {
+    board: SlitherlinkBoard;
+    edges: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};

package/dist/slitherlink.types.js

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

package/dist/slitherlinkBoard.d.ts

@@ -0,0 +1,12 @@
+import type { SlitherlinkBoard, SlitherlinkCheck, SlitherlinkProgress } from "./slitherlink.types.ts";
+export declare function isSlitherlinkBoard(value: unknown): value is SlitherlinkBoard;
+export declare function slitherlinkHorizontalCount(board: SlitherlinkBoard): number;
+/** An edge index is horizontal row-major first, then vertical row-major. */
+export declare function slitherlinkEdgeCount(board: SlitherlinkBoard): number;
+export declare function slitherlinkCellEdges(board: SlitherlinkBoard, cell: number): [number, number, number, number] | null;
+export declare function slitherlinkVertexEdges(board: SlitherlinkBoard, vertex: number): number[];
+/** Checks all numbered cells, degree-two vertices, and one connected closed loop. */
+export declare function checkSlitherlink(board: SlitherlinkBoard, edges: readonly number[]): SlitherlinkCheck;
+/** Reports overfilled clues and branched vertices during play without requiring a finished loop. */
+export declare function progressSlitherlink(board: SlitherlinkBoard, edges: readonly number[]): SlitherlinkProgress;
+export declare function edgeVertices(board: SlitherlinkBoard, edge: number): [number, number];