@cubingcenter/scrambler 0.1.0

package/dist-cjs/core/errors.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorFailedError = exports.InvalidOptionsError = exports.InvalidCountError = exports.UnsupportedEventError = exports.ScramblerError = void 0;
+class ScramblerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+exports.ScramblerError = ScramblerError;
+class UnsupportedEventError extends ScramblerError {
+    eventId;
+    constructor(eventId) {
+        super(`Unsupported scramble event: ${eventId}`);
+        this.eventId = eventId;
+    }
+}
+exports.UnsupportedEventError = UnsupportedEventError;
+class InvalidCountError extends ScramblerError {
+    count;
+    constructor(count) {
+        super(`Scramble count must be a positive integer. Received: ${count}`);
+        this.count = count;
+    }
+}
+exports.InvalidCountError = InvalidCountError;
+class InvalidOptionsError extends ScramblerError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.InvalidOptionsError = InvalidOptionsError;
+class GeneratorFailedError extends ScramblerError {
+    eventId;
+    cause;
+    constructor(eventId, cause) {
+        super(`Scramble generator failed for event: ${eventId}`);
+        this.eventId = eventId;
+        this.cause = cause;
+    }
+}
+exports.GeneratorFailedError = GeneratorFailedError;

package/dist-cjs/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScrambleGenerator = exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.defaultRegistry = exports.DefaultScramblerRegistry = exports.UnsupportedEventError = exports.ScramblerError = exports.InvalidOptionsError = exports.InvalidCountError = exports.GeneratorFailedError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "GeneratorFailedError", { enumerable: true, get: function () { return errors_js_1.GeneratorFailedError; } });
+Object.defineProperty(exports, "InvalidCountError", { enumerable: true, get: function () { return errors_js_1.InvalidCountError; } });
+Object.defineProperty(exports, "InvalidOptionsError", { enumerable: true, get: function () { return errors_js_1.InvalidOptionsError; } });
+Object.defineProperty(exports, "ScramblerError", { enumerable: true, get: function () { return errors_js_1.ScramblerError; } });
+Object.defineProperty(exports, "UnsupportedEventError", { enumerable: true, get: function () { return errors_js_1.UnsupportedEventError; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "DefaultScramblerRegistry", { enumerable: true, get: function () { return registry_js_1.DefaultScramblerRegistry; } });
+Object.defineProperty(exports, "defaultRegistry", { enumerable: true, get: function () { return registry_js_1.defaultRegistry; } });
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return api_js_1.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return api_js_1.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return api_js_1.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return api_js_1.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return api_js_1.initializeScrambler; } });
+Object.defineProperty(exports, "registerScrambleGenerator", { enumerable: true, get: function () { return api_js_1.registerScrambleGenerator; } });

package/dist-cjs/core/registry.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRegistry = exports.DefaultScramblerRegistry = void 0;
+const errors_js_1 = require("./errors.js");
+class DefaultScramblerRegistry {
+    generators = new Map();
+    register(generator) {
+        validateGenerator(generator);
+        this.generators.set(generator.info.eventId, generator);
+    }
+    get(eventId) {
+        return this.generators.get(eventId);
+    }
+    has(eventId) {
+        return this.generators.has(eventId);
+    }
+    list() {
+        return Array.from(this.generators.values())
+            .map((generator) => ({ ...generator.info }))
+            .sort((left, right) => left.eventId.localeCompare(right.eventId));
+    }
+}
+exports.DefaultScramblerRegistry = DefaultScramblerRegistry;
+exports.defaultRegistry = new DefaultScramblerRegistry();
+function validateGenerator(generator) {
+    const { info } = generator;
+    if (!info.eventId.trim()) {
+        throw new errors_js_1.InvalidOptionsError("Scramble generator eventId cannot be empty.");
+    }
+    if (!info.name.trim()) {
+        throw new errors_js_1.InvalidOptionsError(`Scramble generator ${info.eventId} must have a name.`);
+    }
+    if (!info.puzzle.trim()) {
+        throw new errors_js_1.InvalidOptionsError(`Scramble generator ${info.eventId} must have a puzzle name.`);
+    }
+    if (!info.generator.trim()) {
+        throw new errors_js_1.InvalidOptionsError(`Scramble generator ${info.eventId} must have a generator id.`);
+    }
+}

