@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/shikakuRate.js

@@ -0,0 +1,27 @@
+import { isShikakuBoard } from "./shikakuBoard.js";
+import { shikakuModel } from "./shikakuLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it with the first rule, with the first two, with all three, then by supposing. */
+export function rateShikaku(board) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const first = shikakuModel(board, 0), second = shikakuModel(board, 1), strong = shikakuModel(board, 2);
+    const proof = solveCsp(strong.csp, openSlots(strong.csp), 2, 100000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Shikaku rating needs a board with one answer");
+    const one = logicCsp(first.csp, openSlots(first.csp), 0);
+    const two = one.solved ? one : logicCsp(second.csp, openSlots(second.csp), 0);
+    const rules = two.solved ? two : logicCsp(strong.csp, openSlots(strong.csp), 0);
+    const probing = rules.solved ? rules : logicCsp(strong.csp, openSlots(strong.csp), 1);
+    const areas = strong.clues.map(cell => board.clues[cell]);
+    const options = strong.clues.map((_, v) => strong.csp.starts[v + 1] - strong.csp.starts[v]);
+    return {
+        depth: rules.solved ? 0 : probing.solved ? 1 : 2,
+        rules: one.solved ? 1 : two.solved ? 2 : 3,
+        probes: rules.solved ? 0 : probing.probes,
+        rectangles: areas.length,
+        meanArea: board.clues.length / areas.length,
+        largest: Math.max(...areas),
+        ambiguity: options.reduce((a, b) => a + b, 0) / options.length,
+    };
+}

package/dist/shikakuSolve.d.ts

@@ -1,5 +1,5 @@
 import type { ShikakuBoard, ShikakuRectangle, ShikakuSolve } from "./shikaku.types.ts";
