@johnmorrisdotca/kazu 1.0.0

package/dist/solve.js

@@ -0,0 +1,60 @@
+import { encodeCells } from "./cells.js";
+import { countSolutionsWithin, guessDepth as groupDepth, solutionOf as groupSolution } from "./groupSolve.js";
+import { layoutOfGivens, readGivens } from "./givens.js";
+import { countSolutions as countMarks, guessDepth as marksDepth, solutionOf as marksSolution } from "./moreOrLessSolve.js";
+import { countSolutions as countClues, guessDepth as cluesDepth, solutionOf as cluesSolution } from "./towersSolve.js";
+/**
+ * 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 function countKazuSolutions(kind, size, givens, limit = 2, budget = Infinity) {
+    const read = readGivens(kind, size, givens);
+    if (read === null)
+        return null;
+    if (kind === "more-or-less")
+        return countMarks(read.cells, size, read.marks, limit);
+    if (kind === "towers")
+        return countClues(read.cells, size, read.clues, limit);
+    const layout = layoutOfGivens(read);
+    return layout === null ? null : countSolutionsWithin(read.cells, layout, limit, budget);
+}
+/**
+ * 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 function solveKazu(kind, size, givens, budget = 2000000) {
+    const read = readGivens(kind, size, givens);
+    if (read === null)
+        return null;
+    let grid;
+    if (kind === "more-or-less")
+        grid = marksSolution(read.cells, size, read.marks);
+    else if (kind === "towers")
+        grid = cluesSolution(read.cells, size, read.clues);
+    else {
+        const layout = layoutOfGivens(read);
+        grid = layout === null ? null : groupSolution(read.cells, layout, budget);
+    }
+    return grid === null ? null : encodeCells(grid);
+}
+/**
+ * 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 function kazuGuessDepth(kind, size, givens) {
+    const read = readGivens(kind, size, givens);
+    if (read === null)
+        return null;
+    if (kind === "more-or-less")
+        return marksDepth(read.cells, size, read.marks);
+    if (kind === "towers")
+        return cluesDepth(read.cells, size, read.clues);
+    const layout = layoutOfGivens(read);
+    return layout === null ? null : groupDepth(read.cells, layout);
+}

package/dist/strings.d.ts

@@ -0,0 +1,17 @@
+import type { KazuKind } from "./kinds.ts";
+/**
+ * THE WORDS A KAZU BOARD SAYS, in English and Japanese: what a screen reader hears of the drawing, the
+ * buttons and lines under a playable board, and what a hint says. Plain data, so a page can read them,
+ * replace a few or add a language of its own beside these two.
+ *
+ * `{name}` in a line is a value filled in; a line `foo` that has a `fooOne` beside it is said as
+ * `fooOne` when its `{n}` is 1.
+ */
+export type KazuLanguage = "en" | "ja";
+export declare const KAZU_STRINGS: Record<KazuLanguage, Record<string, string>>;
+/** A line in a language, with its values filled in; the line itself if there is none by that name. */
+export declare function kazuSay(language: KazuLanguage, key: string, values?: Record<string, string | number>): string;
+/** The language a piece of text is in: Japanese for anything starting `ja`, English for everything else. */
+export declare function kazuLanguageOf(tag: string | null | undefined): KazuLanguage;
+/** What a puzzle is called in a language, as a screen reader says it. */
+export declare function kazuNameOf(kind: KazuKind, language: KazuLanguage): string;

package/dist/strings.js

