@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/shikakuSolve.js

@@ -1,54 +1,33 @@
 import { SHIKAKU_MOST_NODES } from "./shikaku.constants.js";
-import { checkShikaku, isShikakuBoard, shikakuCandidates, shikakuCells } from "./shikakuBoard.js";
-/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+import { checkShikaku, isShikakuBoard } from "./shikakuBoard.js";
+import { shikakuModel } from "./shikakuLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
+/** Exact cover over squares. A bounded search reports incompleteness instead of claiming uniqueness. */
 export function solveShikaku(board, placed = [], options = {}) {
     if (!isShikakuBoard(board))
         throw new RangeError("Invalid Shikaku board");
     const limit = options.limit ?? 2, budget = options.nodes ?? SHIKAKU_MOST_NODES;
     if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
         throw new RangeError("Invalid search bounds");
-    const maskOf = (r) => shikakuCells(board, r).reduce((m, c) => m | 1n << BigInt(c), 0n);
     if (checkShikaku(board, placed).errors.length)
         return { count: 0, solution: null, complete: true, nodes: 0 };
-    const all = (1n << BigInt(board.clues.length)) - 1n;
-    let occupied = 0n;
-    for (const r of placed)
-        occupied |= maskOf(r);
-    const candidates = board.clues.flatMap((n, c) => n ? shikakuCandidates(board, c).map(r => ({ r, mask: maskOf(r) })) : []);
-    const byCell = board.clues.map((_, c) => candidates.filter(r => (r.mask & 1n << BigInt(c)) !== 0n));
-    let count = 0, nodes = 0, complete = true, solution = null;
-    const visit = (mask, rectangles) => {
-        if (++nodes > budget) {
-            complete = false;
-            return;
-        }
-        if (mask === all) {
-            count += 1;
-            solution ?? (solution = rectangles.map(r => ({ ...r })));
-            return;
-        }
-        let choices = null;
-        for (let c = 0; c < board.clues.length; c += 1) {
-            if ((mask & 1n << BigInt(c)) !== 0n)
-                continue;
-            const available = byCell[c].filter(r => (mask & r.mask) === 0n);
-            if (!available.length)
-                return;
-            if (!choices || available.length < choices.length)
-                choices = available;
-            if (choices.length === 1)
-                break;
-        }
-        for (const next of choices ?? []) {
-            visit(mask | next.mask, [...rectangles, next.r]);
-            if (!complete)
-                return;
-            if (count >= limit) {
-                complete = false;
-                return;
-            }
-        }
-    };
-    visit(occupied, placed);
-    return { count, solution, complete, nodes };
+    const { csp, rectangles, clues } = shikakuModel(board);
+    const start = openSlots(csp);
+    for (const r of placed) {
+        const slot = rectangles.findIndex(c => c.x === r.x && c.y === r.y && c.width === r.width && c.height === r.height);
+        if (slot < 0)
+            return { count: 0, solution: null, complete: true, nodes: 0 };
+        decide(csp, start, clues.indexOf(clueOf(board, r)), slot);
+    }
+    const found = solveCsp(csp, start, limit, budget);
+    const solution = found.solution ? [...placed.map(r => ({ ...r })), ...rectangles.filter((_, slot) => found.solution[slot] === 1 && !placed.some(r => sameRectangle(r, rectangles[slot])))] : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }
+const sameRectangle = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+const clueOf = (board, r) => {
+    for (let y = r.y; y < r.y + r.height; y += 1)
+        for (let x = r.x; x < r.x + r.width; x += 1)
+            if (board.clues[y * board.width + x])
+                return y * board.width + x;
+    return -1;
+};

package/dist/shikakuTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { ShikakuLevel, ShikakuPuzzle } from "./shikaku.types.ts";
+/** The first generator, kept as the fallback that cannot fail on a board it can make: seeded cuts into rectangles, accepted when the answer is single. */
+export declare function templateShikaku(width?: number, height?: number, level?: ShikakuLevel, seed?: number): ShikakuPuzzle;

package/dist/shikakuTemplate.js

