@johnmorrisdotca/kazu 1.0.0

package/dist/names.js

@@ -0,0 +1,163 @@
+export const KAZU_NAMES = {
+    "number-place": {
+        en: "Sudoku",
+        ja: "ナンプレ",
+        alsoKnownAs: ["Number Place", "Nanpure"],
+        tagline: {
+            en: "Fill the grid so every row, column and box holds each number once.",
+            ja: "どの行、列、ブロックにも、同じ数字が一つずつ入るように、盤を埋めます。",
+        },
+        rules: {
+            en: [
+                "Fill every empty cell with a number from 1 up to the side of the grid, so that each row, each column and each box holds every number exactly once.",
+                "The numbers already printed are the givens. They stay where they are, and every puzzle has exactly one answer that fits them.",
+                "The 16×16 Giant has sixteen symbols: 1 to 9, then A to G for 10 to 16.",
+                "Easy yields to reasoning alone: every cell can be found from what is already there. Medium and hard ask you to try something and see.",
+            ],
+            ja: [
+                "空いているマスに、1から盤の一辺の数までの数字を入れます。どの行、列、ブロックにも、同じ数字が一つずつ入ります。",
+                "最初から書かれている数字はそのままです。どの問題も、答えはちょうど一つだけです。",
+                "16×16の「特大」は、1から9までの数字に、10から16までを表すAからGを足した16種類を使います。",
+                "やさしい問題は、推理だけで全部のマスが決まります。ふつうとむずかしい問題では、試してみる場面があります。",
+            ],
+        },
+        origin: {
+            en: "Howard Garns's Number Place, printed by Dell in 1979; Nikoli took it to Japan in 1984 and named it Sudoku.",
+            ja: "1979年にデル社が載せた、ハワード・ガーンズの「ナンバー・プレース」です。1984年にニコリが日本に紹介し、数独と名づけました。",
+        },
+    },
+    jigsaw: {
+        en: "Jigsaw Sudoku",
+        ja: "変形ナンプレ",
+        alsoKnownAs: ["Nonomino", "Irregular Sudoku"],
+        tagline: {
+            en: "Sudoku with the boxes cut into irregular regions.",
+            ja: "ブロックが、いびつな形の領域に変わったナンプレです。",
+        },
+        rules: {
+            en: [
+                "Fill every empty cell with a number from 1 up to the side of the grid, so that each row, each column and each outlined region holds every number exactly once.",
+                "The regions are drawn in heavier lines, and each has as many cells as the grid is wide, in a shape of its own.",
+                "Every puzzle has exactly one answer. Easy yields to reasoning alone.",
+            ],
+            ja: [
+                "空いているマスに、1から盤の一辺の数までの数字を入れます。どの行、列、太線で囲まれた領域にも、同じ数字が一つずつ入ります。",
+                "領域は太い線で描かれ、どれも盤の一辺と同じ数のマスでできていて、形はそれぞれ違います。",
+                "どの問題も、答えはちょうど一つです。やさしい問題は、推理だけで解けます。",
+            ],
+        },
+        origin: {
+            en: "Sudoku with its boxes traded for irregular shapes, printed under names such as Nonomino and Jigsaw Sudoku. With no boxes it is not tied to sides that divide evenly, so it comes at five and seven as well.",
+            ja: "ブロックをいびつな形に置きかえたナンプレで、ノノミノやジグソー数独などの名前で載っています。ブロックがないので、5×5や7×7もあります。",
+        },
+    },
+    diagonal: {
+        en: "Diagonal Sudoku",
+        ja: "対角ナンプレ",
+        alsoKnownAs: ["Sudoku X", "X-Sudoku"],
+        tagline: {
+            en: "Sudoku where the two long diagonals must hold each number once too.",
+            ja: "二本の対角線にも、同じ数字が一つずつ入るナンプレです。",
+        },
+        rules: {
+            en: [
+                "Fill every empty cell with a number from 1 up to the side of the grid, so that each row, each column and each box holds every number exactly once.",
+                "The two long diagonals, shaded corner to corner, must each hold every number exactly once as well.",
+                "Every puzzle has exactly one answer, and the diagonals are part of reaching it: fewer numbers are printed than a plain grid would need.",
+            ],
+            ja: [
+                "空いているマスに、1から盤の一辺の数までの数字を入れます。どの行、列、ブロックにも、同じ数字が一つずつ入ります。",
+                "角から角へ色のついた二本の対角線にも、同じ数字が一つずつ入ります。",
+                "どの問題も、答えはちょうど一つです。対角線も手がかりなので、ふつうの盤より書かれている数字は少なめです。",
+            ],
+        },
+        origin: {
+            en: "The most common extra rule laid on Sudoku: the two diagonals count as groups as well. Newspapers print it as Sudoku X.",
+            ja: "ナンプレにいちばんよく足される決まりで、二本の対角線もグループとして数えます。新聞では「数独X」の名で載っています。",
+        },
+    },
+    "sum-cages": {
+        en: "Killer Sudoku",
+        ja: "サムナンプレ",
+        alsoKnownAs: ["Sumdoku", "Sum Number Place"],
+        tagline: {
+            en: "Sudoku with almost no numbers printed: dashed cages each give the sum of the numbers inside them.",
+            ja: "数字はほとんど書かれていません。点線の囲みごとに、中の数字の合計だけが示されます。",
+        },
+        rules: {
+            en: [
+                "Fill every cell with a number from 1 up to the side of the grid, so that each row, each column and each box holds every number exactly once.",
+                "The dashed outlines are cages. The small number in a cage's corner is the sum of the numbers inside it, and no number appears twice in one cage.",
+                "Almost nothing is printed: the sums are the clues. Every puzzle has exactly one answer, and the harder levels have fewer, bigger cages.",
+            ],
+            ja: [
+                "すべてのマスに、1から盤の一辺の数までの数字を入れます。どの行、列、ブロックにも、同じ数字が一つずつ入ります。",
+                "点線で囲まれた部分が「囲み」です。囲みの角の小さな数字は、中の数字の合計で、同じ数字は一つの囲みに二度入りません。",
+                "ほとんど何も書かれておらず、合計が手がかりです。どの問題も答えはちょうど一つで、むずかしいほど囲みは大きく、数は少なくなります。",
+            ],
+        },
+        origin: {
+            en: "Played in Japan in the 1990s as sum number place, and made famous as Killer Sudoku by The Times in 2005.",
+            ja: "1990年代の日本で「サムナンプレ」として遊ばれ、2005年に英国のタイムズ紙が「キラー数独」として広めました。",
+        },
+    },
+    "more-or-less": {
+        en: "Futoshiki",
+        ja: "不等式",
+        alsoKnownAs: ["Unequal", "Greater Than Sudoku"],
+        tagline: {
+            en: "Fill the square so every row and column holds each number once, and every more-than mark is true.",
+            ja: "どの行と列にも同じ数字が一つずつ入り、不等号がすべて正しくなるように、盤を埋めます。",
+        },
+        rules: {
+            en: [
+                "Fill every cell with a number from 1 up to the side of the square, so that each row and each column holds every number exactly once.",
+                "A mark between two cells says which is the bigger: the open end faces the larger number, the point the smaller.",
+                "Every puzzle has exactly one answer, and every mark and given is needed to reach it.",
+            ],
+            ja: [
+                "すべてのマスに、1から盤の一辺の数までの数字を入れます。どの行にも列にも、同じ数字が一つずつ入ります。",
+                "二つのマスのあいだの印は、どちらが大きいかを示します。開いているほうが大きい数字、とがっているほうが小さい数字です。",
+                "どの問題も、答えはちょうど一つです。書かれている数字と印は、すべて必要なものだけです。",
+            ],
+        },
+        origin: {
+            en: "Futoshiki 不等式, Tamaki Seimiya's puzzle of 2001, which Nikoli published.",
+            ja: "2001年に日本で考案された不等式のパズルで、ニコリが載せました。",
+        },
+    },
+    towers: {
+        en: "Skyscrapers",
+        ja: "摩天楼",
+        alsoKnownAs: ["Towers", "Building Heights"],
+        tagline: {
+            en: "Every number is a tower's height. The clues around the edge say how many towers you can see from there.",
+            ja: "数字は塔の高さです。盤の外の数字は、そこから見える塔の数を表します。",
+        },
+        rules: {
+            en: [
+                "Fill every cell with a tower from 1 up to the side of the square, so that each row and each column holds every height exactly once.",
+                "A number outside the square says how many towers can be seen looking in from there. A taller tower hides every shorter one behind it.",
+                "So a 1 means the tallest tower stands right beside the clue, and a clue as big as the square means the towers climb one step at a time.",
+            ],
+            ja: [
+                "すべてのマスに、1から盤の一辺の数までの高さの塔を置きます。どの行にも列にも、同じ高さが一つずつ入ります。",
+                "盤の外の数字は、そこから中を見たときに見える塔の数です。高い塔は、その後ろの低い塔を隠します。",
+                "つまり、1は一番高い塔がすぐ隣にあること、盤の一辺と同じ数は、塔が一段ずつ高くなることを意味します。",
+            ],
+        },
+        origin: {
+            en: "A Japanese logic puzzle known in English as Skyscrapers, set at the first World Puzzle Championship in 1992; Simon Tatham's puzzle collection calls it Towers.",
+            ja: "英語ではスカイスクレイパーと呼ばれる日本のロジックパズルで、1992年の第1回世界パズル選手権で出題されました。",
+        },
+    },
+};
+/** What each side is for, under its size on a chooser: the quick one, the usual one, the long one. */
+export const KAZU_SIZE_NAMES = {
+    "number-place": { 4: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" }, 16: { en: "Giant", ja: "特大" } },
+    jigsaw: { 5: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 7: { en: "Standard", ja: "定番" }, 9: { en: "Classic", ja: "本格" } },
+    diagonal: { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },
+    "sum-cages": { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },
+    "more-or-less": { 4: { en: "Quick", ja: "速" }, 5: { en: "Standard", ja: "定番" }, 6: { en: "Longer", ja: "長め" }, 7: { en: "Long", ja: "長" } },
+    towers: { 4: { en: "Quick", ja: "速" }, 5: { en: "Standard", ja: "定番" }, 6: { en: "Longer", ja: "長め" }, 7: { en: "Long", ja: "長" } },
+};

package/dist/numberPlace.d.ts

@@ -0,0 +1,14 @@
+import { type Grid } from "./groupSolve.ts";
+import type { KazuLevel, KazuPuzzle } from "./kinds.ts";
+import { type Layout } from "./layout.ts";
+import { type Random } from "./random.ts";
+/**
+ * The givens: the solution with cells taken away in a seeded order, each removal kept only while the
+ * puzzle still has one answer and stays within the level, down to the level's floor. Shared by every
+ * puzzle on a layout (Sudoku, Diagonal and Jigsaw).
+ */
+export declare function carve(solution: Grid, layout: Layout, level: KazuLevel, floor: number, random: Random): Grid;
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+export declare function generateNumberPlace(size: number, level: KazuLevel, seed: number): KazuPuzzle;
+/** A Diagonal Sudoku (Sudoku X): Sudoku with the two long diagonals as groups too. 6 or 9. */
+export declare function generateDiagonal(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/numberPlace.js

@@ -0,0 +1,123 @@
+import { encodeCells } from "./cells.js";
+import { countSolutions, guessDepth } from "./groupSolve.js";
+import { boxedLayout } from "./layout.js";
+import { seededRandom, shuffled } from "./random.js";
+/**
+ * Making a Sudoku (Number Place) puzzle, and its Diagonal variant, from a seed.
+ *
+ * Two steps. Fill a whole grid by backtracking with the values tried in a seeded order, so the seed
+ * decides the grid. Then take cells away in a seeded order, keeping each removal only while the
+ * puzzle still has exactly one answer AND stays within the level: an easy puzzle must go on
+ * yielding to singles, a medium one to a single guess, a hard one to whatever it takes. The
+ * removal stops at the level's floor of givens, so a hard 9×9 does not run every one of its 81
+ * cells past the solver for the sake of two more blanks.
+ *
+ * Everything here is deterministic in the seed. Change this file and every seed makes a different
+ * puzzle, and a solve kept as (kind, size, level, seed) is a different one: `site.fixture.test.ts`
+ * holds every puzzle itsutsu.com made from its seeds, byte for byte.
+ */
+/**
+ * How deep a guess the level allows, and where its removal stops. The floor is a count of givens
+ * left, by side. Below it the solver's answer rarely changes and the time does; above it a 9×9
+ * hard puzzle would be a medium one with a different label.
+ */
+const LEVELS = {
+    easy: { depth: 0, floor: { 4: 9, 6: 20, 9: 40, 16: 150 } },
+    medium: { depth: 1, floor: { 4: 7, 6: 15, 9: 31, 16: 125 } },
+    hard: { depth: Infinity, floor: { 4: 5, 6: 11, 9: 24, 16: 116 } },
+};
+/**
+ * A whole grid, filled cell by cell in reading order with the values tried in a seeded order. The
+ * groups come from the layout, so the diagonals are honoured the same way.
+ */
+function fillInOrder(layout, random) {
+    const { size } = layout;
+    const grid = new Array(size * size).fill(0);
+    const values = Array.from({ length: size }, (_, i) => i + 1);
+    const taken = new Array(layout.groups.length).fill(0);
+    const fill = (index) => {
+        if (index === grid.length)
+            return true;
+        const groups = layout.groupsOf[index];
+        let blocked = 0;
+        for (const group of groups)
+            blocked |= taken[group];
+        for (const value of shuffled(values, random)) {
+            const bit = 1 << value;
+            if (blocked & bit)
+                continue;
+            grid[index] = value;
+            for (const group of groups)
+                taken[group] |= bit;
+            if (fill(index + 1))
+                return true;
+            for (const group of groups)
+                taken[group] &= ~bit;
+            grid[index] = 0;
+        }
+        return false;
+    };
+    fill(0);
+    return grid;
+}
+/**
+ * A FILLED 16×16 FROM A PATTERN, SHUFFLED BY THE SEED. Cell by cell with a random order can wander
+ * into a dead end deep in a 256-cell grid and take seconds to climb out. A grid that is right by
+ * construction (each row the one above it shifted a box's width, each band shifted by one), then
+ * shuffled in every way that keeps it right (the numbers relabelled, rows within a band, the
+ * bands, columns within a stack, the stacks), is as varied and costs nothing. Only 16×16 is made
+ * this way, so every smaller grid comes out of its seed exactly as it always has.
+ */
+function fillByPattern(size, random) {
+    const box = Math.sqrt(size);
+    const labels = shuffled(Array.from({ length: size }, (_, i) => i + 1), random);
+    const order = () => shuffled(Array.from({ length: box }, (_, b) => b), random).flatMap((band) => shuffled(Array.from({ length: box }, (_, r) => band * box + r), random));
+    const rows = order();
+    const cols = order();
+    const base = (r, c) => (box * (r % box) + Math.floor(r / box) + c) % size;
+    return Array.from({ length: size * size }, (_, index) => labels[base(rows[Math.floor(index / size)], cols[index % size])]);
+}
+/**
+ * The givens: the solution with cells taken away in a seeded order, each removal kept only while the
+ * puzzle still has one answer and stays within the level, down to the level's floor. Shared by every
+ * puzzle on a layout (Sudoku, Diagonal and Jigsaw).
+ */
+export function carve(solution, layout, level, floor, random) {
+    const { depth } = LEVELS[level];
+    const givens = [...solution];
+    let left = givens.length;
+    for (const index of shuffled(givens.map((_, i) => i), random)) {
+        if (left <= floor)
+            break;
+        const value = givens[index];
+        givens[index] = 0;
+        const stillOne = countSolutions(givens, layout, 2) === 1 && guessDepth(givens, layout) <= depth;
+        if (stillOne)
+            left -= 1;
+        else
+            givens[index] = value;
+    }
+    return givens;
+}
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+export function generateNumberPlace(size, level, seed) {
+    const random = seededRandom(seed);
+    const layout = boxedLayout(size);
+    const solution = size === 16 ? fillByPattern(size, random) : fillInOrder(layout, random);
+    const givens = carve(solution, layout, level, LEVELS[level].floor[size], random);
+    return { kind: "number-place", size, level, seed, givens: encodeCells(givens), solution: encodeCells(solution) };
+}
+/** Where a Diagonal's removal stops, by level and side: a few below the classic floors, because the extra groups need fewer givens for one answer. */
+const DIAGONAL_FLOOR = {
+    easy: { 6: 16, 9: 34 },
+    medium: { 6: 12, 9: 27 },
+    hard: { 6: 9, 9: 21 },
+};
+/** A Diagonal Sudoku (Sudoku X): Sudoku with the two long diagonals as groups too. 6 or 9. */
+export function generateDiagonal(size, level, seed) {
+    const random = seededRandom(seed);
+    const layout = boxedLayout(size, true);
+    const solution = fillInOrder(layout, random);
+    const givens = carve(solution, layout, level, DIAGONAL_FLOOR[level][size], random);
+    return { kind: "diagonal", size, level, seed, givens: encodeCells(givens), solution: encodeCells(solution) };
+}

package/dist/play-entry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Kazu, played in a page: `mountKazu` draws a puzzle into any element and plays it by touch, mouse and
+ * keyboard, with a number pad, pencil marks, Undo, Hint, Check and a clock, and the words in English and
+ * Japanese. A separate entry (`@johnmorrisdotca/kazu/play`), so a server never loads any of it.
+ */
+export { ensureKazuPlayStyle, mountKazu } from "./mount.ts";
+export type { KazuEventDetail, KazuMount, KazuMountOptions, KazuMountSettings } from "./mount.ts";
+export { KAZU_PLAY_STYLE } from "./playStyle.ts";
+export { kazuClockText } from "./clock.ts";

package/dist/play-entry.js

@@ -0,0 +1,8 @@
+/**
+ * Kazu, played in a page: `mountKazu` draws a puzzle into any element and plays it by touch, mouse and
+ * keyboard, with a number pad, pencil marks, Undo, Hint, Check and a clock, and the words in English and
+ * Japanese. A separate entry (`@johnmorrisdotca/kazu/play`), so a server never loads any of it.
+ */
+export { ensureKazuPlayStyle, mountKazu } from "./mount.js";
+export { KAZU_PLAY_STYLE } from "./playStyle.js";
+export { kazuClockText } from "./clock.js";

package/dist/playStyle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * THE STYLE a playable Kazu board wears (`mountKazu`, `<kazu-board>`): the drawing's own (`KAZU_STYLE`)
+ * and the board's box, its number pad, its buttons and its lines of words. Colours are custom properties
+ * on `.kazu-play` (`--kzp-ink`, `--kzp-muted`, `--kzp-rule`, `--kzp-surface`, `--kzp-accent`,
+ * `--kzp-good`) so a page sets only what it wants different.
+ *
+ * Nothing moves when something is chosen: the board is one square box, the lines of words keep the room
+ * their longest wording takes, and the buttons are one size. Nothing the player touches can be
+ * selected, and no tap on it zooms the page.
+ */
+export declare const KAZU_PLAY_STYLE = "\n.kazu {\n  --kz-paper: #fbf8f1; --kz-ink: #1f2320; --kz-given: #1f2320; --kz-entry: #1d5fa8; --kz-note: #5b6b7d;\n  --kz-grid: #cfc6b2; --kz-box: #3a3d38; --kz-frame: #a98954; --kz-cage: #6a5a8e; --kz-clue: #7a4b14;\n  --kz-diagonal: #e9dfc6; --kz-peer: #efe8d8; --kz-same: #dcd0f2; --kz-select: #ffe08a; --kz-hint: #b9e3c4;\n  --kz-conflict: #f4b8ad; --kz-wrong: #f4b8ad; --kz-bad: #b5452c; --kz-good: #2f7a4f;\n  --kz-font: system-ui, -apple-system, \"Segoe UI\", sans-serif;\n  display: block; width: 100%; height: auto;\n  user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; touch-action: manipulation; -webkit-tap-highlight-color: transparent;\n  overflow: visible;\n}\n@media (prefers-color-scheme: dark) {\n  :root:not([data-theme=\"light\"]) .kazu {\n    --kz-paper: #262a27; --kz-ink: #ece8dc; --kz-given: #ece8dc; --kz-entry: #8fc1ff; --kz-note: #9fb0c2;\n    --kz-grid: #454a44; --kz-box: #c9c5b8; --kz-frame: #6b5632; --kz-cage: #b8a5e6; --kz-clue: #e8c48f;\n    --kz-diagonal: #34382f; --kz-peer: #2f332f; --kz-same: #433a5c; --kz-select: #6b5a1f; --kz-hint: #25503a;\n    --kz-conflict: #6e2f26; --kz-wrong: #6e2f26; --kz-bad: #ff8a6b; --kz-good: #6fcf97;\n  }\n}\n:root[data-theme=\"dark\"] .kazu {\n  --kz-paper: #262a27; --kz-ink: #ece8dc; --kz-given: #ece8dc; --kz-entry: #8fc1ff; --kz-note: #9fb0c2;\n  --kz-grid: #454a44; --kz-box: #c9c5b8; --kz-frame: #6b5632; --kz-cage: #b8a5e6; --kz-clue: #e8c48f;\n  --kz-diagonal: #34382f; --kz-peer: #2f332f; --kz-same: #433a5c; --kz-select: #6b5a1f; --kz-hint: #25503a;\n  --kz-conflict: #6e2f26; --kz-wrong: #6e2f26; --kz-bad: #ff8a6b; --kz-good: #6fcf97;\n}\n.kazu * { user-select: none; -webkit-user-select: none; }\n.kazu .kz-frame { fill: var(--kz-frame); }\n.kazu .kz-paper { fill: var(--kz-paper); }\n.kazu .kz-diagonal { fill: var(--kz-diagonal); }\n.kazu .kz-peer { fill: var(--kz-peer); }\n.kazu .kz-same { fill: var(--kz-same); }\n.kazu .kz-select { fill: var(--kz-select); }\n.kazu .kz-hint { fill: var(--kz-hint); }\n.kazu .kz-conflict, .kazu .kz-wrong { fill: var(--kz-conflict); }\n.kazu .kz-solved { fill: var(--kz-good); opacity: .14; pointer-events: none; }\n.kazu .kz-grid { fill: none; stroke: var(--kz-grid); stroke-width: 1px; vector-effect: non-scaling-stroke; }\n.kazu .kz-box { fill: none; stroke: var(--kz-box); stroke-width: 2.5px; stroke-linecap: square; vector-effect: non-scaling-stroke; }\n.kazu .kz-cage { stroke: var(--kz-cage); stroke-width: 1.5px; stroke-dasharray: 4 3; vector-effect: non-scaling-stroke; }\n.kazu .kz-digit { font-family: var(--kz-font); font-weight: 600; text-anchor: middle; dominant-baseline: central; font-variant-numeric: tabular-nums; pointer-events: none; }\n.kazu .kz-given { fill: var(--kz-given); font-weight: 700; }\n.kazu .kz-entry { fill: var(--kz-entry); }\n.kazu .kz-digit.kz-bad { fill: var(--kz-bad); }\n.kazu .kz-note { font-family: var(--kz-font); font-weight: 600; fill: var(--kz-note); text-anchor: middle; dominant-baseline: central; pointer-events: none; }\n.kazu .kz-cage-sum { font-family: var(--kz-font); font-weight: 600; fill: var(--kz-cage); text-anchor: start; dominant-baseline: hanging; pointer-events: none; }\n.kazu .kz-clue { font-family: var(--kz-font); font-weight: 700; fill: var(--kz-clue); text-anchor: middle; dominant-baseline: central; pointer-events: none; }\n.kazu .kz-mark-bg { fill: var(--kz-paper); stroke: none; pointer-events: none; }\n.kazu .kz-mark { fill: none; stroke: var(--kz-ink); stroke-width: 2px; stroke-linecap: round; stroke-linejoin: round; vector-effect: non-scaling-stroke; pointer-events: none; }\n.kazu .kz-hit { fill: transparent; cursor: pointer; }\n\n.kazu-play {\n  --kzp-ink: #1f2320; --kzp-muted: #6b6f68; --kzp-rule: #ddd6c6; --kzp-surface: #fbf8f1; --kzp-accent: #b5452c; --kzp-good: #2f7a4f;\n  display: block; max-width: 100%; box-sizing: border-box; color: var(--kzp-ink); font-family: system-ui, -apple-system, \"Segoe UI\", sans-serif;\n  user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; -webkit-tap-highlight-color: transparent;\n}\n@media (prefers-color-scheme: dark) {\n  :root:not([data-theme=\"light\"]) .kazu-play { --kzp-ink: #ece8dc; --kzp-muted: #a09d93; --kzp-rule: #3a3d38; --kzp-surface: #1d201e; --kzp-accent: #ff8a6b; --kzp-good: #6fcf97; }\n}\n:root[data-theme=\"dark\"] .kazu-play { --kzp-ink: #ece8dc; --kzp-muted: #a09d93; --kzp-rule: #3a3d38; --kzp-surface: #1d201e; --kzp-accent: #ff8a6b; --kzp-good: #6fcf97; }\n.kazu-play *, .kazu-play *::before, .kazu-play *::after { box-sizing: border-box; }\n.kazu-play .kzp-bar { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; margin: 0 0 8px; min-height: 1.5em; font-variant-numeric: tabular-nums; }\n.kazu-play .kzp-clock { font-weight: 700; font-size: 1.05rem; min-width: 4.5ch; }\n.kazu-play .kzp-progress { color: var(--kzp-muted); font-size: .85rem; }\n.kazu-play .kzp-box { position: relative; width: 100%; aspect-ratio: 1; overflow: hidden; touch-action: manipulation; user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; cursor: pointer; border-radius: 8px; }\n.kazu-play .kzp-box:focus-visible { outline: 3px solid var(--kzp-accent); outline-offset: 2px; }\n.kazu-play .kzp-box[data-over=\"true\"] { cursor: default; }\n.kazu-play .kzp-inner { position: absolute; inset: 0; }\n.kazu-play .kzp-inner .kazu { position: absolute; inset: 0; width: 100%; height: 100%; }\n.kazu-play .kzp-pad { display: grid; grid-template-columns: repeat(var(--kzp-columns, 5), minmax(0, 1fr)); gap: 6px; margin-top: 10px; }\n.kazu-play .kzp-controls { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-top: 10px; }\n.kazu-play [hidden] { display: none !important; }\n.kazu-play button { font: inherit; color: inherit; user-select: none; -webkit-user-select: none; touch-action: manipulation; }\n.kazu-play .kzp-key, .kazu-play .kzp-button { border: 1px solid var(--kzp-rule); background: var(--kzp-surface); color: var(--kzp-ink); border-radius: 12px; min-height: 44px; min-width: 44px; padding: 0 12px; font-size: 1.05rem; font-weight: 700; display: inline-flex; align-items: center; justify-content: center; gap: 6px; cursor: pointer; }\n.kazu-play .kzp-button { border-radius: 999px; font-size: .85rem; font-weight: 600; }\n.kazu-play .kzp-key:hover:not(:disabled), .kazu-play .kzp-button:hover:not(:disabled) { border-color: var(--kzp-ink); }\n.kazu-play .kzp-key:disabled, .kazu-play .kzp-button:disabled { opacity: .32; cursor: default; }\n.kazu-play .kzp-key[data-done=\"true\"] { opacity: .4; }\n.kazu-play .kzp-key[data-erase=\"true\"] { color: var(--kzp-muted); }\n.kazu-play .kzp-button[aria-pressed=\"true\"] { background: var(--kzp-ink); color: var(--kzp-surface); border-color: var(--kzp-ink); }\n.kazu-play .kzp-key:focus-visible, .kazu-play .kzp-button:focus-visible { outline: 3px solid var(--kzp-accent); outline-offset: 2px; }\n.kazu-play .kzp-says { margin: 10px 0 0; min-height: 3.9em; font-size: .85rem; line-height: 1.4; color: var(--kzp-muted); }\n.kazu-play .kzp-says[data-warn=\"true\"] { color: var(--kzp-accent); font-weight: 600; }\n.kazu-play[data-solved=\"true\"] .kzp-says, .kazu-play[data-solved=\"true\"] .kzp-clock { color: var(--kzp-good); font-weight: 600; }\n.kazu-play .kzp-sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }\n";

package/dist/playStyle.js

@@ -0,0 +1,47 @@
+import { KAZU_STYLE } from "./style.js";
+/**
+ * THE STYLE a playable Kazu board wears (`mountKazu`, `<kazu-board>`): the drawing's own (`KAZU_STYLE`)
+ * and the board's box, its number pad, its buttons and its lines of words. Colours are custom properties
+ * on `.kazu-play` (`--kzp-ink`, `--kzp-muted`, `--kzp-rule`, `--kzp-surface`, `--kzp-accent`,
+ * `--kzp-good`) so a page sets only what it wants different.
+ *
+ * Nothing moves when something is chosen: the board is one square box, the lines of words keep the room
+ * their longest wording takes, and the buttons are one size. Nothing the player touches can be
+ * selected, and no tap on it zooms the page.
+ */
+export const KAZU_PLAY_STYLE = `${KAZU_STYLE}
+.kazu-play {
+  --kzp-ink: #1f2320; --kzp-muted: #6b6f68; --kzp-rule: #ddd6c6; --kzp-surface: #fbf8f1; --kzp-accent: #b5452c; --kzp-good: #2f7a4f;
+  display: block; max-width: 100%; box-sizing: border-box; color: var(--kzp-ink); font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
+  user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; -webkit-tap-highlight-color: transparent;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) .kazu-play { --kzp-ink: #ece8dc; --kzp-muted: #a09d93; --kzp-rule: #3a3d38; --kzp-surface: #1d201e; --kzp-accent: #ff8a6b; --kzp-good: #6fcf97; }
+}
+:root[data-theme="dark"] .kazu-play { --kzp-ink: #ece8dc; --kzp-muted: #a09d93; --kzp-rule: #3a3d38; --kzp-surface: #1d201e; --kzp-accent: #ff8a6b; --kzp-good: #6fcf97; }
+.kazu-play *, .kazu-play *::before, .kazu-play *::after { box-sizing: border-box; }
+.kazu-play .kzp-bar { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; margin: 0 0 8px; min-height: 1.5em; font-variant-numeric: tabular-nums; }
+.kazu-play .kzp-clock { font-weight: 700; font-size: 1.05rem; min-width: 4.5ch; }
+.kazu-play .kzp-progress { color: var(--kzp-muted); font-size: .85rem; }
+.kazu-play .kzp-box { position: relative; width: 100%; aspect-ratio: 1; overflow: hidden; touch-action: manipulation; user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; cursor: pointer; border-radius: 8px; }
+.kazu-play .kzp-box:focus-visible { outline: 3px solid var(--kzp-accent); outline-offset: 2px; }
+.kazu-play .kzp-box[data-over="true"] { cursor: default; }
+.kazu-play .kzp-inner { position: absolute; inset: 0; }
+.kazu-play .kzp-inner .kazu { position: absolute; inset: 0; width: 100%; height: 100%; }
+.kazu-play .kzp-pad { display: grid; grid-template-columns: repeat(var(--kzp-columns, 5), minmax(0, 1fr)); gap: 6px; margin-top: 10px; }
+.kazu-play .kzp-controls { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-top: 10px; }
+.kazu-play [hidden] { display: none !important; }
+.kazu-play button { font: inherit; color: inherit; user-select: none; -webkit-user-select: none; touch-action: manipulation; }
+.kazu-play .kzp-key, .kazu-play .kzp-button { border: 1px solid var(--kzp-rule); background: var(--kzp-surface); color: var(--kzp-ink); border-radius: 12px; min-height: 44px; min-width: 44px; padding: 0 12px; font-size: 1.05rem; font-weight: 700; display: inline-flex; align-items: center; justify-content: center; gap: 6px; cursor: pointer; }
+.kazu-play .kzp-button { border-radius: 999px; font-size: .85rem; font-weight: 600; }
+.kazu-play .kzp-key:hover:not(:disabled), .kazu-play .kzp-button:hover:not(:disabled) { border-color: var(--kzp-ink); }
+.kazu-play .kzp-key:disabled, .kazu-play .kzp-button:disabled { opacity: .32; cursor: default; }
+.kazu-play .kzp-key[data-done="true"] { opacity: .4; }
+.kazu-play .kzp-key[data-erase="true"] { color: var(--kzp-muted); }
+.kazu-play .kzp-button[aria-pressed="true"] { background: var(--kzp-ink); color: var(--kzp-surface); border-color: var(--kzp-ink); }
+.kazu-play .kzp-key:focus-visible, .kazu-play .kzp-button:focus-visible { outline: 3px solid var(--kzp-accent); outline-offset: 2px; }
+.kazu-play .kzp-says { margin: 10px 0 0; min-height: 3.9em; font-size: .85rem; line-height: 1.4; color: var(--kzp-muted); }
+.kazu-play .kzp-says[data-warn="true"] { color: var(--kzp-accent); font-weight: 600; }
+.kazu-play[data-solved="true"] .kzp-says, .kazu-play[data-solved="true"] .kzp-clock { color: var(--kzp-good); font-weight: 600; }
+.kazu-play .kzp-sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
+`;

package/dist/progress.d.ts

@@ -0,0 +1,29 @@
+/**
+ * WHAT HAS BEEN WRITTEN ON AN UNFINISHED PUZZLE, as strings a page can keep and bring back.
+ *
+ * A run is the player's entries the way a puzzle's cells are written (`cells.ts`): one character a
+ * cell, the printed cells left empty. These are the spellings itsutsu.com keeps (`PuzzleRun.progress`
+ * and its step log), and they read here unchanged. Pencil marks are Kazu's own and ride beside a run
+ * as a second string.
+ */
+/** The entries of a run as its code. */
+export declare function encodeRun(entries: readonly number[]): string;
+/** The entries a run's code says, or null for a code that is not a run of this side. */
+export declare function decodeRun(code: string, size: number): number[] | null;
+/** Every value of a pencil-mark mask, smallest first. */
+export declare function notesOf(mask: number): number[];
+/** Pencil marks as a code: for each cell that has any, its index in base 36 (two characters) and its marks as one number in base 36 (four characters); nothing at all for a grid with none. */
+export declare function encodeNotes(notes: readonly number[]): string;
+/** The pencil marks a code says (each cell a bit mask, bit `v` for the number `v`), or null for a code that is not one for a grid of this side. */
+export declare function decodeNotes(code: string, size: number): number[] | null;
+/** How many grids a step log keeps: the newest, so a long puzzle's log has a ceiling. */
+export declare const KAZU_STEPS_KEPT = 400;
+/**
+ * THE STEPS OF A PUZZLE, written down so a scrubber has them when the puzzle is picked up again. Every
+ * step is a grid in a run's code. The first is written whole; each after it as the cells that changed
+ * (a cell's place in base 36, two characters, and its new character), the steps parted by "~", which
+ * no run uses. A long puzzle's log is a few hundred characters, not a grid per step.
+ */
+export declare function encodeSteps(codes: readonly string[]): string;
+/** The grids a step log holds, each `cells` characters long, or null for a log that does not read as one. */
+export declare function decodeSteps(log: string, cells: number): string[] | null;

package/dist/progress.js

@@ -0,0 +1,96 @@
+import { decodeCells, encodeCells } from "./cells.js";
+/**
+ * WHAT HAS BEEN WRITTEN ON AN UNFINISHED PUZZLE, as strings a page can keep and bring back.
+ *
+ * A run is the player's entries the way a puzzle's cells are written (`cells.ts`): one character a
+ * cell, the printed cells left empty. These are the spellings itsutsu.com keeps (`PuzzleRun.progress`
+ * and its step log), and they read here unchanged. Pencil marks are Kazu's own and ride beside a run
+ * as a second string.
+ */
+/** The entries of a run as its code. */
+export function encodeRun(entries) {
+    return encodeCells(entries);
+}
+/** The entries a run's code says, or null for a code that is not a run of this side. */
+export function decodeRun(code, size) {
+    return code.length === size * size ? decodeCells(code, size) : null;
+}
+/** Every value of a pencil-mark mask, smallest first. */
+export function notesOf(mask) {
+    const out = [];
+    for (let value = 1; mask >>> value !== 0; value += 1)
+        if ((mask >>> value) & 1)
+            out.push(value);
+    return out;
+}
+/** Pencil marks as a code: for each cell that has any, its index in base 36 (two characters) and its marks as one number in base 36 (four characters); nothing at all for a grid with none. */
+export function encodeNotes(notes) {
+    let code = "";
+    notes.forEach((mask, index) => {
+        if (mask !== 0)
+            code += index.toString(36).padStart(2, "0") + (mask >>> 1).toString(36).padStart(4, "0");
+    });
+    return code;
+}
+/** The pencil marks a code says (each cell a bit mask, bit `v` for the number `v`), or null for a code that is not one for a grid of this side. */
+export function decodeNotes(code, size) {
+    if (code.length % 6 !== 0)
+        return null;
+    const notes = new Array(size * size).fill(0);
+    for (let at = 0; at < code.length; at += 6) {
+        const index = Number.parseInt(code.slice(at, at + 2), 36);
+        const bits = Number.parseInt(code.slice(at + 2, at + 6), 36);
+        if (!Number.isInteger(index) || index < 0 || index >= size * size || !Number.isInteger(bits) || bits <= 0 || bits >= 2 ** size)
+            return null;
+        notes[index] = bits << 1;
+    }
+    return notes;
+}
+/** How many grids a step log keeps: the newest, so a long puzzle's log has a ceiling. */
+export const KAZU_STEPS_KEPT = 400;
+const PARTED = "~";
+/**
+ * THE STEPS OF A PUZZLE, written down so a scrubber has them when the puzzle is picked up again. Every
+ * step is a grid in a run's code. The first is written whole; each after it as the cells that changed
+ * (a cell's place in base 36, two characters, and its new character), the steps parted by "~", which
+ * no run uses. A long puzzle's log is a few hundred characters, not a grid per step.
+ */
+export function encodeSteps(codes) {
+    const kept = codes.slice(-KAZU_STEPS_KEPT);
+    if (kept.length === 0)
+        return "";
+    const parts = [kept[0]];
+    for (let at = 1; at < kept.length; at += 1) {
+        const before = kept[at - 1];
+        const after = kept[at];
+        let changed = "";
+        for (let cell = 0; cell < after.length; cell += 1) {
+            if (after[cell] !== before[cell])
+                changed += cell.toString(36).padStart(2, "0") + after[cell];
+        }
+        parts.push(changed);
+    }
+    return parts.join(PARTED);
+}
+/** The grids a step log holds, each `cells` characters long, or null for a log that does not read as one. */
+export function decodeSteps(log, cells) {
+    if (log === "")
+        return null;
+    const [first, ...changes] = log.split(PARTED);
+    if (first === undefined || first.length !== cells || changes.length >= KAZU_STEPS_KEPT)
+        return null;
+    const codes = [first];
+    for (const change of changes) {
+        if (change.length % 3 !== 0)
+            return null;
+        const grid = [...codes.at(-1)];
+        for (let at = 0; at < change.length; at += 3) {
+            const cell = Number.parseInt(change.slice(at, at + 2), 36);
+            if (!Number.isInteger(cell) || cell < 0 || cell >= cells)
+                return null;
+            grid[cell] = change[at + 2];
+        }
+        codes.push(grid.join(""));
+    }
+    return codes;
+}

package/dist/random.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SEEDED RANDOMNESS, the one thing every puzzle is made from.
+ *
+ * mulberry32 (Tommy Ettinger, 2017): one 32-bit word of state, a few multiplies
+ * a draw, the same stream for the same seed in every browser and every Node. It
+ * decides every shuffle, so it must never change: a solve kept as its kind, size,
+ * level and seed is made again from them, and a changed stream would hand somebody
+ * a different puzzle from the one they were playing. It is the same stream
+ * `@johnmorrisdotca/tane` draws, written out here so this package depends on
+ * nothing; `site.fixture.test.ts` pins every puzzle the site made from it.
+ *
+ * Not a credential: it is for fair-looking puzzles, never for secrets.
+ */
+/** A number in [0, 1), like `Math.random`, from a stream a seed fixes. */
+export type Random = () => number;
+/** A stream of numbers in [0, 1) fixed by a seed. The seed is read as an unsigned 32-bit integer. */
+export declare function seededRandom(seed: number): Random;
+/** A copy of the list in a random order (Fisher–Yates, from the end); the list given is left alone. */
+export declare function shuffled<T>(items: readonly T[], random: Random): T[];
+/** The most a seed can be: a whole number from 1 to 2³¹ − 1, so it travels in an address as a plain integer. */
+export declare const KAZU_SEED_MOST: number;
+/** Whether a value is a seed this package takes: a whole number from 1 to `KAZU_SEED_MOST`. */
+export declare function isKazuSeed(value: unknown): value is number;
+/** A new seed, from `Math.random` or the stream given: anywhere in the range. */
+export declare function freshKazuSeed(random?: Random): number;

package/dist/random.js

@@ -0,0 +1,42 @@
+/**
+ * SEEDED RANDOMNESS, the one thing every puzzle is made from.
+ *
+ * mulberry32 (Tommy Ettinger, 2017): one 32-bit word of state, a few multiplies
+ * a draw, the same stream for the same seed in every browser and every Node. It
+ * decides every shuffle, so it must never change: a solve kept as its kind, size,
+ * level and seed is made again from them, and a changed stream would hand somebody
+ * a different puzzle from the one they were playing. It is the same stream
+ * `@johnmorrisdotca/tane` draws, written out here so this package depends on
+ * nothing; `site.fixture.test.ts` pins every puzzle the site made from it.
+ *
+ * Not a credential: it is for fair-looking puzzles, never for secrets.
+ */
+/** A stream of numbers in [0, 1) fixed by a seed. The seed is read as an unsigned 32-bit integer. */
+export function seededRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(state ^ (state >>> 15), state | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** A copy of the list in a random order (Fisher–Yates, from the end); the list given is left alone. */
+export function shuffled(items, random) {
+    const out = [...items];
+    for (let i = out.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(random() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+/** The most a seed can be: a whole number from 1 to 2³¹ − 1, so it travels in an address as a plain integer. */
+export const KAZU_SEED_MOST = 2 ** 31 - 1;
+/** Whether a value is a seed this package takes: a whole number from 1 to `KAZU_SEED_MOST`. */
+export function isKazuSeed(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= KAZU_SEED_MOST;
+}
+/** A new seed, from `Math.random` or the stream given: anywhere in the range. */
+export function freshKazuSeed(random = Math.random) {
+    return 1 + Math.floor(random() * KAZU_SEED_MOST);
+}

package/dist/solve.d.ts

@@ -0,0 +1,22 @@
+import type { KazuKind } from "./kinds.ts";
+/**
+ * How many answers a puzzle has, up to `limit` (two by default, so "many" costs no more than "two"):
+ * 1 is a puzzle, 0 is a grid that cannot be finished, 2 is a guessing game. Null, never a number,
+ * for givens that are not a puzzle of this kind and side, and for a search that ran past `budget`
+ * steps (Sudoku, Jigsaw, Diagonal and Sum Cages count steps; the other two have no budget): "I
+ * could not say" is not "there are none".
+ */
+export declare function countKazuSolutions(kind: KazuKind, size: number, givens: string, limit?: number, budget?: number): number | null;
+/**
+ * The one answer a puzzle's givens allow, as a cells code, or null when they allow none, more than
+ * one, or the search ran past `budget` steps (Sudoku, Jigsaw, Diagonal and Sum Cages). A grid this
+ * cannot vouch for is never handed back as though it were the answer.
+ */
+export declare function solveKazu(kind: KazuKind, size: number, givens: string, budget?: number): string | null;
+/**
+ * How many guesses, each followed by everything reasoning then finds, a person needs to finish the
+ * puzzle: 0 when reasoning alone finishes it (easy), 1 when one guess does (medium), more when more
+ * (hard); Infinity when there is no answer. Null for givens that are not a puzzle. Meant for a
+ * puzzle already known to have exactly one answer.
+ */
+export declare function kazuGuessDepth(kind: KazuKind, size: number, givens: string): number | null;