@@ -0,0 +1,143 @@
+import { KAZU_NAMES } from "./names.js";
+export const KAZU_STRINGS = {
+    en: {
+        board: "{name} puzzle, {size} by {size}",
+        cell: "row {row}, column {col}",
+        cellEmpty: "{cell}, empty",
+        cellValue: "{cell}, {value}",
+        cellGiven: "{cell}, {value}, printed",
+        cellNotes: "{cell}, empty, pencil marks {notes}",
+        cellConflict: "{cell}, {value}, breaks a rule",
+        cageSum: "a cage adding to {sum}",
+        clueTop: "Towers seen from the top of column {at}: {n}",
+        clueBottom: "Towers seen from the bottom of column {at}: {n}",
+        clueLeft: "Towers seen from the left of row {at}: {n}",
+        clueRight: "Towers seen from the right of row {at}: {n}",
+        markLess: "{a} is smaller than {b}",
+        solved: "Solved. Every cell is filled and right.",
+        solvedIn: "Solved in {time}. Every cell is filled and right.",
+        tap: "Tap a cell, then a number.",
+        tapPencil: "Pencil marks are on: tap a number to note it in the cell.",
+        keys: "Arrow keys move, a number fills the cell, Backspace empties it, N turns pencil marks on or off.",
+        undo: "Undo",
+        pencil: "Pencil",
+        pencilTitle: "Write small notes in a cell instead of a number",
+        erase: "Erase the cell",
+        hint: "Hint",
+        hintTitle: "Show the next cell you could fill in, and why",
+        check: "Check",
+        checkTitle: "Say how many cells are wrong, without saying which",
+        restart: "Restart",
+        clock: "Time",
+        pad: "Numbers",
+        padNumber: "Number {n}",
+        padDone: "Number {n}, all placed",
+        full: "Every cell is filled, and it is not right yet.",
+        checkRight: "Everything filled in so far is right.",
+        checkWrong: "{wrong} cells are wrong, {empty} still to fill.",
+        checkWrongOne: "{wrong} cell is wrong, {empty} still to fill.",
+        checkWrongNoneEmpty: "{wrong} cells are wrong.",
+        checkWrongNoneEmptyOne: "{wrong} cell is wrong.",
+        checkOnlyEmpty: "Nothing wrong so far, {empty} still to fill.",
+        conflicts: "{n} cells break a rule.",
+        conflictsOne: "{n} cell breaks a rule.",
+        hintOnly: "{cell} can only be {value}: every other number is ruled out by {where}.",
+        hintOnlyBy: "{cell} can only be {value}: every other number is ruled out by {where} and {by}.",
+        hintPlace: "In {group}, the {value} can only go in {cell}: no other cell there can hold it.",
+        hintAnswer: "{cell} is {value}. Nothing here follows from a single step, so this is the answer's own number.",
+        hintReplaces: "What is in {cell} now is wrong. ",
+        hintDone: "Every cell is right.",
+        whereNumberPlace: "its row, column and box",
+        whereDiagonal: "its row, column, box and diagonal",
+        whereJigsaw: "its row, column and region",
+        whereSumCages: "its row, column, box and cage",
+        whereMoreOrLess: "its row and column",
+        whereTowers: "its row and column",
+        byCage: "the cage's sum",
+        byMarks: "the more-than marks",
+        byClues: "the clues round the edge",
+        groupRow: "row {n}",
+        groupColumn: "column {n}",
+        groupBox: "box {n}",
+        groupRegion: "region {n}",
+        groupDiagonal: "the diagonal from the top left",
+        groupDiagonalOther: "the diagonal from the top right",
+        paused: "Paused",
+    },
+    ja: {
+        board: "{name}、{size}×{size}",
+        cell: "{row}行{col}列",
+        cellEmpty: "{cell}、空き",
+        cellValue: "{cell}、{value}",
+        cellGiven: "{cell}、{value}、最初から書かれています",
+        cellNotes: "{cell}、空き、メモ{notes}",
+        cellConflict: "{cell}、{value}、ルールに反しています",
+        cageSum: "合計{sum}の囲み",
+        clueTop: "第{at}列の上から見える塔の数：{n}",
+        clueBottom: "第{at}列の下から見える塔の数：{n}",
+        clueLeft: "第{at}行の左から見える塔の数：{n}",
+        clueRight: "第{at}行の右から見える塔の数：{n}",
+        markLess: "{a}は{b}より小さい",
+        solved: "解けました。すべてのマスが埋まり、すべて正しい数字です。",
+        solvedIn: "{time}で解けました。すべてのマスが埋まり、すべて正しい数字です。",
+        tap: "マスをタップして、数字を選びます。",
+        tapPencil: "メモがオンです。数字をタップすると、マスにメモします。",
+        keys: "矢印キーで移動、数字キーで入力、Backspaceで消去、Nでメモのオンとオフ。",
+        undo: "元に戻す",
+        pencil: "メモ",
+        pencilTitle: "数字のかわりに、マスに小さくメモを書きます",
+        erase: "このマスを消す",
+        hint: "ヒント",
+        hintTitle: "次に入れられるマスと、その理由を表示します",
+        check: "確かめる",
+        checkTitle: "まちがっているマスの数だけを教えます（どこかは教えません）",
+        restart: "やり直す",
+        clock: "時間",
+        pad: "数字",
+        padNumber: "数字{n}",
+        padDone: "数字{n}、すべて置きました",
+        full: "すべてのマスが埋まりましたが、まだ正しくありません。",
+        checkRight: "ここまでに入れた数字は、すべて正しいです。",
+        checkWrong: "まちがいが{wrong}マス、まだ空きが{empty}マスあります。",
+        checkWrongNoneEmpty: "まちがいが{wrong}マスあります。",
+        checkOnlyEmpty: "いまのところまちがいはなく、空きが{empty}マスあります。",
+        conflicts: "ルールに反するマスが{n}マスあります。",
+        hintOnly: "{cell}は{value}しか入りません。ほかの数字は、{where}で入れないからです。",
+        hintOnlyBy: "{cell}は{value}しか入りません。ほかの数字は、{where}と{by}で入れないからです。",
+        hintPlace: "{group}で、{value}を入れられるのは{cell}だけです。ほかのマスには入りません。",
+        hintAnswer: "{cell}は{value}です。ここは一手で決まるところがないので、答えの数字をそのまま示しています。",
+        hintReplaces: "いま{cell}に入っている数字はまちがいです。",
+        hintDone: "すべてのマスが正しいです。",
+        whereNumberPlace: "同じ行、列、ブロック",
+        whereDiagonal: "同じ行、列、ブロック、対角線",
+        whereJigsaw: "同じ行、列、領域",
+        whereSumCages: "同じ行、列、ブロック、囲み",
+        whereMoreOrLess: "同じ行と列",
+        whereTowers: "同じ行と列",
+        byCage: "囲みの合計",
+        byMarks: "不等号",
+        byClues: "盤の外の数字",
+        groupRow: "第{n}行",
+        groupColumn: "第{n}列",
+        groupBox: "第{n}ブロック",
+        groupRegion: "第{n}領域",
+        groupDiagonal: "左上から右下への対角線",
+        groupDiagonalOther: "右上から左下への対角線",
+        paused: "一時停止中",
+    },
+};
+/** A line in a language, with its values filled in; the line itself if there is none by that name. */
+export function kazuSay(language, key, values = {}) {
+    const table = KAZU_STRINGS[language] ?? KAZU_STRINGS.en;
+    const one = values.n === 1 || values.wrong === 1 ? table[`${key}One`] : undefined;
+    const line = one ?? table[key] ?? KAZU_STRINGS.en[key] ?? key;
+    return line.replace(/\{(\w+)\}/g, (whole, name) => (name in values ? String(values[name]) : whole));
+}
+/** The language a piece of text is in: Japanese for anything starting `ja`, English for everything else. */
+export function kazuLanguageOf(tag) {
+    return String(tag ?? "").toLowerCase().startsWith("ja") ? "ja" : "en";
+}
+/** What a puzzle is called in a language, as a screen reader says it. */
+export function kazuNameOf(kind, language) {
+    return KAZU_NAMES[kind][language];
+}

