@cubingcenter/scrambler 0.1.0

package/dist/puzzles/pyraminx/solver.js

@@ -0,0 +1,160 @@
+import { applyPyraminxMove } from "./moves.js";
+import { createSolvedPyraminxState } from "./state.js";
+// Fast state-to-index encoder/decoder to allow optimal BFS solving
+// Factorials for permutation encoding
+const FACT = [1, 1, 2, 6, 24, 120, 720];
+export function getPermutationIndex(perm) {
+    let index = 0;
+    const n = perm.length;
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = i + 1; j < n; j++) {
+            if (perm[j] < perm[i])
+                count++;
+        }
+        index += count * FACT[n - 1 - i];
+    }
+    return index;
+}
+export function getPermutationFromIndex(index, n) {
+    const perm = Array(n).fill(0);
+    const temp = Array.from({ length: n }, (_, i) => i);
+    let val = index;
+    for (let i = 0; i < n; i++) {
+        const f = FACT[n - 1 - i];
+        const choice = Math.floor(val / f);
+        val %= f;
+        perm[i] = temp[choice];
+        temp.splice(choice, 1);
+    }
+    return perm;
+}
+export function getOrientationIndex(orient) {
+    let index = 0;
+    for (let i = 0; i < 5; i++) {
+        index = (index << 1) | orient[i];
+    }
+    return index;
+}
+export function getOrientationFromIndex(index) {
+    const orient = Array(6).fill(0);
+    let temp = index;
+    let sum = 0;
+    for (let i = 4; i >= 0; i--) {
+        const bit = temp & 1;
+        orient[i] = bit;
+        sum += bit;
+        temp >>= 1;
+    }
+    orient[5] = sum % 2 === 0 ? 0 : 1;
+    return orient;
+}
+export function getCentersIndex(centers) {
+    return centers[0] + 3 * centers[1] + 9 * centers[2] + 27 * centers[3];
+}
+export function getCentersFromIndex(index) {
+    let temp = index;
+    const centers = Array(4).fill(0);
+    for (let i = 0; i < 4; i++) {
+        centers[i] = temp % 3;
+        temp = Math.floor(temp / 3);
+    }
+    return centers;
+}
+export function getStateIndex(state) {
+    const c = getCentersIndex(state.centers);
+    const p = getPermutationIndex(state.edgesPerm);
+    const o = getOrientationIndex(state.edgesOrient);
+    // c is 0..80, p is 0..719, o is 0..31
+    return c + 81 * (p + 720 * o);
+}
+// Bidirectional BFS solver
+const MOVES = ["U", "U'", "L", "L'", "R", "R'", "B", "B'"];
+export function solvePyraminx(state) {
+    const startIdx = getStateIndex(state);
+    const solvedIdx = getStateIndex(createSolvedPyraminxState());
+    if (startIdx === solvedIdx)
+        return [];
+    // Bidirectional BFS:
+    // forwardMap and backwardMap store the move that led to this index and the parent index
+    const forwardMap = new Map();
+    const backwardMap = new Map();
+    const forwardQueue = [startIdx];
+    const backwardQueue = [solvedIdx];
+    forwardMap.set(startIdx, { move: "", parent: -1 });
+    backwardMap.set(solvedIdx, { move: "", parent: -1 });
+    while (forwardQueue.length > 0 && backwardQueue.length > 0) {
+        // Expand forward
+        const fSize = forwardQueue.length;
+        for (let i = 0; i < Math.min(fSize, 1000); i++) {
+            const currIdx = forwardQueue.shift();
+            const currState = getPyraminxStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = applyPyraminxMove(currState, move);
+                const nextIdx = getStateIndex(nextState);
+                if (!forwardMap.has(nextIdx)) {
+                    forwardMap.set(nextIdx, { move, parent: currIdx });
+                    if (backwardMap.has(nextIdx)) {
+                        return reconstructPath(nextIdx, forwardMap, backwardMap);
+                    }
+                    forwardQueue.push(nextIdx);
+                }
+            }
+        }
+        // Expand backward
+        const bSize = backwardQueue.length;
+        for (let i = 0; i < Math.min(bSize, 1000); i++) {
+            const currIdx = backwardQueue.shift();
+            const currState = getPyraminxStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = applyPyraminxMove(currState, move);
+                const nextIdx = getStateIndex(nextState);
+                if (!backwardMap.has(nextIdx)) {
+                    // Note: we record the inverse move since we are searching from solved
+                    const invMove = move.endsWith("'") ? move.slice(0, -1) : `${move}'`;
+                    backwardMap.set(nextIdx, { move: invMove, parent: currIdx });
+                    if (forwardMap.has(nextIdx)) {
+                        return reconstructPath(nextIdx, forwardMap, backwardMap);
+                    }
+                    backwardQueue.push(nextIdx);
+                }
+            }
+        }
+    }
+    throw new Error("Pyraminx state is unsolvable");
+}
+function getPyraminxStateFromIndex(index) {
+    let val = index;
+    const centersIdx = val % 81;
+    val = Math.floor(val / 81);
+    const permIdx = val % 720;
+    const orientIdx = Math.floor(val / 720);
+    return {
+        centers: getCentersFromIndex(centersIdx),
+        edgesPerm: getPermutationFromIndex(permIdx, 6),
+        edgesOrient: getOrientationFromIndex(orientIdx),
+        tips: [0, 0, 0, 0] // tips are solved separately
+    };
+}
+function reconstructPath(meetingIdx, forwardMap, backwardMap) {
+    const path = [];
+    // Reconstruct forward path
+    let curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = forwardMap.get(curr);
+        if (edge.parent !== -1) {
+            path.unshift(edge.move);
+        }
+        curr = edge.parent;
+    }
+    // Reconstruct backward path
+    curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = backwardMap.get(curr);
+        if (edge.parent !== -1) {
+            path.push(edge.move);
+        }
+        curr = edge.parent;
+    }
+    return path;
+}

