@cubingcenter/scrambler 0.1.0

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cube6ScrambleGenerator = void 0;
+exports.generateCube6Scramble = generateCube6Scramble;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+exports.cube6ScrambleGenerator = {
+    info: {
+        eventId: "666",
+        name: "6x6x6 Cube",
+        puzzle: "cube-6x6",
+        quality: "random-move",
+        generator: "cube6-random-move",
+        description: "Random-move 6x6 scramble with 80 moves."
+    },
+    generate(options = {}) {
+        return generateCube6Scramble(options);
+    }
+};
+function generateCube6Scramble(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const moves = [];
+    for (let i = 0; i < types_js_1.SCRAMBLE_LENGTH; i++) {
+        let move;
+        do {
+            move = random.choice(types_js_1.CUBE6_ALL_MOVES);
+        } while (isRedundant(moves, move));
+        moves.push(move);
+    }
+    const scramble = moves.join(" ");
+    const result = {
+        eventId: "666",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "cube6-random-move",
+        metadata: {
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+const MAX_AXIS_BLOCK = 4;
+// On a 6x6, these 3-wide pairs cover all 6 layers together.
+// Any combination of both in the same block is always reducible
+// to at most 1 move + a free cube reorientation.
+const ROTATION_PAIRS = {
+    "3Uw": "3Dw", "3Dw": "3Uw",
+    "3Rw": "3Lw", "3Lw": "3Rw",
+    "3Fw": "3Bw", "3Bw": "3Fw",
+};
+function getBaseMove(move) {
+    if (move.endsWith("2") || move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return move;
+}
+function getAxis(base) {
+    if (base.includes("R") || base.includes("L"))
+        return "X";
+    if (base.includes("U") || base.includes("D"))
+        return "Y";
+    if (base.includes("F") || base.includes("B"))
+        return "Z";
+    return "";
+}
+function isRedundant(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newBase = getBaseMove(newMove);
+    const newAxis = getAxis(newBase);
+    const lastBase = getBaseMove(moves[moves.length - 1]);
+    // No same base move consecutively
+    if (lastBase === newBase)
+        return true;
+    const lastAxis = getAxis(lastBase);
+    // Different axis: always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis: scan the current block
+    const basesInBlock = new Set();
+    basesInBlock.add(lastBase);
+    let blockLength = 1;
+    for (let i = moves.length - 2; i >= 0; i--) {
+        const base = getBaseMove(moves[i]);
+        if (getAxis(base) === newAxis) {
+            basesInBlock.add(base);
+            blockLength++;
+        }
+        else {
+            break;
+        }
+    }
+    // No same base within the block
+    if (basesInBlock.has(newBase))
+        return true;
+    // No rotation pairs (3-wide complements that cover all 6 layers)
+    const complement = ROTATION_PAIRS[newBase];
+    if (complement && basesInBlock.has(complement))
+        return true;
+    // Max block length
+    if (blockLength >= MAX_AXIS_BLOCK)
+        return true;
+    return false;
+}

package/dist-cjs/puzzles/cube6x6/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRAMBLE_LENGTH = exports.CUBE6_ALL_MOVES = void 0;
+const BASE_MOVES = [
+    "U", "D", "R", "L", "F", "B",
+    "Uw", "Dw", "Rw", "Lw", "Fw", "Bw",
+    "3Uw", "3Dw", "3Rw", "3Lw", "3Fw", "3Bw"
+];
+const SUFFIXES = ["", "2", "'"];
+exports.CUBE6_ALL_MOVES = BASE_MOVES.flatMap((base) => SUFFIXES.map(suffix => `${base}${suffix}`));
+exports.SCRAMBLE_LENGTH = 80;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCube7Scramble = exports.cube7ScrambleGenerator = exports.SCRAMBLE_LENGTH = exports.CUBE7_ALL_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CUBE7_ALL_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE7_ALL_MOVES; } });
+Object.defineProperty(exports, "SCRAMBLE_LENGTH", { enumerable: true, get: function () { return types_js_1.SCRAMBLE_LENGTH; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube7ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube7ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube7Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube7Scramble; } });

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cube7ScrambleGenerator = void 0;
+exports.generateCube7Scramble = generateCube7Scramble;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+exports.cube7ScrambleGenerator = {
+    info: {
+        eventId: "777",
+        name: "7x7x7 Cube",
+        puzzle: "cube-7x7",
+        quality: "random-move",
+        generator: "cube7-random-move",
+        description: "Random-move 7x7 scramble with 100 moves."
+    },
+    generate(options = {}) {
+        return generateCube7Scramble(options);
+    }
+};
+function generateCube7Scramble(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const moves = [];
+    for (let i = 0; i < types_js_1.SCRAMBLE_LENGTH; i++) {
+        let move;
+        do {
+            move = random.choice(types_js_1.CUBE7_ALL_MOVES);
+        } while (isRedundant(moves, move));
+        moves.push(move);
+    }
+    const scramble = moves.join(" ");
+    const result = {
+        eventId: "777",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "cube7-random-move",
+        metadata: {
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+const MAX_AXIS_BLOCK = 4;
+function getBaseMove(move) {
+    if (move.endsWith("2") || move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return move;
+}
+function getAxis(base) {
+    if (base.includes("R") || base.includes("L"))
+        return "X";
+    if (base.includes("U") || base.includes("D"))
+        return "Y";
+    if (base.includes("F") || base.includes("B"))
+        return "Z";
+    return "";
+}
+function isRedundant(moves, newMove) {
+    if (moves.length === 0)
+        return false;
+    const newBase = getBaseMove(newMove);
+    const newAxis = getAxis(newBase);
+    const lastBase = getBaseMove(moves[moves.length - 1]);
+    // No same base move consecutively
+    if (lastBase === newBase)
+        return true;
+    const lastAxis = getAxis(lastBase);
+    // Different axis: always allowed
+    if (newAxis !== lastAxis)
+        return false;
+    // Same axis: scan the current block
+    const basesInBlock = new Set();
+    basesInBlock.add(lastBase);
+    let blockLength = 1;
+    for (let i = moves.length - 2; i >= 0; i--) {
+        const base = getBaseMove(moves[i]);
+        if (getAxis(base) === newAxis) {
+            basesInBlock.add(base);
+            blockLength++;
+        }
+        else {
+            break;
+        }
+    }
+    // No same base within the block
+    if (basesInBlock.has(newBase))
+        return true;
+    // Max block length
+    if (blockLength >= MAX_AXIS_BLOCK)
+        return true;
+    return false;
+}

package/dist-cjs/puzzles/cube7x7/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRAMBLE_LENGTH = exports.CUBE7_ALL_MOVES = void 0;
+const BASE_MOVES = [
+    "U", "D", "R", "L", "F", "B",
+    "Uw", "Dw", "Rw", "Lw", "Fw", "Bw",
+    "3Uw", "3Dw", "3Rw", "3Lw", "3Fw", "3Bw"
+];
+const SUFFIXES = ["", "2", "'"];
+exports.CUBE7_ALL_MOVES = BASE_MOVES.flatMap((base) => SUFFIXES.map(suffix => `${base}${suffix}`));
+exports.SCRAMBLE_LENGTH = 100;

package/dist-cjs/puzzles/index.js

@@ -0,0 +1,64 @@
+"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.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");
+const index_js_4 = require("./cube4/index.js");
+const index_js_5 = require("./megaminx/index.js");
+const index_js_6 = require("./cube5x5/index.js");
+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");
+(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);
+(0, index_js_1.registerScrambleGenerator)(index_js_5.megaminxScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_6.cube5ScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_7.cube6ScrambleGenerator);
+(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);
+exports.cube2 = __importStar(require("./cube2/index.js"));
+exports.cube3 = __importStar(require("./cube3/index.js"));
+exports.cube4 = __importStar(require("./cube4/index.js"));
+exports.megaminx = __importStar(require("./megaminx/index.js"));
+exports.cube5x5 = __importStar(require("./cube5x5/index.js"));
+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"));

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMegaminxScramble = exports.megaminxScrambleGenerator = exports.MOVES_PER_LINE = exports.SCRAMBLE_LINES = exports.MEGAMINX_D_MOVES = exports.MEGAMINX_R_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "MEGAMINX_R_MOVES", { enumerable: true, get: function () { return types_js_1.MEGAMINX_R_MOVES; } });
+Object.defineProperty(exports, "MEGAMINX_D_MOVES", { enumerable: true, get: function () { return types_js_1.MEGAMINX_D_MOVES; } });
+Object.defineProperty(exports, "SCRAMBLE_LINES", { enumerable: true, get: function () { return types_js_1.SCRAMBLE_LINES; } });
+Object.defineProperty(exports, "MOVES_PER_LINE", { enumerable: true, get: function () { return types_js_1.MOVES_PER_LINE; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "megaminxScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.megaminxScrambleGenerator; } });
+Object.defineProperty(exports, "generateMegaminxScramble", { enumerable: true, get: function () { return scrambler_js_1.generateMegaminxScramble; } });

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.megaminxScrambleGenerator = void 0;
+exports.generateMegaminxScramble = generateMegaminxScramble;
+const index_js_1 = require("../../random/index.js");
+const types_js_1 = require("./types.js");
+exports.megaminxScrambleGenerator = {
+    info: {
+        eventId: "mega",
+        name: "Megaminx",
+        puzzle: "megaminx",
+        quality: "random-move",
+        generator: "megaminx-random-move",
+        description: "Random-move Megaminx scramble using WCA notation (7 lines of 10 moves + U/U')."
+    },
+    generate(options = {}) {
+        return generateMegaminxScramble(options);
+    }
+};
+function generateMegaminxScramble(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const moves = [];
+    for (let line = 0; line < types_js_1.SCRAMBLE_LINES; line++) {
+        let lastD = "D++";
+        for (let pair = 0; pair < 5; pair++) {
+            const rMove = random.choice(types_js_1.MEGAMINX_R_MOVES);
+            const dMove = random.choice(types_js_1.MEGAMINX_D_MOVES);
+            moves.push(rMove, dMove);
+            lastD = dMove;
+        }
+        const uMove = lastD === "D++" ? "U" : "U'";
+        moves.push(uMove);
+    }
+    const scramble = formatMegaminxScramble(moves);
+    const result = {
+        eventId: "mega",
+        scramble,
+        moves,
+        quality: "random-move",
+        generator: "megaminx-random-move",
+        metadata: {
+            lines: types_js_1.SCRAMBLE_LINES,
+            movesPerLine: types_js_1.MOVES_PER_LINE,
+            totalMoves: moves.length,
+            distribution: "random-move-wca-format"
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}
+function formatMegaminxScramble(moves) {
+    const lines = [];
+    for (let i = 0; i < types_js_1.SCRAMBLE_LINES; i++) {
+        const lineMoves = moves.slice(i * types_js_1.MOVES_PER_LINE, (i + 1) * types_js_1.MOVES_PER_LINE);
+        lines.push(lineMoves.join(" "));
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOVES_PER_LINE = exports.SCRAMBLE_LINES = exports.MEGAMINX_D_MOVES = exports.MEGAMINX_R_MOVES = void 0;
+exports.MEGAMINX_R_MOVES = ["R++", "R--"];
+exports.MEGAMINX_D_MOVES = ["D++", "D--"];
+exports.SCRAMBLE_LINES = 7;
+exports.MOVES_PER_LINE = 11;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solvePyraminx = exports.generatePyraminxScramble = exports.pyraminxScrambleGenerator = exports.generateRandomPyraminxState = exports.isAllowedRandomPyraminxState = exports.validatePyraminxState = exports.permutationParity = exports.isSolvedPyraminxState = exports.pyraminxStatesEqual = exports.createSolvedPyraminxState = exports.clonePyraminxState = exports.parsePyraminxMove = exports.parsePyraminxAlgorithm = exports.invertPyraminxMove = exports.invertPyraminxAlgorithm = exports.formatPyraminxAlgorithm = exports.applyPyraminxMove = exports.applyPyraminxAlgorithm = exports.PYRAMINX_TIPS = exports.PYRAMINX_CORE_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "PYRAMINX_CORE_MOVES", { enumerable: true, get: function () { return types_js_1.PYRAMINX_CORE_MOVES; } });
+Object.defineProperty(exports, "PYRAMINX_TIPS", { enumerable: true, get: function () { return types_js_1.PYRAMINX_TIPS; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "applyPyraminxAlgorithm", { enumerable: true, get: function () { return moves_js_1.applyPyraminxAlgorithm; } });
+Object.defineProperty(exports, "applyPyraminxMove", { enumerable: true, get: function () { return moves_js_1.applyPyraminxMove; } });
+Object.defineProperty(exports, "formatPyraminxAlgorithm", { enumerable: true, get: function () { return moves_js_1.formatPyraminxAlgorithm; } });
+Object.defineProperty(exports, "invertPyraminxAlgorithm", { enumerable: true, get: function () { return moves_js_1.invertPyraminxAlgorithm; } });
+Object.defineProperty(exports, "invertPyraminxMove", { enumerable: true, get: function () { return moves_js_1.invertPyraminxMove; } });
+Object.defineProperty(exports, "parsePyraminxAlgorithm", { enumerable: true, get: function () { return moves_js_1.parsePyraminxAlgorithm; } });
+Object.defineProperty(exports, "parsePyraminxMove", { enumerable: true, get: function () { return moves_js_1.parsePyraminxMove; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "clonePyraminxState", { enumerable: true, get: function () { return state_js_1.clonePyraminxState; } });
+Object.defineProperty(exports, "createSolvedPyraminxState", { enumerable: true, get: function () { return state_js_1.createSolvedPyraminxState; } });
+Object.defineProperty(exports, "pyraminxStatesEqual", { enumerable: true, get: function () { return state_js_1.pyraminxStatesEqual; } });
+Object.defineProperty(exports, "isSolvedPyraminxState", { enumerable: true, get: function () { return state_js_1.isSolvedPyraminxState; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "permutationParity", { enumerable: true, get: function () { return validation_js_1.permutationParity; } });
+Object.defineProperty(exports, "validatePyraminxState", { enumerable: true, get: function () { return validation_js_1.validatePyraminxState; } });
+Object.defineProperty(exports, "isAllowedRandomPyraminxState", { enumerable: true, get: function () { return validation_js_1.isAllowedRandomPyraminxState; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomPyraminxState", { enumerable: true, get: function () { return random_state_js_1.generateRandomPyraminxState; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "pyraminxScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.pyraminxScrambleGenerator; } });
+Object.defineProperty(exports, "generatePyraminxScramble", { enumerable: true, get: function () { return scrambler_js_1.generatePyraminxScramble; } });
+var solver_js_1 = require("./solver.js");
+Object.defineProperty(exports, "solvePyraminx", { enumerable: true, get: function () { return solver_js_1.solvePyraminx; } });

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPyraminxMove = applyPyraminxMove;
+exports.applyPyraminxAlgorithm = applyPyraminxAlgorithm;
+exports.invertPyraminxAlgorithm = invertPyraminxAlgorithm;
+exports.parsePyraminxAlgorithm = parsePyraminxAlgorithm;
+exports.formatPyraminxAlgorithm = formatPyraminxAlgorithm;
+exports.parsePyraminxMove = parsePyraminxMove;
+exports.invertPyraminxMove = invertPyraminxMove;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+// Mathematical representation of Pyraminx moves
+function applyPyraminxMove(state, move) {
+    const isInverse = move.endsWith("'");
+    const baseMove = move.replace("'", "");
+    const isTip = baseMove === baseMove.toLowerCase();
+    const next = (0, state_js_1.clonePyraminxState)(state);
+    if (isTip) {
+        const tipIndex = types_js_1.PYRAMINX_TIPS.indexOf(baseMove);
+        if (tipIndex !== -1) {
+            if (isInverse) {
+                next.tips[tipIndex] = (next.tips[tipIndex] + 2) % 3;
+            }
+            else {
+                next.tips[tipIndex] = (next.tips[tipIndex] + 1) % 3;
+            }
+        }
+        return next;
+    }
+    // Otherwise, it is a core layer move
+    const face = baseMove;
+    const turns = isInverse ? 2 : 1; // CW is 1, CCW is 2 turns CW
+    for (let step = 0; step < turns; step++) {
+        applySingleCoreMoveCW(next, face);
+    }
+    return next;
+}
+function applySingleCoreMoveCW(state, face) {
+    const centers = state.centers;
+    const perm = state.edgesPerm;
+    const orient = state.edgesOrient;
+    // Clone arrays for temporary storage
+    const prevPerm = [...perm];
+    const prevOrient = [...orient];
+    if (face === "U") {
+        // Center
+        centers[0] = (centers[0] + 1) % 3;
+        // Edges cycle: 0 -> 1 -> 2 -> 0 (UL -> UR -> UB -> UL)
+        // No orientation flips for U
+        perm[1] = prevPerm[0];
+        perm[2] = prevPerm[1];
+        perm[0] = prevPerm[2];
+        orient[1] = prevOrient[0];
+        orient[2] = prevOrient[1];
+        orient[0] = prevOrient[2];
+    }
+    else if (face === "L") {
+        // Center
+        centers[1] = (centers[1] + 1) % 3;
+        // Edges cycle: 0 -> 4 -> 3 -> 0 (UL -> LB -> LR -> UL)
+        // Flips: UL(0) flips, LB(4) flips, LR(3) does not flip
+        perm[4] = prevPerm[0];
+        perm[3] = prevPerm[4];
+        perm[0] = prevPerm[3];
+        orient[4] = (prevOrient[0] + 1) % 2;
+        orient[3] = (prevOrient[4] + 1) % 2;
+        orient[0] = prevOrient[3];
+    }
+    else if (face === "R") {
+        // Center
+        centers[2] = (centers[2] + 1) % 3;
+        // Edges cycle: 1 -> 3 -> 5 -> 1 (UR -> LR -> RB -> UR)
+        // Flips: UR(1) flips, LR(3) flips, RB(5) does not flip
+        perm[3] = prevPerm[1];
+        perm[5] = prevPerm[3];
+        perm[1] = prevPerm[5];
+        orient[3] = (prevOrient[1] + 1) % 2;
+        orient[5] = (prevOrient[3] + 1) % 2;
+        orient[1] = prevOrient[5];
+    }
+    else if (face === "B") {
+        // Center
+        centers[3] = (centers[3] + 1) % 3;
+        // Edges cycle: 2 -> 5 -> 4 -> 2 (UB -> RB -> LB -> UB)
+        // Flips: UB(2) flips, RB(5) flips, LB(4) does not flip
+        perm[5] = prevPerm[2];
+        perm[4] = prevPerm[5];
+        perm[2] = prevPerm[4];
+        orient[5] = (prevOrient[2] + 1) % 2;
+        orient[4] = (prevOrient[5] + 1) % 2;
+        orient[2] = prevOrient[4];
+    }
+}
+function applyPyraminxAlgorithm(state, moves) {
+    return moves.reduce((current, move) => applyPyraminxMove(current, move), state);
+}
+function invertPyraminxAlgorithm(moves) {
+    return [...moves].reverse().map(invertPyraminxMove);
+}
+function parsePyraminxAlgorithm(algorithm) {
+    const trimmed = algorithm.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(/\s+/).map(parsePyraminxMove);
+}
+function formatPyraminxAlgorithm(moves) {
+    return moves.join(" ");
+}
+function parsePyraminxMove(value) {
+    const baseMove = value.replace("'", "");
+    const isInverse = value.endsWith("'") || value.endsWith(""); // wait, standard validation
+    if (types_js_1.PYRAMINX_CORE_MOVES.includes(value) || types_js_1.PYRAMINX_TIPS.map(t => `${t}'`).includes(value) || types_js_1.PYRAMINX_TIPS.includes(value)) {
+        return value;
+    }
+    if (types_js_1.PYRAMINX_CORE_MOVES.map(m => `${m}'`).includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid Pyraminx move: ${value}`);
+}
+function invertPyraminxMove(move) {
+    if (move.endsWith("'")) {
+        return move.slice(0, -1);
+    }
+    return `${move}'`;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomPyraminxState = generateRandomPyraminxState;
+const index_js_1 = require("../../random/index.js");
+const validation_js_1 = require("./validation.js");
+function generateRandomPyraminxState(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.isAllowedRandomPyraminxState)(state)) {
+            return state;
+        }
+    }
+    throw new Error("Unable to generate a non-trivial random Pyraminx state.");
+}
+function createLegalRandomState(random) {
+    // 4 random centers
+    const centers = Array.from({ length: 4 }, () => random.nextInt(3));
+    // 4 random tips
+    const tips = Array.from({ length: 4 }, () => random.nextInt(3));
+    // 6 edges permutation
+    const edgesPerm = shuffledRange(6, random);
+    // Ensure even parity
+    if ((0, validation_js_1.permutationParity)(edgesPerm) !== 0) {
+        // Swap the first two elements to flip parity
+        const temp = edgesPerm[0];
+        edgesPerm[0] = edgesPerm[1];
+        edgesPerm[1] = temp;
+    }
+    // 6 edges orientation (sum must be even)
+    const edgesOrient = Array(6).fill(0);
+    let sumOrient = 0;
+    for (let i = 0; i < 5; i++) {
+        const val = random.nextInt(2);
+        edgesOrient[i] = val;
+        sumOrient += val;
+    }
+    edgesOrient[5] = sumOrient % 2 === 0 ? 0 : 1;
+    return {
+        centers,
+        edgesPerm,
+        edgesOrient,
+        tips
+    };
+}
+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);
+        const temporary = values[index];
+        values[index] = values[swapIndex];
+        values[swapIndex] = temporary;
+    }
+    return values;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pyraminxScrambleGenerator = void 0;
+exports.generatePyraminxScramble = generatePyraminxScramble;
+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");
+exports.pyraminxScrambleGenerator = {
+    info: {
+        eventId: "pyrso",
+        name: "Pyraminx",
+        puzzle: "pyraminx",
+        quality: "random-state",
+        generator: "pyraminx-ida-star",
+        description: "Random-state Pyraminx scramble generated by an optimal bidirectional BFS solver."
+    },
+    generate(options = {}) {
+        return generatePyraminxScramble(options);
+    }
+};
+async function generatePyraminxScramble(options = {}) {
+    const state = (0, random_state_js_1.generateRandomPyraminxState)(options);
+    // Solve the core edges and centers
+    const solution = (0, solver_js_1.solvePyraminx)(state);
+    const scrambleMoves = (0, moves_js_1.invertPyraminxAlgorithm)(solution);
+    // Append tips to scrambleMoves
+    const finalMoves = [...scrambleMoves];
+    const tipsNotation = ["u", "l", "r", "b"];
+    for (let i = 0; i < 4; i++) {
+        const tipVal = state.tips[i];
+        if (tipVal === 1) {
+            finalMoves.push(tipsNotation[i]);
+        }
+        else if (tipVal === 2) {
+            finalMoves.push(`${tipsNotation[i]}'`);
+        }
+    }
+    if (!options.skipValidation) {
+        const scrambledState = (0, moves_js_1.applyPyraminxAlgorithm)((0, state_js_1.createSolvedPyraminxState)(), finalMoves);
+        if (scrambledState.edgesPerm.toString() !== state.edgesPerm.toString() ||
+            scrambledState.edgesOrient.toString() !== state.edgesOrient.toString() ||
+            scrambledState.centers.toString() !== state.centers.toString() ||
+            scrambledState.tips.toString() !== state.tips.toString()) {
+            throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
+        }
+    }
+    return {
+        eventId: "pyrso",
+        scramble: finalMoves.join(" "),
+        moves: finalMoves,
+        quality: "random-state",
+        generator: "pyraminx-ida-star",
+        metadata: {
+            state,
+            solutionMoves: solution,
+            solutionDepth: solution.length
+        }
+    };
+}