@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/shikakuGame.js

@@ -0,0 +1,61 @@
+import { checkShikaku, isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { solveShikaku } from "./shikakuSolve.js";
+/** Begin with a copy of just the public clues; a generated answer is never kept in play. */
+export function newShikaku(board) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    return { board: { width: board.width, height: board.height, clues: [...board.clues] }, rectangles: [], history: [], helped: false };
+}
+/** Place a rectangle, replacing any it touches. Local rule errors are allowed for the player to check. */
+export function placeShikaku(game, rectangle) {
+    const cells = shikakuCells(game.board, rectangle);
+    if (!cells)
+        return game;
+    const covered = new Set(cells);
+    return { ...game, rectangles: [...game.rectangles.filter(r => !shikakuCells(game.board, r).some(c => covered.has(c))), { ...rectangle }],
+        history: [...game.history, game.rectangles.map(r => ({ ...r }))] };
+}
+/** Remove the rectangle containing a cell. */
+export function removeShikaku(game, cell) {
+    const rectangles = game.rectangles.filter(r => !shikakuCells(game.board, r).includes(cell));
+    return rectangles.length === game.rectangles.length ? game : { ...game, rectangles, history: [...game.history, game.rectangles] };
+}
+export function undoShikaku(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, rectangles: previous.map(r => ({ ...r })), history: game.history.slice(0, -1) } : game;
+}
+/** A rectangle is offered only when the remaining partition has one proved answer. */
+export function hintShikaku(game) {
+    const solved = solveShikaku(game.board, game.rectangles);
+    if (!solved.complete || solved.count !== 1)
+        return null;
+    return solved.solution.find(r => !game.rectangles.some(p => p.x === r.x && p.y === r.y && p.width === r.width && p.height === r.height)) ?? null;
+}
+export function shikakuFinished(game) { return checkShikaku(game.board, game.rectangles).ok; }
+/** Versioned public puzzle and placement data, with no hidden answer. */
+export function encodeShikaku(game) {
+    return JSON.stringify({ version: 1, board: game.board, rectangles: game.rectangles, helped: game.helped });
+}
+export function decodeShikaku(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isShikakuBoard(value.board) || !Array.isArray(value.rectangles)
+            || value.rectangles.length > value.board.clues.length || typeof value.helped !== "boolean")
+            return null;
+        let game = newShikaku(value.board);
+        for (const r of value.rectangles) {
+            if (!shikakuCells(game.board, r))
+                return null;
+            const next = placeShikaku(game, r);
+            if (next.rectangles.length !== game.rectangles.length + 1)
+                return null;
+            game = next;
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/shikakuGenerate.d.ts

@@ -0,0 +1,3 @@
+import type { ShikakuLevel, ShikakuPuzzle } from "./shikaku.types.ts";
+/** Seeded partitions with an independently counted, unique answer. Levels choose rectangle sizes, not a promised human rating. */
+export declare function generateShikaku(width?: number, height?: number, level?: ShikakuLevel, seed?: number): ShikakuPuzzle;

package/dist/shikakuGenerate.js

@@ -0,0 +1,43 @@
+import { SHIKAKU_LEVELS, SHIKAKU_MOST_ATTEMPTS } from "./shikaku.constants.js";
+import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { solveShikaku } from "./shikakuSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** Seeded partitions with an independently counted, unique answer. Levels choose rectangle sizes, not a promised human rating. */
+export function generateShikaku(width = 7, height = width, level = "medium", seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= 16))
+        throw new RangeError("Invalid Shikaku dimensions");
+    const empty = { width, height, clues: Array(width * height).fill(0) };
+    if (!isKazuSeed(seed) || !SHIKAKU_LEVELS.includes(level)
+        || !isShikakuBoard({ ...empty, clues: [width * height, ...empty.clues.slice(1)] }))
+        throw new RangeError("Invalid Shikaku settings");
+    const random = seededRandom(seed), maximum = { easy: 5, medium: 9, hard: 15 }[level];
+    for (let attempt = 0; attempt < SHIKAKU_MOST_ATTEMPTS; attempt += 1) {
+        const solution = [];
+        const split = (r) => {
+            if (r.width * r.height <= maximum && (r.width * r.height < 3 || random() < .6)) {
+                solution.push(r);
+                return;
+            }
+            const vertical = r.height === 1 || (r.width > 1 && random() < .5);
+            const cut = 1 + Math.floor(random() * ((vertical ? r.width : r.height) - 1));
+            if (vertical) {
+                split({ ...r, width: cut });
+                split({ ...r, x: r.x + cut, width: r.width - cut });
+            }
+            else {
+                split({ ...r, height: cut });
+                split({ ...r, y: r.y + cut, height: r.height - cut });
+            }
+        };
+        split({ x: 0, y: 0, width, height });
+        const clues = [...empty.clues];
+        for (const r of solution) {
+            const cells = shikakuCells(empty, r);
+            clues[cells[Math.floor(random() * cells.length)]] = cells.length;
+        }
+        const board = { width, height, clues }, counted = solveShikaku(board);
+        if (counted.complete && counted.count === 1)
+            return { ...board, seed, level, solution: counted.solution };
+    }
+    throw new Error("No unique Shikaku found within the generation budget; try another seed");
+}

