@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/fillominoGenerate.js

@@ -0,0 +1,125 @@
+import { FILLOMINO_GENERATOR_MOST_CELLS, FILLOMINO_LEVELS, FILLOMINO_MOST_ATTEMPTS } from "./fillomino.constants.js";
+import { checkFillomino, fillominoNeighbours } from "./fillominoBoard.js";
+import { solveFillomino } from "./fillominoSolve.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+/** Makes an original connected-region partition, then keeps only independently proved unique clues. */
+export function generateFillomino(width = 5, height = width, level = "medium", seed = 1) {
+    if (![width, height].every(value => Number.isInteger(value) && value >= 4 && value <= 8) || width * height > FILLOMINO_GENERATOR_MOST_CELLS
+        || !FILLOMINO_LEVELS.includes(level) || !isKazuSeed(seed)) {
+        throw new RangeError("Fillomino generation supports 4–8 cells per side and a valid level and seed");
+    }
+    const random = seededRandom(seed);
+    for (let attempt = 0; attempt < FILLOMINO_MOST_ATTEMPTS; attempt += 1) {
+        const solution = partitionBoard(width, height, level, random);
+        if (!solution)
+            continue;
+        const regions = regionCells(width, height, solution);
+        if (regions.length >= width * height * 0.34)
+            continue;
+        const givens = Array(width * height).fill(0);
+        const extraClues = [];
+        for (const region of regions) {
+            const choices = shuffled(region, random);
+            const count = level === "easy" && region.length > 1 ? 2 : level === "hard" && random() < 0.2 ? 0 : 1;
+            for (const cell of choices.slice(0, count))
+                givens[cell] = solution[cell];
+            extraClues.push(...choices.slice(count));
+        }
+        const clueOrder = shuffled(extraClues, random);
+        const board = { width, height, givens };
+        const maximumGivens = Math.floor(width * height * ({ easy: 0.9, medium: 0.72, hard: 0.62 }[level]));
+        for (let added = 0;; added += 1) {
+            const proof = solveFillomino(board, givens);
+            if (proof.complete && proof.count === 1 && proof.solution && checkFillomino(board, proof.solution).ok) {
+                return { ...board, seed, level, solution: proof.solution };
+            }
+            if (added >= clueOrder.length || givens.filter(Boolean).length >= maximumGivens)
+                break;
+            const cell = clueOrder[added];
+            givens[cell] = solution[cell];
+        }
+    }
+    throw new Error("No unique Fillomino found within the generation budget; try another seed or smaller board");
+}
+function partitionBoard(width, height, level, random) {
+    const board = { width, height, givens: Array(width * height).fill(0) };
+    const entries = Array(width * height).fill(0);
+    const maxArea = { easy: 4, medium: 6, hard: 8 }[level];
+    let trials = 0;
+    const visit = () => {
+        if (++trials > 12000)
+            return false;
+        const anchor = entries.findIndex(value => value === 0);
+        if (anchor < 0)
+            return true;
+        const remaining = entries.filter(value => value === 0).length;
+        const preferred = Array.from({ length: Math.min(maxArea, remaining) }, (_, index) => index + 1);
+        const sizes = shuffled(preferred, random).sort((left, right) => right - left);
+        for (const area of sizes) {
+            for (let proposal = 0; proposal < 5; proposal += 1) {
+                if (fillominoNeighbours(board, anchor).some(cell => entries[cell] === area))
+                    continue;
+                const shape = growShape(board, anchor, area, entries, random);
+                if (!shape)
+                    continue;
+                for (const cell of shape)
+                    entries[cell] = area;
+                if (visit())
+                    return true;
+                for (const cell of shape)
+                    entries[cell] = 0;
+            }
+        }
+        return false;
+    };
+    const result = visit() ? [...entries] : null;
+    return result && checkFillomino(board, result).ok ? result : null;
+}
+function growShape(board, anchor, area, entries, random) {
+    const cells = [anchor];
+    const members = new Set(cells);
+    while (cells.length < area) {
+        const frontier = new Set();
+        for (const cell of cells) {
+            for (const next of fillominoNeighbours(board, cell)) {
+                if (entries[next] !== 0 || members.has(next))
+                    continue;
+                if (fillominoNeighbours(board, next).some(adjacent => entries[adjacent] === area))
+                    continue;
+                frontier.add(next);
+            }
+        }
+        const choices = [...frontier];
+        if (!choices.length)
+            return null;
+        const next = choices[Math.floor(random() * choices.length)];
+        cells.push(next);
+        members.add(next);
+    }
+    return cells;
+}
+function regionCells(width, height, entries) {
+    const board = { width, height, givens: Array(width * height).fill(0) };
+    const visited = new Set();
+    const regions = [];
+    for (let start = 0; start < entries.length; start += 1) {
+        if (visited.has(start))
+            continue;
+        const value = entries[start];
+        const region = [];
+        const pending = [start];
+        visited.add(start);
+        while (pending.length) {
+            const cell = pending.pop();
+            region.push(cell);
+            for (const next of fillominoNeighbours(board, cell)) {
+                if (!visited.has(next) && entries[next] === value) {
+                    visited.add(next);
+                    pending.push(next);
+                }
+            }
+        }
+        regions.push(region);
+    }
+    return regions;
+}