package/dist/puzzles/pyraminx/state.d.ts

@@ -0,0 +1,6 @@
+import type { PyraminxState } from "./types.js";
+export declare function createSolvedPyraminxState(): PyraminxState;
+export declare function clonePyraminxState(state: PyraminxState): PyraminxState;
+export declare function pyraminxStatesEqual(left: PyraminxState, right: PyraminxState): boolean;
+export declare function isSolvedPyraminxState(state: PyraminxState): boolean;
+//# sourceMappingURL=state.d.ts.map

package/dist/puzzles/pyraminx/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wBAAgB,yBAAyB,IAAI,aAAa,CAOzD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,aAAa,CAOtE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAOtF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAOnE"}

package/dist/puzzles/pyraminx/state.js

@@ -0,0 +1,32 @@
+export function createSolvedPyraminxState() {
+    return {
+        centers: [0, 0, 0, 0],
+        edgesPerm: [0, 1, 2, 3, 4, 5],
+        edgesOrient: [0, 0, 0, 0, 0, 0],
+        tips: [0, 0, 0, 0]
+    };
+}
+export function clonePyraminxState(state) {
+    return {
+        centers: [...state.centers],
+        edgesPerm: [...state.edgesPerm],
+        edgesOrient: [...state.edgesOrient],
+        tips: [...state.tips]
+    };
+}
+export function pyraminxStatesEqual(left, right) {
+    return (arraysEqual(left.centers, right.centers) &&
+        arraysEqual(left.edgesPerm, right.edgesPerm) &&
+        arraysEqual(left.edgesOrient, right.edgesOrient) &&
+        arraysEqual(left.tips, right.tips));
+}
+export function isSolvedPyraminxState(state) {
+    return (state.centers.every(c => c === 0) &&
+        state.edgesPerm.every((e, idx) => e === idx) &&
+        state.edgesOrient.every(o => o === 0)
+    // tips don't have to be 0 for the core to be solved in the state-matching, but for full solved they do
+    );
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/puzzles/pyraminx/types.d.ts

@@ -0,0 +1,17 @@
+export type PyraminxFaceMove = "U" | "L" | "R" | "B";
+export type PyraminxTipMove = "u" | "l" | "r" | "b";
+export type PyraminxMoveSuffix = "" | "'";
+export type PyraminxMove = `${PyraminxFaceMove}${PyraminxMoveSuffix}` | `${PyraminxTipMove}${PyraminxMoveSuffix}`;
+export interface PyraminxState {
+    centers: number[];
+    edgesPerm: number[];
+    edgesOrient: number[];
+    tips: number[];
+}
+export interface PyraminxRandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+}
+export declare const PYRAMINX_CORE_MOVES: readonly PyraminxMove[];
+export declare const PYRAMINX_TIPS: readonly PyraminxTipMove[];
+//# sourceMappingURL=types.d.ts.map