package/dist/shikakuMount.d.ts

@@ -0,0 +1,3 @@
+import type { ShikakuMount, ShikakuMountOptions } from "./shikakuPlay.types.ts";
+/** A rectangle player in any element; mount once, update appearance with set, destroy on unmount. */
+export declare function mountShikaku(host: HTMLElement, initial: ShikakuMountOptions): ShikakuMount;

package/dist/shikakuMount.js

@@ -0,0 +1,143 @@
+import { checkShikaku, shikakuCells } from "./shikakuBoard.js";
+import { decodeShikaku, encodeShikaku, hintShikaku, newShikaku, placeShikaku, removeShikaku, shikakuFinished, undoShikaku } from "./shikakuGame.js";
+import { drawShikaku } from "./shikakuDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.js";
+import { shikakuWords } from "./shikakuStrings.js";
+/** A rectangle player in any element; mount once, update appearance with set, destroy on unmount. */
+export function mountShikaku(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial }, game = initial.progress ? decodeShikaku(initial.progress) : null;
+    game ?? (game = newShikaku(initial.board));
+    let selected = 0, anchor = null, errors = [], message = "", finished = shikakuFinished(game), dead = false;
+    const root = doc.createElement("div"), style = doc.createElement("style"), board = doc.createElement("div"), status = doc.createElement("p"), tools = doc.createElement("div"), help = doc.createElement("p");
+    root.className = "ks-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".ks-palette") + SHIKAKU_PLAY_STYLE;
+    board.className = "ks-board";
+    status.className = "ks-status";
+    status.setAttribute("role", "status");
+    tools.className = "ks-tools";
+    help.className = "ks-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({ ...game, board: { ...game.board, clues: [...game.board.clues] }, rectangles: game.rectangles.map(r => ({ ...r })), history: game.history.map(turn => turn.map(r => ({ ...r }))) });
+    const words = () => shikakuWords(options.language);
+    const button = (text, action, disabled = false) => {
+        const b = doc.createElement("button");
+        b.type = "button";
+        b.textContent = text;
+        b.disabled = disabled;
+        b.onclick = action;
+        tools.append(b);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        anchor = null;
+        const won = shikakuFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("shikaku-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("shikaku-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const choose = (cell) => {
+        if (finished)
+            return;
+        selected = cell;
+        if (anchor === null) {
+            anchor = cell;
+            message = "";
+            render();
+            return;
+        }
+        const a = anchor, width = game.board.width, ax = a % width, ay = Math.floor(a / width), x = cell % width, y = Math.floor(cell / width);
+        game = placeShikaku(game, { x: Math.min(ax, x), y: Math.min(ay, y), width: Math.abs(ax - x) + 1, height: Math.abs(ay - y) + 1 });
+        changed();
+    };
+    const remove = () => { game = removeShikaku(game, selected); changed(); };
+    const restart = () => { game = newShikaku(game.board); finished = false; changed(); };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words(), b = game.board, focused = board.contains(doc.activeElement);
+        board.classList.toggle("ks-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawShikaku(b, { ...options, rectangles: game.rectangles, selected, anchor, errors });
+        const cells = doc.createElement("div");
+        cells.className = "ks-cells";
+        cells.style.gridTemplateColumns = `repeat(${b.width},1fr)`;
+        for (let c = 0; c < b.clues.length; c += 1) {
+            const cell = doc.createElement("button");
+            cell.type = "button";
+            cell.className = "ks-cell";
+            cell.dataset.cell = String(c);
+            cell.tabIndex = c === selected ? 0 : -1;
+            const inside = game.rectangles.find(r => shikakuCells(b, r).includes(c));
+            cell.setAttribute("aria-label", `${w.row} ${Math.floor(c / b.width) + 1}, ${w.column} ${c % b.width + 1}: ${b.clues[c] ? `${w.clue} ${b.clues[c]}` : w.blank}${inside ? `, ${w.covered}` : ""}`);
+            cell.onclick = () => choose(c);
+            cell.onkeydown = e => {
+                const steps = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -b.width, ArrowDown: b.width };
+                if (e.key in steps) {
+                    e.preventDefault();
+                    selected = Math.max(0, Math.min(b.clues.length - 1, c + steps[e.key]));
+                    render();
+                }
+                else if (e.key === "Escape") {
+                    e.preventDefault();
+                    anchor = null;
+                    render();
+                }
+                else if (e.key === "Delete" || e.key === "Backspace") {
+                    e.preventDefault();
+                    selected = c;
+                    remove();
+                }
+            };
+            cells.append(cell);
+        }
+        board.append(cells);
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = shikakuFinished(game) ? (game.helped ? w.helped : w.won) : message || (anchor === null ? w.ready : w.corner);
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => { game = undoShikaku(game); finished = shikakuFinished(game); changed(); }, !game.history.length);
+        button(w.remove, remove, finished || !game.rectangles.some(r => shikakuCells(b, r).includes(selected)));
+        button(w.cancel, () => { anchor = null; message = ""; render(); }, anchor === null);
+        button(w.check, () => { errors = checkShikaku(b, game.rectangles).errors; message = errors.length ? w.wrong : w.checked; render(); });
+        button(w.hint, () => {
+            const r = hintShikaku(game);
+            if (!r) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...placeShikaku(game, r), helped: true };
+            changed();
+            message = w.hintWhy;
+            render();
+        }, finished);
+        button(w.restart, restart);
+        button(w.expand, () => {
+            if (root.parentElement !== host)
+                return;
+            const dialog = doc.createElement("dialog"), close = doc.createElement("button");
+            dialog.className = "ks-dialog";
+            close.className = "ks-close";
+            close.textContent = w.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: () => encodeShikaku(game), restart,
+        set: (next) => { if (next.language && next.language !== options.language)
+            message = ""; options = { ...options, ...next }; render(); },
+        destroy: () => { dead = true; const dialog = root.closest("dialog"); root.remove(); dialog?.remove(); } };
+}

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/shikakuPlay.types.d.ts

