/* Puzzle Capsule Maker semantic core: deterministic generation, solving, scoring, minimization, and export. */ "use strict"; (function installPuzzleCapsuleCore(globalScope) { const SCHEMA = "puzzle-capsule/v1"; const ENGINE_VERSION = "1.0.0"; const ACTIONS = Object.freeze([ Object.freeze({ id: "U", dx: 0, dy: -1, label: "Up", glyph: "↑" }), Object.freeze({ id: "R", dx: 1, dy: 0, label: "Right", glyph: "→" }), Object.freeze({ id: "D", dx: 0, dy: 1, label: "Down", glyph: "↓" }), Object.freeze({ id: "L", dx: -1, dy: 0, label: "Left", glyph: "←" }), ]); const ACTION_BY_ID = Object.freeze(Object.fromEntries(ACTIONS.map((action) => [action.id, action]))); const MAX_HASH_64 = 0xffffffffffffffffn; const RULES = Object.freeze({ wrap_edges: Object.freeze({ id: "wrap_edges", order: 10, name: "Seam Wrap", short: "Walk off one edge and re-enter from the opposite edge.", family: "coordinate", representation: "bounded grid coordinate", mismatch: "modulo projection replaces ordinary out-of-bounds rejection", boundary: "outer board seam", transition: "an attempted step beyond the board wraps both player and pushed crates", observable: "an apparently disconnected region becomes adjacent through the seam", glyph: "↻", color: "amber", }), push_crates: Object.freeze({ id: "push_crates", order: 20, name: "Single Push", short: "Walking into a crate pushes it one legal cell.", family: "state", representation: "player occupancy and movable crate occupancy", mismatch: "a blocking collision is reinterpreted as a bounded state transfer", boundary: "player–crate contact", transition: "the crate advances first and the player inherits its former cell", observable: "a sealed corridor can be rearranged exactly once per push", glyph: "▣", color: "copper", }), ice_slide: Object.freeze({ id: "ice_slide", order: 30, name: "Ice Carry", short: "Entering ice repeats the move until ordinary ground or a blockage.", family: "temporal", representation: "one input command versus multiple deterministic substeps", mismatch: "input duration and movement duration disagree", boundary: "entry onto an ice tile", transition: "the current direction is replayed while the player remains on ice", observable: "one input crosses several cells and may overshoot a target", glyph: "≋", color: "cyan", }), paired_portals: Object.freeze({ id: "paired_portals", order: 40, name: "Paired Fold", short: "Entering either portal continues from the other portal.", family: "projection", representation: "visible cell adjacency and logical portal adjacency", mismatch: "collision arrival and continued location use different projections", boundary: "portal tile entry", transition: "the player is relocated to the paired portal before the command ends", observable: "a wall-separated room becomes one step away", glyph: "◎", color: "violet", }), toggle_doors: Object.freeze({ id: "toggle_doors", order: 50, name: "Latched Door", short: "Switches toggle every door between solid and passable.", family: "state", representation: "static door tile plus one shared latch bit", mismatch: "geometry depends on retained world state rather than appearance alone", boundary: "switch contact and door collision", transition: "stepping on a switch flips the canonical latch bit", observable: "a route changes without moving any visible wall", glyph: "⌁", color: "lime", }), phase_gates: Object.freeze({ id: "phase_gates", order: 60, name: "Phase Gate", short: "Phase switches flip between 0 and 1; only matching gates are passable.", family: "identity", representation: "one visible position with a hidden binary phase", mismatch: "the same gate is solid or empty for different canonical phases", boundary: "phase-switch contact and numbered gate entry", transition: "F flips phase; 0 and 1 admit only their matching phase", observable: "revisiting a coordinate in another phase changes its topology", glyph: "◐", color: "pink", }), crumble_floor: Object.freeze({ id: "crumble_floor", order: 70, name: "One-Way Floor", short: "A crumble tile becomes a wall after you leave it.", family: "lifecycle", representation: "tile identity plus a destroyed-cell set", mismatch: "the floor’s future collision state depends on traversal history", boundary: "departure from a crumble tile", transition: "the departed tile is inserted into canonical destroyed geometry", observable: "a route can be crossed once but cannot be retraced", glyph: "◇", color: "sand", }), echo_pad: Object.freeze({ id: "echo_pad", order: 80, name: "Echo Pad", short: "Landing on an echo pad repeats the same direction once.", family: "scheduler", representation: "one action event and a queued duplicate movement event", mismatch: "the scheduler executes one legal move twice", boundary: "arrival on an echo pad", transition: "after normal and ice movement, the command schedules one extra advance", observable: "a single tap clears a two-cell gap or causes an intentional overshoot", glyph: "»", color: "blue", }), }); const RULE_IDS = Object.freeze(Object.keys(RULES).sort((left, right) => RULES[left].order - RULES[right].order)); const SPECIAL_RULE_BY_TILE = Object.freeze({ I: "ice_slide", P: "paired_portals", K: "crumble_floor", E: "echo_pad", D: "toggle_doors", 0: "phase_gates", 1: "phase_gates", F: "phase_gates", }); const RECIPES = Object.freeze([ Object.freeze({ id: "wrap-column", rules: Object.freeze(["wrap_edges"]), rows: Object.freeze(["S###.", ".###.", ".###.", ".###G", "#####"]), note: "A disconnected column becomes reachable only through the left/right seam.", }), Object.freeze({ id: "portal-step", rules: Object.freeze(["paired_portals"]), rows: Object.freeze(["#######", "#S.P###", "###P.G#", "#######"]), note: "A paired projection folds two sealed corridors together.", }), Object.freeze({ id: "switch-drop", rules: Object.freeze(["toggle_doors"]), rows: Object.freeze(["#######", "#S.!###", "###D.G#", "#######"]), note: "The player changes collision geometry before descending through it.", }), Object.freeze({ id: "phase-stair", rules: Object.freeze(["phase_gates"]), rows: Object.freeze(["#########", "#S.F#####", "###1.F###", "#####0.G#", "#########"]), note: "Two phase changes make a staircase through mutually exclusive gates.", }), Object.freeze({ id: "crate-drop", rules: Object.freeze(["push_crates"]), rows: Object.freeze(["#######", "#S..###", "##.C.G#", "##...##", "#######"]), note: "The crate must be pushed into a pocket to open the only connector.", }), Object.freeze({ id: "ice-bridge", rules: Object.freeze(["ice_slide"]), rows: Object.freeze(["###########", "#S..III..G#", "###########"]), note: "A command expands into several substeps across an otherwise impassable bridge.", }), Object.freeze({ id: "crumbled-bridge", rules: Object.freeze(["crumble_floor"]), rows: Object.freeze(["#########", "#S..K..G#", "#########"]), note: "The bridge is traversable once and becomes history-dependent geometry.", }), Object.freeze({ id: "echo-gap", rules: Object.freeze(["echo_pad"]), rows: Object.freeze(["#########", "#S.E..G##", "#########"]), note: "The duplicated scheduler event advances farther than one visible input.", }), Object.freeze({ id: "portal-crumble", rules: Object.freeze(["paired_portals", "crumble_floor"]), rows: Object.freeze(["#########", "#S.P#####", "###P.K.G#", "#########"]), note: "A portal commits the player to a bridge that cannot be retraced.", }), Object.freeze({ id: "switch-phase", rules: Object.freeze(["toggle_doors", "phase_gates"]), rows: Object.freeze(["###########", "#S.!#######", "###D.F#####", "#####1...G#", "###########"]), note: "One shared latch and one personal phase must be changed in sequence.", }), Object.freeze({ id: "ice-portal", rules: Object.freeze(["ice_slide", "paired_portals"]), rows: Object.freeze(["###########", "#S.III.P###", "#######P.G#", "###########"]), note: "Stored direction carries the player to a projection fold.", }), Object.freeze({ id: "phase-echo", rules: Object.freeze(["phase_gates", "echo_pad"]), rows: Object.freeze(["###########", "#S.EF######", "####1.E.G##", "###########"]), note: "An echoed move lands on a phase switch before a second echo closes the route.", }), Object.freeze({ id: "push-switch", rules: Object.freeze(["push_crates", "toggle_doors"]), rows: Object.freeze(["#########", "#S..#####", "##.C.!###", "##..D.G##", "#########"]), note: "The crate is displaced before a retained latch can open the exit.", }), Object.freeze({ id: "portal-switch-phase", rules: Object.freeze(["paired_portals", "toggle_doors", "phase_gates"]), rows: Object.freeze(["#############", "#S.P#########", "###P.!#######", "#####D.F#####", "#######1...G#", "#############"]), note: "A topological fold, world latch, and personal phase form one causal chain.", }), Object.freeze({ id: "wrap-ice-crumble", rules: Object.freeze(["wrap_edges", "ice_slide", "crumble_floor"]), rows: Object.freeze(["S#########.", "##########.", "##G.K.III..", "###########"]), note: "The seam reaches an ice run that ends on a disposable bridge.", }), Object.freeze({ id: "push-portal-crumble", rules: Object.freeze(["push_crates", "paired_portals", "crumble_floor"]), rows: Object.freeze(["############", "#S..########", "##.C.P######", "##..#P.K.G##", "############"]), note: "A displaced crate exposes a fold leading to a one-use route.", }), ]); class RNG { constructor(seed) { const normalized = Number.isFinite(Number(seed)) ? Number(seed) : 0; this.state = (normalized >>> 0) || 0x6d2b79f5; } nextUint32() { let value = (this.state += 0x6d2b79f5) >>> 0; value = Math.imul(value ^ (value >>> 15), value | 1); value ^= value + Math.imul(value ^ (value >>> 7), value | 61); value = (value ^ (value >>> 14)) >>> 0; this.state = value; return value; } next() { return this.nextUint32() / 4294967296; } int(minimum, maximumExclusive) { if (!Number.isInteger(minimum) || !Number.isInteger(maximumExclusive) || maximumExclusive <= minimum) { throw new RangeError("RNG.int requires an increasing integer range"); } return minimum + Math.floor(this.next() * (maximumExclusive - minimum)); } bool(probability = 0.5) { return this.next() < probability; } pick(items) { if (!Array.isArray(items) || items.length === 0) { throw new RangeError("RNG.pick requires a non-empty array"); } return items[this.int(0, items.length)]; } shuffle(items) { const result = Array.from(items); for (let index = result.length - 1; index > 0; index -= 1) { const swap = this.int(0, index + 1); [result[index], result[swap]] = [result[swap], result[index]]; } return result; } } function clamp(value, minimum = 0, maximum = 1) { return Math.max(minimum, Math.min(maximum, Number(value))); } function round(value, digits = 6) { const scale = 10 ** digits; return Math.round((Number(value) + Number.EPSILON) * scale) / scale; } function stableStringify(value) { if (value === null || typeof value !== "object") { return JSON.stringify(value); } if (Array.isArray(value)) { return `[${value.map((item) => stableStringify(item)).join(",")}]`; } const entries = Object.keys(value) .sort() .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`); return `{${entries.join(",")}}`; } function fingerprint(value) { const text = typeof value === "string" ? value : stableStringify(value); let hash = 0xcbf29ce484222325n; for (let index = 0; index < text.length; index += 1) { const code = text.charCodeAt(index); hash ^= BigInt(code & 0xff); hash = (hash * 0x100000001b3n) & MAX_HASH_64; hash ^= BigInt((code >>> 8) & 0xff); hash = (hash * 0x100000001b3n) & MAX_HASH_64; } return hash.toString(16).padStart(16, "0"); } function canonicalRuleIds(ruleIds) { const unique = new Set(Array.from(ruleIds || [], (item) => String(item))); for (const id of unique) { if (!RULES[id]) { throw new Error(`unknown rule: ${id}`); } } return RULE_IDS.filter((id) => unique.has(id)); } function normalizeRows(inputRows) { if (!Array.isArray(inputRows) || inputRows.length < 2) { throw new Error("a board requires at least two rows"); } const rows = inputRows.map((row) => String(row)); const width = rows[0].length; if (width < 2 || rows.some((row) => row.length !== width)) { throw new Error("board rows must share a width of at least two cells"); } const allowed = new Set("#.SGCIP!D01FKE"); const counts = new Map(); for (const row of rows) { for (const tile of row) { if (!allowed.has(tile)) { throw new Error(`unsupported board tile: ${tile}`); } counts.set(tile, (counts.get(tile) || 0) + 1); } } if (counts.get("S") !== 1 || counts.get("G") !== 1) { throw new Error("board must contain exactly one S and one G"); } const portalCount = counts.get("P") || 0; if (portalCount !== 0 && portalCount !== 2) { throw new Error("portal boards require exactly two P tiles"); } return rows; } function parseBoard(inputRows) { const rows = normalizeRows(inputRows); const width = rows[0].length; const height = rows.length; const cells = []; const portals = []; const crates = []; let start = -1; let goal = -1; for (let y = 0; y < height; y += 1) { for (let x = 0; x < width; x += 1) { const index = y * width + x; let tile = rows[y][x]; if (tile === "S") start = index; if (tile === "G") goal = index; if (tile === "P") portals.push(index); if (tile === "C") { crates.push(index); tile = "."; } cells.push(tile); } } return Object.freeze({ rows: Object.freeze(rows.slice()), width, height, cells: Object.freeze(cells), start, goal, portals: Object.freeze(portals), initialCrates: Object.freeze(crates.sort((left, right) => left - right)), }); } function initialState(boardInput) { const board = boardInput.cells ? boardInput : parseBoard(boardInput); return { player: board.start, crates: Array.from(board.initialCrates), switchOn: false, phase: 0, crumbled: [], }; } function cloneState(state) { return { player: state.player, crates: Array.from(state.crates), switchOn: Boolean(state.switchOn), phase: Number(state.phase) === 1 ? 1 : 0, crumbled: Array.from(state.crumbled), }; } function canonicalState(state) { return { player: Number(state.player), crates: Array.from(new Set(Array.from(state.crates || [], Number))).sort((left, right) => left - right), switchOn: Boolean(state.switchOn), phase: Number(state.phase) === 1 ? 1 : 0, crumbled: Array.from(new Set(Array.from(state.crumbled || [], Number))).sort((left, right) => left - right), }; } function stateKey(state) { const normalized = canonicalState(state); return `${normalized.player}|${normalized.crates.join(".")}|${normalized.switchOn ? 1 : 0}|${normalized.phase}|${normalized.crumbled.join(".")}`; } function stateVariantKey(state) { const normalized = canonicalState(state); return `${normalized.crates.join(".")}|${normalized.switchOn ? 1 : 0}|${normalized.phase}|${normalized.crumbled.join(".")}`; } function coordinates(board, index) { return { x: index % board.width, y: Math.floor(index / board.width) }; } function indexAt(board, x, y) { return y * board.width + x; } function resolveNeighbor(board, state, action, ruleSet, fromIndex = state.player) { const point = coordinates(board, fromIndex); let x = point.x + action.dx; let y = point.y + action.dy; let wrapped = false; if (x < 0 || x >= board.width || y < 0 || y >= board.height) { if (!ruleSet.has("wrap_edges")) return null; x = ((x % board.width) + board.width) % board.width; y = ((y % board.height) + board.height) % board.height; wrapped = true; } return { index: indexAt(board, x, y), wrapped }; } function tileAt(board, index) { return board.cells[index]; } function isCrumbled(state, index) { return state.crumbled.includes(index); } function isPassable(board, state, index, ruleSet) { if (index < 0 || index >= board.cells.length || isCrumbled(state, index)) return false; const tile = tileAt(board, index); if (tile === "#") return false; if (tile === "D") return ruleSet.has("toggle_doors") && state.switchOn; if (tile === "0" || tile === "1") return ruleSet.has("phase_gates") && state.phase === Number(tile); if (tile === "F") return ruleSet.has("phase_gates"); if (tile === "I") return ruleSet.has("ice_slide"); if (tile === "P") return ruleSet.has("paired_portals"); if (tile === "K") return ruleSet.has("crumble_floor"); if (tile === "E") return ruleSet.has("echo_pad"); return true; } function portalDestination(board, current) { if (board.portals.length !== 2) return null; if (board.portals[0] === current) return board.portals[1]; if (board.portals[1] === current) return board.portals[0]; return null; } function attemptUnit(board, rules, sourceState, action) { const ruleSet = rules instanceof Set ? rules : new Set(canonicalRuleIds(rules)); const state = cloneState(sourceState); const events = []; const neighbor = resolveNeighbor(board, state, action, ruleSet); if (!neighbor) return null; const target = neighbor.index; if (!isPassable(board, state, target, ruleSet)) return null; const crateIndex = state.crates.indexOf(target); if (crateIndex >= 0) { if (!ruleSet.has("push_crates")) return null; const pushedNeighbor = resolveNeighbor(board, state, action, ruleSet, target); if (!pushedNeighbor || !isPassable(board, state, pushedNeighbor.index, ruleSet)) return null; if (state.crates.includes(pushedNeighbor.index)) return null; state.crates[crateIndex] = pushedNeighbor.index; state.crates.sort((left, right) => left - right); events.push("push_crates"); if (pushedNeighbor.wrapped) events.push("wrap_edges"); } const origin = state.player; state.player = target; if (neighbor.wrapped) events.push("wrap_edges"); if (ruleSet.has("crumble_floor") && tileAt(board, origin) === "K" && !state.crumbled.includes(origin)) { state.crumbled.push(origin); state.crumbled.sort((left, right) => left - right); events.push("crumble_floor"); } const enteredTile = tileAt(board, state.player); if (enteredTile === "!" && ruleSet.has("toggle_doors")) { state.switchOn = !state.switchOn; events.push("toggle_doors"); } if (enteredTile === "F" && ruleSet.has("phase_gates")) { state.phase = state.phase === 0 ? 1 : 0; events.push("phase_gates"); } if ((enteredTile === "0" || enteredTile === "1") && ruleSet.has("phase_gates")) { events.push("phase_gates"); } if (enteredTile === "P" && ruleSet.has("paired_portals")) { const destination = portalDestination(board, state.player); if (destination === null || state.crates.includes(destination) || !isPassable(board, state, destination, ruleSet)) { return null; } state.player = destination; events.push("paired_portals"); } return { state: canonicalState(state), events }; } function advanceWithIce(board, ruleSet, sourceState, action) { const first = attemptUnit(board, ruleSet, sourceState, action); if (!first) return null; let state = first.state; const events = Array.from(first.events); let guard = 0; const seen = new Set([stateKey(state)]); while (ruleSet.has("ice_slide") && tileAt(board, state.player) === "I") { const next = attemptUnit(board, ruleSet, state, action); if (!next) break; state = next.state; events.push(...next.events, "ice_slide"); const key = stateKey(state); guard += 1; if (seen.has(key) || guard > board.cells.length * 4) { return null; } seen.add(key); } return { state, events }; } function step(boardInput, ruleIds, sourceState, actionInput) { const board = boardInput.cells ? boardInput : parseBoard(boardInput); const rules = canonicalRuleIds(ruleIds); const ruleSet = new Set(rules); const action = typeof actionInput === "string" ? ACTION_BY_ID[actionInput] : actionInput; if (!action || !ACTION_BY_ID[action.id]) { throw new Error(`unknown action: ${String(actionInput)}`); } const startKey = stateKey(sourceState); const initialAdvance = advanceWithIce(board, ruleSet, sourceState, action); if (!initialAdvance) return null; let state = initialAdvance.state; const events = Array.from(initialAdvance.events); if (ruleSet.has("echo_pad") && tileAt(board, state.player) === "E") { const echoed = advanceWithIce(board, ruleSet, state, action); if (echoed) { state = echoed.state; events.push("echo_pad", ...echoed.events); } } const normalized = canonicalState(state); if (stateKey(normalized) === startKey) return null; return { state: normalized, action: action.id, events: Array.from(new Set(events)), goal: normalized.player === board.goal, }; } function replay(boardInput, ruleIds, actions, sourceState = null) { const board = boardInput.cells ? boardInput : parseBoard(boardInput); let state = sourceState ? canonicalState(sourceState) : initialState(board); const frames = [{ step: 0, action: null, state, events: [], goal: state.player === board.goal }]; for (let index = 0; index < actions.length; index += 1) { const transition = step(board, ruleIds, state, actions[index]); if (!transition) { return { ok: false, failedAt: index, frames, state, goal: state.player === board.goal }; } state = transition.state; frames.push({ step: index + 1, action: transition.action, state, events: transition.events, goal: transition.goal }); } return { ok: true, failedAt: null, frames, state, goal: state.player === board.goal }; } function solve(boardInput, ruleIds, options = {}) { const board = boardInput.cells ? boardInput : parseBoard(boardInput); const rules = canonicalRuleIds(ruleIds); const maxStates = Math.max(16, Number(options.maxStates || 25000)); const maxDepth = Math.max(1, Number(options.maxDepth || 80)); const start = options.initialState ? canonicalState(options.initialState) : initialState(board); const startKey = stateKey(start); const nodes = [{ state: start, depth: 0, parent: -1, action: null, ways: 1 }]; const keyToIndex = new Map([[startKey, 0]]); let cursor = 0; let firstGoalIndex = -1; let goalDepth = Infinity; let shortestSolutionCount = 0; let expandedStates = 0; let legalTransitions = 0; let truncated = false; while (cursor < nodes.length) { const nodeIndex = cursor; const node = nodes[cursor]; cursor += 1; if (node.depth >= goalDepth || node.depth >= maxDepth) continue; expandedStates += 1; for (const action of ACTIONS) { const transition = step(board, rules, node.state, action); if (!transition) continue; legalTransitions += 1; const nextDepth = node.depth + 1; const key = stateKey(transition.state); let existingIndex = keyToIndex.get(key); if (existingIndex === undefined) { if (nodes.length >= maxStates) { truncated = true; continue; } existingIndex = nodes.length; keyToIndex.set(key, existingIndex); nodes.push({ state: transition.state, depth: nextDepth, parent: nodeIndex, action: action.id, ways: node.ways, }); } else if (nodes[existingIndex].depth === nextDepth) { nodes[existingIndex].ways = Math.min(999, nodes[existingIndex].ways + node.ways); } else { continue; } if (transition.state.player === board.goal) { if (nextDepth < goalDepth) { goalDepth = nextDepth; firstGoalIndex = existingIndex; shortestSolutionCount = nodes[existingIndex].ways; } else if (nextDepth === goalDepth) { shortestSolutionCount = Math.min(999, shortestSolutionCount + node.ways); } } } } if (firstGoalIndex < 0) { return { solvable: false, solution: [], shortestLength: null, shortestSolutionCount: 0, exploredStates: nodes.length, expandedStates, averageBranching: expandedStates ? round(legalTransitions / expandedStates) : 0, truncated, usedRules: [], ruleUseCounts: {}, statefulRevisits: 0, interactionSteps: 0, traceHash: fingerprint({ board: board.rows, rules, result: "unsolved", explored: nodes.length }), }; } const solution = []; let walker = firstGoalIndex; while (walker > 0) { solution.push(nodes[walker].action); walker = nodes[walker].parent; } solution.reverse(); const proofReplay = replay(board, rules, solution); const usedRuleSet = new Set(); const ruleUseCounts = {}; const variantsByPosition = new Map(); let interactionSteps = 0; for (const frame of proofReplay.frames) { const position = frame.state.player; if (!variantsByPosition.has(position)) variantsByPosition.set(position, new Set()); variantsByPosition.get(position).add(stateVariantKey(frame.state)); const ruleEvents = frame.events.filter((event) => RULES[event]); if (new Set(ruleEvents).size >= 2) interactionSteps += 1; for (const event of ruleEvents) { usedRuleSet.add(event); ruleUseCounts[event] = (ruleUseCounts[event] || 0) + 1; } } const statefulRevisits = Array.from(variantsByPosition.values()).reduce( (total, variants) => total + Math.max(0, variants.size - 1), 0, ); return { solvable: true, solution, shortestLength: solution.length, shortestSolutionCount: Math.max(1, shortestSolutionCount), exploredStates: nodes.length, expandedStates, averageBranching: expandedStates ? round(legalTransitions / expandedStates) : 0, truncated, usedRules: canonicalRuleIds(usedRuleSet), ruleUseCounts, statefulRevisits, interactionSteps, traceHash: fingerprint({ board: board.rows, rules, solution, frames: proofReplay.frames.map((frame) => ({ action: frame.action, state: frame.state, events: frame.events })), }), }; } function countNonWall(rows) { return rows.reduce((total, row) => total + Array.from(row).filter((tile) => tile !== "#").length, 0); } function countSpecialTiles(rows) { return rows.reduce( (total, row) => total + Array.from(row).filter((tile) => !["#", ".", "S", "G"].includes(tile)).length, 0, ); } function boardDifference(leftRows, rightRows) { const height = Math.max(leftRows.length, rightRows.length); const width = Math.max(leftRows[0]?.length || 0, rightRows[0]?.length || 0); let difference = 0; for (let y = 0; y < height; y += 1) { for (let x = 0; x < width; x += 1) { if ((leftRows[y]?.[x] || "#") !== (rightRows[y]?.[x] || "#")) difference += 1; } } return difference; } function ruleDistance(left, right) { const a = new Set(left); const b = new Set(right); const union = new Set([...a, ...b]); if (union.size === 0) return 0; let difference = 0; for (const item of union) if (a.has(item) !== b.has(item)) difference += 1; return difference / union.size; } function candidateRuleIds(candidate) { return candidate.genome?.ruleIds || candidate.evaluation?.ruleIds || candidate.ruleIds || []; } function candidateDistance(left, right) { const leftDescriptor = left.descriptors || left; const rightDescriptor = right.descriptors || right; const numericKeys = ["surprise", "teachability", "compactness", "statefulness", "synergy", "branching", "solutionLengthNorm"]; const numeric = numericKeys.reduce( (total, key) => total + Math.abs(Number(leftDescriptor[key] || 0) - Number(rightDescriptor[key] || 0)), 0, ) / numericKeys.length; const rules = ruleDistance(candidateRuleIds(left), candidateRuleIds(right)); return round(0.65 * numeric + 0.35 * rules); } function evaluateCandidate(candidate, options = {}) { const rows = normalizeRows(candidate.rows); const ruleIds = canonicalRuleIds(candidate.ruleIds); const board = parseBoard(rows); const proof = solve(board, ruleIds, options); if (!proof.solvable) { return { valid: false, reason: proof.truncated ? "search-truncated" : "unsolved", board, proof, ruleIds }; } const baseline = solve(board, [], { ...options, maxStates: Math.min(Number(options.maxStates || 25000), 12000) }); const ablations = []; for (const ruleId of ruleIds) { const remaining = ruleIds.filter((item) => item !== ruleId); const ablated = solve(board, remaining, { ...options, maxStates: Math.min(Number(options.maxStates || 25000), 16000) }); const essential = !ablated.solvable || ablated.shortestLength >= proof.shortestLength + Math.max(2, Math.ceil(proof.shortestLength * 0.25)); ablations.push({ removedRule: ruleId, solvable: ablated.solvable, shortestLength: ablated.shortestLength, traceHash: ablated.traceHash, essential, }); } const allRulesUsed = ruleIds.every((ruleId) => proof.usedRules.includes(ruleId)); const essentialCount = ablations.filter((item) => item.essential).length; const essentialRatio = ruleIds.length ? essentialCount / ruleIds.length : 0; const baselineEffect = !baseline.solvable ? 1 : clamp((baseline.shortestLength - proof.shortestLength) / Math.max(4, baseline.shortestLength)); const uniqueness = clamp(1 - Math.log2(Math.max(1, proof.shortestSolutionCount)) / 6); const lengthFit = clamp(1 - Math.abs(proof.shortestLength - 12) / 24); const branchingFit = clamp(1 - Math.abs(proof.averageBranching - 1.8) / 2.2); const statefulness = clamp((proof.statefulRevisits + proof.interactionSteps * 1.5) / Math.max(2, proof.shortestLength * 0.45)); const synergy = clamp( essentialRatio * 0.65 + (ruleIds.length > 1 && essentialCount === ruleIds.length ? 0.25 : 0) + Math.min(0.1, proof.interactionSteps * 0.05), ); const openCells = countNonWall(rows); const compactness = clamp(1 - (openCells - (proof.shortestLength + 2)) / Math.max(10, rows.length * rows[0].length)); const teachability = clamp(0.32 * lengthFit + 0.28 * uniqueness + 0.22 * branchingFit + 0.18 * (1 - (ruleIds.length - 1) / 4)); const surprise = clamp(0.42 * baselineEffect + 0.3 * essentialRatio + 0.18 * statefulness + 0.1 * (ruleIds.length > 1 ? synergy : uniqueness)); const solvability = clamp(0.5 * lengthFit + 0.25 * branchingFit + 0.25 * uniqueness); const quality = clamp(0.31 * surprise + 0.23 * teachability + 0.19 * synergy + 0.15 * compactness + 0.12 * solvability); const solutionLengthNorm = clamp(proof.shortestLength / 40); const topologyRules = ruleIds.filter((id) => ["wrap_edges", "paired_portals"].includes(id)).length; const stateRules = ruleIds.filter((id) => ["toggle_doors", "phase_gates", "crumble_floor"].includes(id)).length; const lengthBand = proof.shortestLength <= 7 ? "short" : proof.shortestLength <= 15 ? "medium" : "long"; const ruleSignature = ruleIds.map((id) => id.replace(/_./g, (match) => match[1].toUpperCase())).join("+"); const niche = `${ruleSignature}:${lengthBand}:${topologyRules}t:${stateRules ? 1 : 0}s`; const descriptors = { surprise: round(surprise), teachability: round(teachability), compactness: round(compactness), statefulness: round(statefulness), synergy: round(synergy), branching: round(branchingFit), solvability: round(solvability), solutionLengthNorm: round(solutionLengthNorm), quality: round(quality), essentialRatio: round(essentialRatio), baselineEffect: round(baselineEffect), uniqueness: round(uniqueness), openCells, boardCells: rows.length * rows[0].length, }; const valid = Boolean( ruleIds.length >= 1 && ruleIds.length <= Number(options.maxRules || 3) && proof.shortestLength >= Number(options.minSolutionLength || 3) && proof.shortestLength <= Number(options.maxSolutionLength || 42) && allRulesUsed && essentialRatio >= Number(options.minimumEssentialRatio || 0.5) && proof.shortestSolutionCount <= Number(options.maximumShortestSolutions || 64) && !proof.truncated, ); return { valid, reason: valid ? "qualified" : !allRulesUsed ? "unused-rule" : essentialRatio < 0.5 ? "weak-ablation" : "proof-constraint", rows, board, ruleIds, proof, baseline: { solvable: baseline.solvable, shortestLength: baseline.shortestLength, exploredStates: baseline.exploredStates, traceHash: baseline.traceHash, }, ablations, descriptors, niche, quality, }; } function rotateRows(rows) { const height = rows.length; const width = rows[0].length; const result = []; for (let x = 0; x < width; x += 1) { let row = ""; for (let y = height - 1; y >= 0; y -= 1) row += rows[y][x]; result.push(row); } return result; } function mirrorRows(rows) { return rows.map((row) => Array.from(row).reverse().join("")); } function setTile(rows, x, y, tile) { const copy = rows.slice(); copy[y] = `${copy[y].slice(0, x)}${tile}${copy[y].slice(x + 1)}`; return copy; } function mutableCells(rows) { const cells = []; for (let y = 0; y < rows.length; y += 1) { for (let x = 0; x < rows[0].length; x += 1) { if (!"SG".includes(rows[y][x])) cells.push({ x, y, tile: rows[y][x] }); } } return cells; } function adjacentFloorCells(rows, x, y) { const result = []; for (const action of ACTIONS) { const nx = x + action.dx; const ny = y + action.dy; if (ny < 0 || ny >= rows.length || nx < 0 || nx >= rows[0].length) continue; if (rows[ny][nx] === ".") result.push({ x: nx, y: ny }); } return result; } function mutateRows(rows, rng, intensity) { let result = rows.slice(); for (let mutation = 0; mutation < intensity; mutation += 1) { const cells = mutableCells(result); if (cells.length === 0) break; const roll = rng.next(); if (roll < 0.38) { const walls = cells.filter((cell) => cell.tile === "#" && adjacentFloorCells(result, cell.x, cell.y).length > 0); if (walls.length) { const chosen = rng.pick(walls); result = setTile(result, chosen.x, chosen.y, "."); } } else if (roll < 0.67) { const floors = cells.filter((cell) => cell.tile === "."); if (floors.length) { const chosen = rng.pick(floors); result = setTile(result, chosen.x, chosen.y, "#"); } } else { const specials = cells.filter((cell) => "IP!D01FKE".includes(cell.tile)); if (specials.length) { const chosen = rng.pick(specials); const destinations = adjacentFloorCells(result, chosen.x, chosen.y); if (destinations.length) { const destination = rng.pick(destinations); result = setTile(result, chosen.x, chosen.y, "."); result = setTile(result, destination.x, destination.y, chosen.tile); } } } } return result; } function generateCandidate(rngInput, options = {}, ordinal = 0) { const rng = rngInput instanceof RNG ? rngInput : new RNG(rngInput); const maxRules = Math.max(1, Math.min(3, Number(options.maxRules || 3))); const eligible = RECIPES.filter((recipe) => recipe.rules.length <= maxRules); const recipe = rng.pick(eligible); let rows = recipe.rows.slice(); const rotations = rng.int(0, 4); for (let index = 0; index < rotations; index += 1) rows = rotateRows(rows); if (rng.bool(0.5)) rows = mirrorRows(rows); if (rng.bool(0.12)) { rows = rows.map((row) => row.replace(/S/g, "@").replace(/G/g, "S").replace(/@/g, "G")); } rows = mutateRows(rows, rng, rng.int(0, Number(options.mutationIntensity || 4) + 1)); let ruleIds = Array.from(recipe.rules); if (rng.bool(0.2) && ruleIds.length < maxRules) { const extras = RULE_IDS.filter((id) => !ruleIds.includes(id)); ruleIds.push(rng.pick(extras)); } if (rng.bool(0.08) && ruleIds.length > 1) { ruleIds.splice(rng.int(0, ruleIds.length), 1); } ruleIds = canonicalRuleIds(ruleIds); return { sourceRecipe: recipe.id, sourceNote: recipe.note, ordinal, rows, ruleIds, generationHash: fingerprint({ recipe: recipe.id, ordinal, rows, ruleIds }), }; } function canRemoveBorder(rows, side) { if (side === "top") return rows[0].split("").every((tile) => tile === "#"); if (side === "bottom") return rows[rows.length - 1].split("").every((tile) => tile === "#"); if (side === "left") return rows.every((row) => row[0] === "#"); if (side === "right") return rows.every((row) => row[row.length - 1] === "#"); return false; } function cropWallBorders(inputRows) { let rows = inputRows.slice(); let top = 0; let left = 0; let bottom = 0; let right = 0; let changed = true; while (changed && (rows.length > 3 || rows[0].length > 3)) { changed = false; if (rows.length > 3 && canRemoveBorder(rows, "top")) { rows = rows.slice(1); top += 1; changed = true; } if (rows.length > 3 && canRemoveBorder(rows, "bottom")) { rows = rows.slice(0, -1); bottom += 1; changed = true; } if (rows[0].length > 3 && canRemoveBorder(rows, "left")) { rows = rows.map((row) => row.slice(1)); left += 1; changed = true; } if (rows[0].length > 3 && canRemoveBorder(rows, "right")) { rows = rows.map((row) => row.slice(0, -1)); right += 1; changed = true; } } return { rows, crop: { top, right, bottom, left } }; } function phenomenonSignature(evaluation) { return { ruleIds: evaluation.ruleIds, baselineUnsolved: !evaluation.baseline.solvable, minimumEssential: Math.max(1, Math.floor(evaluation.ruleIds.length * 0.5)), minimumSurprise: Math.max(0.34, evaluation.descriptors.surprise - 0.16), maximumLength: evaluation.proof.shortestLength + Math.max(4, Math.ceil(evaluation.proof.shortestLength * 0.4)), }; } function preservesPhenomenon(evaluation, signature) { if (!evaluation.valid) return false; if (evaluation.descriptors.surprise < signature.minimumSurprise) return false; if (evaluation.proof.shortestLength > signature.maximumLength) return false; if (signature.baselineUnsolved && evaluation.baseline.solvable && evaluation.descriptors.baselineEffect < 0.45) return false; return evaluation.ablations.filter((item) => item.essential).length >= Math.min(signature.minimumEssential, evaluation.ruleIds.length); } function minimizeCandidate(candidate, options = {}) { const originalEvaluation = candidate.evaluation || evaluateCandidate(candidate, options); if (!originalEvaluation.valid) { return { candidate, evaluation: originalEvaluation, receipt: { changed: false, reason: originalEvaluation.reason } }; } const signature = phenomenonSignature(originalEvaluation); let rows = originalEvaluation.rows.slice(); let ruleIds = originalEvaluation.ruleIds.slice(); let evaluation = originalEvaluation; const removedRules = []; const tileChanges = []; for (const ruleId of ruleIds.slice().reverse()) { const trialRules = ruleIds.filter((item) => item !== ruleId); if (trialRules.length === 0) continue; const trial = evaluateCandidate({ rows, ruleIds: trialRules }, options); if (preservesPhenomenon(trial, { ...signature, minimumEssential: Math.min(signature.minimumEssential, trialRules.length) })) { ruleIds = trialRules; evaluation = trial; removedRules.push(ruleId); } } const maxAttempts = Math.max(0, Number(options.minimizationAttempts || 80)); let attempts = 0; let changed = true; const seenBoards = new Set([rows.join("\n")]); while (changed && attempts < maxAttempts) { changed = false; const candidates = []; for (let y = 0; y < rows.length; y += 1) { for (let x = 0; x < rows[0].length; x += 1) { const tile = rows[y][x]; if (tile === "S" || tile === "G" || tile === "#") continue; if (tile === ".") candidates.push({ x, y, from: tile, to: "#", kind: "remove-floor" }); else candidates.push({ x, y, from: tile, to: ".", kind: "remove-special" }); } } candidates.sort((left, right) => { const leftPriority = left.kind === "remove-special" ? 0 : 1; const rightPriority = right.kind === "remove-special" ? 0 : 1; return leftPriority - rightPriority || left.y - right.y || left.x - right.x; }); for (const edit of candidates) { if (attempts >= maxAttempts) break; attempts += 1; const trialRows = setTile(rows, edit.x, edit.y, edit.to); const key = trialRows.join("\n"); if (seenBoards.has(key)) continue; seenBoards.add(key); let trial; try { trial = evaluateCandidate({ rows: trialRows, ruleIds }, options); } catch (_error) { continue; } const beforeComplexity = [countSpecialTiles(rows), countNonWall(rows)]; const afterComplexity = [countSpecialTiles(trialRows), countNonWall(trialRows)]; const strictlySimpler = afterComplexity[0] < beforeComplexity[0] || (afterComplexity[0] === beforeComplexity[0] && afterComplexity[1] < beforeComplexity[1]); if ( strictlySimpler && preservesPhenomenon(trial, signature) && trial.descriptors.quality >= evaluation.descriptors.quality - 0.08 ) { rows = trialRows; evaluation = trial; tileChanges.push(edit); changed = true; break; } } } let acceptedCrop = { top: 0, right: 0, bottom: 0, left: 0 }; const cropped = cropWallBorders(rows); if (cropped.rows.join("\n") !== rows.join("\n")) { try { const cropEvaluation = evaluateCandidate({ rows: cropped.rows, ruleIds }, options); if (preservesPhenomenon(cropEvaluation, signature)) { rows = cropped.rows; evaluation = cropEvaluation; acceptedCrop = cropped.crop; } } catch (_error) { // Keep the pre-crop candidate when the crop invalidates a seam-sensitive board. } } const receipt = { changed: removedRules.length > 0 || tileChanges.length > 0 || rows.join("\n") !== originalEvaluation.rows.join("\n"), before: { width: originalEvaluation.rows[0].length, height: originalEvaluation.rows.length, boardCells: originalEvaluation.rows[0].length * originalEvaluation.rows.length, openCells: countNonWall(originalEvaluation.rows), specialTiles: countSpecialTiles(originalEvaluation.rows), ruleCount: originalEvaluation.ruleIds.length, solutionLength: originalEvaluation.proof.shortestLength, }, after: { width: rows[0].length, height: rows.length, boardCells: rows[0].length * rows.length, openCells: countNonWall(rows), specialTiles: countSpecialTiles(rows), ruleCount: ruleIds.length, solutionLength: evaluation.proof.shortestLength, }, removedRules, tileChanges, crop: acceptedCrop, attempts, proofPreserved: evaluation.valid, beforeHash: fingerprint({ rows: originalEvaluation.rows, rules: originalEvaluation.ruleIds, trace: originalEvaluation.proof.traceHash }), afterHash: fingerprint({ rows, rules: ruleIds, trace: evaluation.proof.traceHash }), }; return { candidate: { ...candidate, rows, ruleIds }, evaluation, receipt }; } function titleFor(ruleIds, digest) { const adjectives = ["Folded", "Latched", "Echoing", "Measured", "Crumbling", "Phase-Locked", "Sideways", "Borrowed", "Glass", "Quiet"]; const nouns = ["Passage", "Pocket", "Bridge", "Seam", "Room", "Circuit", "Stair", "Shortcut", "Vault", "Loop"]; const first = RULES[ruleIds[0]]?.name.split(" ")[0] || adjectives[Number.parseInt(digest.slice(0, 2), 16) % adjectives.length]; const adjective = ruleIds.length === 1 ? first : adjectives[Number.parseInt(digest.slice(2, 4), 16) % adjectives.length]; const noun = nouns[Number.parseInt(digest.slice(4, 6), 16) % nouns.length]; return `The ${adjective} ${noun}`; } function capsuleFromEvaluation(candidate, evaluation, minimization, searchMeta = {}) { const canonical = { schema: SCHEMA, engineVersion: ENGINE_VERSION, board: { width: evaluation.rows[0].length, height: evaluation.rows.length, rows: evaluation.rows, }, genome: { ruleIds: evaluation.ruleIds, rules: evaluation.ruleIds.map((id) => ({ ...RULES[id] })), }, proof: { solvable: true, shortestSolution: evaluation.proof.solution, shortestLength: evaluation.proof.shortestLength, shortestSolutionCount: evaluation.proof.shortestSolutionCount, exploredStates: evaluation.proof.exploredStates, expandedStates: evaluation.proof.expandedStates, averageBranching: evaluation.proof.averageBranching, usedRules: evaluation.proof.usedRules, ruleUseCounts: evaluation.proof.ruleUseCounts, statefulRevisits: evaluation.proof.statefulRevisits, interactionSteps: evaluation.proof.interactionSteps, traceHash: evaluation.proof.traceHash, baseline: evaluation.baseline, ablations: evaluation.ablations, }, descriptors: evaluation.descriptors, niche: evaluation.niche, minimization, provenance: { generator: candidate.generator || "structured-recipe-mutation", sourceRecipe: candidate.sourceRecipe || null, sourceNote: candidate.sourceNote || null, generationHash: candidate.generationHash || null, campaignSeed: searchMeta.seed ?? null, evaluationOrdinal: candidate.ordinal ?? null, budget: searchMeta.budget ?? null, }, }; const capsuleId = `pc-${fingerprint({ schema: SCHEMA, engineVersion: ENGINE_VERSION, rows: evaluation.rows, ruleIds: evaluation.ruleIds, traceHash: evaluation.proof.traceHash, })}`; return { ...canonical, capsuleId, title: titleFor(evaluation.ruleIds, capsuleId.slice(3)), pitch: `${evaluation.ruleIds.map((id) => RULES[id].name).join(" + ")} turns a ${evaluation.proof.shortestLength}-move proof into a compact playable rule.`, status: "verified", }; } function normalizeCapsule(input) { if (!input || typeof input !== "object") throw new Error("capsule must be an object"); if (input.schema !== SCHEMA) throw new Error(`unsupported capsule schema: ${String(input.schema)}`); const rows = normalizeRows(input.board?.rows); const ruleIds = canonicalRuleIds(input.genome?.ruleIds); const evaluation = evaluateCandidate({ rows, ruleIds }); if (!evaluation.valid) throw new Error(`capsule proof failed: ${evaluation.reason}`); const normalized = capsuleFromEvaluation( { rows, ruleIds, generator: input.provenance?.generator || "structured-recipe-mutation", sourceRecipe: input.provenance?.sourceRecipe || null, sourceNote: input.provenance?.sourceNote || null, generationHash: input.provenance?.generationHash || null, ordinal: input.provenance?.evaluationOrdinal ?? null, }, evaluation, input.minimization || { changed: false }, { seed: input.provenance?.campaignSeed ?? null, budget: input.provenance?.budget ?? null }, ); return { ...normalized, title: typeof input.title === "string" && input.title.trim() ? input.title.trim() : normalized.title, pitch: typeof input.pitch === "string" && input.pitch.trim() ? input.pitch.trim() : normalized.pitch, descriptors: { ...normalized.descriptors, novelty: round(Number(input.descriptors?.novelty ?? normalized.descriptors.novelty ?? 0)), rankScore: round(Number(input.descriptors?.rankScore ?? normalized.descriptors.quality)), }, }; } async function searchCapsules(options = {}, onProgress = null) { const seed = Number.isFinite(Number(options.seed)) ? Number(options.seed) : 17; const budget = Math.max(8, Math.min(5000, Number(options.budget || 160))); const archiveLimit = Math.max(1, Math.min(64, Number(options.top || 12))); const maxRules = Math.max(1, Math.min(3, Number(options.maxRules || 3))); const rng = new RNG(seed); const archive = new Map(); const qualified = []; const rejectionCounts = {}; const started = Date.now(); const yieldEvery = Math.max(1, Number(options.yieldEvery || 12)); const yieldFunction = typeof options.yieldFunction === "function" ? options.yieldFunction : null; for (let ordinal = 0; ordinal < budget; ordinal += 1) { const candidate = generateCandidate(rng, { ...options, maxRules }, ordinal); let evaluation; try { evaluation = evaluateCandidate(candidate, { ...options, maxRules }); } catch (error) { rejectionCounts.invalid = (rejectionCounts.invalid || 0) + 1; continue; } if (!evaluation.valid) { rejectionCounts[evaluation.reason] = (rejectionCounts[evaluation.reason] || 0) + 1; } else { const provisional = { ...candidate, evaluation }; provisional.novelty = archive.size === 0 ? 1 : Math.min(...Array.from(archive.values(), (item) => candidateDistance({ ...provisional, descriptors: evaluation.descriptors, genome: { ruleIds: evaluation.ruleIds } }, item))); provisional.rankScore = round(evaluation.quality * 0.86 + provisional.novelty * 0.14); const incumbent = archive.get(evaluation.niche); if (!incumbent || provisional.rankScore > incumbent.rankScore) archive.set(evaluation.niche, provisional); qualified.push(provisional); } if (typeof onProgress === "function" && (ordinal % yieldEvery === 0 || ordinal + 1 === budget)) { onProgress({ evaluated: ordinal + 1, budget, qualified: qualified.length, niches: archive.size, elapsedMs: Date.now() - started, }); } if (yieldFunction && ordinal % yieldEvery === 0) await yieldFunction(); } const finalists = Array.from(archive.values()) .sort((left, right) => right.rankScore - left.rankScore || left.generationHash.localeCompare(right.generationHash)) .slice(0, archiveLimit); const capsules = []; for (let index = 0; index < finalists.length; index += 1) { const finalist = finalists[index]; const minimized = minimizeCandidate(finalist, { ...options, maxRules }); if (!minimized.evaluation.valid) continue; const capsule = capsuleFromEvaluation( minimized.candidate, minimized.evaluation, minimized.receipt, { seed, budget }, ); capsules.push({ ...capsule, descriptors: { ...capsule.descriptors, novelty: round(finalist.novelty), rankScore: round(minimized.evaluation.quality * 0.86 + finalist.novelty * 0.14), }, }); if (yieldFunction) await yieldFunction(); } capsules.sort((left, right) => right.descriptors.rankScore - left.descriptors.rankScore || left.capsuleId.localeCompare(right.capsuleId)); const receipt = { schema: "puzzle-capsule-campaign/v1", engineVersion: ENGINE_VERSION, seed, budget, maxRules, evaluated: budget, qualified: qualified.length, niches: archive.size, retained: capsules.length, rejectionCounts, capsuleIds: capsules.map((capsule) => capsule.capsuleId), digest: fingerprint(capsules.map((capsule) => ({ id: capsule.capsuleId, proof: capsule.proof.traceHash, score: capsule.descriptors.rankScore }))), }; return { capsules, receipt }; } function capsuleJson(capsule, pretty = true) { const normalized = normalizeCapsule(capsule); return `${JSON.stringify(normalized, null, pretty ? 2 : 0)}\n`; } function downloadName(capsule, extension) { const safe = String(capsule.title || "puzzle-capsule") .toLowerCase() .replace(/[^a-z0-9]+/g, "-") .replace(/^-|-$/g, "") .slice(0, 48) || "puzzle-capsule"; return `${safe}-${capsule.capsuleId.slice(-8)}.${extension}`; } function compactScriptJson(value) { return JSON.stringify(value) .replace(//g, "\\u003e") .replace(/&/g, "\\u0026") .replace(/\u2028/g, "\\u2028") .replace(/\u2029/g, "\\u2029"); } const api = Object.freeze({ SCHEMA, ENGINE_VERSION, ACTIONS, ACTION_BY_ID, RULES, RULE_IDS, RECIPES, RNG, clamp, round, stableStringify, fingerprint, canonicalRuleIds, normalizeRows, parseBoard, initialState, canonicalState, stateKey, coordinates, step, replay, solve, evaluateCandidate, generateCandidate, cropWallBorders, minimizeCandidate, capsuleFromEvaluation, normalizeCapsule, searchCapsules, capsuleJson, downloadName, candidateDistance, compactScriptJson, countNonWall, countSpecialTiles, boardDifference, }); globalScope.PuzzleCapsuleCore = api; if (typeof module !== "undefined" && module.exports) module.exports = api; })(typeof globalThis !== "undefined" ? globalThis : this);

Loading capsule…

Why this capsule counts