package/dist-cjs/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/index.js"), exports);
+__exportStar(require("./puzzles/index.js"), exports);
+__exportStar(require("./random/index.js"), exports);

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist-cjs/puzzles/clock/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateClockScramble = exports.clockScrambleGenerator = void 0;
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "clockScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.clockScrambleGenerator; } });
+Object.defineProperty(exports, "generateClockScramble", { enumerable: true, get: function () { return scrambler_js_1.generateClockScramble; } });

package/dist-cjs/puzzles/clock/scrambler.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clockScrambleGenerator = void 0;
+exports.generateClockScramble = generateClockScramble;
+exports.clockScrambleGenerator = {
+    info: {
+        eventId: "clkwca",
+        name: "Clock",
+        puzzle: "clock",
+        quality: "random-state",
+        generator: "clock-random-moves",
+        description: "Generates standard WCA Clock scrambles."
+    },
+    generate(options = {}) {
+        return generateClockScramble(options);
+    }
+};
+function getRandomTurns() {
+    const value = Math.floor(Math.random() * 12) - 5; // -5 to +6
+    if (value >= 0) {
+        return `${value}+`;
+    }
+    return `${Math.abs(value)}-`;
+}
+async function generateClockScramble(options = {}) {
+    const moves = [];
+    // Front face moves
+    const frontPins = ["UR", "DR", "DL", "UL", "U", "R", "D", "L", "ALL"];
+    for (const pin of frontPins) {
+        moves.push(`${pin}${getRandomTurns()}`);
+    }
+    // Flip
+    moves.push("y2");
+    // Back face moves
+    const backPins = ["U", "R", "D", "L", "ALL"];
+    for (const pin of backPins) {
+        moves.push(`${pin}${getRandomTurns()}`);
+    }
+    // Final pins state
+    const pins = ["UR", "DR", "DL", "UL"];
+    const finalPins = pins.filter(() => Math.random() < 0.5);
+    const finalPinsStr = finalPins.join(" ");
+    const scramble = [...moves, finalPinsStr].filter(Boolean).join(" ");
+    return {
+        eventId: "clkwca",
+        scramble,
+        moves, // For moves we return the steps without final pins as parsed moves, or just string array
+        quality: "random-state",
+        generator: "clock-random-moves",
+        metadata: {
+            finalPins
+        }
+    };
+}

package/dist-cjs/puzzles/cube2/facelets.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCube2Facelets = toCube2Facelets;
+exports.formatCube2Facelets = formatCube2Facelets;
+exports.getCube2FaceOrder = getCube2FaceOrder;
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const CORNER_PIECE_STICKERS = [
+    ["U", "R", "F"],
+    ["U", "F", "L"],
+    ["U", "L", "B"],
+    ["U", "B", "R"],
+    ["D", "F", "R"],
+    ["D", "L", "F"],
+    ["D", "B", "L"],
+    ["D", "R", "B"]
+];
+const CORNER_POSITION_SLOTS = [
+    [["U", 3], ["R", 0], ["F", 1]],
+    [["U", 2], ["F", 0], ["L", 1]],
+    [["U", 0], ["L", 0], ["B", 1]],
+    [["U", 1], ["B", 0], ["R", 1]],
+    [["D", 1], ["F", 3], ["R", 2]],
+    [["D", 0], ["L", 3], ["F", 2]],
+    [["D", 2], ["B", 3], ["L", 2]],
+    [["D", 3], ["R", 3], ["B", 2]]
+];
+function toCube2Facelets(state) {
+    const facelets = createEmptyFacelets();
+    for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
+        const piece = state.corners.permutation[position];
+        const orientation = state.corners.orientation[position];
+        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+    }
+    return facelets;
+}
+function formatCube2Facelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+function getCube2FaceOrder() {
+    return FACE_ORDER;
+}
+function createEmptyFacelets() {
+    return {
+        U: Array(4).fill("U"),
+        R: Array(4).fill("R"),
+        F: Array(4).fill("F"),
+        D: Array(4).fill("D"),
+        L: Array(4).fill("L"),
+        B: Array(4).fill("B")
+    };
+}
+function placeOrientedStickers(facelets, slots, stickers, orientation) {
+    for (let index = 0; index < slots.length; index += 1) {
+        const [face, stickerIndex] = slots[index];
+        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
+        facelets[face][stickerIndex] = sticker;
+    }
+}

