@cubingcenter/scrambler 0.2.0 → 0.4.0

package/dist/puzzles/skewb/types.js

@@ -0,0 +1,13 @@
+export const CORNER_COUNT = 8;
+export const CENTER_COUNT = 6;
+export const SKEWB_MOVES = [
+    "R",
+    "R'",
+    "U",
+    "U'",
+    "L",
+    "L'",
+    "B",
+    "B'",
+];
+export const SKEWB_FACES = ["U", "R", "F", "D", "L", "B"];

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

@@ -0,0 +1,6 @@
+import type { SkewbState, SkewbValidationResult } from "./types.js";
+export declare function validateSkewbState(state: SkewbState): SkewbValidationResult;
+export declare function isOneMoveFromSolvedSkewbState(state: SkewbState): boolean;
+export declare function isAllowedRandomSkewbState(state: SkewbState): boolean;
+export declare function permutationParity(permutation: readonly number[]): 0 | 1;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAwB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAGxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAQvE"}

package/dist/puzzles/skewb/validation.js

@@ -0,0 +1,69 @@
+import { SKEWB_MOVES, CENTER_COUNT, CORNER_COUNT } from "./types.js";
+import { applySkewbMove } from "./moves.js";
+import { createSolvedSkewbState, isSolvedSkewbState, skewbStatesEqual } from "./state.js";
+export function validateSkewbState(state) {
+    const errors = [];
+    // corners permutation
+    errors.push(...validatePermutation("corner", state.corners.permutation, CORNER_COUNT));
+    // corners orientation
+    errors.push(...validateOrientations("corner", state.corners.orientation, CORNER_COUNT, 3));
+    // centers
+    errors.push(...validatePermutation("center", state.centers, CENTER_COUNT));
+    // parity checks - both perms must be even (as observed in BFS)
+    if (errors.length === 0) {
+        if (permutationParity(state.corners.permutation) !== 0) {
+            errors.push("Corner permutation parity must be even.");
+        }
+        if (permutationParity(state.centers) !== 0) {
+            errors.push("Center permutation parity must be even.");
+        }
+        // Check fixed corner invariant: corner 0 must be at position 0 with orientation 0 for WCA fixed model
+        // But we allow all states for validation; this is enforced by solver's reachable set, not validation.
+        // So we don't enforce fixed corner here; any even parity state is considered valid.
+    }
+    return { valid: errors.length === 0, errors };
+}
+export function isOneMoveFromSolvedSkewbState(state) {
+    const solved = createSolvedSkewbState();
+    return SKEWB_MOVES.some((move) => skewbStatesEqual(applySkewbMove(solved, move), state));
+}
+export function isAllowedRandomSkewbState(state) {
+    return validateSkewbState(state).valid && !isSolvedSkewbState(state) && !isOneMoveFromSolvedSkewbState(state);
+}
+export function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left++) {
+        for (let right = left + 1; right < permutation.length; right++) {
+            if (permutation[left] > permutation[right])
+                inversions++;
+        }
+    }
+    return (inversions % 2);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length)
+        errors.push(`${label} permutation must contain ${length} values.`);
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value))
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length)
+        errors.push(`${label} orientation must contain ${length} values.`);
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}

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

