@johnmorrisdotca/kazu 1.0.0

package/dist/layout.js

@@ -0,0 +1,128 @@
+/**
+ * WHICH CELLS MUST HOLD EVERY NUMBER ONCE: the one thing that differs between Sudoku and the
+ * puzzles built on it.
+ *
+ * Classic Sudoku asks it of every row, column and box. Diagonal adds the two long diagonals.
+ * Jigsaw keeps the rows and columns and trades the boxes for irregular regions. Sum Cages adds
+ * cages, each also a group. The solver, the generator and the check read a layout rather than
+ * knowing which puzzle they are in, so a variant is a new list of groups and never a new solver.
+ *
+ * `region` is what the grid draws heavier rules between: the boxes, or the jigsaw's regions.
+ * `diagonal` says the diagonals are groups too, so the grid can shade them.
+ */
+/**
+ * A 9×9 has 3×3 boxes and a 4×4 has 2×2; a 6×6 has boxes two rows tall and three columns wide,
+ * which is the one people get wrong and the reason this is a table rather than a square root.
+ */
+export const KAZU_BOXES = {
+    4: { rows: 2, cols: 2 },
+    6: { rows: 2, cols: 3 },
+    9: { rows: 3, cols: 3 },
+    16: { rows: 4, cols: 4 },
+};
+/** The box a cell is in, numbered row-major from 0. */
+export function boxOf(size, index) {
+    const boxes = KAZU_BOXES[size];
+    const row = Math.floor(index / size);
+    const col = index % size;
+    return Math.floor(row / boxes.rows) * (size / boxes.cols) + Math.floor(col / boxes.cols);
+}
+function build(size, region, regionWord, diagonal) {
+    const groups = [];
+    const add = (cells) => groups.push(cells);
+    for (let r = 0; r < size; r += 1)
+        add(Array.from({ length: size }, (_, c) => r * size + c));
+    for (let c = 0; c < size; c += 1)
+        add(Array.from({ length: size }, (_, r) => r * size + c));
+    for (let g = 0; g < size; g += 1)
+        add(region.flatMap((value, index) => (value === g ? [index] : [])));
+    if (diagonal) {
+        add(Array.from({ length: size }, (_, i) => i * size + i));
+        add(Array.from({ length: size }, (_, i) => i * size + (size - 1 - i)));
+    }
+    const groupsOf = Array.from({ length: size * size }, () => []);
+    groups.forEach((cells, g) => cells.forEach((index) => groupsOf[index].push(g)));
+    return { size, groups, groupsOf, region, regionWord, diagonal };
+}
+const CLASSIC = new Map();
+/** Rows, columns and boxes; with `diagonal`, the two long diagonals as well. */
+export function boxedLayout(size, diagonal = false) {
+    const key = `${size}:${diagonal}`;
+    const known = CLASSIC.get(key);
+    if (known !== undefined)
+        return known;
+    const layout = build(size, Array.from({ length: size * size }, (_, index) => boxOf(size, index)), "box", diagonal);
+    CLASSIC.set(key, layout);
+    return layout;
+}
+/** Rows, columns and the given regions, numbered 0..size-1, each `size` cells. */
+export function regionLayout(size, region) {
+    return build(size, [...region], "region", false);
+}
+/** Rows, columns and boxes, and the cages over them, each cage a group of its own as well. */
+export function cagedLayout(size, cages) {
+    const boxed = boxedLayout(size);
+    const groups = [...boxed.groups, ...cages.map((cage) => [...cage.cells])];
+    const groupsOf = Array.from({ length: size * size }, () => []);
+    groups.forEach((cells, g) => cells.forEach((index) => groupsOf[index].push(g)));
+    const cageOf = new Array(size * size).fill(-1);
+    cages.forEach((cage, c) => cage.cells.forEach((index) => (cageOf[index] = c)));
+    return {
+        ...boxed,
+        groups,
+        groupsOf,
+        cages: cages.map((cage) => ({ cells: [...cage.cells], sum: cage.sum })),
+        cageOf,
+    };
+}
+/** The cells sharing an edge with `index`. */
+export function neighbours(size, index) {
+    const row = Math.floor(index / size);
+    const col = index % size;
+    const out = [];
+    if (row > 0)
+        out.push(index - size);
+    if (row < size - 1)
+        out.push(index + size);
+    if (col > 0)
+        out.push(index - 1);
+    if (col < size - 1)
+        out.push(index + 1);
+    return out;
+}
+/**
+ * Whether `region` divides a size×size grid into `size` regions of `size` cells each, every one of
+ * them joined edge to edge. O(cells): a check of a Jigsaw asks it of whatever regions it was sent.
+ */
+export function regionsAreSound(size, region) {
+    if (region.length !== size * size)
+        return false;
+    const counts = new Array(size).fill(0);
+    for (const value of region) {
+        if (!Number.isInteger(value) || value < 0 || value >= size)
+            return false;
+        counts[value] += 1;
+    }
+    if (counts.some((count) => count !== size))
+        return false;
+    const seen = new Array(size * size).fill(false);
+    for (let g = 0; g < size; g += 1) {
+        const start = region.indexOf(g);
+        const stack = [start];
+        seen[start] = true;
+        let reached = 0;
+        while (stack.length > 0) {
+            const index = stack.pop();
+            reached += 1;
+            for (const next of neighbours(size, index)) {
+                if (!seen[next] && region[next] === g) {
+                    seen[next] = true;
+                    stack.push(next);
+                }
+            }
+        }
+        if (reached !== size)
+            return false;
+    }
+    return true;
+}