package/dist/puzzles/pyraminx/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AACrD,MAAM,MAAM,eAAe,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AACpD,MAAM,MAAM,kBAAkB,GAAG,EAAE,GAAG,GAAG,CAAC;AAC1C,MAAM,MAAM,YAAY,GAAG,GAAG,gBAAgB,GAAG,kBAAkB,EAAE,GAAG,GAAG,eAAe,GAAG,kBAAkB,EAAE,CAAC;AAElH,MAAM,WAAW,aAAa;IAE5B,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,eAAO,MAAM,mBAAmB,EAAE,SAAS,YAAY,EAKtD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,SAAS,eAAe,EAAyB,CAAC"}

package/dist/puzzles/pyraminx/types.js

@@ -0,0 +1,7 @@
+export const PYRAMINX_CORE_MOVES = [
+    "U", "U'",
+    "L", "L'",
+    "R", "R'",
+    "B", "B'"
+];
+export const PYRAMINX_TIPS = ["u", "l", "r", "b"];

package/dist/puzzles/pyraminx/validation.d.ts

@@ -0,0 +1,8 @@
+import type { PyraminxState } from "./types.js";
+export declare function validatePyraminxState(state: PyraminxState): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function permutationParity(permutation: readonly number[]): number;
+export declare function isAllowedRandomPyraminxState(state: PyraminxState): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/puzzles/pyraminx/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAiEhG;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAUxE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAE1E"}

package/dist/puzzles/pyraminx/validation.js

@@ -0,0 +1,79 @@
+import { isSolvedPyraminxState } from "./state.js";
+export function validatePyraminxState(state) {
+    const errors = [];
+    // 1. Centers validation
+    if (state.centers.length !== 4) {
+        errors.push("Centers must contain 4 values.");
+    }
+    else {
+        for (const val of state.centers) {
+            if (val < 0 || val > 2 || !Number.isInteger(val)) {
+                errors.push(`Center orientation out of range: ${val}`);
+            }
+        }
+    }
+    // 2. Tips validation
+    if (state.tips.length !== 4) {
+        errors.push("Tips must contain 4 values.");
+    }
+    else {
+        for (const val of state.tips) {
+            if (val < 0 || val > 2 || !Number.isInteger(val)) {
+                errors.push(`Tip orientation out of range: ${val}`);
+            }
+        }
+    }
+    // 3. Edges Permutation validation
+    if (state.edgesPerm.length !== 6) {
+        errors.push("Edges permutation must contain 6 values.");
+    }
+    else {
+        const seen = new Set();
+        for (const val of state.edgesPerm) {
+            if (val < 0 || val > 5 || !Number.isInteger(val) || seen.has(val)) {
+                errors.push(`Invalid edge permutation value: ${val}`);
+            }
+            seen.add(val);
+        }
+    }
+    // 4. Edges Orientation validation
+    if (state.edgesOrient.length !== 6) {
+        errors.push("Edges orientation must contain 6 values.");
+    }
+    else {
+        let sumOrient = 0;
+        for (const val of state.edgesOrient) {
+            if (val < 0 || val > 1 || !Number.isInteger(val)) {
+                errors.push(`Edge orientation out of range: ${val}`);
+            }
+            sumOrient += val;
+        }
+        if (sumOrient % 2 !== 0) {
+            errors.push("Edge orientation sum must be even.");
+        }
+    }
+    // 5. Permutation parity validation
+    if (errors.length === 0) {
+        if (permutationParity(state.edgesPerm) !== 0) {
+            errors.push("Edge permutation parity must be even.");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+export function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left += 1) {
+        for (let right = left + 1; right < permutation.length; right += 1) {
+            if (permutation[left] > permutation[right]) {
+                inversions += 1;
+            }
+        }
+    }
+    return inversions % 2;
+}
+export function isAllowedRandomPyraminxState(state) {
+    return validatePyraminxState(state).valid && !isSolvedPyraminxState(state);
+}

package/dist/random/index.d.ts

@@ -0,0 +1,3 @@
+export { createRandomSource } from "./prng.js";
+export type { RandomSource } from "./prng.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/random/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/random/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC"}

