@johnmorrisdotca/kazu 1.0.0

package/dist/hint.js

@@ -0,0 +1,158 @@
+import { decodeCells } from "./cells.js";
+import { layoutOfGivens, readGivens } from "./givens.js";
+import { bitCount, candidatesAt, lowestBit, used } from "./groupSolve.js";
+import { solveKazu } from "./solve.js";
+import { cluedLines, narrowEdges } from "./towersSolve.js";
+const ALL = (size) => (1 << (size + 1)) - 2;
+/** The type and number of the group at a place in a layout's list of groups (`layout.ts`'s order): only the groups that hold every number, never a cage. */
+function groupInfo(givens, g) {
+    const { size } = givens;
+    if (g < size)
+        return { type: "row", index: g };
+    if (g < 2 * size)
+        return { type: "column", index: g - size };
+    if (givens.regions !== null && g < 3 * size)
+        return { type: givens.kind === "jigsaw" ? "region" : "box", index: g - 2 * size };
+    return { type: "diagonal", index: g - 3 * size };
+}
+/** Candidate masks for every cell of a grid, and which rule beyond the groups narrowed each. */
+function candidatesFor(givens, grid) {
+    const { size } = givens;
+    const layout = layoutOfGivens(givens);
+    if (layout !== null) {
+        const taken = used(grid, layout);
+        const masks = grid.map((value, index) => (value !== 0 ? 0 : candidatesAt(layout, index, taken, grid)));
+        const by = grid.map((value, index) => {
+            if (value !== 0)
+                return undefined;
+            let blocked = 0;
+            for (const group of layout.groupsOf[index])
+                blocked |= taken[group];
+            const open = ALL(size) & ~blocked;
+            return bitCount(open) > 1 && bitCount(masks[index]) === 1 && layout.cages !== undefined ? "cage" : undefined;
+        });
+        return { masks, by, groups: layout.groups };
+    }
+    const rows = Array.from({ length: size }, (_, r) => Array.from({ length: size }, (_, c) => r * size + c));
+    const cols = Array.from({ length: size }, (_, c) => Array.from({ length: size }, (_, r) => r * size + c));
+    const groups = [...rows, ...cols];
+    const masks = grid.map((value, index) => {
+        if (value !== 0)
+            return 0;
+        let mask = ALL(size);
+        for (const other of rows[Math.floor(index / size)])
+            if (grid[other] !== 0)
+                mask &= ~(1 << grid[other]);
+        for (const other of cols[index % size])
+            if (grid[other] !== 0)
+                mask &= ~(1 << grid[other]);
+        return mask;
+    });
+    const plain = [...masks];
+    // What the marks or the clues rule out is narrowed to a fixpoint, as a person works along a chain of them.
+    if (givens.kind === "more-or-less") {
+        const candidates = grid.map((value, index) => (value !== 0 ? 1 << value : masks[index]));
+        const highest = (mask) => 31 - Math.clz32(mask);
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const mark of givens.marks) {
+                const lessMask = candidates[mark.less] & ((1 << highest(candidates[mark.more])) - 1);
+                const moreMask = candidates[mark.more] & (ALL(size) & ~((1 << (lowestBit(candidates[mark.less]) + 1)) - 1));
+                if (lessMask !== candidates[mark.less]) {
+                    candidates[mark.less] = lessMask;
+                    changed = true;
+                }
+                if (moreMask !== candidates[mark.more]) {
+                    candidates[mark.more] = moreMask;
+                    changed = true;
+                }
+            }
+            if (candidates.some((mask) => mask === 0))
+                return null;
+        }
+        return { masks: grid.map((value, index) => (value !== 0 ? 0 : candidates[index])), by: grid.map((value, index) => (value === 0 && bitCount(plain[index]) > 1 && bitCount(candidates[index]) === 1 ? "marks" : undefined)), groups };
+    }
+    if (givens.clues !== null) {
+        const candidates = grid.map((value, index) => (value !== 0 ? 1 << value : masks[index]));
+        const lines = cluedLines(size, givens.clues);
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const line of lines) {
+                const narrowed = narrowEdges(line, candidates, size);
+                if (narrowed === null)
+                    return null;
+                if (narrowed)
+                    changed = true;
+            }
+        }
+        return { masks: grid.map((value, index) => (value !== 0 ? 0 : candidates[index])), by: grid.map((value, index) => (value === 0 && bitCount(plain[index]) > 1 && bitCount(candidates[index]) === 1 ? "clues" : undefined)), groups };
+    }
+    return { masks, by: grid.map(() => undefined), groups };
+}
+/**
+ * The next cell a person could fill in, and why (see `KazuHint`). `entries` is what the player has
+ * written, row-major (0 for empty; printed cells are ignored). `answer` is the puzzle's solution as a
+ * cells code; left out, it is worked out from the givens. Null when every cell is right, or when
+ * the givens are not a puzzle with exactly one answer: there is nothing true to say.
+ */
+export function hintKazu(kind, size, givens, entries, answer) {
+    const read = readGivens(kind, size, givens);
+    if (read === null)
+        return null;
+    const solved = decodeCells(answer ?? solveKazu(kind, size, givens) ?? "", size);
+    if (solved === null)
+        return null;
+    const right = read.cells.map((printed, index) => (printed !== 0 ? printed : entries[index] === solved[index] ? solved[index] : 0));
+    if (right.every((value) => value !== 0))
+        return null;
+    const replaces = (cell) => (entries[cell] ?? 0) !== 0 && read.cells[cell] === 0;
+    const found = candidatesFor(read, right);
+    if (found !== null) {
+        const empty = right.flatMap((value, index) => (value === 0 ? [index] : []));
+        // A cell that is empty is a gentler hint than one that holds a wrong number, so those come first.
+        const ordered = [...empty.filter((cell) => !replaces(cell)), ...empty.filter(replaces)];
+        for (const cell of ordered) {
+            if (bitCount(found.masks[cell]) === 1)
+                return { cell, value: lowestBit(found.masks[cell]), why: "only-number", by: found.by[cell], replaces: replaces(cell) };
+        }
+        for (const rank of [false, true]) {
+            for (const [g, group] of found.groups.entries()) {
+                // A cage holds some of the numbers, not all, so a number with one place left in it is no reason to put it there.
+                if (group.length !== size)
+                    continue;
+                let present = 0;
+                for (const index of group)
+                    if (right[index] !== 0)
+                        present |= 1 << right[index];
+                for (let value = 1; value <= size; value += 1) {
+                    if (present & (1 << value))
+                        continue;
+                    const places = group.filter((index) => right[index] === 0 && (found.masks[index] & (1 << value)) !== 0);
+                    if (places.length === 1 && replaces(places[0]) === rank)
+                        return { cell: places[0], value, why: "only-place", group: groupInfo(read, g), replaces: rank };
+                }
+            }
+        }
+    }
+    // Nothing follows by a single step: the tightest cell, where the most of its row and column are right already.
+    let best = -1;
+    let bestPeers = -1;
+    for (let index = 0; index < size * size; index += 1) {
+        if (right[index] !== 0)
+            continue;
+        const row = Math.floor(index / size);
+        const col = index % size;
+        let peers = 0;
+        for (let k = 0; k < size; k += 1) {
+            if (k !== col && right[row * size + k] !== 0)
+                peers += 1;
+            if (k !== row && right[k * size + col] !== 0)
+                peers += 1;
+        }
+        if (peers > bestPeers) {
+            best = index;
+            bestPeers = peers;
+        }
+    }
+    return best === -1 ? null : { cell: best, value: solved[best], why: "answer", replaces: replaces(best) };
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Kazu 数: the Numbers family of grid puzzles. Sudoku, Jigsaw Sudoku, Diagonal Sudoku, Killer Sudoku
+ * (Sum Cages), Futoshiki (More or Less) and Skyscrapers (Towers): a seeded generator whose every puzzle
+ * has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished
+ * grid in O(cells); a hint that says which cell to fill next and why; puzzles and runs as short codes;
+ * and a game in play as pure functions. The drawing is `@johnmorrisdotca/kazu/draw`, playing in a page
+ * is `@johnmorrisdotca/kazu/play`, and the tag is `@johnmorrisdotca/kazu/element/define`.
+ */
+export * from "./kinds.ts";
+export * from "./generate.ts";
+export * from "./solve.ts";
+export * from "./check.ts";
+export * from "./hint.ts";
+export * from "./givens.ts";
+export * from "./conflicts.ts";
+export * from "./game.ts";
+export * from "./cells.ts";
+export * from "./progress.ts";
+export { kazuClockText } from "./clock.ts";
+export { generateNumberPlace, generateDiagonal } from "./numberPlace.ts";
+export { generateJigsaw } from "./jigsaw.ts";
+export { generateSumCages } from "./sumCages.ts";
+export { generateMoreOrLess } from "./moreOrLess.ts";
+export { generateTowers } from "./towers.ts";
+export { encodeJigsaw, decodeJigsaw, encodeRegions, decodeRegions } from "./jigsaw.ts";
+export { encodeKiller, decodeKiller, cageOutline, CAGE_LETTERS } from "./sumCages.ts";
+export type { Cage, Segment } from "./sumCages.ts";
+export { encodeMoreOrLess, decodeMoreOrLess, NO_MARK } from "./moreOrLessCode.ts";
+export type { Mark } from "./moreOrLessCode.ts";
+export { encodeTowers, decodeTowers, cluesOf, lineFrom, towersSeen, noClues, TOWER_SIDES } from "./towersCode.ts";
+export type { TowerClues, TowerSide } from "./towersCode.ts";
+export { boxedLayout, boxOf, KAZU_BOXES, neighbours, regionsAreSound } from "./layout.ts";
+export type { Boxes } from "./layout.ts";
+export { seededRandom, shuffled, freshKazuSeed, isKazuSeed, KAZU_SEED_MOST } from "./random.ts";
+export type { Random } from "./random.ts";
+export { VERSION } from "./version.ts";

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * Kazu 数: the Numbers family of grid puzzles. Sudoku, Jigsaw Sudoku, Diagonal Sudoku, Killer Sudoku
+ * (Sum Cages), Futoshiki (More or Less) and Skyscrapers (Towers): a seeded generator whose every puzzle
+ * has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished
+ * grid in O(cells); a hint that says which cell to fill next and why; puzzles and runs as short codes;
+ * and a game in play as pure functions. The drawing is `@johnmorrisdotca/kazu/draw`, playing in a page
+ * is `@johnmorrisdotca/kazu/play`, and the tag is `@johnmorrisdotca/kazu/element/define`.
+ */
+export * from "./kinds.js";
+export * from "./generate.js";
+export * from "./solve.js";
+export * from "./check.js";
+export * from "./hint.js";
+export * from "./givens.js";
+export * from "./conflicts.js";
+export * from "./game.js";
+export * from "./cells.js";
+export * from "./progress.js";
+export { kazuClockText } from "./clock.js";
+export { generateNumberPlace, generateDiagonal } from "./numberPlace.js";
+export { generateJigsaw } from "./jigsaw.js";
+export { generateSumCages } from "./sumCages.js";
+export { generateMoreOrLess } from "./moreOrLess.js";
+export { generateTowers } from "./towers.js";
+export { encodeJigsaw, decodeJigsaw, encodeRegions, decodeRegions } from "./jigsaw.js";
+export { encodeKiller, decodeKiller, cageOutline, CAGE_LETTERS } from "./sumCages.js";
+export { encodeMoreOrLess, decodeMoreOrLess, NO_MARK } from "./moreOrLessCode.js";
+export { encodeTowers, decodeTowers, cluesOf, lineFrom, towersSeen, noClues, TOWER_SIDES } from "./towersCode.js";
+export { boxedLayout, boxOf, KAZU_BOXES, neighbours, regionsAreSound } from "./layout.js";
+export { seededRandom, shuffled, freshKazuSeed, isKazuSeed, KAZU_SEED_MOST } from "./random.js";
+export { VERSION } from "./version.js";

package/dist/jigsaw.d.ts

@@ -0,0 +1,21 @@
+import type { KazuLevel, KazuPuzzle } from "./kinds.ts";
+import { type Random } from "./random.ts";
+/** The region of every cell as a letter, `a` for the first region and so on: one character a cell. */
+export declare function encodeRegions(regions: readonly number[]): string;
+/** Regions row-major, one letter each, or null for a string that is not that. */
+export declare function decodeRegions(code: string, size: number): number[] | null;
+/**
+ * A Jigsaw's givens: the cells, then the regions, one letter a cell. The regions ride in the givens
+ * because they are the puzzle: a check reads a finished grid against the regions it was handed, in
+ * one pass, and never has to make them again.
+ */
+export declare function encodeJigsaw(cells: readonly number[], regions: readonly number[]): string;
+/** The cells and regions a Jigsaw's givens say, or null for a string that is not a Jigsaw of this side. */
+export declare function decodeJigsaw(code: string, size: number): {
+    cells: number[];
+    regions: number[];
+} | null;
+/** Irregular regions for a grid of this side, shaken from the boxes (or the rows) by exchanges, in a seeded order. Every region is joined and none is a straight line. */
+export declare function shakeRegions(size: number, random: Random): number[];
+/** A Jigsaw Sudoku of this side, level and seed: 5, 6, 7 or 9. */
+export declare function generateJigsaw(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/jigsaw.js

@@ -0,0 +1,144 @@
+import { decodeCells, encodeCells } from "./cells.js";
+import { fillLayout } from "./groupSolve.js";
+import { KAZU_BOXES, neighbours, regionLayout, regionsAreSound } from "./layout.js";
+import { carve } from "./numberPlace.js";
+import { seededRandom } from "./random.js";
+/**
+ * Making a Jigsaw Sudoku from a seed: Sudoku with the boxes traded for irregular regions of the
+ * same size.
+ *
+ * The regions come first. They start as a regular partition (the boxes where the side has boxes,
+ * the rows where it does not) and are shaken by exchanges: a cell passes to a neighbouring region
+ * and a cell of that region touching the first passes back, kept only while both regions stay
+ * joined edge to edge, so the sizes never change. A shaken layout with a region that is still a
+ * whole row or column is drawn again, because that region would ask nothing the row does not.
+ *
+ * Then a full grid for those regions, by the solver's own search with a step budget: some layouts
+ * fill slowly, and one that runs past the budget is swapped for another rather than waited on.
+ * Then the givens, carved exactly as Sudoku's are (`carve`). Deterministic in the seed.
+ */
+const REGION_FIRST = "a".charCodeAt(0);
+/** The region of every cell as a letter, `a` for the first region and so on: one character a cell. */
+export function encodeRegions(regions) {
+    return regions.map((region) => String.fromCharCode(REGION_FIRST + region)).join("");
+}
+/** Regions row-major, one letter each, or null for a string that is not that. */
+export function decodeRegions(code, size) {
+    if (typeof code !== "string" || code.length !== size * size)
+        return null;
+    const regions = [];
+    for (const letter of code) {
+        const region = letter.charCodeAt(0) - REGION_FIRST;
+        if (letter.length !== 1 || region < 0 || region >= size)
+            return null;
+        regions.push(region);
+    }
+    return regions;
+}
+/**
+ * A Jigsaw's givens: the cells, then the regions, one letter a cell. The regions ride in the givens
+ * because they are the puzzle: a check reads a finished grid against the regions it was handed, in
+ * one pass, and never has to make them again.
+ */
+export function encodeJigsaw(cells, regions) {
+    return encodeCells(cells) + encodeRegions(regions);
+}
+/** The cells and regions a Jigsaw's givens say, or null for a string that is not a Jigsaw of this side. */
+export function decodeJigsaw(code, size) {
+    if (typeof code !== "string" || code.length !== 2 * size * size)
+        return null;
+    const cells = decodeCells(code.slice(0, size * size), size);
+    const regions = decodeRegions(code.slice(size * size), size);
+    return cells === null || regions === null ? null : { cells, regions };
+}
+/** Where the removal stops, by level and side: the same proportions as Sudoku's floors. */
+const FLOOR = {
+    easy: { 5: 12, 6: 18, 7: 25, 9: 38 },
+    medium: { 5: 9, 6: 14, 7: 20, 9: 30 },
+    hard: { 5: 7, 6: 11, 7: 16, 9: 24 },
+};
+/** Exchanges tried per cell when shaking the regions. */
+const SHAKES_PER_CELL = 40;
+/** Layouts tried before giving up; a layout that cannot be filled inside the budget is replaced. */
+const LAYOUTS_TRIED = 40;
+function startingRegions(size) {
+    const boxes = KAZU_BOXES[size];
+    return Array.from({ length: size * size }, (_, index) => {
+        const row = Math.floor(index / size);
+        const col = index % size;
+        return boxes === undefined ? row : Math.floor(row / boxes.rows) * (size / boxes.cols) + Math.floor(col / boxes.cols);
+    });
+}
+function joined(size, region, group) {
+    const start = region.indexOf(group);
+    const seen = new Set([start]);
+    const stack = [start];
+    while (stack.length > 0) {
+        const index = stack.pop();
+        for (const next of neighbours(size, index)) {
+            if (!seen.has(next) && region[next] === group) {
+                seen.add(next);
+                stack.push(next);
+            }
+        }
+    }
+    return seen.size === size;
+}
+/** Whether some region is exactly one row or one column. */
+function hasStraightRegion(size, region) {
+    for (let group = 0; group < size; group += 1) {
+        const cells = region.flatMap((value, index) => (value === group ? [index] : []));
+        const rows = new Set(cells.map((index) => Math.floor(index / size)));
+        const cols = new Set(cells.map((index) => index % size));
+        if (rows.size === 1 || cols.size === 1)
+            return true;
+    }
+    return false;
+}
+/** Irregular regions for a grid of this side, shaken from the boxes (or the rows) by exchanges, in a seeded order. Every region is joined and none is a straight line. */
+export function shakeRegions(size, random) {
+    for (;;) {
+        const region = startingRegions(size);
+        for (let shake = 0; shake < SHAKES_PER_CELL * size * size; shake += 1) {
+            /*
+             * One cell passes from its region A to a neighbouring region B, and then any cell of B that
+             * touches A passes back, so both keep their size. A straight swap of two neighbours almost
+             * always cuts one region in two, and starting from rows it never can succeed at all.
+             */
+            const a = Math.floor(random() * size * size);
+            const ra = region[a];
+            const across = neighbours(size, a).filter((next) => region[next] !== ra);
+            if (across.length === 0)
+                continue;
+            const rb = region[across[Math.floor(random() * across.length)]];
+            region[a] = rb;
+            const back = region.flatMap((value, index) => value === rb && index !== a && neighbours(size, index).some((next) => region[next] === ra) ? [index] : []);
+            if (back.length === 0) {
+                region[a] = ra;
+                continue;
+            }
+            const b = back[Math.floor(random() * back.length)];
+            region[b] = ra;
+            if (!joined(size, region, ra) || !joined(size, region, rb)) {
+                region[a] = ra;
+                region[b] = rb;
+            }
+        }
+        if (!hasStraightRegion(size, region) && regionsAreSound(size, region))
+            return region;
+    }
+}
+/** A Jigsaw Sudoku of this side, level and seed: 5, 6, 7 or 9. */
+export function generateJigsaw(size, level, seed) {
+    const random = seededRandom(seed);
+    for (let tried = 0; tried < LAYOUTS_TRIED; tried += 1) {
+        const regions = shakeRegions(size, random);
+        const layout = regionLayout(size, regions);
+        const solution = fillLayout(layout, random);
+        if (solution === null)
+            continue;
+        const givens = carve(solution, layout, level, FLOOR[level][size], random);
+        return { kind: "jigsaw", size, level, seed, givens: encodeJigsaw(givens, regions), solution: encodeCells(solution) };
+    }
+    throw new Error(`No jigsaw could be filled from seed ${seed} at ${size}×${size}.`);
+}

package/dist/kinds.d.ts

@@ -0,0 +1,51 @@
+/**
+ * THE SIX PUZZLES, and what each offers: the keys, the sizes and the levels.
+ *
+ * A key is kebab case and is the name of the puzzle everywhere in this package: the
+ * address of one, the `kind` of a puzzle, the value of the element's `kind` attribute.
+ * itsutsu.com spelled the same six `numberPlace`, `jigsaw`, `diagonal`, `sumCages`,
+ * `moreOrLess` and `towers`; `KAZU_KIND_OF_SITE_KIND` maps one to the other.
+ */
+export declare const KAZU_KINDS: readonly ["number-place", "jigsaw", "diagonal", "sum-cages", "more-or-less", "towers"];
+export type KazuKind = (typeof KAZU_KINDS)[number];
+/** How hard a puzzle is made: what the solver needed. Easy yields to singles alone, medium to one guess, hard to whatever it takes. */
+export declare const KAZU_LEVELS: readonly ["easy", "medium", "hard"];
+export type KazuLevel = (typeof KAZU_LEVELS)[number];
+/** What one puzzle offers. */
+export type KazuSpec = {
+    /** Every side it can be made at, smallest first. */
+    sizes: readonly number[];
+    /** The side a first visit opens on. */
+    defaultSize: number;
+    /** The most characters one of its codes can hold, for a route to refuse anything larger. */
+    mostCells: number;
+};
+export declare const KAZU_SPECS: Record<KazuKind, KazuSpec>;
+/** The names itsutsu.com gave the six in its code, to the keys here: what a site's stored kind becomes. */
+export declare const KAZU_KIND_OF_SITE_KIND: Record<string, KazuKind>;
+/** Whether a value is one of the six keys. */
+export declare function isKazuKind(value: unknown): value is KazuKind;
+/** Whether a value is one of the three levels. */
+export declare function isKazuLevel(value: unknown): value is KazuLevel;
+/** Whether this puzzle can be made at this side. */
+export declare function isKazuSize(kind: KazuKind, size: number): boolean;
+/**
+ * One puzzle, made from a seed or read back from its codes. `givens` and `solution` are the strings
+ * `cells.ts` and the kinds' own codes write: row-major cells, one character each, and for a Jigsaw, Sum
+ * Cages, More or Less or Towers the rest of what the puzzle is printed with, after the cells.
+ */
+export type KazuPuzzle = {
+    kind: KazuKind;
+    size: number;
+    level: KazuLevel;
+    seed: number;
+    givens: string;
+    solution: string;
+};
+/** The verdict on a submitted answer: `{ ok: true }`, or `{ ok: false, reason }` in the words the site has always used. */
+export type KazuCheck = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/kinds.js

@@ -0,0 +1,40 @@
+/**
+ * THE SIX PUZZLES, and what each offers: the keys, the sizes and the levels.
+ *
+ * A key is kebab case and is the name of the puzzle everywhere in this package: the
+ * address of one, the `kind` of a puzzle, the value of the element's `kind` attribute.
+ * itsutsu.com spelled the same six `numberPlace`, `jigsaw`, `diagonal`, `sumCages`,
+ * `moreOrLess` and `towers`; `KAZU_KIND_OF_SITE_KIND` maps one to the other.
+ */
+export const KAZU_KINDS = ["number-place", "jigsaw", "diagonal", "sum-cages", "more-or-less", "towers"];
+/** How hard a puzzle is made: what the solver needed. Easy yields to singles alone, medium to one guess, hard to whatever it takes. */
+export const KAZU_LEVELS = ["easy", "medium", "hard"];
+export const KAZU_SPECS = {
+    "number-place": { sizes: [4, 6, 9, 16], defaultSize: 9, mostCells: 256 },
+    jigsaw: { sizes: [5, 6, 7, 9], defaultSize: 7, mostCells: 162 },
+    diagonal: { sizes: [6, 9], defaultSize: 9, mostCells: 81 },
+    "sum-cages": { sizes: [6, 9], defaultSize: 9, mostCells: 286 },
+    "more-or-less": { sizes: [4, 5, 6, 7], defaultSize: 5, mostCells: 133 },
+    towers: { sizes: [4, 5, 6, 7], defaultSize: 5, mostCells: 77 },
+};
+/** The names itsutsu.com gave the six in its code, to the keys here: what a site's stored kind becomes. */
+export const KAZU_KIND_OF_SITE_KIND = {
+    numberPlace: "number-place",
+    jigsaw: "jigsaw",
+    diagonal: "diagonal",
+    sumCages: "sum-cages",
+    moreOrLess: "more-or-less",
+    towers: "towers",
+};
+/** Whether a value is one of the six keys. */
+export function isKazuKind(value) {
+    return KAZU_KINDS.includes(value);
+}
+/** Whether a value is one of the three levels. */
+export function isKazuLevel(value) {
+    return KAZU_LEVELS.includes(value);
+}
+/** Whether this puzzle can be made at this side. */
+export function isKazuSize(kind, size) {
+    return isKazuKind(kind) && KAZU_SPECS[kind].sizes.includes(size);
+}

package/dist/layout.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+/** Where the boxes are on a Sudoku grid: how many rows and columns of cells each box holds. */
+export type Boxes = {
+    rows: number;
+    cols: number;
+};
+/**
+ * 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 declare const KAZU_BOXES: Record<number, Boxes>;
+/** The box a cell is in, numbered row-major from 0. */
+export declare function boxOf(size: number, index: number): number;
+export type Layout = {
+    size: number;
+    /** Every group of cells that holds 1..size once each. */
+    groups: number[][];
+    /** For each cell, the groups it is in. */
+    groupsOf: number[][];
+    /** For each cell, the region it is drawn in: a box, or a jigsaw region. */
+    region: number[];
+    /** What a region is called when a check says which group repeats: a box, or a jigsaw's region. */
+    regionWord: "box" | "region";
+    diagonal: boolean;
+    /**
+     * Sum Cages' cages: cells that hold different numbers adding to `sum`. Each is also one of
+     * `groups`, so "different" is the solver's ordinary rule; the sum is the one thing the solver
+     * reads from here. Absent for every other puzzle, which is what keeps their search as it was.
+     */
+    cages?: {
+        cells: number[];
+        sum: number;
+    }[];
+    /** For each cell, the index of its cage in `cages`. */
+    cageOf?: number[];
+};
+/** Rows, columns and boxes; with `diagonal`, the two long diagonals as well. */
+export declare function boxedLayout(size: number, diagonal?: boolean): Layout;
+/** Rows, columns and the given regions, numbered 0..size-1, each `size` cells. */
+export declare function regionLayout(size: number, region: readonly number[]): Layout;
+/** Rows, columns and boxes, and the cages over them, each cage a group of its own as well. */
+export declare function cagedLayout(size: number, cages: readonly {
+    cells: readonly number[];
+    sum: number;
+}[]): Layout;
+/** The cells sharing an edge with `index`. */
+export declare function neighbours(size: number, index: number): number[];
+/**
+ * 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 declare function regionsAreSound(size: number, region: readonly number[]): boolean;