@@ -0,0 +1,43 @@
+import { SHIKAKU_LEVELS, SHIKAKU_MOST_ATTEMPTS } from "./shikaku.constants.js";
+import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { solveShikaku } from "./shikakuSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** The first generator, kept as the fallback that cannot fail on a board it can make: seeded cuts into rectangles, accepted when the answer is single. */
+export function templateShikaku(width = 7, height = width, level = "medium", seed = 1) {
+    if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= 16))
+        throw new RangeError("Invalid Shikaku dimensions");
+    const empty = { width, height, clues: Array(width * height).fill(0) };
+    if (!isKazuSeed(seed) || !SHIKAKU_LEVELS.includes(level)
+        || !isShikakuBoard({ ...empty, clues: [width * height, ...empty.clues.slice(1)] }))
+        throw new RangeError("Invalid Shikaku settings");
+    const random = seededRandom(seed), maximum = { easy: 5, medium: 9, hard: 15, "extra-hard": 20 }[level];
+    for (let attempt = 0; attempt < SHIKAKU_MOST_ATTEMPTS; attempt += 1) {
+        const solution = [];
+        const split = (r) => {
+            if (r.width * r.height <= maximum && (r.width * r.height < 3 || random() < .6)) {
+                solution.push(r);
+                return;
+            }
+            const vertical = r.height === 1 || (r.width > 1 && random() < .5);
+            const cut = 1 + Math.floor(random() * ((vertical ? r.width : r.height) - 1));
+            if (vertical) {
+                split({ ...r, width: cut });
+                split({ ...r, x: r.x + cut, width: r.width - cut });
+            }
+            else {
+                split({ ...r, height: cut });
+                split({ ...r, y: r.y + cut, height: r.height - cut });
+            }
+        };
+        split({ x: 0, y: 0, width, height });
+        const clues = [...empty.clues];
+        for (const r of solution) {
+            const cells = shikakuCells(empty, r);
+            clues[cells[Math.floor(random() * cells.length)]] = cells.length;
+        }
+        const board = { width, height, clues }, counted = solveShikaku(board);
+        if (counted.complete && counted.count === 1)
+            return { ...board, seed, level, solution: counted.solution };
+    }
+    throw new Error("No unique Shikaku found within the generation budget; try another seed");
+}

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

@@ -0,0 +1,2 @@
+export { drawSlitherlink } from "./slitherlinkDraw.ts";
+export type { SlitherlinkDrawOptions } from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-draw-entry.js

@@ -0,0 +1 @@
+export { drawSlitherlink } from "./slitherlinkDraw.js";

package/dist/slitherlink-entry.d.ts

@@ -0,0 +1,12 @@
+/** Slitherlink uses a dedicated edge model and a single-loop constraint. */
+export * from "./slitherlink.types.ts";
+export * from "./slitherlink.constants.ts";
+export * from "./slitherlinkBoard.ts";
+export * from "./slitherlinkSolve.ts";
+export * from "./slitherlinkGenerate.ts";
+export * from "./slitherlinkRate.ts";
+export * from "./slitherlinkGame.ts";
+export { drawSlitherlink } from "./slitherlinkDraw.ts";
+export type { SlitherlinkDrawOptions } from "./slitherlinkPlay.types.ts";
+export { mountSlitherlink } from "./slitherlinkMount.ts";
+export type * from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-entry.js

@@ -0,0 +1,10 @@
+/** Slitherlink uses a dedicated edge model and a single-loop constraint. */
+export * from "./slitherlink.types.js";
+export * from "./slitherlink.constants.js";
+export * from "./slitherlinkBoard.js";
+export * from "./slitherlinkSolve.js";
+export * from "./slitherlinkGenerate.js";
+export * from "./slitherlinkRate.js";
+export * from "./slitherlinkGame.js";
+export { drawSlitherlink } from "./slitherlinkDraw.js";
+export { mountSlitherlink } from "./slitherlinkMount.js";

package/dist/slitherlink-play-entry.d.ts

@@ -0,0 +1,4 @@
+export { mountSlitherlink } from "./slitherlinkMount.ts";
+export { SLITHERLINK_PLAY_STYLE } from "./slitherlinkStyle.ts";
+export { SLITHERLINK_STRINGS } from "./slitherlinkStrings.ts";
+export type * from "./slitherlinkPlay.types.ts";

package/dist/slitherlink-play-entry.js

@@ -0,0 +1,3 @@
+export { mountSlitherlink } from "./slitherlinkMount.js";
+export { SLITHERLINK_PLAY_STYLE } from "./slitherlinkStyle.js";
+export { SLITHERLINK_STRINGS } from "./slitherlinkStrings.js";