package/dist/random/index.js

@@ -0,0 +1 @@
+export { createRandomSource } from "./prng.js";

package/dist/random/prng.d.ts

@@ -0,0 +1,7 @@
+export interface RandomSource {
+    next(): number;
+    nextInt(maxExclusive: number): number;
+    choice<T>(items: readonly T[]): T;
+}
+export declare function createRandomSource(seed?: string | number): RandomSource;
+//# sourceMappingURL=prng.d.ts.map

package/dist/random/prng.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAMvE"}

package/dist/random/prng.js

@@ -0,0 +1,60 @@
+import { randomBytes } from "node:crypto";
+export function createRandomSource(seed) {
+    if (seed === undefined) {
+        return new CryptoRandomSource();
+    }
+    return new SeededRandomSource(hashSeed(seed));
+}
+class CryptoRandomSource {
+    next() {
+        const value = randomBytes(6).readUIntBE(0, 6);
+        return value / 0x1000000000000;
+    }
+    nextInt(maxExclusive) {
+        validateMax(maxExclusive);
+        return Math.floor(this.next() * maxExclusive);
+    }
+    choice(items) {
+        if (items.length === 0) {
+            throw new RangeError("Cannot choose from an empty collection.");
+        }
+        return items[this.nextInt(items.length)];
+    }
+}
+class SeededRandomSource {
+    state;
+    constructor(seed) {
+        this.state = seed >>> 0;
+    }
+    next() {
+        this.state += 0x6d2b79f5;
+        let value = this.state;
+        value = Math.imul(value ^ (value >>> 15), value | 1);
+        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+        return ((value ^ (value >>> 14)) >>> 0) / 0x100000000;
+    }
+    nextInt(maxExclusive) {
+        validateMax(maxExclusive);
+        return Math.floor(this.next() * maxExclusive);
+    }
+    choice(items) {
+        if (items.length === 0) {
+            throw new RangeError("Cannot choose from an empty collection.");
+        }
+        return items[this.nextInt(items.length)];
+    }
+}
+function validateMax(maxExclusive) {
+    if (!Number.isInteger(maxExclusive) || maxExclusive < 1) {
+        throw new RangeError(`maxExclusive must be a positive integer. Received: ${maxExclusive}`);
+    }
+}
+function hashSeed(seed) {
+    const text = String(seed);
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

package/dist-cjs/cli/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const run_js_1 = require("./run.js");
+async function main() {
+    const result = await (0, run_js_1.runCli)(process.argv.slice(2), {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text)
+    });
+    process.exitCode = result.exitCode;
+}
+main();