package/dist/style.d.ts

@@ -0,0 +1,13 @@
+/**
+ * THE STYLE a Kazu drawing wears: the colours of its board as custom properties, and the one rule that
+ * matters for a puzzle played with fingers: nothing in the drawing can be selected, dragged or
+ * double-tapped.
+ *
+ * `drawKazu` only writes classes, data attributes and a few custom properties; this is what gives them
+ * a look. Every colour is a custom property on `.kazu` (`--kz-paper`, `--kz-ink`, `--kz-given`,
+ * `--kz-entry`, `--kz-note`, `--kz-grid`, `--kz-box`, `--kz-frame`, `--kz-cage`, `--kz-clue`,
+ * `--kz-diagonal`, `--kz-peer`, `--kz-same`, `--kz-select`, `--kz-hint`, `--kz-conflict`, `--kz-wrong`,
+ * `--kz-good`), so a page's own style needs to set only the ones it wants different. The paper follows
+ * the page's light or dark. Nothing moves, so there is nothing for reduced motion to still.
+ */
+export declare const KAZU_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";

package/dist/style.js

@@ -0,0 +1,61 @@
+/**
+ * THE STYLE a Kazu drawing wears: the colours of its board as custom properties, and the one rule that
+ * matters for a puzzle played with fingers: nothing in the drawing can be selected, dragged or
+ * double-tapped.
+ *
+ * `drawKazu` only writes classes, data attributes and a few custom properties; this is what gives them
+ * a look. Every colour is a custom property on `.kazu` (`--kz-paper`, `--kz-ink`, `--kz-given`,
+ * `--kz-entry`, `--kz-note`, `--kz-grid`, `--kz-box`, `--kz-frame`, `--kz-cage`, `--kz-clue`,
+ * `--kz-diagonal`, `--kz-peer`, `--kz-same`, `--kz-select`, `--kz-hint`, `--kz-conflict`, `--kz-wrong`,
+ * `--kz-good`), so a page's own style needs to set only the ones it wants different. The paper follows
+ * the page's light or dark. Nothing moves, so there is nothing for reduced motion to still.
+ */
+export const KAZU_STYLE = `
+.kazu {
+  --kz-paper: #fbf8f1; --kz-ink: #1f2320; --kz-given: #1f2320; --kz-entry: #1d5fa8; --kz-note: #5b6b7d;
+  --kz-grid: #cfc6b2; --kz-box: #3a3d38; --kz-frame: #a98954; --kz-cage: #6a5a8e; --kz-clue: #7a4b14;
+  --kz-diagonal: #e9dfc6; --kz-peer: #efe8d8; --kz-same: #dcd0f2; --kz-select: #ffe08a; --kz-hint: #b9e3c4;
+  --kz-conflict: #f4b8ad; --kz-wrong: #f4b8ad; --kz-bad: #b5452c; --kz-good: #2f7a4f;
+  --kz-font: system-ui, -apple-system, "Segoe UI", sans-serif;
+  display: block; width: 100%; height: auto;
+  user-select: none; -webkit-user-select: none; -webkit-touch-callout: none; touch-action: manipulation; -webkit-tap-highlight-color: transparent;
+  overflow: visible;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) .kazu {
+    --kz-paper: #262a27; --kz-ink: #ece8dc; --kz-given: #ece8dc; --kz-entry: #8fc1ff; --kz-note: #9fb0c2;
+    --kz-grid: #454a44; --kz-box: #c9c5b8; --kz-frame: #6b5632; --kz-cage: #b8a5e6; --kz-clue: #e8c48f;
+    --kz-diagonal: #34382f; --kz-peer: #2f332f; --kz-same: #433a5c; --kz-select: #6b5a1f; --kz-hint: #25503a;
+    --kz-conflict: #6e2f26; --kz-wrong: #6e2f26; --kz-bad: #ff8a6b; --kz-good: #6fcf97;
+  }
+}
+:root[data-theme="dark"] .kazu {
+  --kz-paper: #262a27; --kz-ink: #ece8dc; --kz-given: #ece8dc; --kz-entry: #8fc1ff; --kz-note: #9fb0c2;
+  --kz-grid: #454a44; --kz-box: #c9c5b8; --kz-frame: #6b5632; --kz-cage: #b8a5e6; --kz-clue: #e8c48f;
+  --kz-diagonal: #34382f; --kz-peer: #2f332f; --kz-same: #433a5c; --kz-select: #6b5a1f; --kz-hint: #25503a;
+  --kz-conflict: #6e2f26; --kz-wrong: #6e2f26; --kz-bad: #ff8a6b; --kz-good: #6fcf97;
+}
+.kazu * { user-select: none; -webkit-user-select: none; }
+.kazu .kz-frame { fill: var(--kz-frame); }
+.kazu .kz-paper { fill: var(--kz-paper); }
+.kazu .kz-diagonal { fill: var(--kz-diagonal); }
+.kazu .kz-peer { fill: var(--kz-peer); }
+.kazu .kz-same { fill: var(--kz-same); }
+.kazu .kz-select { fill: var(--kz-select); }
+.kazu .kz-hint { fill: var(--kz-hint); }
+.kazu .kz-conflict, .kazu .kz-wrong { fill: var(--kz-conflict); }
+.kazu .kz-solved { fill: var(--kz-good); opacity: .14; pointer-events: none; }
+.kazu .kz-grid { fill: none; stroke: var(--kz-grid); stroke-width: 1px; vector-effect: non-scaling-stroke; }
+.kazu .kz-box { fill: none; stroke: var(--kz-box); stroke-width: 2.5px; stroke-linecap: square; vector-effect: non-scaling-stroke; }
+.kazu .kz-cage { stroke: var(--kz-cage); stroke-width: 1.5px; stroke-dasharray: 4 3; vector-effect: non-scaling-stroke; }
+.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; }
+.kazu .kz-given { fill: var(--kz-given); font-weight: 700; }
+.kazu .kz-entry { fill: var(--kz-entry); }
+.kazu .kz-digit.kz-bad { fill: var(--kz-bad); }
+.kazu .kz-note { font-family: var(--kz-font); font-weight: 600; fill: var(--kz-note); text-anchor: middle; dominant-baseline: central; pointer-events: none; }
+.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; }
+.kazu .kz-clue { font-family: var(--kz-font); font-weight: 700; fill: var(--kz-clue); text-anchor: middle; dominant-baseline: central; pointer-events: none; }
+.kazu .kz-mark-bg { fill: var(--kz-paper); stroke: none; pointer-events: none; }
+.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; }
+.kazu .kz-hit { fill: transparent; cursor: pointer; }
+`;