package/dist/slitherlink.constants.d.ts

@@ -0,0 +1,7 @@
+export declare const SLITHERLINK_MOST_SIDE = 10;
+export declare const SLITHERLINK_MOST_NODES = 300000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateSlitherlink`. */
+export declare const SLITHERLINK_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 2 to `SLITHERLINK_MOST_SIDE` can be made. */
+export declare const SLITHERLINK_SIZES: readonly [5, 7, 10];
+export declare const SLITHERLINK_MOST_ATTEMPTS = 40;

package/dist/slitherlink.constants.js

@@ -0,0 +1,7 @@
+export const SLITHERLINK_MOST_SIDE = 10;
+export const SLITHERLINK_MOST_NODES = 300000;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateSlitherlink`. */
+export const SLITHERLINK_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+/** The sides on offer for a square board; any side from 2 to `SLITHERLINK_MOST_SIDE` can be made. */
+export const SLITHERLINK_SIZES = [5, 7, 10];
+export const SLITHERLINK_MOST_ATTEMPTS = 40;

package/dist/slitherlink.types.d.ts

@@ -0,0 +1,52 @@
+export type SlitherlinkBoard = {
+    width: number;
+    height: number;
+    clues: readonly (number | null)[];
+};
+export type SlitherlinkLevel = "easy" | "medium" | "hard" | "extra-hard";
+export type SlitherlinkPuzzle = SlitherlinkBoard & {
+    seed: number;
+    level: SlitherlinkLevel;
+    solution: readonly number[];
+};
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the plain rules solve it, 1 that somebody has to
+ * suppose an edge drawn or crossed and watch it break, 2 that more than that is needed; `probes` is how many
+ * suppositions depth 1 needed. The rest describes the board.
+ */
+export type SlitherlinkRating = {
+    depth: 0 | 1 | 2;
+    probes: number;
+    clues: number;
+    /** Numbered squares as a share of all squares. */
+    clueShare: number;
+    /** Squares numbered 0 as a share of the numbered ones. */
+    zeroShare: number;
+    /** Edges in the loop. */
+    loop: number;
+};
+export type SlitherlinkCheck = {
+    ok: boolean;
+    errors: readonly number[];
+    clues: readonly number[];
+    vertices: readonly number[];
+    loops: number;
+};
+export type SlitherlinkProgress = {
+    ok: boolean;
+    clues: readonly number[];
+    vertices: readonly number[];
+    loops: number;
+};
+export type SlitherlinkSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type SlitherlinkGame = {
+    board: SlitherlinkBoard;
+    edges: readonly number[];
+    history: readonly (readonly number[])[];
+    helped: boolean;
+};

package/dist/slitherlink.types.js

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

package/dist/slitherlinkBoard.d.ts

@@ -0,0 +1,12 @@
+import type { SlitherlinkBoard, SlitherlinkCheck, SlitherlinkProgress } from "./slitherlink.types.ts";
+export declare function isSlitherlinkBoard(value: unknown): value is SlitherlinkBoard;
+export declare function slitherlinkHorizontalCount(board: SlitherlinkBoard): number;
+/** An edge index is horizontal row-major first, then vertical row-major. */
+export declare function slitherlinkEdgeCount(board: SlitherlinkBoard): number;
+export declare function slitherlinkCellEdges(board: SlitherlinkBoard, cell: number): [number, number, number, number] | null;
+export declare function slitherlinkVertexEdges(board: SlitherlinkBoard, vertex: number): number[];
+/** Checks all numbered cells, degree-two vertices, and one connected closed loop. */
+export declare function checkSlitherlink(board: SlitherlinkBoard, edges: readonly number[]): SlitherlinkCheck;
+/** Reports overfilled clues and branched vertices during play without requiring a finished loop. */
+export declare function progressSlitherlink(board: SlitherlinkBoard, edges: readonly number[]): SlitherlinkProgress;
+export declare function edgeVertices(board: SlitherlinkBoard, edge: number): [number, number];

package/dist/slitherlinkBoard.js