@@ -0,0 +1,26 @@
+import type { ShikakuBoard, ShikakuGame } from "./shikaku.types.ts";
+export type ShikakuMaterial = "ivory" | "wood" | "slate";
+export type ShikakuPieces = "ink" | "tiles";
+export type ShikakuLanguage = "en" | "ja";
+export type ShikakuDrawOptions = {
+    rectangles?: ShikakuGame["rectangles"];
+    selected?: number | null;
+    anchor?: number | null;
+    errors?: readonly number[];
+    material?: ShikakuMaterial;
+    pieces?: ShikakuPieces;
+    language?: ShikakuLanguage;
+};
+export type ShikakuMountOptions = ShikakuDrawOptions & {
+    board: ShikakuBoard;
+    progress?: string;
+    onChange?: (game: ShikakuGame) => void;
+    onFinish?: (game: ShikakuGame) => void;
+};
+export type ShikakuMount = {
+    game: () => ShikakuGame;
+    progress: () => string;
+    set: (options: ShikakuDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/shikakuPlay.types.js

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

package/dist/shikakuSolve.d.ts

@@ -0,0 +1,6 @@
+import type { ShikakuBoard, ShikakuRectangle, ShikakuSolve } from "./shikaku.types.ts";
+/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+export declare function solveShikaku(board: ShikakuBoard, placed?: readonly ShikakuRectangle[], options?: {
+    limit?: number;
+    nodes?: number;
+}): ShikakuSolve;

package/dist/shikakuSolve.js

@@ -0,0 +1,54 @@
+import { SHIKAKU_MOST_NODES } from "./shikaku.constants.js";
+import { checkShikaku, isShikakuBoard, shikakuCandidates, shikakuCells } from "./shikakuBoard.js";
+/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+export function solveShikaku(board, placed = [], options = {}) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? SHIKAKU_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const maskOf = (r) => shikakuCells(board, r).reduce((m, c) => m | 1n << BigInt(c), 0n);
+    if (checkShikaku(board, placed).errors.length)
+        return { count: 0, solution: null, complete: true, nodes: 0 };
+    const all = (1n << BigInt(board.clues.length)) - 1n;
+    let occupied = 0n;
+    for (const r of placed)
+        occupied |= maskOf(r);
+    const candidates = board.clues.flatMap((n, c) => n ? shikakuCandidates(board, c).map(r => ({ r, mask: maskOf(r) })) : []);
+    const byCell = board.clues.map((_, c) => candidates.filter(r => (r.mask & 1n << BigInt(c)) !== 0n));
+    let count = 0, nodes = 0, complete = true, solution = null;
+    const visit = (mask, rectangles) => {
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        if (mask === all) {
+            count += 1;
+            solution ?? (solution = rectangles.map(r => ({ ...r })));
+            return;
+        }
+        let choices = null;
+        for (let c = 0; c < board.clues.length; c += 1) {
+            if ((mask & 1n << BigInt(c)) !== 0n)
+                continue;
+            const available = byCell[c].filter(r => (mask & r.mask) === 0n);
+            if (!available.length)
+                return;
+            if (!choices || available.length < choices.length)
+                choices = available;
+            if (choices.length === 1)
+                break;
+        }
+        for (const next of choices ?? []) {
+            visit(mask | next.mask, [...rectangles, next.r]);
+            if (!complete)
+                return;
+            if (count >= limit) {
+                complete = false;
+                return;
+            }
+        }
+    };
+    visit(occupied, placed);
+    return { count, solution, complete, nodes };
+}

package/dist/shikakuStrings.d.ts

@@ -0,0 +1,102 @@
+import type { ShikakuLanguage } from "./shikakuPlay.types.ts";
+export declare const SHIKAKU_STRINGS: {
+    readonly en: {
+        readonly title: "Shikaku";
+        readonly help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly cancel: "Cancel";
+        readonly expand: "Just the board";
+        readonly close: "Close";
+        readonly ready: "Choose the first corner.";
+        readonly corner: "Choose the opposite corner.";
+        readonly won: "Every rectangle fits. Solved!";
+        readonly helped: "Every rectangle fits. Solved with help.";
+        readonly hintWhy: "This rectangle occurs in the only remaining complete partition.";
+        readonly noHint: "No proved hint: undo a conflicting rectangle or continue drawing.";
+        readonly checked: "All drawn rectangles follow the rules. Keep filling the board.";
+        readonly wrong: "Some rectangles need changing: each must hold one number equal to its area.";
+        readonly remove: "Remove selected rectangle";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly clue: "area";
+        readonly blank: "no clue";
+        readonly covered: "in a rectangle";
+    };
+    readonly ja: {
+        readonly title: "四角に切れ";
+        readonly help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly cancel: "取り消す";
+        readonly expand: "盤だけ";
+        readonly close: "閉じる";
+        readonly ready: "最初の角を選びます。";
+        readonly corner: "向かいの角を選びます。";
+        readonly won: "全部の長方形が合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly hintWhy: "残った唯一の答えに、この長方形があります。";
+        readonly noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。";
+        readonly checked: "描いた長方形はルールに合っています。残りも埋めましょう。";
+        readonly wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。";
+        readonly remove: "選んだ長方形を消す";
+        readonly row: "行";
+        readonly column: "列";
+        readonly clue: "面積";
+        readonly blank: "数字なし";
+        readonly covered: "長方形の中";
+    };
+};
+export declare function shikakuWords(language?: ShikakuLanguage): {
+    readonly title: "Shikaku";
+    readonly help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly cancel: "Cancel";
+    readonly expand: "Just the board";
+    readonly close: "Close";
+    readonly ready: "Choose the first corner.";
+    readonly corner: "Choose the opposite corner.";
+    readonly won: "Every rectangle fits. Solved!";
+    readonly helped: "Every rectangle fits. Solved with help.";
+    readonly hintWhy: "This rectangle occurs in the only remaining complete partition.";
+    readonly noHint: "No proved hint: undo a conflicting rectangle or continue drawing.";
+    readonly checked: "All drawn rectangles follow the rules. Keep filling the board.";
+    readonly wrong: "Some rectangles need changing: each must hold one number equal to its area.";
+    readonly remove: "Remove selected rectangle";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly clue: "area";
+    readonly blank: "no clue";
+    readonly covered: "in a rectangle";
+} | {
+    readonly title: "四角に切れ";
+    readonly help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly cancel: "取り消す";
+    readonly expand: "盤だけ";
+    readonly close: "閉じる";
+    readonly ready: "最初の角を選びます。";
+    readonly corner: "向かいの角を選びます。";
+    readonly won: "全部の長方形が合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly hintWhy: "残った唯一の答えに、この長方形があります。";
+    readonly noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。";
+    readonly checked: "描いた長方形はルールに合っています。残りも埋めましょう。";
+    readonly wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。";
+    readonly remove: "選んだ長方形を消す";
+    readonly row: "行";
+    readonly column: "列";
+    readonly clue: "面積";
+    readonly blank: "数字なし";
+    readonly covered: "長方形の中";
+};

package/dist/shikakuStrings.js

@@ -0,0 +1,5 @@
+export const SHIKAKU_STRINGS = {
+    en: { title: "Shikaku", help: "Choose two opposite corners to draw a rectangle. Each rectangle must contain one number equal to its area. Cover the whole board. Arrow keys move; Enter chooses a corner; Delete removes a rectangle; Escape cancels.", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", cancel: "Cancel", expand: "Just the board", close: "Close", ready: "Choose the first corner.", corner: "Choose the opposite corner.", won: "Every rectangle fits. Solved!", helped: "Every rectangle fits. Solved with help.", hintWhy: "This rectangle occurs in the only remaining complete partition.", noHint: "No proved hint: undo a conflicting rectangle or continue drawing.", checked: "All drawn rectangles follow the rules. Keep filling the board.", wrong: "Some rectangles need changing: each must hold one number equal to its area.", remove: "Remove selected rectangle", row: "Row", column: "column", clue: "area", blank: "no clue", covered: "in a rectangle" },
+    ja: { title: "四角に切れ", help: "向かい合う二つの角を選んで長方形を描きます。各長方形に数字を一つ入れ、その数字と面積を同じにします。盤全体を埋めましょう。矢印キーで移動、Enterで角を選び、Deleteで長方形を消し、Escapeで取り消します。", undo: "戻す", hint: "ヒント", check: "確かめる", restart: "やり直す", cancel: "取り消す", expand: "盤だけ", close: "閉じる", ready: "最初の角を選びます。", corner: "向かいの角を選びます。", won: "全部の長方形が合いました。完成！", helped: "ヒントを使って完成！", hintWhy: "残った唯一の答えに、この長方形があります。", noHint: "確かなヒントがありません。合わない長方形を戻すか、続けて描きましょう。", checked: "描いた長方形はルールに合っています。残りも埋めましょう。", wrong: "直す長方形があります。数字を一つ含み、その数字と面積を同じにします。", remove: "選んだ長方形を消す", row: "行", column: "列", clue: "面積", blank: "数字なし", covered: "長方形の中" }
+};
+export function shikakuWords(language = "en") { return SHIKAKU_STRINGS[language]; }

package/dist/shikakuStyle.d.ts

@@ -0,0 +1 @@
+export declare const SHIKAKU_PLAY_STYLE = "\n.ks-root{color:var(--ks-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}\n.ks-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}\n.ks-cells{position:absolute;inset:0;display:grid;padding:2px}\n.ks-cell{background:transparent;border:0;min-width:0;min-height:0;padding:0;cursor:crosshair;touch-action:manipulation}\n.ks-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}\n.ks-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}\n.ks-tools button,.ks-close{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:var(--ks-ink,#1f2320);cursor:pointer}\n.ks-tools button:disabled{opacity:.45;cursor:default}.ks-status{min-height:1.5em}.ks-help{font-size:14px;opacity:.8}\n.ks-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ks-ink:var(--ink,#1f2320);--ks-surface:var(--surface,#fbf8f1);--ks-rule:var(--rule,#ddd6c6)}.ks-dialog::backdrop{background:#172c28bb}\n.ks-close{float:right;margin-bottom:10px}.ks-dialog .ks-root{clear:both}\n";

package/dist/shikakuStyle.js

@@ -0,0 +1,12 @@
+export const SHIKAKU_PLAY_STYLE = `
+.ks-root{color:var(--ks-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:680px;margin:auto}
+.ks-board{position:relative;width:100%;min-width:240px;touch-action:manipulation}
+.ks-cells{position:absolute;inset:0;display:grid;padding:2px}
+.ks-cell{background:transparent;border:0;min-width:0;min-height:0;padding:0;cursor:crosshair;touch-action:manipulation}
+.ks-cell:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-4px;border-radius:4px}
+.ks-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.ks-tools button,.ks-close{font:inherit;border:1px solid var(--ks-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--ks-surface,#fbf8f1);color:var(--ks-ink,#1f2320);cursor:pointer}
+.ks-tools button:disabled{opacity:.45;cursor:default}.ks-status{min-height:1.5em}.ks-help{font-size:14px;opacity:.8}
+.ks-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,760px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--ks-ink:var(--ink,#1f2320);--ks-surface:var(--surface,#fbf8f1);--ks-rule:var(--rule,#ddd6c6)}.ks-dialog::backdrop{background:#172c28bb}
+.ks-close{float:right;margin-bottom:10px}.ks-dialog .ks-root{clear:both}
+`;

package/dist/shikakuWorker.d.ts

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

package/dist/shikakuWorker.js

@@ -0,0 +1,10 @@
+import { generateShikaku } from "./shikakuGenerate.js";
+self.onmessage = (event) => {
+    try {
+        const { width, height, level, seed } = event.data;
+        self.postMessage({ puzzle: generateShikaku(width, height, level, seed) });
+    }
+    catch (error) {
+        self.postMessage({ error: error instanceof Error ? error.message : String(error) });
+    }
+};

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 {};