package/dist/fillominoMount.d.ts

@@ -0,0 +1,2 @@
+import type { FillominoMount, FillominoMountOptions } from "./fillominoPlay.types.ts";
+export declare function mountFillomino(host: HTMLElement, initial: FillominoMountOptions): FillominoMount;

package/dist/fillominoMount.js

@@ -0,0 +1,211 @@
+import { checkFillomino } from "./fillominoBoard.js";
+import { drawFillomino } from "./fillominoDraw.js";
+import { decodeFillomino, encodeFillomino, hintFillomino, newFillomino, restartFillomino, setFillominoCell, undoFillomino } from "./fillominoGame.js";
+import { FILLOMINO_PLAY_STYLE } from "./fillominoStyle.js";
+import { fillominoWords } from "./fillominoStrings.js";
+export function mountFillomino(host, initial) {
+    const document = host.ownerDocument;
+    let options = { ...initial };
+    let game = restoreGame(initial);
+    let selected = null;
+    let errors = [];
+    let message = "";
+    let destroyed = false;
+    let lastFinishState = false;
+    const style = document.createElement("style");
+    style.textContent = FILLOMINO_PLAY_STYLE;
+    const root = document.createElement("div");
+    root.className = "fillomino-play";
+    const status = document.createElement("p");
+    status.className = "fillomino-status";
+    status.setAttribute("role", "status");
+    const board = document.createElement("div");
+    board.className = "fillomino-board";
+    const controls = document.createElement("div");
+    controls.className = "fillomino-controls";
+    root.append(status, board, controls);
+    host.append(style, root);
+    const language = () => options.language ?? "en";
+    const copyGame = (state = game) => ({
+        board: { ...state.board, givens: [...state.board.givens] },
+        entries: [...state.entries],
+        history: state.history.map(entries => [...entries]),
+        helped: state.helped,
+    });
+    const emit = () => {
+        const snapshot = copyGame();
+        options.onChange?.(snapshot);
+        host.dispatchEvent(new document.defaultView.CustomEvent("fillomino-change", { detail: snapshot }));
+    };
+    const button = (label, action, disabled = false) => {
+        const control = document.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.addEventListener("click", action);
+        controls.append(control);
+    };
+    const update = () => {
+        if (destroyed)
+            return;
+        const words = fillominoWords(language());
+        const checked = checkFillomino(game.board, game.entries);
+        status.textContent = message || (checked.ok ? game.helped ? words.helped : words.solved : checked.errors.length ? words.wrong : words.remaining);
+        board.replaceChildren();
+        board.style.setProperty("--fillomino-width", String(game.board.width));
+        board.style.setProperty("--fillomino-height", String(game.board.height));
+        const drawing = document.createElement("div");
+        drawing.className = "fillomino-drawing";
+        drawing.innerHTML = drawFillomino(game.board, {
+            entries: game.entries,
+            selected,
+            errors,
+            material: options.material,
+            pieces: options.pieces,
+            language: language(),
+        });
+        const cells = document.createElement("div");
+        cells.className = "fillomino-cells";
+        cells.setAttribute("role", "grid");
+        cells.setAttribute("aria-label", words.title);
+        for (let cell = 0; cell < game.entries.length; cell += 1) {
+            const x = cell % game.board.width;
+            const y = Math.floor(cell / game.board.width);
+            const given = game.board.givens[cell];
+            const value = game.entries[cell];
+            const control = document.createElement("button");
+            control.type = "button";
+            control.className = "fillomino-cell";
+            control.dataset.cell = String(cell);
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-label", `${words.row} ${y + 1}, ${words.column} ${x + 1}, ${value || words.empty}${value ? `, ${words.filled}` : ""}${given ? `, ${words.clue}` : ""}`);
+            control.setAttribute("aria-pressed", String(selected === cell));
+            control.tabIndex = selected === cell || (selected === null && cell === 0) ? 0 : -1;
+            control.addEventListener("click", () => {
+                selected = cell;
+                message = "";
+                update();
+            });
+            control.addEventListener("keydown", event => moveByKeyboard(event, cell));
+            cells.append(control);
+        }
+        drawing.append(cells);
+        board.append(drawing);
+        controls.replaceChildren();
+        const label = document.createElement("label");
+        label.className = "fillomino-number-label";
+        label.textContent = words.selectNumber;
+        const number = document.createElement("select");
+        number.setAttribute("aria-label", words.selectNumber);
+        number.dataset.number = "true";
+        for (let value = 1; value <= game.entries.length; value += 1) {
+            const option = document.createElement("option");
+            option.value = String(value);
+            option.textContent = String(value);
+            number.append(option);
+        }
+        label.append(number);
+        controls.append(label);
+        button(words.fill, () => applySelected(Number(number.value)), selected === null || Boolean(game.board.givens[selected]));
+        button(words.clear, () => applySelected(0), selected === null || Boolean(game.board.givens[selected]));
+        button(words.undo, () => {
+            game = undoFillomino(game);
+            errors = [];
+            message = "";
+            emit();
+            update();
+        }, game.history.length === 0);
+        button(words.check, checkBoard);
+        button(words.hint, giveHint);
+        button(words.restart, restart);
+        const nowFinished = checked.ok;
+        if (nowFinished && !lastFinishState)
+            options.onFinish?.(copyGame());
+        lastFinishState = nowFinished;
+    };
+    const applySelected = (value) => {
+        if (selected === null)
+            return;
+        const next = setFillominoCell(game, selected, value);
+        if (next === game)
+            return;
+        game = next;
+        errors = [];
+        message = "";
+        emit();
+        update();
+    };
+    const moveByKeyboard = (event, cell) => {
+        const x = cell % game.board.width;
+        const y = Math.floor(cell / game.board.width);
+        const moves = {
+            ArrowUp: y > 0 ? cell - game.board.width : cell,
+            ArrowDown: y + 1 < game.board.height ? cell + game.board.width : cell,
+            ArrowLeft: x > 0 ? cell - 1 : cell,
+            ArrowRight: x + 1 < game.board.width ? cell + 1 : cell,
+        };
+        if (event.key in moves) {
+            event.preventDefault();
+            selected = moves[event.key];
+            update();
+            board.querySelector(`button[data-cell="${selected}"]`)?.focus();
+            return;
+        }
+        if (/^[1-9]$/.test(event.key)) {
+            event.preventDefault();
+            selected = cell;
+            applySelected(Number(event.key));
+            return;
+        }
+        if (event.key === "Backspace" || event.key === "Delete") {
+            event.preventDefault();
+            selected = cell;
+            applySelected(0);
+        }
+    };
+    const checkBoard = () => {
+        const checked = checkFillomino(game.board, game.entries);
+        errors = checked.errors;
+        message = checked.ok ? game.helped ? fillominoWords(language()).helped : fillominoWords(language()).solved
+            : checked.errors.length ? fillominoWords(language()).wrong : fillominoWords(language()).checked;
+        update();
+    };
+    const giveHint = () => {
+        const hint = hintFillomino(game);
+        if (!hint) {
+            message = fillominoWords(language()).noHint;
+            update();
+            return;
+        }
+        game = setFillominoCell(game, hint.cell, hint.value);
+        game = { ...game, helped: true };
+        selected = hint.cell;
+        errors = [];
+        message = fillominoWords(language()).hintWhy;
+        emit();
+        update();
+    };
+    const restart = () => {
+        game = restartFillomino(game);
+        selected = null;
+        errors = [];
+        message = "";
+        emit();
+        update();
+    };
+    update();
+    return {
+        game: () => copyGame(),
+        progress: () => encodeFillomino(game),
+        set: (next) => { options = { ...options, ...next }; update(); },
+        restart,
+        destroy: () => { destroyed = true; root.remove(); style.remove(); },
+    };
+}
+function restoreGame(source) {
+    const saved = source.progress ? decodeFillomino(source.progress) : null;
+    return saved && saved.board.width === source.board.width && saved.board.height === source.board.height
+        && saved.board.givens.every((given, cell) => given === source.board.givens[cell])
+        ? saved
+        : newFillomino(source.board);
+}