package/dist-cjs/cli/run.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const index_js_1 = require("../index.js");
+async function runCli(argv, io) {
+    try {
+        await run(parseArgs(argv), io);
+        return { exitCode: 0 };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        io.stderr(`${message}\n`);
+        return { exitCode: error instanceof index_js_1.ScramblerError ? 2 : 1 };
+    }
+}
+async function run(cliArgs, io) {
+    if (cliArgs.help || !cliArgs.command) {
+        printHelp(io);
+        return;
+    }
+    if (cliArgs.command === "list") {
+        printEvents(io);
+        return;
+    }
+    const scrambles = await (0, index_js_1.generateScrambles)(cliArgs.command, cliArgs.count, {
+        ...(cliArgs.seed === undefined ? {} : { seed: cliArgs.seed })
+    });
+    if (cliArgs.json) {
+        printJson(scrambles, io);
+        return;
+    }
+    for (const result of scrambles) {
+        io.stdout(`${result.scramble}\n`);
+    }
+}
+function printJson(scrambles, io) {
+    const serialized = scrambles.map(serializeScramble);
+    const output = serialized.length === 1 ? serialized[0] : serialized;
+    io.stdout(`${JSON.stringify(output, null, 2)}\n`);
+}
+function serializeScramble(result) {
+    const metadata = result.metadata ?? {};
+    const serialized = {
+        eventId: result.eventId,
+        scramble: result.scramble,
+        moves: result.moves,
+        quality: result.quality,
+        generator: result.generator
+    };
+    if (result.seed !== undefined) {
+        serialized.seed = result.seed;
+    }
+    if ("facelets" in metadata) {
+        serialized.facelets = metadata.facelets;
+    }
+    if ("faceletString" in metadata) {
+        serialized.faceletString = metadata.faceletString;
+    }
+    return serialized;
+}
+function printEvents(io) {
+    const events = (0, index_js_1.getSupportedEvents)();
+    if (events.length === 0) {
+        io.stdout("No scramble events are registered yet.\n");
+        return;
+    }
+    for (const event of events) {
+        io.stdout(`${event.eventId}\t${event.name}\t${event.quality}\n`);
+    }
+}
+function printHelp(io) {
+    io.stdout(`Usage:
+  cubingcenter-scrambler --help
+  cubingcenter-scrambler list
+  cubingcenter-scrambler <eventId> [--count N] [--seed value] [--json]
+
+Options:
+  --count, -c  Number of scrambles to generate. Defaults to 1.
+  --seed, -s   Seed value for reproducible generation when supported.
+  --json       Print structured JSON with metadata when available.
+  --help, -h   Show this help message.
+`);
+}
+function parseArgs(argv) {
+    const parsed = {
+        count: 1,
+        help: false,
+        json: false
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === undefined) {
+            continue;
+        }
+        if (value === "--help" || value === "-h") {
+            parsed.help = true;
+            continue;
+        }
+        if (value === "--json") {
+            parsed.json = true;
+            continue;
+        }
+        if (value === "--count" || value === "-c") {
+            parsed.count = parsePositiveInteger(readValue(argv, index, value));
+            index += 1;
+            continue;
+        }
+        if (value === "--seed" || value === "-s") {
+            parsed.seed = readValue(argv, index, value);
+            index += 1;
+            continue;
+        }
+        if (value.startsWith("--count=")) {
+            parsed.count = parsePositiveInteger(value.slice("--count=".length));
+            continue;
+        }
+        if (value.startsWith("--seed=")) {
+            parsed.seed = value.slice("--seed=".length);
+            continue;
+        }
+        if (!parsed.command) {
+            parsed.command = value;
+            continue;
+        }
+        throw new Error(`Unexpected argument: ${value}`);
+    }
+    return parsed;
+}
+function readValue(argv, index, flag) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+function parsePositiveInteger(value) {
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 1) {
+        throw new Error(`Count must be a positive integer. Received: ${value}`);
+    }
+    return count;
+}