@@ -0,0 +1,132 @@
+import { SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
+export function isSlitherlinkBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    return Number.isInteger(board.width) && board.width >= 2 && board.width <= SLITHERLINK_MOST_SIDE
+        && Number.isInteger(board.height) && board.height >= 2 && board.height <= SLITHERLINK_MOST_SIDE
+        && Array.isArray(board.clues) && board.clues.length === board.width * board.height
+        && board.clues.every(clue => clue === null || Number.isInteger(clue) && clue >= 0 && clue <= 3);
+}
+export function slitherlinkHorizontalCount(board) {
+    return board.width * (board.height + 1);
+}
+/** An edge index is horizontal row-major first, then vertical row-major. */
+export function slitherlinkEdgeCount(board) {
+    return slitherlinkHorizontalCount(board) + (board.width + 1) * board.height;
+}
+export function slitherlinkCellEdges(board, cell) {
+    if (!Number.isInteger(cell) || cell < 0 || cell >= board.width * board.height)
+        return null;
+    const x = cell % board.width;
+    const y = Math.floor(cell / board.width);
+    const horizontal = slitherlinkHorizontalCount(board);
+    const top = y * board.width + x;
+    const bottom = (y + 1) * board.width + x;
+    const left = horizontal + y * (board.width + 1) + x;
+    const right = left + 1;
+    return [top, right, bottom, left];
+}
+export function slitherlinkVertexEdges(board, vertex) {
+    const vertexWidth = board.width + 1;
+    if (!Number.isInteger(vertex) || vertex < 0 || vertex >= vertexWidth * (board.height + 1))
+        return [];
+    const x = vertex % vertexWidth;
+    const y = Math.floor(vertex / vertexWidth);
+    const horizontal = slitherlinkHorizontalCount(board);
+    const edges = [];
+    if (x > 0)
+        edges.push(y * board.width + x - 1);
+    if (x < board.width)
+        edges.push(y * board.width + x);
+    if (y > 0)
+        edges.push(horizontal + (y - 1) * vertexWidth + x);
+    if (y < board.height)
+        edges.push(horizontal + y * vertexWidth + x);
+    return edges;
+}
+function evaluate(board, selected, complete) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    const edgeCount = slitherlinkEdgeCount(board);
+    const errors = selected.filter((edge, index) => !Number.isInteger(edge)
+        || edge < 0 || edge >= edgeCount || selected.indexOf(edge) !== index);
+    const edges = [...new Set(selected.filter(edge => Number.isInteger(edge) && edge >= 0 && edge < edgeCount))];
+    const edgeSet = new Set(edges);
+    const vertexDegrees = Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => slitherlinkVertexEdges(board, vertex).filter(edge => edgeSet.has(edge)).length);
+    const vertices = vertexDegrees.flatMap((degree, vertex) => degree > 2 || complete && degree === 1 ? [vertex] : []);
+    const clues = board.clues.flatMap((clue, cell) => {
+        if (clue === null)
+            return [];
+        const count = slitherlinkCellEdges(board, cell).filter(edge => edgeSet.has(edge)).length;
+        return complete ? count !== clue ? [cell] : [] : count > clue ? [cell] : [];
+    });
+    const closed = closedComponents(board, edgeSet);
+    const loops = closed.count;
+    const detachedClosedLoop = loops > 0 && closed.edges !== edges.length;
+    const loopError = complete
+        ? edges.length === 0 || loops !== 1
+        : loops > 1 || detachedClosedLoop;
+    return {
+        ok: !errors.length && !vertices.length && !clues.length && !loopError,
+        errors,
+        clues,
+        vertices,
+        loops,
+    };
+}
+/** Checks all numbered cells, degree-two vertices, and one connected closed loop. */
+export function checkSlitherlink(board, edges) {
+    return evaluate(board, edges, true);
+}
+/** Reports overfilled clues and branched vertices during play without requiring a finished loop. */
+export function progressSlitherlink(board, edges) {
+    const result = evaluate(board, edges, false);
+    return { ok: result.ok, clues: result.clues, vertices: result.vertices, loops: result.loops };
+}
+function closedComponents(board, edges) {
+    if (!edges.size)
+        return { count: 0, edges: 0 };
+    const unseen = new Set(edges);
+    let count = 0;
+    let closedEdges = 0;
+    while (unseen.size) {
+        const first = unseen.values().next().value;
+        const component = new Set([first]);
+        const queue = [first];
+        unseen.delete(first);
+        while (queue.length) {
+            const edge = queue.pop();
+            for (const vertex of edgeVertices(board, edge)) {
+                for (const neighbour of slitherlinkVertexEdges(board, vertex)) {
+                    if (!unseen.has(neighbour))
+                        continue;
+                    unseen.delete(neighbour);
+                    component.add(neighbour);
+                    queue.push(neighbour);
+                }
+            }
+        }
+        const degreeTwo = [...component].every(edge => edgeVertices(board, edge)
+            .every(vertex => slitherlinkVertexEdges(board, vertex).filter(adjacent => component.has(adjacent)).length === 2));
+        if (degreeTwo) {
+            count += 1;
+            closedEdges += component.size;
+        }
+    }
+    return { count, edges: closedEdges };
+}
+export function edgeVertices(board, edge) {
+    const horizontal = slitherlinkHorizontalCount(board);
+    if (edge < horizontal) {
+        const x = edge % board.width;
+        const y = Math.floor(edge / board.width);
+        const left = y * (board.width + 1) + x;
+        return [left, left + 1];
+    }
+    const local = edge - horizontal;
+    const x = local % (board.width + 1);
+    const y = Math.floor(local / (board.width + 1));
+    const top = y * (board.width + 1) + x;
+    return [top, top + board.width + 1];
+}