package/dist/fillominoPlay.types.d.ts

@@ -0,0 +1,25 @@
+import type { FillominoBoard, FillominoGame } from "./fillomino.types.ts";
+export type FillominoLanguage = "en" | "ja";
+export type FillominoMaterial = "ivory" | "wood" | "slate";
+export type FillominoPieces = "ink" | "tiles";
+export type FillominoDrawOptions = {
+    entries?: readonly number[];
+    errors?: readonly number[];
+    selected?: number | null;
+    material?: FillominoMaterial;
+    pieces?: FillominoPieces;
+    language?: FillominoLanguage;
+};
+export type FillominoMountOptions = FillominoDrawOptions & {
+    board: FillominoBoard;
+    progress?: string;
+    onChange?: (game: FillominoGame) => void;
+    onFinish?: (game: FillominoGame) => void;
+};
+export type FillominoMount = {
+    game: () => FillominoGame;
+    progress: () => string;
+    set: (options: FillominoDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/fillominoPlay.types.js

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

package/dist/fillominoSolve.d.ts

@@ -0,0 +1,6 @@
+import type { FillominoBoard, FillominoSolve } from "./fillomino.types.ts";
+/** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
+export declare function solveFillomino(board: FillominoBoard, entries?: readonly number[], options?: {
+    limit?: number;
+    nodes?: number;
+}): FillominoSolve;

package/dist/fillominoSolve.js

@@ -0,0 +1,111 @@
+import { FILLOMINO_MOST_NODES } from "./fillomino.constants.js";
+import { fillominoNeighbours, isFillominoBoard } from "./fillominoBoard.js";
+/** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
+export function solveFillomino(board, entries = board.givens, options = {}) {
+    if (!isFillominoBoard(board))
+        throw new RangeError("Invalid Fillomino board");
+    const limit = options.limit ?? 2;
+    const budget = options.nodes ?? FILLOMINO_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
+        throw new RangeError("Invalid search bounds");
+    }
+    if (!Array.isArray(entries) || entries.length !== board.givens.length) {
+        throw new RangeError("Invalid Fillomino entries");
+    }
+    const fixed = entries.map((value, cell) => {
+        if (!Number.isInteger(value) || value < 0 || value > entries.length)
+            return -1;
+        if (board.givens[cell] && value !== board.givens[cell])
+            return -1;
+        return value || board.givens[cell];
+    });
+    if (fixed.some(value => value < 0))
+        return { count: 0, solution: null, complete: true, nodes: 0 };
+    const resolved = Array(entries.length).fill(0);
+    const state = { nodes: 0, stopped: false };
+    let count = 0;
+    let solution = null;
+    const visit = () => {
+        if (++state.nodes > budget) {
+            state.stopped = true;
+            return;
+        }
+        let anchor = -1;
+        for (let cell = 0; cell < resolved.length; cell += 1) {
+            if (resolved[cell] === 0) {
+                anchor = cell;
+                break;
+            }
+        }
+        if (anchor < 0) {
+            count += 1;
+            solution ?? (solution = [...resolved]);
+            if (count >= limit)
+                state.stopped = true;
+            return;
+        }
+        const choices = fixed[anchor] ? [fixed[anchor]] : Array.from({ length: entries.length }, (_, index) => index + 1);
+        for (const value of choices) {
+            const shapes = regionShapes(board, anchor, value, resolved, fixed, state, budget);
+            if (state.stopped)
+                return;
+            for (const shape of shapes) {
+                for (const cell of shape)
+                    resolved[cell] = value;
+                visit();
+                for (const cell of shape)
+                    resolved[cell] = 0;
+                if (state.stopped)
+                    return;
+            }
+        }
+    };
+    visit();
+    const complete = !state.stopped;
+    return { count, solution, complete, nodes: Math.min(state.nodes, budget) };
+}
+function regionShapes(board, anchor, area, resolved, fixed, state, budget) {
+    if (fixed[anchor] !== 0 && fixed[anchor] !== area)
+        return [];
+    const shapes = [];
+    const seen = new Set();
+    const grow = (cells) => {
+        if (state.stopped)
+            return;
+        if (++state.nodes > budget) {
+            state.stopped = true;
+            return;
+        }
+        const key = [...cells].sort((a, b) => a - b).join(",");
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        if (cells.length === area) {
+            const members = new Set(cells);
+            for (const cell of cells) {
+                for (const next of fillominoNeighbours(board, cell)) {
+                    if (members.has(next))
+                        continue;
+                    if (resolved[next] === area || fixed[next] === area)
+                        return;
+                }
+            }
+            shapes.push([...cells]);
+            return;
+        }
+        const frontier = new Set();
+        for (const cell of cells) {
+            for (const next of fillominoNeighbours(board, cell)) {
+                if (cells.includes(next) || resolved[next] !== 0)
+                    continue;
+                if (fixed[next] !== 0 && fixed[next] !== area)
+                    continue;
+                frontier.add(next);
+            }
+        }
+        for (const next of frontier)
+            grow([...cells, next]);
+    };
+    grow([anchor]);
+    return shapes;
+}

package/dist/fillominoStrings.d.ts

@@ -0,0 +1,102 @@
+import type { FillominoLanguage } from "./fillominoPlay.types.ts";
+export declare const FILLOMINO_STRINGS: {
+    readonly en: {
+        readonly title: "Fillomino";
+        readonly help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly selectNumber: "Number";
+        readonly fill: "Enter";
+        readonly clear: "Clear";
+        readonly selected: "Selected";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly empty: "empty";
+        readonly clue: "given";
+        readonly filled: "filled";
+        readonly checked: "The filled regions follow the rules so far.";
+        readonly wrong: "Some regions are too large or a clue was changed.";
+        readonly remaining: "Keep filling the empty cells.";
+        readonly solved: "Every region has the right size. Solved!";
+        readonly helped: "Solved with a hint.";
+        readonly hintWhy: "This cell follows from the only complete solution.";
+        readonly noHint: "No proved hint is available from the current entries.";
+        readonly restored: "Progress restored.";
+    };
+    readonly ja: {
+        readonly title: "フィロミノ";
+        readonly help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly selectNumber: "数字";
+        readonly fill: "入力";
+        readonly clear: "消去";
+        readonly selected: "選択中";
+        readonly row: "行";
+        readonly column: "列";
+        readonly empty: "空き";
+        readonly clue: "ヒント";
+        readonly filled: "入力済み";
+        readonly checked: "ここまでの領域はルールに合っています。";
+        readonly wrong: "大きすぎる領域か、変更されたヒントがあります。";
+        readonly remaining: "空きマスを埋めましょう。";
+        readonly solved: "すべての領域の大きさが合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly hintWhy: "唯一の完成形から、このマスが決まります。";
+        readonly noHint: "現在の入力から確かなヒントを出せません。";
+        readonly restored: "続きから再開しました。";
+    };
+};
+export declare function fillominoWords(language?: FillominoLanguage): {
+    readonly title: "Fillomino";
+    readonly help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly selectNumber: "Number";
+    readonly fill: "Enter";
+    readonly clear: "Clear";
+    readonly selected: "Selected";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly empty: "empty";
+    readonly clue: "given";
+    readonly filled: "filled";
+    readonly checked: "The filled regions follow the rules so far.";
+    readonly wrong: "Some regions are too large or a clue was changed.";
+    readonly remaining: "Keep filling the empty cells.";
+    readonly solved: "Every region has the right size. Solved!";
+    readonly helped: "Solved with a hint.";
+    readonly hintWhy: "This cell follows from the only complete solution.";
+    readonly noHint: "No proved hint is available from the current entries.";
+    readonly restored: "Progress restored.";
+} | {
+    readonly title: "フィロミノ";
+    readonly help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly selectNumber: "数字";
+    readonly fill: "入力";
+    readonly clear: "消去";
+    readonly selected: "選択中";
+    readonly row: "行";
+    readonly column: "列";
+    readonly empty: "空き";
+    readonly clue: "ヒント";
+    readonly filled: "入力済み";
+    readonly checked: "ここまでの領域はルールに合っています。";
+    readonly wrong: "大きすぎる領域か、変更されたヒントがあります。";
+    readonly remaining: "空きマスを埋めましょう。";
+    readonly solved: "すべての領域の大きさが合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly hintWhy: "唯一の完成形から、このマスが決まります。";
+    readonly noHint: "現在の入力から確かなヒントを出せません。";
+    readonly restored: "続きから再開しました。";
+};

package/dist/fillominoStrings.js

@@ -0,0 +1,13 @@
+export const FILLOMINO_STRINGS = {
+    en: {
+        title: "Fillomino", help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.",
+        undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", selectNumber: "Number", fill: "Enter", clear: "Clear", selected: "Selected", row: "Row", column: "column", empty: "empty", clue: "given", filled: "filled", checked: "The filled regions follow the rules so far.", wrong: "Some regions are too large or a clue was changed.", remaining: "Keep filling the empty cells.", solved: "Every region has the right size. Solved!", helped: "Solved with a hint.", hintWhy: "This cell follows from the only complete solution.", noHint: "No proved hint is available from the current entries.", restored: "Progress restored.",
+    },
+    ja: {
+        title: "フィロミノ", help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。",
+        undo: "戻す", hint: "ヒント", check: "確かめる", restart: "やり直す", selectNumber: "数字", fill: "入力", clear: "消去", selected: "選択中", row: "行", column: "列", empty: "空き", clue: "ヒント", filled: "入力済み", checked: "ここまでの領域はルールに合っています。", wrong: "大きすぎる領域か、変更されたヒントがあります。", remaining: "空きマスを埋めましょう。", solved: "すべての領域の大きさが合いました。完成！", helped: "ヒントを使って完成！", hintWhy: "唯一の完成形から、このマスが決まります。", noHint: "現在の入力から確かなヒントを出せません。", restored: "続きから再開しました。",
+    },
+};
+export function fillominoWords(language = "en") {
+    return FILLOMINO_STRINGS[language];
+}

package/dist/fillominoStyle.d.ts

@@ -0,0 +1 @@
+export declare const FILLOMINO_PLAY_STYLE = "\n.fillomino-play{font:1rem/1.45 system-ui,sans-serif;color:var(--kz-ink,#202521);max-width:58rem;margin:auto}\n.fillomino-status{min-height:1.5em;text-align:center;font-weight:600}\n.fillomino-board{width:min(100%,42rem);margin:1rem auto}\n.fillomino-drawing{position:relative}\n.fillomino-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--fillomino-width),1fr);grid-template-rows:repeat(var(--fillomino-height),1fr)}\n.fillomino-cell{min-width:0;min-height:0;border:0;background:transparent;color:transparent;cursor:pointer}\n.fillomino-cell:focus-visible{outline:3px solid #b5963d;outline-offset:-3px}\n.fillomino-controls{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:.5rem;margin:1rem auto}\n.fillomino-controls button,.fillomino-controls select{font:inherit;min-height:2.75rem;padding:.45rem .8rem;border:1px solid var(--kz-grid,#cfc6b2);border-radius:.55rem;background:var(--kz-paper,#fbf8f1);color:inherit}\n.fillomino-number-label{display:flex;align-items:center;gap:.45rem}\n@media(max-width:700px){.fillomino-controls{gap:.35rem}.fillomino-controls button{flex:1 1 28%}}\n";

package/dist/fillominoStyle.js

@@ -0,0 +1,13 @@
+export const FILLOMINO_PLAY_STYLE = `
+.fillomino-play{font:1rem/1.45 system-ui,sans-serif;color:var(--kz-ink,#202521);max-width:58rem;margin:auto}
+.fillomino-status{min-height:1.5em;text-align:center;font-weight:600}
+.fillomino-board{width:min(100%,42rem);margin:1rem auto}
+.fillomino-drawing{position:relative}
+.fillomino-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--fillomino-width),1fr);grid-template-rows:repeat(var(--fillomino-height),1fr)}
+.fillomino-cell{min-width:0;min-height:0;border:0;background:transparent;color:transparent;cursor:pointer}
+.fillomino-cell:focus-visible{outline:3px solid #b5963d;outline-offset:-3px}
+.fillomino-controls{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:.5rem;margin:1rem auto}
+.fillomino-controls button,.fillomino-controls select{font:inherit;min-height:2.75rem;padding:.45rem .8rem;border:1px solid var(--kz-grid,#cfc6b2);border-radius:.55rem;background:var(--kz-paper,#fbf8f1);color:inherit}
+.fillomino-number-label{display:flex;align-items:center;gap:.45rem}
+@media(max-width:700px){.fillomino-controls{gap:.35rem}.fillomino-controls button{flex:1 1 28%}}
+`;

package/dist/fillominoWorker.d.ts

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

package/dist/fillominoWorker.js

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

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

@@ -0,0 +1,2 @@
+export { drawHeyawake } from "./heyawakeDraw.ts";
+export type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";

package/dist/heyawake-draw-entry.js

@@ -0,0 +1 @@
+export { drawHeyawake } from "./heyawakeDraw.js";

package/dist/heyawake-entry.d.ts

@@ -0,0 +1,13 @@
+/** Heyawake has its own room model alongside Kazu's number puzzles. */
+export * from "./heyawake.types.ts";
+export * from "./heyawake.constants.ts";
+export * from "./heyawakeBoard.ts";
+export * from "./heyawakeSolve.ts";
+export * from "./heyawakeGenerate.ts";
+export * from "./heyawakeGame.ts";
+export { drawHeyawake } from "./heyawakeDraw.ts";
+export type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";
+export { mountHeyawake } from "./heyawakeMount.ts";
+export { HEYAWAKE_PLAY_STYLE } from "./heyawakeStyle.ts";
+export { heyawakeWords } from "./heyawakeStrings.ts";
+export type * from "./heyawakePlay.types.ts";