package/dist/sumCages.d.ts

@@ -0,0 +1,60 @@
+import type { KazuLevel, KazuPuzzle } from "./kinds.ts";
+/**
+ * Making a Killer Sudoku (Sum Cages) puzzle from a seed: a filled Sudoku grid, cut into cages whose
+ * sums are printed, and no numbers printed at all beyond the odd cage of one cell.
+ *
+ * THE CAGES ARE GROWN BY JOINING, NOT CUT. Every cell starts as a cage of its own (a grid of printed
+ * numbers, which has one answer) and two neighbouring cages are joined only while the puzzle still
+ * has exactly one answer, the joined cage holds no number twice, and it is no bigger than the level
+ * allows. It stops at the level's count of cages. That is Sudoku's carving the other way up: there
+ * a given is taken away while one answer remains; here two sums become one. The answer is checked
+ * with a step budget, and a join whose check runs past it is not made: "I stopped looking" is not
+ * "one answer".
+ *
+ * Deterministic in the seed.
+ */
+/** The letters that name a cage in a code: up to sixty-two cages. */
+export declare const CAGE_LETTERS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/** A cage: the cells in it and the sum of the numbers inside. */
+export type Cage = {
+    cells: number[];
+    sum: number;
+};
+/**
+ * A Sum Cages puzzle's givens: the cells, then which cage each cell is in, then each cage's sum.
+ *
+ * `cells` is size² characters as every number puzzle writes them (all empty, usually; a cage of one
+ * cell is its own given). `cages` is size² characters, one per cell, naming its cage from
+ * `CAGE_LETTERS`. `sums` is two base-36 characters a cage, in cage order. The cages ride in the
+ * givens because they are the puzzle.
+ */
+export declare function encodeKiller(cells: readonly number[], cages: readonly Cage[]): string;
+/**
+ * The cells and cages a code says, or null for one that is not a whole, well-formed puzzle: every
+ * cell named to a cage, every cage used, and a sum for each.
+ */
+export declare function decodeKiller(code: string, size: number): {
+    cells: number[];
+    cages: Cage[];
+} | null;
+/** A line segment in cell units: where one part of a cage's dashed outline runs. */
+export type Segment = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/**
+ * THE DASHED OUTLINE OF EVERY CAGE, as line segments in cell units: each cage drawn a little inside
+ * its own edge, the way a printed Killer Sudoku draws it, so a cage reads as a shape within the box
+ * rules rather than as one of them.
+ *
+ * Each cell draws the sides where its neighbour is in another cage, `inset` inside the cell. Where
+ * the cage goes on past a side's end, the line runs on to meet the next line of the outline: to the
+ * cell's edge when the cage's edge carries on straight, and `inset` past it at an inside corner,
+ * where the outline turns back into the cage. That is what makes the lines of one cage meet, with
+ * no gap and no overshoot, whatever its shape.
+ */
+export declare function cageOutline(size: number, cageOf: (index: number) => number | undefined, inset?: number): Segment[];
+/** A Killer Sudoku (Sum Cages) of this side, level and seed: 6 or 9. */
+export declare function generateSumCages(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/sumCages.js

@@ -0,0 +1,190 @@
+import { decodeCells, encodeCells } from "./cells.js";
+import { countSolutionsWithin, fillLayout } from "./groupSolve.js";
+import { boxedLayout, cagedLayout, neighbours } from "./layout.js";
+import { seededRandom } from "./random.js";
+/**
+ * Making a Killer Sudoku (Sum Cages) puzzle from a seed: a filled Sudoku grid, cut into cages whose
+ * sums are printed, and no numbers printed at all beyond the odd cage of one cell.
+ *
+ * THE CAGES ARE GROWN BY JOINING, NOT CUT. Every cell starts as a cage of its own (a grid of printed
+ * numbers, which has one answer) and two neighbouring cages are joined only while the puzzle still
+ * has exactly one answer, the joined cage holds no number twice, and it is no bigger than the level
+ * allows. It stops at the level's count of cages. That is Sudoku's carving the other way up: there
+ * a given is taken away while one answer remains; here two sums become one. The answer is checked
+ * with a step budget, and a join whose check runs past it is not made: "I stopped looking" is not
+ * "one answer".
+ *
+ * Deterministic in the seed.
+ */
+/** The letters that name a cage in a code: up to sixty-two cages. */
+export const CAGE_LETTERS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+/**
+ * A Sum Cages puzzle's givens: the cells, then which cage each cell is in, then each cage's sum.
+ *
+ * `cells` is size² characters as every number puzzle writes them (all empty, usually; a cage of one
+ * cell is its own given). `cages` is size² characters, one per cell, naming its cage from
+ * `CAGE_LETTERS`. `sums` is two base-36 characters a cage, in cage order. The cages ride in the
+ * givens because they are the puzzle.
+ */
+export function encodeKiller(cells, cages) {
+    const cageOf = new Array(cells.length).fill(0);
+    cages.forEach((cage, c) => cage.cells.forEach((index) => (cageOf[index] = c)));
+    if (cages.length > CAGE_LETTERS.length)
+        throw new Error(`${cages.length} cages is more than a code can name.`);
+    const letters = cageOf.map((c) => CAGE_LETTERS[c]).join("");
+    const sums = cages.map((cage) => cage.sum.toString(36).padStart(2, "0")).join("");
+    return encodeCells(cells) + letters + sums;
+}
+/**
+ * The cells and cages a code says, or null for one that is not a whole, well-formed puzzle: every
+ * cell named to a cage, every cage used, and a sum for each.
+ */
+export function decodeKiller(code, size) {
+    const area = size * size;
+    if (typeof code !== "string" || code.length < 2 * area)
+        return null;
+    const cells = decodeCells(code.slice(0, area), size);
+    if (cells === null)
+        return null;
+    const cageOf = [];
+    for (const letter of code.slice(area, 2 * area)) {
+        const c = CAGE_LETTERS.indexOf(letter);
+        if (c === -1)
+            return null;
+        cageOf.push(c);
+    }
+    const count = Math.max(...cageOf) + 1;
+    const sums = code.slice(2 * area);
+    if (sums.length !== 2 * count)
+        return null;
+    const cages = [];
+    for (let c = 0; c < count; c += 1) {
+        const sum = Number.parseInt(sums.slice(2 * c, 2 * c + 2), 36);
+        const members = cageOf.flatMap((value, index) => (value === c ? [index] : []));
+        if (!Number.isInteger(sum) || sum <= 0 || members.length === 0)
+            return null;
+        cages.push({ cells: members, sum });
+    }
+    return { cells, cages };
+}
+/**
+ * THE DASHED OUTLINE OF EVERY CAGE, as line segments in cell units: each cage drawn a little inside
+ * its own edge, the way a printed Killer Sudoku draws it, so a cage reads as a shape within the box
+ * rules rather than as one of them.
+ *
+ * Each cell draws the sides where its neighbour is in another cage, `inset` inside the cell. Where
+ * the cage goes on past a side's end, the line runs on to meet the next line of the outline: to the
+ * cell's edge when the cage's edge carries on straight, and `inset` past it at an inside corner,
+ * where the outline turns back into the cage. That is what makes the lines of one cage meet, with
+ * no gap and no overshoot, whatever its shape.
+ */
+export function cageOutline(size, cageOf, inset = 0.12) {
+    const at = (row, col) => (row < 0 || col < 0 || row >= size || col >= size ? undefined : cageOf(row * size + col));
+    const out = [];
+    for (let row = 0; row < size; row += 1) {
+        for (let col = 0; col < size; col += 1) {
+            const mine = at(row, col);
+            if (mine === undefined)
+                continue;
+            const same = (r, c) => at(r, c) === mine;
+            const edge = { top: !same(row - 1, col), bottom: !same(row + 1, col), left: !same(row, col - 1), right: !same(row, col + 1) };
+            /*
+             * How far a side's line runs past the cell toward one end: stops `inset` short when the cage
+             * ends there, runs to the edge when the neighbour carries the same side on, and `inset` past
+             * it at an inside corner.
+             */
+            const reach = (ends, neighbourHasSide) => (ends ? -inset : neighbourHasSide ? 0 : inset);
+            if (edge.top) {
+                const y = row + inset;
+                out.push({ x1: col - reach(edge.left, !same(row - 1, col - 1) && same(row, col - 1)), y1: y, x2: col + 1 + reach(edge.right, !same(row - 1, col + 1) && same(row, col + 1)), y2: y });
+            }
+            if (edge.bottom) {
+                const y = row + 1 - inset;
+                out.push({ x1: col - reach(edge.left, !same(row + 1, col - 1) && same(row, col - 1)), y1: y, x2: col + 1 + reach(edge.right, !same(row + 1, col + 1) && same(row, col + 1)), y2: y });
+            }
+            if (edge.left) {
+                const x = col + inset;
+                out.push({ x1: x, y1: row - reach(edge.top, !same(row - 1, col - 1) && same(row - 1, col)), x2: x, y2: row + 1 + reach(edge.bottom, !same(row + 1, col - 1) && same(row + 1, col)) });
+            }
+            if (edge.right) {
+                const x = col + 1 - inset;
+                out.push({ x1: x, y1: row - reach(edge.top, !same(row - 1, col + 1) && same(row - 1, col)), x2: x, y2: row + 1 + reach(edge.bottom, !same(row + 1, col + 1) && same(row + 1, col)) });
+            }
+        }
+    }
+    return out;
+}
+/** The biggest cage, and how many cages to stop at, by level and side. */
+const SHAPE = {
+    easy: { biggest: 3, cages: { 6: 17, 9: 38 } },
+    medium: { biggest: 4, cages: { 6: 14, 9: 31 } },
+    hard: { biggest: 5, cages: { 6: 12, 9: 27 } },
+};
+/** Steps the answer check may take for one join before the join is passed over. */
+const CHECK_BUDGET = 4000;
+/** Joins tried, per cell, before the cages are taken as they stand. */
+const JOINS_PER_CELL = 12;
+/**
+ * Joins refused in a row, per side, after which the cages are taken as they stand. Near the level's
+ * count most joins would leave two answers, and each refusal is a full search: a run of them is the
+ * grid saying it is done.
+ */
+const REFUSED_IN_A_ROW_PER_SIDE = 3;
+/** A Killer Sudoku (Sum Cages) of this side, level and seed: 6 or 9. */
+export function generateSumCages(size, level, seed) {
+    const random = seededRandom(seed);
+    for (;;) {
+        const solution = fillLayout(boxedLayout(size), random);
+        if (solution === null)
+            continue;
+        const cages = joinCages(size, solution, level, random);
+        // A cage of one cell is printed as its number too, as it would be in a newspaper's.
+        const single = new Set(cages.flatMap((cage) => (cage.cells.length === 1 ? cage.cells : [])));
+        const cells = solution.map((value, index) => (single.has(index) ? value : 0));
+        return { kind: "sum-cages", size, level, seed, givens: encodeKiller(cells, cages), solution: encodeCells(solution) };
+    }
+}
+function joinCages(size, solution, level, random) {
+    const { biggest, cages: target } = SHAPE[level];
+    const want = target[size] ?? Math.round(size * size * 0.4);
+    let cages = solution.map((value, index) => ({ cells: [index], sum: value }));
+    const blank = new Array(size * size).fill(0);
+    let refused = 0;
+    for (let tried = 0; tried < JOINS_PER_CELL * size * size && cages.length > want && refused < REFUSED_IN_A_ROW_PER_SIDE * size; tried += 1) {
+        const cageOf = new Array(size * size);
+        cages.forEach((cage, c) => cage.cells.forEach((index) => (cageOf[index] = c)));
+        /*
+         * The smallest cages first, most of the time: a cage of one cell is a printed number, and a Sum
+         * Cages puzzle is the one with next to none of those. The rest of the time any cage, so the
+         * shapes are not all grown from the same few.
+         */
+        const smallest = Math.min(...cages.map((cage) => cage.cells.length));
+        const pool = random() < 0.8 ? cages.flatMap((cage, c) => (cage.cells.length === smallest ? [c] : [])) : cages.map((_, c) => c);
+        const a = pool[Math.floor(random() * pool.length)];
+        const touching = [...new Set(cages[a].cells.flatMap((index) => neighbours(size, index)).map((index) => cageOf[index]))].filter((c) => c !== a);
+        if (touching.length === 0)
+            continue;
+        const b = touching[Math.floor(random() * touching.length)];
+        const cells = [...cages[a].cells, ...cages[b].cells];
+        if (cells.length > biggest)
+            continue;
+        const values = cells.map((index) => solution[index]);
+        if (new Set(values).size !== values.length)
+            continue;
+        const joined = { cells: cells.sort((x, y) => x - y), sum: values.reduce((total, value) => total + value, 0) };
+        const next = cages.filter((_, c) => c !== a && c !== b).concat(joined);
+        // A cage of one cell is a printed number: the check sees it as a given, as the solver would.
+        const givens = blank.map((_, index) => (next[cageIndex(next, index)].cells.length === 1 ? solution[index] : 0));
+        if (countSolutionsWithin(givens, cagedLayout(size, next), 2, CHECK_BUDGET) === 1) {
+            cages = next;
+            refused = 0;
+        }
+        else
+            refused += 1;
+    }
+    // In reading order of each cage's first cell, so the code and the sums read top to bottom.
+    return cages.sort((x, y) => x.cells[0] - y.cells[0]);
+}
+function cageIndex(cages, index) {
+    return cages.findIndex((cage) => cage.cells.includes(index));
+}

package/dist/towers.d.ts

@@ -0,0 +1,3 @@
+import type { KazuLevel, KazuPuzzle } from "./kinds.ts";
+/** A Skyscrapers (Towers) puzzle of this side, level and seed: 4, 5, 6 or 7. */
+export declare function generateTowers(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/towers.js

@@ -0,0 +1,48 @@
+import { encodeCells } from "./cells.js";
+import { latinSquare } from "./moreOrLess.js";
+import { seededRandom, shuffled } from "./random.js";
+import { cluesOf, encodeTowers, TOWER_SIDES } from "./towersCode.js";
+import { countSolutions, guessDepth } from "./towersSolve.js";
+/**
+ * Making a Skyscrapers (Towers) puzzle from a seed.
+ *
+ * A seeded Latin square first, and every clue it makes true around its edge. Givens are added only
+ * if the clues alone are not yet a puzzle of the level asked for, which with all of them showing is
+ * rare. Then, in a seeded order, every given and after them every clue is tried for removal, kept
+ * out only while the puzzle stays unique and within its level. Givens go first so that what is left
+ * leans on the clues, which are the puzzle; what remains is all needed.
+ *
+ * Deterministic in the seed.
+ */
+const LEVELS = { easy: 0, medium: 1, hard: Infinity };
+/** A Skyscrapers (Towers) puzzle of this side, level and seed: 4, 5, 6 or 7. */
+export function generateTowers(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, clues) => countSolutions(grid, size, clues, 2) === 1 && (allowed === Infinity || guessDepth(grid, size, clues, allowed) <= allowed);
+    const clues = cluesOf(solution, size);
+    const givens = new Array(size * size).fill(0);
+    for (const index of shuffled(givens.map((_, i) => i), random)) {
+        if (fits(givens, clues))
+            break;
+        givens[index] = solution[index];
+    }
+    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, clues))
+            givens[index] = value;
+    }
+    const places = TOWER_SIDES.flatMap((side) => Array.from({ length: size }, (_, at) => ({ side, at })));
+    for (const { side, at } of shuffled(places, random)) {
+        const clue = clues[side][at];
+        clues[side][at] = 0;
+        if (!fits(givens, clues))
+            clues[side][at] = clue;
+    }
+    return { kind: "towers", size, level, seed, givens: encodeTowers(givens, clues), solution: encodeCells(solution) };
+}