package/dist/slitherlinkDraw.d.ts

@@ -0,0 +1,4 @@
+import type { SlitherlinkBoard } from "./slitherlink.types.ts";
+import type { SlitherlinkDrawOptions } from "./slitherlinkPlay.types.ts";
+/** Draws public clues and selected loop edges as an SVG board. */
+export declare function drawSlitherlink(board: SlitherlinkBoard, options?: SlitherlinkDrawOptions): string;

package/dist/slitherlinkDraw.js

@@ -0,0 +1,51 @@
+import { edgeVertices, isSlitherlinkBoard, } from "./slitherlinkBoard.js";
+import { slitherlinkWords } from "./slitherlinkStrings.js";
+/** Draws public clues and selected loop edges as an SVG board. */
+export function drawSlitherlink(board, options = {}) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    const words = slitherlinkWords(options.language);
+    const size = 48;
+    const colours = {
+        ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"],
+        wood: ["#e5cda6", "#493e2f", "#bca582"],
+        slate: ["#262a27", "#ece8dc", "#454a44"],
+    };
+    const [paper, ink, grid] = colours[options.material ?? "ivory"];
+    const selected = new Set(options.edges ?? []);
+    const clueText = board.clues.map((clue, cell) => {
+        if (clue === null)
+            return "";
+        const x = (cell % board.width + .5) * size;
+        const y = (Math.floor(cell / board.width) + .53) * size;
+        return `<text x="${x}" y="${y}" dominant-baseline="middle" text-anchor="middle" fill="${ink}" font-size="20" font-weight="700" font-family="system-ui,sans-serif">${clue}</text>`;
+    }).join("");
+    const lines = [...selected].map(edge => {
+        const [a, b] = edgeVertices(board, edge);
+        const x1 = (a % (board.width + 1)) * size;
+        const y1 = Math.floor(a / (board.width + 1)) * size;
+        const x2 = (b % (board.width + 1)) * size;
+        const y2 = Math.floor(b / (board.width + 1)) * size;
+        const bad = options.errors?.includes(edge);
+        const active = options.selected === edge;
+        const colour = bad ? "var(--kz-bad,#b5452c)" : active ? "var(--kz-frame,#a98954)" : ink;
+        return `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${colour}" stroke-width="${active ? 6 : 4}" stroke-linecap="round"/>`;
+    }).join("");
+    const dots = Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => {
+        const x = (vertex % (board.width + 1)) * size;
+        const y = Math.floor(vertex / (board.width + 1)) * size;
+        return `<circle cx="${x}" cy="${y}" r="3.2" fill="${ink}"/>`;
+    }).join("");
+    const gridLines = [];
+    for (let y = 0; y <= board.height; y += 1) {
+        for (let x = 0; x < board.width; x += 1) {
+            gridLines.push(`<line x1="${x * size}" y1="${y * size}" x2="${(x + 1) * size}" y2="${y * size}" stroke="${grid}" stroke-width="1"/>`);
+        }
+    }
+    for (let y = 0; y < board.height; y += 1) {
+        for (let x = 0; x <= board.width; x += 1) {
+            gridLines.push(`<line x1="${x * size}" y1="${y * size}" x2="${x * size}" y2="${(y + 1) * size}" stroke="${grid}" stroke-width="1"/>`);
+        }
+    }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-4 -4 ${board.width * size + 8} ${board.height * size + 8}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${gridLines.join("")}${clueText}${lines}${dots}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/slitherlinkGame.d.ts