package/dist-cjs/puzzles/cube2/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solver = exports.toCube2Facelets = exports.getCube2FaceOrder = exports.formatCube2Facelets = exports.generateCube2Scramble = exports.cube2ScrambleGenerator = exports.generateRandomCube2State = exports.validateCube2State = exports.permutationParity = exports.isOneMoveFromSolvedCube2State = exports.isAllowedRandomCube2State = exports.isSolvedCube2State = exports.cube2StatesEqual = exports.createSolvedCube2State = exports.cloneCube2State = exports.parseCube2Move = exports.parseCube2Algorithm = exports.invertCube2Move = exports.invertCube2Algorithm = exports.formatCube2Algorithm = exports.applyCube2Move = exports.applyCube2Algorithm = exports.CORNER_COUNT = exports.CUBE2_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CUBE2_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE2_MOVES; } });
+Object.defineProperty(exports, "CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.CORNER_COUNT; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "applyCube2Algorithm", { enumerable: true, get: function () { return moves_js_1.applyCube2Algorithm; } });
+Object.defineProperty(exports, "applyCube2Move", { enumerable: true, get: function () { return moves_js_1.applyCube2Move; } });
+Object.defineProperty(exports, "formatCube2Algorithm", { enumerable: true, get: function () { return moves_js_1.formatCube2Algorithm; } });
+Object.defineProperty(exports, "invertCube2Algorithm", { enumerable: true, get: function () { return moves_js_1.invertCube2Algorithm; } });
+Object.defineProperty(exports, "invertCube2Move", { enumerable: true, get: function () { return moves_js_1.invertCube2Move; } });
+Object.defineProperty(exports, "parseCube2Algorithm", { enumerable: true, get: function () { return moves_js_1.parseCube2Algorithm; } });
+Object.defineProperty(exports, "parseCube2Move", { enumerable: true, get: function () { return moves_js_1.parseCube2Move; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "cloneCube2State", { enumerable: true, get: function () { return state_js_1.cloneCube2State; } });
+Object.defineProperty(exports, "createSolvedCube2State", { enumerable: true, get: function () { return state_js_1.createSolvedCube2State; } });
+Object.defineProperty(exports, "cube2StatesEqual", { enumerable: true, get: function () { return state_js_1.cube2StatesEqual; } });
+Object.defineProperty(exports, "isSolvedCube2State", { enumerable: true, get: function () { return state_js_1.isSolvedCube2State; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "isAllowedRandomCube2State", { enumerable: true, get: function () { return validation_js_1.isAllowedRandomCube2State; } });
+Object.defineProperty(exports, "isOneMoveFromSolvedCube2State", { enumerable: true, get: function () { return validation_js_1.isOneMoveFromSolvedCube2State; } });
+Object.defineProperty(exports, "permutationParity", { enumerable: true, get: function () { return validation_js_1.permutationParity; } });
+Object.defineProperty(exports, "validateCube2State", { enumerable: true, get: function () { return validation_js_1.validateCube2State; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomCube2State", { enumerable: true, get: function () { return random_state_js_1.generateRandomCube2State; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube2ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube2ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube2Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube2Scramble; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "formatCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube2Facelets; } });
+Object.defineProperty(exports, "getCube2FaceOrder", { enumerable: true, get: function () { return facelets_js_1.getCube2FaceOrder; } });
+Object.defineProperty(exports, "toCube2Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube2Facelets; } });
+exports.solver = __importStar(require("./solver/index.js"));

package/dist-cjs/puzzles/cube2/moves.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCube2Move = applyCube2Move;
+exports.applyCube2Algorithm = applyCube2Algorithm;
+exports.invertCube2Algorithm = invertCube2Algorithm;
+exports.parseCube2Algorithm = parseCube2Algorithm;
+exports.formatCube2Algorithm = formatCube2Algorithm;
+exports.parseCube2Move = parseCube2Move;
+exports.invertCube2Move = invertCube2Move;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const FACE_MOVE_TABLES = {
+    U: {
+        permutation: [3, 0, 1, 2, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    D: {
+        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    R: {
+        permutation: [4, 1, 2, 0, 7, 5, 6, 3],
+        orientation: [2, 0, 0, 1, 1, 0, 0, 2]
+    },
+    L: {
+        permutation: [0, 2, 6, 3, 4, 1, 5, 7],
+        orientation: [0, 1, 2, 0, 0, 2, 1, 0]
+    },
+    F: {
+        permutation: [1, 5, 2, 3, 0, 4, 6, 7],
+        orientation: [1, 2, 0, 0, 2, 1, 0, 0]
+    },
+    B: {
+        permutation: [0, 1, 3, 7, 4, 5, 2, 6],
+        orientation: [0, 0, 1, 2, 0, 0, 2, 1]
+    }
+};
+function applyCube2Move(state, move) {
+    const { face, turns } = parseMoveParts(move);
+    let next = (0, state_js_1.cloneCube2State)(state);
+    for (let index = 0; index < turns; index += 1) {
+        next = applyFaceMove(next, FACE_MOVE_TABLES[face]);
+    }
+    return next;
+}
+function applyCube2Algorithm(state, moves) {
+    return moves.reduce((current, move) => applyCube2Move(current, move), state);
+}
+function invertCube2Algorithm(moves) {
+    return [...moves].reverse().map(invertCube2Move);
+}
+function parseCube2Algorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(/\s+/).map(parseCube2Move);
+}
+function formatCube2Algorithm(moves) {
+    return moves.join(" ");
+}
+function parseCube2Move(value) {
+    if (types_js_1.CUBE2_MOVES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid 2x2 move: ${value}`);
+}
+function invertCube2Move(move) {
+    const { face, suffix } = parseMoveParts(move);
+    if (suffix === "2") {
+        return move;
+    }
+    return `${face}${suffix === "'" ? "" : "'"}`;
+}
+function applyFaceMove(state, table) {
+    return {
+        corners: {
+            permutation: table.permutation.map((source) => state.corners.permutation[source]),
+            orientation: table.permutation.map((source, target) => ((state.corners.orientation[source] + table.orientation[target]) % 3))
+        }
+    };
+}
+function parseMoveParts(move) {
+    const face = move[0];
+    const suffix = move.slice(1);
+    const turns = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    return { face, suffix, turns };
+}

package/dist-cjs/puzzles/cube2/random-state.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomCube2State = generateRandomCube2State;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+const validation_js_1 = require("./validation.js");
+function generateRandomCube2State(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube2State)(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random 2x2 state.");
+}
+function createLegalRandomState(random) {
+    const perm7 = shuffledRange(types_js_1.CORNER_COUNT - 1, random);
+    const mappedPerm = perm7.map((val) => (val >= 6 ? val + 1 : val));
+    mappedPerm.splice(6, 0, 6);
+    const orient7 = randomOrientations(types_js_1.CORNER_COUNT - 1, 3, random);
+    orient7.splice(6, 0, 0);
+    return {
+        corners: {
+            permutation: mappedPerm,
+            orientation: orient7
+        }
+    };
+}
+function shuffledRange(length, random) {
+    const values = Array.from({ length }, (_, index) => index);
+    for (let index = values.length - 1; index > 0; index -= 1) {
+        const swapIndex = random.nextInt(index + 1);
+        swap(values, index, swapIndex);
+    }
+    return values;
+}
+function randomOrientations(length, modulo, random) {
+    const orientations = Array(length).fill(0);
+    let total = 0;
+    for (let index = 0; index < length - 1; index += 1) {
+        const orientation = random.nextInt(modulo);
+        orientations[index] = orientation;
+        total += orientation;
+    }
+    orientations[length - 1] = (modulo - (total % modulo)) % modulo;
+    return orientations;
+}
+function swap(values, left, right) {
+    const temporary = values[left];
+    values[left] = values[right];
+    values[right] = temporary;
+}

package/dist-cjs/puzzles/cube2/scrambler.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cube2ScrambleGenerator = void 0;
+exports.generateCube2Scramble = generateCube2Scramble;
+const moves_js_1 = require("./moves.js");
+const random_state_js_1 = require("./random-state.js");
+const state_js_1 = require("./state.js");
+const facelets_js_1 = require("./facelets.js");
+const index_js_1 = require("./solver/index.js");
+exports.cube2ScrambleGenerator = {
+    info: {
+        eventId: "222",
+        name: "2x2x2 Cube",
+        puzzle: "cube-2x2",
+        quality: "random-state",
+        generator: "cube2-ida-star",
+        description: "Random-state 2x2 scramble generated by an optimal IDA* corner solver."
+    },
+    generate(options = {}) {
+        return generateCube2Scramble(options);
+    }
+};
+async function generateCube2Scramble(options = {}) {
+    const state = (0, random_state_js_1.generateRandomCube2State)(options);
+    const solution = await (0, index_js_1.solveCube2State)(state);
+    const scrambleMoves = (0, moves_js_1.invertCube2Algorithm)(solution.moves);
+    if (!options.skipValidation) {
+        const scrambledState = (0, moves_js_1.applyCube2Algorithm)((0, state_js_1.createSolvedCube2State)(), scrambleMoves);
+        if (!(0, state_js_1.cube2StatesEqual)(scrambledState, state)) {
+            throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
+        }
+        if (!(0, state_js_1.isSolvedCube2State)(solution.state)) {
+            throw new Error("Generated 2x2 solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2) {
+            throw new Error("Generated 2x2 scramble is too short.");
+        }
+    }
+    const facelets = (0, facelets_js_1.toCube2Facelets)(state);
+    const result = {
+        eventId: "222",
+        scramble: (0, moves_js_1.formatCube2Algorithm)(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube2-ida-star",
+        metadata: {
+            state,
+            facelets,
+            faceletString: (0, facelets_js_1.formatCube2Facelets)(facelets),
+            solutionMoves: solution.moves,
+            solutionDepth: solution.depth
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

package/dist-cjs/puzzles/cube2/solver/browser-loader.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedBrowserTables = getCachedBrowserTables;
+exports.clearCachedBrowserTables = clearCachedBrowserTables;
+exports.loadBrowserTables = loadBrowserTables;
+const table_metadata_js_1 = require("./table-metadata.js");
+let cachedBrowserTables;
+function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+async function loadBrowserTables(baseUrl) {
+    if (cachedBrowserTables) {
+        return cachedBrowserTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolved);
+    const [permTable, orientTable, dist] = await Promise.all([
+        fetchUint16Table(resolved, manifest.files.permutationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.permutationTable.entries),
+        fetchUint16Table(resolved, manifest.files.orientationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.orientationTable.entries),
+        fetchUint8Table(resolved, manifest.files.distances, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.distances.entries)
+    ]);
+    cachedBrowserTables = {
+        permutationTable: permTable,
+        orientationTable: orientTable,
+        distances: dist
+    };
+    return cachedBrowserTables;
+}
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load cube2 solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported cube2 solver table manifest version: ${manifest.version}`);
+    }
+    return manifest;
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength !== expectedEntries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getUint16(i * 2, true);
+    }
+    return values;
+}
+async function fetchUint8Table(baseUrl, entry, expectedEntries) {
+    const url = `${baseUrl}/puzzles/cube2/solver/generated/${entry.file}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load ${entry.file}: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength !== expectedEntries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    return new Uint8Array(buffer);
+}