-/** Exact cover over cells. A bounded search reports incompleteness instead of claiming uniqueness. */
+/** Exact cover over squares. A bounded search reports incompleteness instead of claiming uniqueness. */
 export declare function solveShikaku(board: ShikakuBoard, placed?: readonly ShikakuRectangle[], options?: {
     limit?: number;
     nodes?: number;

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-entry.d.ts

@@ -4,6 +4,7 @@ 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";

package/dist/slitherlink-entry.js

@@ -4,6 +4,7 @@ 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.constants.d.ts

@@ -1,2 +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

@@ -1,2 +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

@@ -3,10 +3,28 @@ export type SlitherlinkBoard = {
     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[];

package/dist/slitherlinkGenerate.d.ts

@@ -1,3 +1,10 @@
-import type { SlitherlinkPuzzle } from "./slitherlink.types.ts";
-/** Makes a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
-export declare function generateSlitherlink(width?: number, height?: number, seed?: number): SlitherlinkPuzzle;
+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;

package/dist/slitherlinkGenerate.js

@@ -1,101 +1,182 @@
-import { SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
-import { checkSlitherlink, isSlitherlinkBoard, slitherlinkCellEdges, } from "./slitherlinkBoard.js";
+import { SLITHERLINK_LEVELS, SLITHERLINK_MOST_ATTEMPTS, SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
+import { checkSlitherlink, slitherlinkCellEdges } from "./slitherlinkBoard.js";
+import { slitherlinkModel } from "./slitherlinkLogic.js";
 import { solveSlitherlink } from "./slitherlinkSolve.js";
-import { isKazuSeed, seededRandom } from "./random.js";
-/** Makes a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
-export function generateSlitherlink(width = 5, height = width, seed = 1) {
+import { templateSlitherlink } from "./slitherlinkTemplate.js";
+import { countCsp, logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+/**
+ * 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 function generateSlitherlink(width = 5, height = width, seed = 1, level = "medium") {
     if (![width, height].every(side => Number.isInteger(side) && side >= 2 && side <= SLITHERLINK_MOST_SIDE)
-        || !isKazuSeed(seed))
+        || !isKazuSeed(seed) || !SLITHERLINK_LEVELS.includes(level))
         throw new RangeError("Invalid Slitherlink settings");
     const random = seededRandom(seed);
-    const useL = width >= 3 && height >= 3 && random() < .5;
-    const region = [];
-    let x0;
-    let y0;
-    let blockWidth;
-    let blockHeight;
-    if (useL) {
-        blockWidth = 2 + Math.floor(random() * (width - 1));
-        blockHeight = 2 + Math.floor(random() * (height - 1));
-        x0 = Math.floor(random() * (width - blockWidth + 1));
-        y0 = Math.floor(random() * (height - blockHeight + 1));
-        for (let y = 0; y < blockHeight; y += 1) {
-            for (let x = 0; x < blockWidth; x += 1) {
-                if (x === 0 || y === 0)
-                    region.push((y0 + y) * width + x0 + x);
+    // The work an attempt does is counted in rule runs, never in time, so a seed makes the same puzzle on every machine. When a level has used its share the next one down is tried.
+    const work = { calls: 0, limit: width * height * 900 };
+    for (let aim = SLITHERLINK_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        work.calls = 0;
+        const aimed = SLITHERLINK_LEVELS[aim];
+        const wanted = 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < SLITHERLINK_MOST_ATTEMPTS && found < wanted && work.calls < work.limit; attempt += 1) {
+            const made = attemptSlitherlink(width, height, aimed, random, work);
+            if (!made)
+                continue;
+            found += 1;
+            if (!best || made.probes > best.probes)
+                best = made;
+        }
+        if (best) {
+            const proof = solveSlitherlink(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkSlitherlink(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
             }
         }
     }
-    else {
-        blockWidth = 1 + Math.floor(random() * width);
-        blockHeight = 1 + Math.floor(random() * height);
-        if (blockWidth === 1 && blockHeight === 1)
-            blockWidth = 2;
-        x0 = Math.floor(random() * (width - blockWidth + 1));
-        y0 = Math.floor(random() * (height - blockHeight + 1));
-        for (let y = 0; y < blockHeight; y += 1) {
-            for (let x = 0; x < blockWidth; x += 1)
-                region.push((y0 + y) * width + x0 + x);
+    return { ...templateSlitherlink(width, height, seed), level };
+}
+/** The loop of a random region of squares: connected, without a hole, and never touching itself at a corner. */
+function growRegion(width, height, share, thin, random) {
+    const stride = width + 2, inside = new Uint8Array(stride * (height + 2));
+    const at = (x, y) => (y + 1) * stride + x + 1;
+    const target = Math.max(2, Math.round(width * height * share));
+    const start = at(Math.floor(random() * width), Math.floor(random() * height));
+    inside[start] = 1;
+    let size = 1;
+    const outsideReaches = () => {
+        // Every square not in the region must still be reachable from beyond the board.
+        const seen = new Uint8Array(inside.length), stack = [0];
+        seen[0] = 1;
+        let reached = 1;
+        while (stack.length) {
+            const cell = stack.pop();
+            for (const next of [cell - 1, cell + 1, cell - stride, cell + stride]) {
+                if (next < 0 || next >= inside.length || seen[next] || inside[next])
+                    continue;
+                seen[next] = 1;
+                reached += 1;
+                stack.push(next);
+            }
         }
+        return reached === inside.length - size;
+    };
+    while (size < target) {
+        const options = [];
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const cell = at(x, y);
+                if (inside[cell])
+                    continue;
+                const touching = (inside[cell - 1] + inside[cell + 1] + inside[cell - stride] + inside[cell + stride]);
+                if (!touching)
+                    continue;
+                // Two squares touching only at a corner would pinch the loop where it passes itself.
+                if ([[cell - 1, cell - stride, cell - stride - 1], [cell + 1, cell - stride, cell - stride + 1], [cell - 1, cell + stride, cell + stride - 1], [cell + 1, cell + stride, cell + stride + 1]]
+                    .some(([a, b, diagonal]) => inside[diagonal] && !inside[a] && !inside[b]))
+                    continue;
+                inside[cell] = 1;
+                size += 1;
+                const fine = outsideReaches();
+                inside[cell] = 0;
+                size -= 1;
+                if (!fine)
+                    continue;
+                options.push({ cell, touching });
+            }
+        if (!options.length)
+            break;
+        const thinnest = options.filter(option => option.touching === 1);
+        const pool = thinnest.length && random() < thin ? thinnest : options;
+        inside[pool[Math.floor(random() * pool.length)].cell] = 1;
+        size += 1;
     }
+    const region = new Uint8Array(width * height);
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1)
+            region[y * width + x] = inside[at(x, y)];
+    return region;
+}
+function loopOf(width, height, region) {
     const blank = { width, height, clues: Array(width * height).fill(null) };
-    const regionSet = new Set(region);
     const edges = new Set();
-    for (const cell of region) {
+    for (let cell = 0; cell < region.length; cell += 1) {
+        if (!region[cell])
+            continue;
         const [top, right, bottom, left] = slitherlinkCellEdges(blank, cell);
         const x = cell % width;
-        if (!regionSet.has(cell - width))
+        if (cell < width || !region[cell - width])
             edges.add(top);
-        if (x === width - 1 || !regionSet.has(cell + 1))
+        if (x === width - 1 || !region[cell + 1])
             edges.add(right);
-        if (!regionSet.has(cell + width))
+        if (cell >= width * (height - 1) || !region[cell + width])
             edges.add(bottom);
-        if (x === 0 || !regionSet.has(cell - 1))
+        if (x === 0 || !region[cell - 1])
             edges.add(left);
     }
-    let board = {
-        width,
-        height,
-        clues: Array.from({ length: width * height }, (_, cell) => slitherlinkCellEdges(blank, cell).filter(edge => edges.has(edge)).length),
+    return edges;
+}
+function attemptSlitherlink(width, height, level, random, work) {
+    const share = { easy: .45, medium: .5, hard: .55, "extra-hard": .6 }[level] * (.9 + random() * .2);
+    const region = growRegion(width, height, share, .75, random);
+    const edges = loopOf(width, height, region);
+    const blank = { width, height, clues: Array(width * height).fill(null) };
+    const full = Array.from({ length: width * height }, (_, cell) => slitherlinkCellEdges(blank, cell).filter(edge => edges.has(edge)).length);
+    const clues = [...full];
+    let calls = 0;
+    const csp = () => {
+        const { csp: model } = slitherlinkModel({ width, height, clues });
+        return { ...model, propagate: (alive, decided) => { calls += 1; work.calls += 1; return model.propagate(alive, decided); } };
+    };
+    const byRules = () => { const c = csp(); return logicCsp(c, openSlots(c), 0).solved; };
+    const bySupposing = () => {
+        const c = csp();
+        const count = countCsp(c, openSlots(c), 2, 800);
+        if (!count.exhausted && count.count !== 1)
+            return false;
+        return logicCsp(c, openSlots(c), 1).solved;
     };
-    let answer = [...edges];
-    // Seeded axis reflections give each selected shape more than one orientation.
-    const reflectX = random() < .5;
-    const reflectY = random() < .5;
-    if (reflectX || reflectY) {
-        const horizontalCount = width * (height + 1);
-        const mapEdge = (edge) => {
-            if (edge < horizontalCount) {
-                const x = edge % width;
-                const y = Math.floor(edge / width);
-                const nextX = reflectX ? width - 1 - x : x;
-                const nextY = reflectY ? height - y : y;
-                return nextY * width + nextX;
+    if (!byRules())
+        return null;
+    const order = shuffled(clues.map((_, cell) => cell), random).sort((a, b) => (full[a] === 0 ? 0 : 1) - (full[b] === 0 ? 0 : 1));
+    const keepAtLeast = level === "easy" ? Math.ceil(width * height * .7) : 0;
+    let left = clues.length;
+    /** Takes numbers away while `test` still passes, until `spent` says the work is used up or `done` says the board is hard enough. */
+    const thin = (test, spent, done = () => false) => {
+        for (const cell of order) {
+            if (clues[cell] === null)
+                continue;
+            if (left <= keepAtLeast || spent())
+                return;
+            const was = clues[cell];
+            clues[cell] = null;
+            if (!test()) {
+                clues[cell] = was;
+                continue;
             }
-            const local = edge - horizontalCount;
-            const x = local % (width + 1);
-            const y = Math.floor(local / (width + 1));
-            const nextX = reflectX ? width - x : x;
-            const nextY = reflectY ? height - 1 - y : y;
-            return horizontalCount + nextY * (width + 1) + nextX;
-        };
-        const reflected = Array(width * height).fill(null);
-        board.clues.forEach((clue, cell) => {
-            const x = cell % width;
-            const y = Math.floor(cell / width);
-            const nextX = reflectX ? width - 1 - x : x;
-            const nextY = reflectY ? height - 1 - y : y;
-            reflected[nextY * width + nextX] = clue;
-        });
-        board = { width, height, clues: reflected };
-        answer = answer.map(mapEdge);
-    }
-    if (!isSlitherlinkBoard(board) || !checkSlitherlink(board, answer).ok) {
-        throw new Error("Unable to construct Slitherlink loop");
-    }
-    const proof = solveSlitherlink(board, { limit: 2 });
-    if (!proof.complete || proof.count !== 1 || !proof.solution) {
-        throw new Error("No uniquely solvable Slitherlink found within the generation budget");
-    }
-    return { ...board, seed, solution: proof.solution };
+            left -= 1;
+            if (done())
+                return;
+        }
+    };
+    thin(byRules, () => false);
+    // Hard stops thinning when its share of work is used; extra-hard is given four times as much and so ends sparser.
+    const budget = width * height * (level === "extra-hard" ? 420 : 120);
+    const from = calls;
+    if (level === "hard" || level === "extra-hard")
+        thin(bySupposing, () => calls - from > budget);
+    const board = { width, height, clues };
+    const c = csp();
+    if (logicCsp(c, openSlots(c), 0).solved)
+        return level === "easy" || level === "medium" ? { board, probes: 0 } : null;
+    if (level === "easy" || level === "medium")
+        return null;
+    const probing = logicCsp(c, openSlots(c), 1);
+    return probing.solved ? { board, probes: probing.probes } : level === "extra-hard" ? { board, probes: 1000 } : null;
 }

package/dist/slitherlinkLogic.d.ts

@@ -0,0 +1,10 @@
+import type { Csp } from "./csp.ts";
+import type { SlitherlinkBoard } from "./slitherlink.types.ts";
+/**
+ * Slitherlink as variables: one per edge, slot 0 for off and slot 1 for on. The pruning rules are the ones
+ * a person uses first: a number counts the edges round its square, every corner has none or two edges, and
+ * a loop may not close while any other part of it is still to be drawn or while a number is not yet met.
+ */
+export declare function slitherlinkModel(board: SlitherlinkBoard): {
+    csp: Csp;
+};