package/dist/towersCode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Towers (Skyscrapers) as a string: the cells, then the clues around the edge.
+ *
+ * The cells come first, row-major, as every number grid is written (`.` for
+ * empty; most puzzles print none). Then one character for every place a clue
+ * can stand outside the square, four sides of `size`: along the top left to
+ * right, along the bottom left to right, down the left top to bottom, down the
+ * right top to bottom. A digit is how many towers can be seen from there; `.`
+ * is no clue. A 7×7 is 49 + 28 characters.
+ */
+export declare const TOWER_SIDES: readonly ["top", "bottom", "left", "right"];
+export type TowerSide = (typeof TOWER_SIDES)[number];
+/** Each side's clues, in reading order along it; 0 where there is none. */
+export type TowerClues = Record<TowerSide, number[]>;
+export declare function noClues(size: number): TowerClues;
+/**
+ * The cells a clue looks along, nearest first: the clue at `at` on the top
+ * looks down column `at`, on the bottom up it, on the left along row `at`
+ * to the right, on the right along it to the left.
+ */
+export declare function lineFrom(side: TowerSide, at: number, size: number): number[];
+/** How many towers show looking along `heights` from its first end: each one taller than every one before it. */
+export declare function towersSeen(heights: readonly number[]): number;
+/** Every clue a finished square makes true: what each side of it sees. */
+export declare function cluesOf(solution: readonly number[], size: number): TowerClues;
+export declare function encodeTowers(cells: readonly number[], clues: TowerClues): string;
+/** The cells and clues a code says, or null for a string that is not a Towers puzzle of this size. */
+export declare function decodeTowers(code: string, size: number): {
+    cells: number[];
+    clues: TowerClues;
+} | null;