@@ -0,0 +1,8 @@
+import type { SlitherlinkBoard, SlitherlinkGame } from "./slitherlink.types.ts";
+export declare function newSlitherlink(board: SlitherlinkBoard): SlitherlinkGame;
+export declare function toggleSlitherlink(game: SlitherlinkGame, edge: number): SlitherlinkGame;
+export declare function undoSlitherlink(game: SlitherlinkGame): SlitherlinkGame;
+export declare function slitherlinkFinished(game: SlitherlinkGame): boolean;
+export declare function hintSlitherlink(game: SlitherlinkGame): number | null;
+export declare function encodeSlitherlink(game: SlitherlinkGame): string;
+export declare function decodeSlitherlink(code: string): SlitherlinkGame | null;

package/dist/slitherlinkGame.js

@@ -0,0 +1,63 @@
+import { checkSlitherlink, isSlitherlinkBoard } from "./slitherlinkBoard.js";
+import { solveSlitherlink } from "./slitherlinkSolve.js";
+export function newSlitherlink(board) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    return {
+        board: { width: board.width, height: board.height, clues: [...board.clues] },
+        edges: [],
+        history: [],
+        helped: false,
+    };
+}
+export function toggleSlitherlink(game, edge) {
+    const maximum = (game.board.height + 1) * game.board.width + game.board.height * (game.board.width + 1);
+    if (!Number.isInteger(edge) || edge < 0 || edge >= maximum)
+        return game;
+    const edges = game.edges.includes(edge)
+        ? game.edges.filter(selected => selected !== edge)
+        : [...game.edges, edge];
+    return { ...game, edges, history: [...game.history, [...game.edges]] };
+}
+export function undoSlitherlink(game) {
+    const previous = game.history.at(-1);
+    return previous
+        ? { ...game, edges: [...previous], history: game.history.slice(0, -1) }
+        : game;
+}
+export function slitherlinkFinished(game) {
+    return checkSlitherlink(game.board, game.edges).ok;
+}
+export function hintSlitherlink(game) {
+    const solved = solveSlitherlink(game.board);
+    if (!solved.complete || solved.count !== 1 || !solved.solution)
+        return null;
+    return solved.solution.find(edge => !game.edges.includes(edge))
+        ?? game.edges.find(edge => !solved.solution.includes(edge))
+        ?? null;
+}
+export function encodeSlitherlink(game) {
+    return JSON.stringify({ version: 1, board: game.board, edges: game.edges, helped: game.helped });
+}
+export function decodeSlitherlink(code) {
+    try {
+        if (code.length > 40000)
+            return null;
+        const value = JSON.parse(code);
+        if (value.version !== 1 || !isSlitherlinkBoard(value.board) || !Array.isArray(value.edges)
+            || value.edges.length > (value.board.width + 1) * (value.board.height + 1) * 2
+            || typeof value.helped !== "boolean" || new Set(value.edges).size !== value.edges.length)
+            return null;
+        let game = newSlitherlink(value.board);
+        for (const edge of value.edges) {
+            const next = toggleSlitherlink(game, edge);
+            if (next === game)
+                return null;
+            game = next;
+        }
+        return { ...game, history: [], helped: value.helped };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/slitherlinkGenerate.d.ts

@@ -0,0 +1,10 @@
+import type { SlitherlinkLevel, SlitherlinkPuzzle } from "./slitherlink.types.ts";
+/**
+ * Makes a seeded puzzle and proves it has one answer. A random winding loop is grown cell by cell, every square is
+ * numbered with how many of its edges the loop uses, and then numbers are taken away for as long as the puzzle can
+ * still be solved the way the level asks: easy and medium by the rules alone (easy keeps most numbers), hard by
+ * supposing one edge at a time, extra-hard the most-supposing of several such boards. Numbers that say 0 are
+ * taken away first, because they say least. If no board of the level is found within the attempts the next level
+ * down is tried, and the first generator, which cannot fail, is the last.
+ */
+export declare function generateSlitherlink(width?: number, height?: number, seed?: number, level?: SlitherlinkLevel): SlitherlinkPuzzle;