package/dist-cjs/core/api.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeScrambler = initializeScrambler;
+exports.registerScrambleGenerator = registerScrambleGenerator;
+exports.getSupportedEvents = getSupportedEvents;
+exports.getEventInfo = getEventInfo;
+exports.generateScramble = generateScramble;
+exports.generateScrambles = generateScrambles;
+const errors_js_1 = require("./errors.js");
+const registry_js_1 = require("./registry.js");
+const browser_loader_js_1 = require("../puzzles/cube2/solver/browser-loader.js");
+const browser_loader_js_2 = require("../puzzles/cube3/solver/browser-loader.js");
+/**
+ * Pre-load solver tables in browser environments.
+ * In Node.js this is a no-op (tables are read lazily from the filesystem).
+ *
+ * @param baseUrl - Base URL where the `puzzles/cube3/solver/generated/`
+ *   assets are served. If omitted, defaults to the current document base URL
+ *   or `"."`. In a Next.js app you typically copy the `.bin` files to
+ *   `public/scrambler-tables/` and pass `"/scrambler-tables"`.
+ * @param eventId - Optional event ID to selectively load tables. If omitted,
+ *   loads all standard tables.
+ */
+async function initializeScrambler(baseUrl, eventId) {
+    if (typeof self === "undefined") {
+        // Node.js — tables are loaded on-demand from the filesystem
+        return;
+    }
+    if (eventId === "222" || eventId === "222so") {
+        await (0, browser_loader_js_1.loadBrowserTables)(baseUrl);
+    }
+    else if (eventId === "333") {
+        await (0, browser_loader_js_2.loadBrowserTables)(baseUrl);
+    }
+    else if (!eventId) {
+        await Promise.all([
+            (0, browser_loader_js_1.loadBrowserTables)(baseUrl),
+            (0, browser_loader_js_2.loadBrowserTables)(baseUrl)
+        ]);
+    }
+}
+function registerScrambleGenerator(generator, registry = registry_js_1.defaultRegistry) {
+    registry.register(generator);
+}
+function getSupportedEvents(registry = registry_js_1.defaultRegistry) {
+    return registry.list();
+}
+function getEventInfo(eventId, registry = registry_js_1.defaultRegistry) {
+    const generator = registry.get(eventId);
+    if (!generator) {
+        throw new errors_js_1.UnsupportedEventError(eventId);
+    }
+    return { ...generator.info };
+}
+async function generateScramble(eventId, options = {}, registry = registry_js_1.defaultRegistry) {
+    const generator = registry.get(eventId);
+    if (!generator) {
+        throw new errors_js_1.UnsupportedEventError(eventId);
+    }
+    try {
+        const result = await generator.generate(options);
+        return normalizeResult(eventId, result, options);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name.endsWith("Error")) {
+            throw error;
+        }
+        throw new errors_js_1.GeneratorFailedError(eventId, error);
+    }
+}
+async function generateScrambles(eventId, count, options = {}, registry = registry_js_1.defaultRegistry) {
+    if (!Number.isInteger(count) || count < 1) {
+        throw new errors_js_1.InvalidCountError(count);
+    }
+    return Promise.all(Array.from({ length: count }, (_, index) => (generateScramble(eventId, deriveBatchScrambleOptions(options, index, count), registry))));
+}
+function deriveBatchScrambleOptions(options, index, count) {
+    if (count === 1 || options.seed === undefined) {
+        return options;
+    }
+    return {
+        ...options,
+        seed: `${options.seed}:${index}`
+    };
+}
+function normalizeResult(requestedEventId, result, options) {
+    const moves = result.moves.length > 0 ? result.moves : splitMoves(result.scramble);
+    const seed = result.seed ?? options.seed;
+    const normalized = {
+        ...result,
+        eventId: result.eventId || requestedEventId,
+        moves
+    };
+    if (seed !== undefined) {
+        normalized.seed = seed;
+    }
+    return normalized;
+}
+function splitMoves(scramble) {
+    const trimmed = scramble.trim();
+    return trimmed.length === 0 ? [] : trimmed.split(/\s+/);
+}