package/dist/moreOrLess.d.ts

@@ -0,0 +1,7 @@
+import type { KazuLevel, KazuPuzzle } from "./kinds.ts";
+import { type Grid } from "./moreOrLessSolve.ts";
+import { type Random } from "./random.ts";
+/** A seeded Latin square: every row and column holds 1..size once. Towers starts from one too. */
+export declare function latinSquare(size: number, random: Random): Grid;
+/** A Futoshiki (More or Less) of this side, level and seed: 4, 5, 6 or 7. */
+export declare function generateMoreOrLess(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/moreOrLess.js

@@ -0,0 +1,90 @@
+import { encodeCells } from "./cells.js";
+import { encodeMoreOrLess } from "./moreOrLessCode.js";
+import { countSolutions, guessDepth } from "./moreOrLessSolve.js";
+import { seededRandom, shuffled } from "./random.js";
+/**
+ * Making a Futoshiki (More or Less) puzzle from a seed.
+ *
+ * A seeded Latin square first; then marks on a third of the edges, chosen at random; then givens
+ * added one at a time until the solver counts one answer within the level's depth; then every
+ * given and every mark tried for removal, in a seeded order, keeping the removal only while the
+ * puzzle stays unique and within its level. What is left is the puzzle: nothing in it is there
+ * for decoration.
+ *
+ * Deterministic in the seed.
+ */
+const LEVELS = { easy: 0, medium: 1, hard: Infinity };
+const MARK_SHARE = 0.35;
+/** A seeded Latin square: every row and column holds 1..size once. Towers starts from one too. */
+export function latinSquare(size, random) {
+    const grid = new Array(size * size).fill(0);
+    const values = Array.from({ length: size }, (_, i) => i + 1);
+    const rows = new Array(size).fill(0);
+    const cols = new Array(size).fill(0);
+    const fill = (index) => {
+        if (index === grid.length)
+            return true;
+        const row = Math.floor(index / size);
+        const col = index % size;
+        for (const value of shuffled(values, random)) {
+            const bit = 1 << value;
+            if ((rows[row] | cols[col]) & bit)
+                continue;
+            grid[index] = value;
+            rows[row] |= bit;
+            cols[col] |= bit;
+            if (fill(index + 1))
+                return true;
+            rows[row] &= ~bit;
+            cols[col] &= ~bit;
+            grid[index] = 0;
+        }
+        return false;
+    };
+    fill(0);
+    return grid;
+}
+/** Every edge between two cells, as the mark the answer makes true on it. */
+function everyMark(solution, size) {
+    const marks = [];
+    for (let index = 0; index < solution.length; index += 1) {
+        const col = index % size;
+        for (const other of [col < size - 1 ? index + 1 : -1, index + size < solution.length ? index + size : -1]) {
+            if (other === -1)
+                continue;
+            marks.push(solution[index] < solution[other] ? { less: index, more: other } : { less: other, more: index });
+        }
+    }
+    return marks;
+}
+/** A Futoshiki (More or Less) of this side, level and seed: 4, 5, 6 or 7. */
+export function generateMoreOrLess(size, level, seed) {
+    const random = seededRandom(seed);
+    const solution = latinSquare(size, random);
+    const allowed = LEVELS[level];
+    // Unique, and within the level: a hard puzzle may be as deep as it likes, so its depth is never measured.
+    const fits = (grid, marks) => countSolutions(grid, size, marks, 2) === 1 && (allowed === Infinity || guessDepth(grid, size, marks, allowed) <= allowed);
+    let marks = shuffled(everyMark(solution, size), random).slice(0, Math.round(everyMark(solution, size).length * MARK_SHARE));
+    const givens = new Array(size * size).fill(0);
+    // Givens until it is a puzzle of the level asked for.
+    for (const index of shuffled(givens.map((_, i) => i), random)) {
+        if (fits(givens, marks))
+            break;
+        givens[index] = solution[index];
+    }
+    // Then nothing that is not needed: each given and each mark, in a seeded order.
+    for (const index of shuffled(givens.map((_, i) => i), random)) {
+        if (givens[index] === 0)
+            continue;
+        const value = givens[index];
+        givens[index] = 0;
+        if (!fits(givens, marks))
+            givens[index] = value;
+    }
+    for (const mark of shuffled(marks, random)) {
+        const without = marks.filter((each) => each !== mark);
+        if (fits(givens, without))
+            marks = without;
+    }
+    return { kind: "more-or-less", size, level, seed, givens: encodeMoreOrLess(givens, marks, size), solution: encodeCells(solution) };
+}

package/dist/moreOrLessCode.d.ts

@@ -0,0 +1,22 @@
+/**
+ * More or Less (Futoshiki) as a string: the cells, then the marks between them.
+ *
+ * The cells come first, row-major, as every number grid is written (`.` for
+ * empty). Then one character per edge between two cells: the horizontal
+ * edges row by row (`size − 1` per row), then the vertical edges row by row
+ * (`size` per row, `size − 1` rows). `<` and `>` say which side is bigger,
+ * the way the mark is drawn between the cells; `^` and `v` do the same for
+ * an edge between a cell and the one below it (`v` points down at the
+ * smaller number). `.` is no mark. A 7×7 is 49 + 42 + 42 characters.
+ */
+/** A mark: the cell at `less` holds a smaller number than the cell at `more`. Both are indexes, always adjacent. */
+export type Mark = {
+    less: number;
+    more: number;
+};
+export declare const NO_MARK = ".";
+export declare function encodeMoreOrLess(cells: readonly number[], marks: readonly Mark[], size: number): string;
+export declare function decodeMoreOrLess(code: string, size: number): {
+    cells: number[];
+    marks: Mark[];
+} | null;

package/dist/moreOrLessCode.js

@@ -0,0 +1,52 @@
+import { decodeCells, encodeCells } from "./cells.js";
+export const NO_MARK = ".";
+export function encodeMoreOrLess(cells, marks, size) {
+    const horizontal = new Array(size * (size - 1)).fill(NO_MARK);
+    const vertical = new Array((size - 1) * size).fill(NO_MARK);
+    for (const mark of marks) {
+        const low = Math.min(mark.less, mark.more);
+        const high = Math.max(mark.less, mark.more);
+        if (high === low + 1) {
+            const row = Math.floor(low / size);
+            const col = low % size;
+            horizontal[row * (size - 1) + col] = mark.less === low ? "<" : ">";
+        }
+        else {
+            vertical[low] = mark.less === low ? "^" : "v";
+        }
+    }
+    return `${encodeCells(cells)}${horizontal.join("")}${vertical.join("")}`;
+}
+export function decodeMoreOrLess(code, size) {
+    const cellsLength = size * size;
+    const horizontalLength = size * (size - 1);
+    const verticalLength = (size - 1) * size;
+    if (typeof code !== "string" || code.length !== cellsLength + horizontalLength + verticalLength)
+        return null;
+    const cells = decodeCells(code.slice(0, cellsLength), size);
+    if (cells === null)
+        return null;
+    const marks = [];
+    const horizontal = code.slice(cellsLength, cellsLength + horizontalLength);
+    for (let i = 0; i < horizontal.length; i += 1) {
+        const row = Math.floor(i / (size - 1));
+        const col = i % (size - 1);
+        const left = row * size + col;
+        if (horizontal[i] === "<")
+            marks.push({ less: left, more: left + 1 });
+        else if (horizontal[i] === ">")
+            marks.push({ less: left + 1, more: left });
+        else if (horizontal[i] !== NO_MARK)
+            return null;
+    }
+    const vertical = code.slice(cellsLength + horizontalLength);
+    for (let i = 0; i < vertical.length; i += 1) {
+        if (vertical[i] === "^")
+            marks.push({ less: i, more: i + size });
+        else if (vertical[i] === "v")
+            marks.push({ less: i + size, more: i });
+        else if (vertical[i] !== NO_MARK)
+            return null;
+    }
+    return { cells, marks };
+}

package/dist/moreOrLessSolve.d.ts

@@ -0,0 +1,45 @@
+import type { Mark } from "./moreOrLessCode.ts";
+/**
+ * The Futoshiki solver (More or Less): counting, the reasoning a person does,
+ * and how deep a guess goes.
+ *
+ * A Latin square with marks: every row and column holds each number once,
+ * and each mark says which of two neighbouring cells is bigger. Candidates
+ * are bitmasks, bit `v` for value `v`, and a mark prunes both ends — the
+ * smaller side can hold nothing at or above the bigger side's largest
+ * candidate, and the other way round.
+ */
+export type Grid = number[];
+/**
+ * How many answers the grid has, up to `limit`.
+ *
+ * Reasoning at every node (`applySingles`), then a branch on the cell with
+ * the fewest candidates. Plain backtracking with the marks checked after
+ * each assignment took twelve seconds to prove a hard 7×7 unique — a Latin
+ * square with few givens has a great many near-answers, and only the marks'
+ * pruning, applied as candidates are narrowed rather than after a value is
+ * placed, cuts them off early.
+ */
+export declare function countSolutions(grid: Grid, size: number, marks: readonly Mark[], limit?: number, first?: (answer: Grid) => void): number;
+/** The one answer the marks allow, or null when they allow none or more than one: see `groupSolve.ts`'s `solutionOf`. */
+export declare function solutionOf(grid: Grid, size: number, marks: readonly Mark[]): Grid | null;
+export type SinglesResult = {
+    grid: Grid;
+    solved: boolean;
+    contradiction: boolean;
+    candidates: number[];
+};
+/**
+ * What a person can see without trying anything: the marks narrowing both
+ * ends, a cell with one candidate, a value with one place in its row or
+ * column. Runs to a fixpoint. Returns a new grid; the input is left alone.
+ */
+export declare function applySingles(grid: Grid, size: number, marks: readonly Mark[]): SinglesResult;
+/**
+ * How many guesses, each followed by every single it lets loose, a solver
+ * needs: 0 when reasoning finishes it, `Infinity` when there is no answer —
+ * or when it needs more than `limit`, which is all a caller asking "is this
+ * within the level" needs to know, and what keeps a hard 7×7 from being
+ * searched to the bottom for an answer nobody asked for.
+ */
+export declare function guessDepth(grid: Grid, size: number, marks: readonly Mark[], limit?: number): number;

package/dist/moreOrLessSolve.js

@@ -0,0 +1,180 @@
+const ALL = (size) => (1 << (size + 1)) - 2;
+function bitCount(mask) {
+    let count = 0;
+    for (let m = mask; m !== 0; m &= m - 1)
+        count += 1;
+    return count;
+}
+function lowestBit(mask) {
+    return 31 - Math.clz32(mask & -mask);
+}
+function highestBit(mask) {
+    return 31 - Math.clz32(mask);
+}
+/** Bits strictly below `value`, and strictly above it. */
+const below = (value) => (1 << value) - 1;
+const above = (value, size) => ALL(size) & ~((1 << (value + 1)) - 1);
+/**
+ * How many answers the grid has, up to `limit`.
+ *
+ * Reasoning at every node (`applySingles`), then a branch on the cell with
+ * the fewest candidates. Plain backtracking with the marks checked after
+ * each assignment took twelve seconds to prove a hard 7×7 unique — a Latin
+ * square with few givens has a great many near-answers, and only the marks'
+ * pruning, applied as candidates are narrowed rather than after a value is
+ * placed, cuts them off early.
+ */
+export function countSolutions(grid, size, marks, limit = 2, first) {
+    let found = 0;
+    const step = (at) => {
+        if (found >= limit)
+            return;
+        const singles = applySingles(at, size, marks);
+        if (singles.contradiction)
+            return;
+        if (singles.solved) {
+            if (found === 0)
+                first?.(singles.grid);
+            found += 1;
+            return;
+        }
+        let best = -1;
+        let bestCount = size + 1;
+        singles.candidates.forEach((mask, index) => {
+            if (singles.grid[index] !== 0)
+                return;
+            const count = bitCount(mask);
+            if (count < bestCount) {
+                best = index;
+                bestCount = count;
+            }
+        });
+        for (let mask = singles.candidates[best]; mask !== 0; mask &= mask - 1) {
+            const next = [...singles.grid];
+            next[best] = lowestBit(mask);
+            step(next);
+            if (found >= limit)
+                return;
+        }
+    };
+    step(grid);
+    return found;
+}
+/** The one answer the marks allow, or null when they allow none or more than one: see `groupSolve.ts`'s `solutionOf`. */
+export function solutionOf(grid, size, marks) {
+    let answer = null;
+    return countSolutions(grid, size, marks, 2, (first) => (answer = [...first])) === 1 ? answer : null;
+}
+/**
+ * What a person can see without trying anything: the marks narrowing both
+ * ends, a cell with one candidate, a value with one place in its row or
+ * column. Runs to a fixpoint. Returns a new grid; the input is left alone.
+ */
+export function applySingles(grid, size, marks) {
+    const work = [...grid];
+    const candidates = work.map((value, index) => {
+        if (value !== 0)
+            return 1 << value;
+        let mask = ALL(size);
+        const row = Math.floor(index / size);
+        const col = index % size;
+        work.forEach((other, at) => {
+            if (other !== 0 && (Math.floor(at / size) === row || at % size === col))
+                mask &= ~(1 << other);
+        });
+        return mask;
+    });
+    const set = (index, value) => {
+        work[index] = value;
+        candidates[index] = 1 << value;
+        const row = Math.floor(index / size);
+        const col = index % size;
+        for (let at = 0; at < work.length; at += 1) {
+            if (at !== index && (Math.floor(at / size) === row || at % size === col))
+                candidates[at] &= ~(1 << value);
+        }
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const mark of marks) {
+            const lessMask = candidates[mark.less] & below(highestBit(candidates[mark.more]));
+            const moreMask = candidates[mark.more] & above(lowestBit(candidates[mark.less]), size);
+            if (lessMask !== candidates[mark.less]) {
+                candidates[mark.less] = lessMask;
+                changed = true;
+            }
+            if (moreMask !== candidates[mark.more]) {
+                candidates[mark.more] = moreMask;
+                changed = true;
+            }
+        }
+        for (let index = 0; index < work.length; index += 1) {
+            if (candidates[index] === 0)
+                return { grid: work, solved: false, contradiction: true, candidates };
+            if (work[index] === 0 && bitCount(candidates[index]) === 1) {
+                set(index, lowestBit(candidates[index]));
+                changed = true;
+            }
+        }
+        for (let unit = 0; unit < size; unit += 1) {
+            for (let value = 1; value <= size; value += 1) {
+                const bit = 1 << value;
+                for (const kind of ["row", "col"]) {
+                    let place = -1;
+                    let places = 0;
+                    for (let k = 0; k < size; k += 1) {
+                        const index = kind === "row" ? unit * size + k : k * size + unit;
+                        if ((candidates[index] & bit) !== 0) {
+                            place = index;
+                            places += 1;
+                        }
+                    }
+                    if (places === 0)
+                        return { grid: work, solved: false, contradiction: true, candidates };
+                    if (places === 1 && work[place] === 0) {
+                        set(place, value);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    return { grid: work, solved: work.every((value) => value !== 0), contradiction: false, candidates };
+}
+/**
+ * How many guesses, each followed by every single it lets loose, a solver
+ * needs: 0 when reasoning finishes it, `Infinity` when there is no answer —
+ * or when it needs more than `limit`, which is all a caller asking "is this
+ * within the level" needs to know, and what keeps a hard 7×7 from being
+ * searched to the bottom for an answer nobody asked for.
+ */
+export function guessDepth(grid, size, marks, limit = Infinity) {
+    const singles = applySingles(grid, size, marks);
+    if (singles.contradiction)
+        return Infinity;
+    if (singles.solved)
+        return 0;
+    if (limit <= 0)
+        return Infinity;
+    let best = -1;
+    let bestCount = size + 1;
+    singles.candidates.forEach((mask, index) => {
+        if (singles.grid[index] !== 0)
+            return;
+        const count = bitCount(mask);
+        if (count < bestCount) {
+            best = index;
+            bestCount = count;
+        }
+    });
+    let deepest = Infinity;
+    for (let mask = singles.candidates[best]; mask !== 0; mask &= mask - 1) {
+        const next = [...singles.grid];
+        next[best] = lowestBit(mask);
+        const depth = guessDepth(next, size, marks, limit - 1);
+        if (depth < deepest)
+            deepest = depth;
+    }
+    return deepest === Infinity ? Infinity : deepest + 1;
+}

package/dist/mount.d.ts

@@ -0,0 +1,117 @@
+import { type KazuGame } from "./game.ts";
+import { type KazuHint } from "./hint.ts";
+import type { KazuKind, KazuLevel } from "./kinds.ts";
+import { type KazuLanguage } from "./strings.ts";
+/**
+ * A PLAYABLE KAZU BOARD IN ANY PAGE: `mountKazu(host, options)` draws a puzzle into an element and plays
+ * it by touch, mouse and keyboard. Tap a cell and tap a number on the pad (or type it); tap the chosen
+ * cell again to step it on, 1, 2, 3 … and back to empty; turn Pencil on and the pad writes small notes
+ * instead; Undo takes the last change back; Hint says which cell to fill next and why; Check says how
+ * many are wrong, never which. A clock starts on the first entry and stops when the last cell is right.
+ *
+ * The keys: the arrows move, a number (1 to 9, and A to G on the 16×16) fills the chosen cell, Shift
+ * with a number writes it as a pencil mark, Backspace empties the cell, N turns Pencil on or off,
+ * Ctrl or Cmd with Z undoes, and Escape lets the cell go.
+ *
+ * What happens is told in events, on the host as DOM events and to the callbacks given: `kazu-change`
+ * for every change to the grid, `kazu-hint` for each hint, `kazu-check` for each check, and `kazu-solve`
+ * once, with the answer ready for `checkKazu`. Every button is also a method of the returned handle.
+ * The rules it plays by are `game.ts`'s, and the drawing is `drawKazu`'s: both are usable alone.
+ *
+ * Needs a page. Its words are English and Japanese and follow the page's `lang`.
+ */
+/** What every event tells of the board. */
+export type KazuEventDetail = {
+    kind: KazuKind;
+    size: number;
+    level?: KazuLevel;
+    seed?: number;
+    /** What the player has written, as a run's code (`decodeRun` brings it back): to keep a puzzle half done. */
+    run: string;
+    /** The pencil marks, as a code (`decodeNotes`). Empty for none. */
+    notes: string;
+    /** The whole grid, printed numbers and the player's: what `checkKazu` takes as an answer. */
+    answer: string;
+    progress: {
+        filled: number;
+        total: number;
+    };
+    /** The time on the clock, in milliseconds. */
+    elapsedMs: number;
+    /** How many hints were taken, and how many times Check was pressed. A solve with any hint is a helped one. */
+    hints: number;
+    checks: number;
+    helped: boolean;
+    solved: boolean;
+    /** For `kazu-hint`: what the hint said. */
+    hint?: KazuHint;
+};
+export type KazuMountOptions = {
+    kind: KazuKind;
+    size: number;
+    /** The puzzle's givens code. */
+    givens: string;
+    /** The puzzle's one answer, as a cells code. Left out, it is worked out from the givens when Hint or Check needs it. */
+    solution?: string;
+    /** Which level and seed made it, to carry in the events. */
+    level?: KazuLevel;
+    seed?: number;
+    /** A run to start from: the entries of a puzzle half done (`decodeRun`'s code). */
+    run?: string;
+    /** Pencil marks to start from (`decodeNotes`'s code). */
+    notes?: string;
+    /** Milliseconds already on the clock, to carry on a puzzle kept half done. */
+    elapsed?: number;
+    /** Show the clock, which starts on the first entry. Default true. */
+    clock?: boolean;
+    /** The number pad and the buttons under the board. Default true. */
+    controls?: boolean;
+    /** What Hint does: `place` writes the number it found (default), `show` only points at the cell and says why, `off` takes the button away. */
+    hints?: "place" | "show" | "off";
+    /** What Check does: `count` says how many cells are wrong (default), `show` marks them too, `off` takes the button away. */
+    check?: "count" | "show" | "off";
+    /** Draw the cells that break a rule in red as they are made. Default true. */
+    conflicts?: boolean;
+    /** Wash the chosen cell's row, column and group, and the cells holding its number. Default true. */
+    peers?: boolean;
+    /** A number written takes itself out of the pencil marks of the cells it shares a group with. Default true. */
+    tidy?: boolean;
+    /** A tap on the chosen cell steps its number on. Default true. */
+    tapToStep?: boolean;
+    /** The language the words are in. Left out, the host's own `lang`, or the page's, and it follows the page's. */
+    language?: KazuLanguage;
+    onChange?: (detail: KazuEventDetail) => void;
+    onHint?: (detail: KazuEventDetail) => void;
+    onCheck?: (detail: KazuEventDetail) => void;
+    onSolve?: (detail: KazuEventDetail) => void;
+};
+/** Everything about how a mounted board plays that can change while it is on the page. */
+export type KazuMountSettings = Pick<KazuMountOptions, "hints" | "check" | "conflicts" | "peers" | "tidy" | "tapToStep" | "language" | "clock" | "controls">;
+export type KazuMount = {
+    readonly host: HTMLElement;
+    /** The game as it stands. */
+    game: () => KazuGame;
+    /** What the events would tell now. */
+    detail: () => KazuEventDetail;
+    /** Play another puzzle (or the same one again, fresh). `run`, `notes` and `elapsed` carry on a kept one. */
+    load: (puzzle: Pick<KazuMountOptions, "kind" | "size" | "givens" | "solution" | "level" | "seed" | "run" | "notes" | "elapsed">) => boolean;
+    /** Change how it plays: hints, check, conflicts, peers, tidy, tapToStep, language, clock, controls. */
+    set: (changes: KazuMountSettings) => void;
+    /** Choose a cell (or none, with null). */
+    select: (cell: number | null) => void;
+    /** Write a number into the chosen cell, or a pencil mark if Pencil is on; 0 empties the cell. */
+    enter: (value: number) => void;
+    /** Turn Pencil on or off. */
+    pencil: (on?: boolean) => void;
+    undo: () => void;
+    hint: () => void;
+    check: () => void;
+    /** Start again: every entry gone and the clock at nothing. */
+    restart: () => void;
+    /** Take the board down: its listeners, its timers and everything it put in the host. */
+    destroy: () => void;
+};
+/** Put the style in the page once: in the document's head, or in the shadow root the host is in. */
+export declare function ensureKazuPlayStyle(host: Element): void;
+/** Draw a puzzle into `host` and play it. Returns the handle that drives it, or null for givens that are not a puzzle of that kind and side. */
+export declare function mountKazu(host: HTMLElement, options: KazuMountOptions): KazuMount | null;