@@ -4,7 +4,7 @@ exports.clockScrambleGenerator = void 0;
 exports.generateClockScramble = generateClockScramble;
 exports.clockScrambleGenerator = {
     info: {
-        eventId: "clkwca",
+        eventId: "clck",
         name: "Clock",
         puzzle: "clock",
         quality: "random-state",
@@ -42,7 +42,7 @@ async function generateClockScramble(options = {}) {
     const finalPinsStr = finalPins.join(" ");
     const scramble = [...moves, finalPinsStr].filter(Boolean).join(" ");
     return {
-        eventId: "clkwca",
+        eventId: "clck",
         scramble,
         moves, // For moves we return the steps without final pins as parsed moves, or just string array
         quality: "random-state",

package/dist-cjs/puzzles/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
+exports.skewb = exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("./cube2/index.js");
 const index_js_3 = require("./cube3/index.js");
@@ -44,6 +44,7 @@ const index_js_7 = require("./cube6x6/index.js");
 const index_js_8 = require("./cube7x7/index.js");
 const index_js_9 = require("./pyraminx/index.js");
 const index_js_10 = require("./clock/index.js");
+const index_js_11 = require("./skewb/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_2.cube2ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_3.cube3ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_4.cube4ScrambleGenerator);
@@ -53,6 +54,7 @@ const index_js_10 = require("./clock/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_8.cube7ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_9.pyraminxScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_10.clockScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_11.skewbScrambleGenerator);
 exports.cube2 = __importStar(require("./cube2/index.js"));
 exports.cube3 = __importStar(require("./cube3/index.js"));
 exports.cube4 = __importStar(require("./cube4/index.js"));
@@ -62,3 +64,4 @@ exports.cube6x6 = __importStar(require("./cube6x6/index.js"));
 exports.cube7x7 = __importStar(require("./cube7x7/index.js"));
 exports.pyraminx = __importStar(require("./pyraminx/index.js"));
 exports.clock = __importStar(require("./clock/index.js"));
+exports.skewb = __importStar(require("./skewb/index.js"));

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

@@ -6,7 +6,7 @@ const index_js_1 = require("../../random/index.js");
 const types_js_1 = require("./types.js");
 exports.megaminxScrambleGenerator = {
     info: {
-        eventId: "mega",
+        eventId: "mgmx",
         name: "Megaminx",
         puzzle: "megaminx",
         quality: "random-move",
@@ -33,7 +33,7 @@ function generateMegaminxScramble(options = {}) {
     }
     const scramble = formatMegaminxScramble(moves);
     const result = {
-        eventId: "mega",
+        eventId: "mgmx",
         scramble,
         moves,
         quality: "random-move",

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

@@ -9,7 +9,7 @@ const solver_js_1 = require("./solver.js");
 const facelets_js_1 = require("./facelets.js");
 exports.pyraminxScrambleGenerator = {
     info: {
-        eventId: "pyrso",
+        eventId: "pymx",
         name: "Pyraminx",
         puzzle: "pyraminx",
         quality: "random-state",
@@ -50,7 +50,7 @@ async function generatePyraminxScramble(options = {}) {
     }
     const facelets = (0, facelets_js_1.toPyraminxFacelets)(state);
     return {
-        eventId: "pyrso",
+        eventId: "pymx",
         scramble: finalMoves.join(" "),
         moves: finalMoves,
         quality: "random-state",

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedSkewbFacelets = createSolvedSkewbFacelets;
+exports.toSkewbFacelets = toSkewbFacelets;
+exports.formatSkewbFacelets = formatSkewbFacelets;
+exports.getSkewbFaceOrder = getSkewbFaceOrder;
+// Facelets model matching cubingcenter-viz/src/puzzles/skewb.ts
+// Each face has 5 stickers: 0=center, 1=TL,2=TR,3=BL,4=BR (net layout)
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+// Canonical sticker faces per corner position: [UD sticker, RL sticker, FB sticker]
+const CORNER_STICKERS = [
+    ["U", "R", "F"],
+    ["U", "L", "F"],
+    ["U", "R", "B"],
+    ["U", "L", "B"],
+    ["D", "R", "F"],
+    ["D", "L", "F"],
+    ["D", "R", "B"],
+    ["D", "L", "B"],
+];
+// Facelet index of each corner position on each of its 3 faces, aligned with CORNER_STICKERS order.
+const CORNER_SLOTS = [
+    [["U", 4], ["R", 1], ["F", 2]],
+    [["U", 3], ["L", 2], ["F", 1]],
+    [["U", 2], ["R", 2], ["B", 1]],
+    [["U", 1], ["L", 1], ["B", 2]],
+    [["D", 2], ["R", 3], ["F", 4]],
+    [["D", 1], ["L", 4], ["F", 3]],
+    [["D", 4], ["R", 4], ["B", 3]],
+    [["D", 3], ["L", 3], ["B", 4]],
+];
+function createSolvedSkewbFacelets() {
+    return {
+        U: Array.from({ length: 5 }, () => "U"),
+        R: Array.from({ length: 5 }, () => "R"),
+        F: Array.from({ length: 5 }, () => "F"),
+        D: Array.from({ length: 5 }, () => "D"),
+        L: Array.from({ length: 5 }, () => "L"),
+        B: Array.from({ length: 5 }, () => "B"),
+    };
+}
+function createEmptySkewbFacelets() {
+    return {
+        U: Array(5).fill("?"),
+        R: Array(5).fill("?"),
+        F: Array(5).fill("?"),
+        D: Array(5).fill("?"),
+        L: Array(5).fill("?"),
+        B: Array(5).fill("?"),
+    };
+}
+function toSkewbFacelets(state) {
+    const facelets = createEmptySkewbFacelets();
+    // centers
+    for (let face = 0; face < 6; face++) {
+        const targetFace = FACE_ORDER[face];
+        facelets[targetFace][0] = FACE_ORDER[state.centers[face]];
+    }
+    // corners
+    for (let pos = 0; pos < 8; pos++) {
+        const piece = state.corners.permutation[pos];
+        const ori = state.corners.orientation[pos];
+        const slots = CORNER_SLOTS[pos];
+        const stickers = CORNER_STICKERS[piece];
+        for (let i = 0; i < 3; i++) {
+            const [face, idx] = slots[i];
+            facelets[face][idx] = stickers[(i + 3 - ori) % 3];
+        }
+    }
+    return facelets;
+}
+function formatSkewbFacelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+function getSkewbFaceOrder() {
+    return FACE_ORDER;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skewbScrambleGenerator = exports.generateSkewbScramble = exports.getStateFromIndex = exports.getStateIndex = exports.solveSkewb = exports.toSkewbFacelets = exports.getSkewbFaceOrder = exports.formatSkewbFacelets = exports.createSolvedSkewbFacelets = exports.generateRandomSkewbState = exports.isOneMoveFromSolvedSkewbState = exports.isAllowedRandomSkewbState = exports.validateSkewbState = exports.permutationParity = exports.skewbStatesEqual = exports.isSolvedSkewbState = exports.createSolvedSkewbState = exports.cloneSkewbState = exports.parseSkewbMove = exports.parseSkewbAlgorithm = exports.invertSkewbMove = exports.invertSkewbAlgorithm = exports.formatSkewbAlgorithm = exports.applySkewbMove = exports.applySkewbAlgorithm = exports.SKEWB_FACES = exports.SKEWB_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "SKEWB_MOVES", { enumerable: true, get: function () { return types_js_1.SKEWB_MOVES; } });
+Object.defineProperty(exports, "SKEWB_FACES", { enumerable: true, get: function () { return types_js_1.SKEWB_FACES; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "applySkewbAlgorithm", { enumerable: true, get: function () { return moves_js_1.applySkewbAlgorithm; } });
+Object.defineProperty(exports, "applySkewbMove", { enumerable: true, get: function () { return moves_js_1.applySkewbMove; } });
+Object.defineProperty(exports, "formatSkewbAlgorithm", { enumerable: true, get: function () { return moves_js_1.formatSkewbAlgorithm; } });
+Object.defineProperty(exports, "invertSkewbAlgorithm", { enumerable: true, get: function () { return moves_js_1.invertSkewbAlgorithm; } });
+Object.defineProperty(exports, "invertSkewbMove", { enumerable: true, get: function () { return moves_js_1.invertSkewbMove; } });
+Object.defineProperty(exports, "parseSkewbAlgorithm", { enumerable: true, get: function () { return moves_js_1.parseSkewbAlgorithm; } });
+Object.defineProperty(exports, "parseSkewbMove", { enumerable: true, get: function () { return moves_js_1.parseSkewbMove; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "cloneSkewbState", { enumerable: true, get: function () { return state_js_1.cloneSkewbState; } });
+Object.defineProperty(exports, "createSolvedSkewbState", { enumerable: true, get: function () { return state_js_1.createSolvedSkewbState; } });
+Object.defineProperty(exports, "isSolvedSkewbState", { enumerable: true, get: function () { return state_js_1.isSolvedSkewbState; } });
+Object.defineProperty(exports, "skewbStatesEqual", { enumerable: true, get: function () { return state_js_1.skewbStatesEqual; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "permutationParity", { enumerable: true, get: function () { return validation_js_1.permutationParity; } });
+Object.defineProperty(exports, "validateSkewbState", { enumerable: true, get: function () { return validation_js_1.validateSkewbState; } });
+Object.defineProperty(exports, "isAllowedRandomSkewbState", { enumerable: true, get: function () { return validation_js_1.isAllowedRandomSkewbState; } });
+Object.defineProperty(exports, "isOneMoveFromSolvedSkewbState", { enumerable: true, get: function () { return validation_js_1.isOneMoveFromSolvedSkewbState; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomSkewbState", { enumerable: true, get: function () { return random_state_js_1.generateRandomSkewbState; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "createSolvedSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.createSolvedSkewbFacelets; } });
+Object.defineProperty(exports, "formatSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.formatSkewbFacelets; } });
+Object.defineProperty(exports, "getSkewbFaceOrder", { enumerable: true, get: function () { return facelets_js_1.getSkewbFaceOrder; } });
+Object.defineProperty(exports, "toSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.toSkewbFacelets; } });
+var solver_js_1 = require("./solver.js");
+Object.defineProperty(exports, "solveSkewb", { enumerable: true, get: function () { return solver_js_1.solveSkewb; } });
+Object.defineProperty(exports, "getStateIndex", { enumerable: true, get: function () { return solver_js_1.getStateIndex; } });
+Object.defineProperty(exports, "getStateFromIndex", { enumerable: true, get: function () { return solver_js_1.getStateFromIndex; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "generateSkewbScramble", { enumerable: true, get: function () { return scrambler_js_1.generateSkewbScramble; } });
+Object.defineProperty(exports, "skewbScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.skewbScrambleGenerator; } });

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOVE_TABLES = void 0;
+exports.applySkewbMove = applySkewbMove;
+exports.applySkewbAlgorithm = applySkewbAlgorithm;
+exports.invertSkewbMove = invertSkewbMove;
+exports.invertSkewbAlgorithm = invertSkewbAlgorithm;
+exports.parseSkewbMove = parseSkewbMove;
+exports.parseSkewbAlgorithm = parseSkewbAlgorithm;
+exports.formatSkewbAlgorithm = formatSkewbAlgorithm;
+exports.getAllSkewbMovesForTables = getAllSkewbMovesForTables;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const MOVE_TABLES = {
+    F: {
+        corners: { permutation: [0, 4, 1, 3, 2, 5, 6, 7], orientation: [1, 1, 1, 0, 1, 0, 0, 0] },
+        centers: [2, 0, 1, 3, 4, 5],
+    },
+    D: {
+        corners: { permutation: [5, 1, 2, 3, 4, 6, 0, 7], orientation: [2, 0, 0, 0, 2, 2, 2, 0] },
+        centers: [0, 2, 3, 1, 4, 5],
+    },
+    U: {
+        corners: { permutation: [0, 2, 7, 3, 4, 5, 6, 1], orientation: [0, 1, 1, 1, 0, 0, 0, 1] },
+        centers: [5, 1, 2, 3, 0, 4],
+    },
+    R: {
+        corners: { permutation: [0, 1, 4, 3, 7, 5, 6, 2], orientation: [0, 0, 1, 0, 1, 0, 1, 1] },
+        centers: [0, 3, 2, 5, 4, 1],
+    },
+    L: {
+        corners: { permutation: [0, 7, 2, 3, 1, 5, 6, 4], orientation: [0, 1, 0, 0, 1, 1, 0, 1] },
+        centers: [0, 1, 4, 2, 3, 5],
+    },
+    B: {
+        corners: { permutation: [0, 1, 2, 6, 4, 3, 5, 7], orientation: [0, 0, 0, 2, 0, 2, 2, 2] },
+        centers: [0, 1, 2, 4, 5, 3],
+    },
+};
+exports.MOVE_TABLES = MOVE_TABLES;
+function applyFaceMove(state, table) {
+    const perm = state.corners.permutation;
+    const orient = state.corners.orientation;
+    const centers = state.centers;
+    const newPerm = table.corners.permutation.map((src) => perm[src]);
+    const newOrient = table.corners.permutation.map((src, tgt) => (orient[src] + table.corners.orientation[tgt]) % 3);
+    const newCenters = table.centers.map((src) => centers[src]);
+    for (let i = 0; i < perm.length; i++)
+        perm[i] = newPerm[i];
+    for (let i = 0; i < orient.length; i++)
+        orient[i] = newOrient[i];
+    for (let i = 0; i < centers.length; i++)
+        centers[i] = newCenters[i];
+}
+function applySkewbMove(state, move) {
+    const face = move[0].toUpperCase();
+    const suffix = move.slice(1);
+    const table = MOVE_TABLES[face];
+    if (!table)
+        throw new Error(`Unknown Skewb move: ${move}`);
+    const repetitions = suffix === "'" || suffix === "2" ? 2 : 1;
+    const next = (0, state_js_1.cloneSkewbState)(state);
+    for (let i = 0; i < repetitions; i++)
+        applyFaceMove(next, table);
+    return next;
+}
+function applySkewbAlgorithm(state, moves) {
+    return moves.reduce((current, move) => applySkewbMove(current, move), state);
+}
+function invertSkewbMove(move) {
+    if (move.endsWith("'"))
+        return move.slice(0, -1);
+    return `${move}'`;
+}
+function invertSkewbAlgorithm(moves) {
+    return [...moves].reverse().map(invertSkewbMove);
+}
+function parseSkewbMove(value) {
+    if (types_js_1.SKEWB_MOVES.includes(value))
+        return value;
+    throw new Error(`Invalid Skewb move: ${value}`);
+}
+function parseSkewbAlgorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0)
+        return [];
+    return trimmed.split(/\s+/).map(parseSkewbMove);
+}
+function formatSkewbAlgorithm(moves) {
+    return moves.join(" ");
+}
+// For internal use by solver (needs all 6 faces for table generation)
+function getAllSkewbMovesForTables() {
+    return ["R", "U", "L", "B", "F", "D"].flatMap((f) => [f, `${f}'`]);
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomSkewbState = generateRandomSkewbState;
+const index_js_1 = require("../../random/index.js");
+const validation_js_1 = require("./validation.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+const types_js_1 = require("./types.js");
+function generateRandomSkewbState(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const state = createLegalRandomState(random);
+        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomSkewbState)(state))
+            return state;
+    }
+    throw new Error("Unable to generate a non-trivial random Skewb state.");
+}
+function createLegalRandomState(random) {
+    // Generate a random reachable Skewb state via random walk from solved.
+    // Skewb has 3,149,280 reachable states with WCA moves (fixed corner).
+    // A walk of 30+ moves is sufficient to approach uniform distribution.
+    let state = (0, state_js_1.createSolvedSkewbState)();
+    const walkLength = 30 + random.nextInt(5); // 30-34 moves
+    for (let i = 0; i < walkLength; i++) {
+        const move = random.choice([...types_js_1.SKEWB_MOVES]);
+        state = (0, moves_js_1.applySkewbMove)(state, move);
+    }
+    return state;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skewbScrambleGenerator = void 0;
+exports.generateSkewbScramble = generateSkewbScramble;
+const random_state_js_1 = require("./random-state.js");
+const state_js_1 = require("./state.js");
+const moves_js_1 = require("./moves.js");
+const solver_js_1 = require("./solver.js");
+const facelets_js_1 = require("./facelets.js");
+exports.skewbScrambleGenerator = {
+    info: {
+        eventId: "skwb",
+        name: "Skewb",
+        puzzle: "skewb",
+        quality: "random-state",
+        generator: "skewb-bfs",
+        description: "Random-state Skewb scramble generated by an optimal bidirectional BFS solver.",
+    },
+    generate(options = {}) {
+        return generateSkewbScramble(options);
+    },
+};
+async function generateSkewbScramble(options = {}) {
+    const state = (0, random_state_js_1.generateRandomSkewbState)(options);
+    const solution = (0, solver_js_1.solveSkewb)(state);
+    const scrambleMoves = (0, moves_js_1.invertSkewbAlgorithm)(solution);
+    if (!options.skipValidation) {
+        const scrambledState = (0, moves_js_1.applySkewbAlgorithm)((0, state_js_1.createSolvedSkewbState)(), scrambleMoves);
+        if (!(0, state_js_1.skewbStatesEqual)(scrambledState, state)) {
+            throw new Error("Generated Skewb scramble does not reproduce the target random state.");
+        }
+        if (!(0, state_js_1.isSolvedSkewbState)((0, moves_js_1.applySkewbAlgorithm)(state, solution))) {
+            throw new Error("Generated Skewb solution does not solve the target random state.");
+        }
+        if (scrambleMoves.length < 2)
+            throw new Error("Generated Skewb scramble is too short.");
+    }
+    const facelets = (0, facelets_js_1.toSkewbFacelets)(state);
+    const result = {
+        eventId: "skwb",
+        scramble: (0, moves_js_1.formatSkewbAlgorithm)(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "skewb-bfs",
+        metadata: {
+            state,
+            facelets,
+            faceletString: (0, facelets_js_1.formatSkewbFacelets)(facelets),
+            solutionMoves: solution,
+            solutionDepth: solution.length,
+        },
+    };
+    if (options.seed !== undefined)
+        result.seed = options.seed;
+    return result;
+}

package/dist-cjs/puzzles/skewb/solver.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermutationIndex = getPermutationIndex;
+exports.getPermutationFromIndex = getPermutationFromIndex;
+exports.getOrientationIndex = getOrientationIndex;
+exports.getOrientationFromIndex = getOrientationFromIndex;
+exports.getCenterIndex = getCenterIndex;
+exports.getCenterFromIndex = getCenterFromIndex;
+exports.getStateIndex = getStateIndex;
+exports.getStateFromIndex = getStateFromIndex;
+exports.solveSkewb = solveSkewb;
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320];
+function getPermutationIndex(perm) {
+    // perm length 8, but pos0 is always 0 for WCA reachable states.
+    // We encode full 8-perm via Lehmer code (0..40319), but for fixed corner it will be in subset.
+    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;
+}
+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;
+}
+function getOrientationIndex(orient) {
+    // orient length 8, index 0 is fixed 0, encode remaining 7 base3
+    let index = 0;
+    for (let i = 7; i >= 1; i--) {
+        index = index * 3 + orient[i];
+    }
+    return index;
+}
+function getOrientationFromIndex(index) {
+    const orient = Array(8).fill(0);
+    orient[0] = 0;
+    let val = index;
+    for (let i = 1; i < 8; i++) {
+        orient[i] = val % 3;
+        val = Math.floor(val / 3);
+    }
+    return orient;
+}
+function getCenterIndex(centers) {
+    let index = 0;
+    const n = centers.length;
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = i + 1; j < n; j++)
+            if (centers[j] < centers[i])
+                count++;
+        index += count * FACT[n - 1 - i];
+    }
+    return index;
+}
+function getCenterFromIndex(index) {
+    return getPermutationFromIndex(index, 6);
+}
+function getStateIndex(state) {
+    const p = getPermutationIndex(state.corners.permutation);
+    const c = getCenterIndex(state.centers);
+    const o = getOrientationIndex(state.corners.orientation);
+    // p in 0..40319, c in 0..719, o in 0..2186
+    // Combine: ((p * 720 + c) * 2187 + o) -> up to 63B fits in JS number (53-bit)
+    return ((p * 720 + c) * 2187 + o);
+}
+function getStateFromIndex(index) {
+    const o = index % 2187;
+    let val = Math.floor(index / 2187);
+    const c = val % 720;
+    const p = Math.floor(val / 720);
+    return {
+        corners: {
+            permutation: getPermutationFromIndex(p, 8),
+            orientation: getOrientationFromIndex(o),
+        },
+        centers: getCenterFromIndex(c),
+    };
+}
+const MOVES = ["R", "R'", "U", "U'", "L", "L'", "B", "B'"];
+function solveSkewb(state) {
+    const startIdx = getStateIndex(state);
+    const solvedIdx = getStateIndex((0, state_js_1.createSolvedSkewbState)());
+    if (startIdx === solvedIdx)
+        return [];
+    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) {
+        const fSize = forwardQueue.length;
+        for (let i = 0; i < Math.min(fSize, 1000); i++) {
+            const currIdx = forwardQueue.shift();
+            const currState = getStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = (0, moves_js_1.applySkewbMove)(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);
+                }
+            }
+        }
+        const bSize = backwardQueue.length;
+        for (let i = 0; i < Math.min(bSize, 1000); i++) {
+            const currIdx = backwardQueue.shift();
+            const currState = getStateFromIndex(currIdx);
+            for (const move of MOVES) {
+                const nextState = (0, moves_js_1.applySkewbMove)(currState, move);
+                const nextIdx = getStateIndex(nextState);
+                if (!backwardMap.has(nextIdx)) {
+                    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("Skewb state is unsolvable");
+}
+function reconstructPath(meetingIdx, forwardMap, backwardMap) {
+    const path = [];
+    let curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = forwardMap.get(curr);
+        if (edge.parent !== -1)
+            path.unshift(edge.move);
+        curr = edge.parent;
+    }
+    curr = meetingIdx;
+    while (curr !== -1) {
+        const edge = backwardMap.get(curr);
+        if (edge.parent !== -1)
+            path.push(edge.move);
+        curr = edge.parent;
+    }
+    return path;
+}