@cubingcenter/scrambler 0.5.0 → 0.5.2

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

@@ -4,6 +4,8 @@ exports.toCube2Facelets = toCube2Facelets;
 exports.formatCube2Facelets = formatCube2Facelets;
 exports.getCube2FaceOrder = getCube2FaceOrder;
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const STICKERS = ["U", "R", "F", "D", "L", "B"];
+const STICKER_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 const CORNER_PIECE_STICKERS = [
     ["U", "R", "F"],
     ["U", "F", "L"],
@@ -24,12 +26,48 @@ const CORNER_POSITION_SLOTS = [
     [["D", 2], ["B", 3], ["L", 2]],
     [["D", 3], ["R", 3], ["B", 2]]
 ];
-function toCube2Facelets(state) {
-    const facelets = createEmptyFacelets();
+const CORNER_CELLS = buildCells();
+function buildCells() {
+    const cells = [];
     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);
+        const byPiece = [];
+        for (let piece = 0; piece < CORNER_PIECE_STICKERS.length; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < 3; orientation += 1) {
+                const stickers = CORNER_PIECE_STICKERS[piece];
+                const slotList = CORNER_POSITION_SLOTS[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+function toCube2Facelets(state) {
+    const facelets = {
+        U: Array(4),
+        R: Array(4),
+        F: Array(4),
+        D: Array(4),
+        L: Array(4),
+        B: Array(4)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const permutation = state.corners.permutation;
+    const orientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        const cells = CORNER_CELLS[position][permutation[position]][orientation[position]];
+        for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+            faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+        }
     }
     return facelets;
 }
@@ -39,20 +77,3 @@ function formatCube2Facelets(facelets) {
 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/random-state.js

@@ -2,53 +2,63 @@
 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");
+const tables_js_1 = require("./solver/tables.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) {
+        // The state is legal by construction (DBL corner fixed, even
+        // permutation, orientation sum divisible by 3, values in range), so the
+        // only meaningful rejection is the trivial set: solved + the 18
+        // single-move states (scrambles shorter than 2 moves). Coordinates are
+        // encoded once for both checks.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube2State)(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        const p = (0, tables_js_1.encodePermutation)(state.corners.permutation);
+        const o = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
+        if (!(0, validation_js_1.isTrivialSamplingCube2State)(p, o)) {
             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) {
+    // 7 free corners (piece 6 = DBL stays fixed at position 6)
+    const perm7 = [0, 1, 2, 3, 4, 5, 6];
+    for (let index = 6; index > 0; index -= 1) {
         const swapIndex = random.nextInt(index + 1);
-        swap(values, index, swapIndex);
+        if (swapIndex < index) {
+            const temporary = perm7[index];
+            perm7[index] = perm7[swapIndex];
+            perm7[swapIndex] = temporary;
+        }
     }
-    return values;
-}
-function randomOrientations(length, modulo, random) {
-    const orientations = Array(length).fill(0);
+    // Map the shuffle domain {0..6} to {0..5,7} and insert 6 at position 6
+    // (DBL fixed). Single allocation, no intermediate arrays.
+    const last = perm7[6] >= 6 ? perm7[6] + 1 : perm7[6];
+    const permutation = new Array(8);
+    for (let index = 0; index < 6; index += 1) {
+        const value = perm7[index];
+        permutation[index] = value >= 6 ? value + 1 : value;
+    }
+    permutation[6] = 6;
+    permutation[7] = last;
+    // 7 free orientations with sum divisible by 3; DBL stays oriented
+    const orientation = [0, 0, 0, 0, 0, 0, 0, 0];
     let total = 0;
-    for (let index = 0; index < length - 1; index += 1) {
-        const orientation = random.nextInt(modulo);
-        orientations[index] = orientation;
-        total += orientation;
+    for (let index = 0; index < 6; index += 1) {
+        const value = random.nextInt(3);
+        orientation[index] = value;
+        total += value;
     }
-    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;
+    orientation[7] = (3 - (total % 3)) % 3;
+    return {
+        corners: {
+            permutation,
+            orientation
+        }
+    };
 }

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

@@ -6,6 +6,9 @@ const moves_js_1 = require("./moves.js");
 const random_state_js_1 = require("./random-state.js");
 const facelets_js_1 = require("./facelets.js");
 const index_js_1 = require("./solver/index.js");
+// BFS_MOVES = [U, U2, U', R, R2, R', F, F2, F'] — the inverse of index m is
+// CUBE2_MOVE_INVERSE[m] (U2/R2/F2 are self-inverse, so m ^ 1 does not apply).
+const CUBE2_MOVE_INVERSE = [2, 1, 0, 5, 4, 3, 8, 7, 6];
 exports.cube2ScrambleGenerator = {
     info: {
         eventId: "222",
@@ -21,20 +24,31 @@ exports.cube2ScrambleGenerator = {
 };
 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);
+    const solution = (0, index_js_1.areCube2TablesLoaded)()
+        ? (0, index_js_1.solveCube2StateIndicesSync)(state)
+        : await (0, index_js_1.solveCube2StateIndices)(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed.
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = index_js_1.BFS_MOVES[CUBE2_MOVE_INVERSE[solution[depth - 1 - index]]];
+    }
     if (!options.skipValidation) {
-        if (!(0, index_js_1.verifyCube2Scramble)(state, scrambleMoves)) {
+        // The scramble is the exact inverse of the solution, so verifying that
+        // the solution solves the target state is equivalent to verifying that
+        // the scramble reproduces it — a single numeric walk suffices.
+        if (!(0, index_js_1.verifyCube2SolutionIndices)(state, solution)) {
             throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
         }
-        if (!(0, index_js_1.verifyCube2Solution)(state, solution.moves)) {
-            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 solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = index_js_1.BFS_MOVES[solution[index]];
+    }
     const result = {
         eventId: "222",
         scramble: (0, moves_js_1.formatCube2Algorithm)(scrambleMoves),
@@ -45,8 +59,8 @@ async function generateCube2Scramble(options = {}) {
             state,
             facelets,
             faceletString: (0, facelets_js_1.formatCube2Facelets)(facelets),
-            solutionMoves: solution.moves,
-            solutionDepth: solution.depth
+            solutionMoves,
+            solutionDepth: depth
         }
     };
     if (options.seed !== undefined) {

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

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyCube2Solution = exports.verifyCube2Scramble = exports.solveCube2State = void 0;
+exports.PERMUTATION_TABLE = exports.ORIENTATION_TABLE = exports.ORIENTATION_COUNT = exports.MOVE_COUNT = exports.getOrientationTransition = exports.getPermutationTransition = exports.getDistance = exports.encodeOrientation = exports.encodePermutation = exports.ensureTablesLoaded = exports.DISTANCES = exports.BFS_MOVES = exports.areCube2TablesLoaded = exports.verifyCube2SolutionIndices = exports.verifyCube2Solution = exports.verifyCube2Scramble = exports.solveCube2StateIndicesSync = exports.solveCube2StateIndices = exports.solveCube2State = void 0;
 var search_js_1 = require("./search.js");
 Object.defineProperty(exports, "solveCube2State", { enumerable: true, get: function () { return search_js_1.solveCube2State; } });
+Object.defineProperty(exports, "solveCube2StateIndices", { enumerable: true, get: function () { return search_js_1.solveCube2StateIndices; } });
+Object.defineProperty(exports, "solveCube2StateIndicesSync", { enumerable: true, get: function () { return search_js_1.solveCube2StateIndicesSync; } });
 Object.defineProperty(exports, "verifyCube2Scramble", { enumerable: true, get: function () { return search_js_1.verifyCube2Scramble; } });
 Object.defineProperty(exports, "verifyCube2Solution", { enumerable: true, get: function () { return search_js_1.verifyCube2Solution; } });
+Object.defineProperty(exports, "verifyCube2SolutionIndices", { enumerable: true, get: function () { return search_js_1.verifyCube2SolutionIndices; } });
+var tables_js_1 = require("./tables.js");
+Object.defineProperty(exports, "areCube2TablesLoaded", { enumerable: true, get: function () { return tables_js_1.areCube2TablesLoaded; } });
+Object.defineProperty(exports, "BFS_MOVES", { enumerable: true, get: function () { return tables_js_1.BFS_MOVES; } });
+Object.defineProperty(exports, "DISTANCES", { enumerable: true, get: function () { return tables_js_1.DISTANCES; } });
+Object.defineProperty(exports, "ensureTablesLoaded", { enumerable: true, get: function () { return tables_js_1.ensureTablesLoaded; } });
+Object.defineProperty(exports, "encodePermutation", { enumerable: true, get: function () { return tables_js_1.encodePermutation; } });
+Object.defineProperty(exports, "encodeOrientation", { enumerable: true, get: function () { return tables_js_1.encodeOrientation; } });
+Object.defineProperty(exports, "getDistance", { enumerable: true, get: function () { return tables_js_1.getDistance; } });
+Object.defineProperty(exports, "getPermutationTransition", { enumerable: true, get: function () { return tables_js_1.getPermutationTransition; } });
+Object.defineProperty(exports, "getOrientationTransition", { enumerable: true, get: function () { return tables_js_1.getOrientationTransition; } });
+Object.defineProperty(exports, "MOVE_COUNT", { enumerable: true, get: function () { return tables_js_1.MOVE_COUNT; } });
+Object.defineProperty(exports, "ORIENTATION_COUNT", { enumerable: true, get: function () { return tables_js_1.ORIENTATION_COUNT; } });
+Object.defineProperty(exports, "ORIENTATION_TABLE", { enumerable: true, get: function () { return tables_js_1.ORIENTATION_TABLE; } });
+Object.defineProperty(exports, "PERMUTATION_TABLE", { enumerable: true, get: function () { return tables_js_1.PERMUTATION_TABLE; } });

package/dist-cjs/puzzles/cube2/solver/search.js

@@ -1,12 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solveCube2State = solveCube2State;
+exports.solveCube2StateIndices = solveCube2StateIndices;
+exports.solveCube2StateIndicesSync = solveCube2StateIndicesSync;
 exports.verifyCube2Scramble = verifyCube2Scramble;
 exports.verifyCube2Solution = verifyCube2Solution;
+exports.verifyCube2SolutionIndices = verifyCube2SolutionIndices;
 const state_js_1 = require("../state.js");
 const tables_js_1 = require("./tables.js");
 async function solveCube2State(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
+    const indices = solveWithTablesIndices(state);
+    return {
+        moves: indices.map((index) => tables_js_1.BFS_MOVES[index]),
+        depth: indices.length,
+        state: (0, state_js_1.createSolvedCube2State)()
+    };
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..8) in walk order. The inverse of index m is CUBE2_MOVE_INVERSE[m]
+// (U2/R2/F2 are self-inverse, so m ^ 1 does not apply here).
+async function solveCube2StateIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solveCube2StateIndicesSync(state) {
+    if (!tables_js_1.DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+function solveWithTablesIndices(state) {
     if (state.corners.permutation[6] !== 6 || state.corners.orientation[6] !== 0) {
         throw new Error("The 2x2 solver requires the DBL corner (index 6) to be solved " +
             "as the frame of reference. Please normalize the state before solving.");
@@ -21,7 +45,7 @@ async function solveCube2State(state) {
     const initialCombined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
     if (distance === 0) {
-        return { moves, depth: 0, state: (0, state_js_1.createSolvedCube2State)() };
+        return moves;
     }
     while (distance > 0) {
         let foundNext = false;
@@ -35,7 +59,7 @@ async function solveCube2State(state) {
             const combined = nextPerm * tables_js_1.ORIENTATION_COUNT + nextOrient;
             const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
             if (nextDist === nextDistance) {
-                moves.push(tables_js_1.BFS_MOVES[m]);
+                moves.push(m);
                 permIndex = nextPerm;
                 orientIndex = nextOrient;
                 distance = nextDistance;
@@ -47,11 +71,7 @@ async function solveCube2State(state) {
             throw new Error("BFS distance table corrupted or unreachable state.");
         }
     }
-    return {
-        moves,
-        depth: moves.length,
-        state: (0, state_js_1.createSolvedCube2State)()
-    };
+    return moves;
 }
 const MOVE_INDEX = {};
 for (let i = 0; i < tables_js_1.BFS_MOVES.length; i++) {
@@ -79,3 +99,21 @@ function verifyCube2Solution(state, solutionMoves) {
     const { permIndex, orientIndex } = walkCube2Coordinates((0, tables_js_1.encodePermutation)(state.corners.permutation), (0, tables_js_1.encodeOrientation)(state.corners.orientation), solutionMoves);
     return permIndex === 0 && orientIndex === 0;
 }
+// Numeric verification for the hot scramble path: walks the solution (move
+// indices, walk order) from the target state to solved. The scramble is the
+// exact inverse of the solution, so this is equivalent to verifying that the
+// scramble reproduces the target state — one walk, no string parsing.
+function verifyCube2SolutionIndices(state, solution) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    if (!permTable || !orientTable) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
+    let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
+    for (const m of solution) {
+        permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];
+    }
+    return permIndex === 0 && orientIndex === 0;
+}

package/dist-cjs/puzzles/cube2/solver/tables.js

@@ -4,6 +4,7 @@ exports.BFS_MOVES = exports.DISTANCES = exports.ORIENTATION_TABLE = exports.PERM
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.areCube2TablesLoaded = areCube2TablesLoaded;
 exports.getDistance = getDistance;
 exports.getPermutationTransition = getPermutationTransition;
 exports.getOrientationTransition = getOrientationTransition;
@@ -61,6 +62,9 @@ async function ensureTablesLoaded() {
     exports.DISTANCES = tables.distances;
     tablesLoaded = true;
 }
+function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCube2State = validateCube2State;
 exports.isOneMoveFromSolvedCube2State = isOneMoveFromSolvedCube2State;
+exports.isTrivialSamplingCube2State = isTrivialSamplingCube2State;
 exports.isAllowedRandomCube2State = isAllowedRandomCube2State;
 exports.permutationParity = permutationParity;
 const types_js_1 = require("./types.js");
@@ -37,7 +38,13 @@ function validateCube2State(state) {
 function isOneMoveFromSolvedCube2State(state) {
     const p = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     const o = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
-    return ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
+    return isTrivialSamplingCube2State(p, o);
+}
+// Cheap trivial check for random-state sampling: the caller has already
+// encoded the coordinates once. True for the solved state and the 18
+// single-move states (which would produce scrambles shorter than 2 moves).
+function isTrivialSamplingCube2State(p, o) {
+    return (p === 0 && o === 0) || ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
 }
 function isAllowedRandomCube2State(state) {
     return validateCube2State(state).valid &&

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

@@ -5,6 +5,8 @@ exports.toPyraminxFacelets = toPyraminxFacelets;
 exports.formatPyraminxFacelets = formatPyraminxFacelets;
 exports.getPyraminxFaceOrder = getPyraminxFaceOrder;
 const FACE_ORDER = ["F", "L", "R", "D"];
+const COLORS = ["F", "L", "R", "D"];
+const COLOR_INDEX = { F: 0, L: 1, R: 2, D: 3 };
 // positionId -> sticker slots (each slot = one triangle cell of the grid).
 // Positions follow the scrambler piece model (moves.ts):
 //   edges 0..5 = UL, UR, UB, LR, LB, RB
@@ -54,6 +56,33 @@ const TIP_PIECE_STICKERS = [
     ["F", "R", "D"], // 2 R
     ["L", "D", "R"], // 3 B
 ];
+const EDGE_CELLS = buildCells(EDGE_POSITION_SLOTS, EDGE_PIECE_STICKERS, 6, 2);
+const CENTER_CELLS = buildCells(CENTER_POSITION_SLOTS, CENTER_PIECE_STICKERS, 4, 3);
+const TIP_CELLS = buildCells(TIP_POSITION_SLOTS, TIP_PIECE_STICKERS, 4, 3);
+function buildCells(slots, stickersTable, pieceCount, orientationCount) {
+    const cells = [];
+    for (let position = 0; position < slots.length; position += 1) {
+        const byPiece = [];
+        for (let piece = 0; piece < pieceCount; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < orientationCount; orientation += 1) {
+                const stickers = stickersTable[piece];
+                const slotList = slots[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(COLOR_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
 function createSolvedPyraminxFacelets() {
     return {
         F: Array.from({ length: 9 }, () => "F"),
@@ -62,36 +91,33 @@ function createSolvedPyraminxFacelets() {
         D: Array.from({ length: 9 }, () => "D"),
     };
 }
+// Sparse arrays: every one of the 36 sticker cells is overwritten by the
+// three placement loops below (12 edges + 12 centers + 12 tips), so no fill
+// is needed. Coverage is enforced by test/pyraminx-facelets.test.ts.
 function createEmptyPyraminxFacelets() {
     return {
-        F: Array(9).fill("?"),
-        L: Array(9).fill("?"),
-        R: Array(9).fill("?"),
-        D: Array(9).fill("?"),
+        F: Array(9),
+        L: Array(9),
+        R: Array(9),
+        D: Array(9),
     };
 }
-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];
-        const arr = facelets[face];
-        arr[stickerIndex] = sticker;
+function placeCells(faces, cells) {
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+        faces[cells[cellIndex]][cells[cellIndex + 1]] = COLORS[cells[cellIndex + 2]];
     }
 }
 function toPyraminxFacelets(state) {
     const facelets = createEmptyPyraminxFacelets();
+    const faces = [facelets.F, facelets.L, facelets.R, facelets.D];
     for (let position = 0; position < 6; position += 1) {
-        const piece = state.edgesPerm[position];
-        const orientation = state.edgesOrient[position];
-        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+        placeCells(faces, EDGE_CELLS[position][state.edgesPerm[position]][state.edgesOrient[position]]);
     }
     for (let position = 0; position < 4; position += 1) {
-        const orientation = state.centers[position];
-        placeOrientedStickers(facelets, CENTER_POSITION_SLOTS[position], CENTER_PIECE_STICKERS[position], orientation);
+        placeCells(faces, CENTER_CELLS[position][position][state.centers[position]]);
     }
     for (let position = 0; position < 4; position += 1) {
-        const orientation = state.tips[position];
-        placeOrientedStickers(facelets, TIP_POSITION_SLOTS[position], TIP_PIECE_STICKERS[position], orientation);
+        placeCells(faces, TIP_CELLS[position][position][state.tips[position]]);
     }
     return facelets;
 }

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

@@ -2,41 +2,71 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomPyraminxState = generateRandomPyraminxState;
 const index_js_1 = require("../../random/index.js");
-const validation_js_1 = require("./validation.js");
+const state_js_1 = require("./state.js");
+// Compact -> full Lehmer index for the 360 even permutations of 6 edges.
+// Generated once: a permutation's parity is the parity of the digit sum of
+// its Lehmer code (each digit counts smaller elements to its right).
+const COMPACT_TO_FULL = new Uint16Array(360);
+(function buildCompactMapping() {
+    let compact = 0;
+    for (let full = 0; full < 720 && compact < 360; full += 1) {
+        let value = full;
+        const c5 = (value / 120) | 0;
+        value -= c5 * 120;
+        const c4 = (value / 24) | 0;
+        value -= c4 * 24;
+        const c3 = (value / 6) | 0;
+        value -= c3 * 6;
+        const c2 = (value / 2) | 0;
+        value -= c2 * 2;
+        const c1 = value;
+        if ((c5 + c4 + c3 + c2 + c1) % 2 === 0) {
+            COMPACT_TO_FULL[compact] = full;
+            compact += 1;
+        }
+    }
+})();
 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) {
+        // The state is legal by construction (even permutation parity, even
+        // orientation sum, values in range), so only the trivial core check is
+        // needed here — no full re-validation.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomPyraminxState)(state)) {
+        if (!rejectTrivial || !(0, state_js_1.isSolvedPyraminxState)(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;
+    // 4 random centers from one uniform value in [0, 81) (4 base-3 digits)
+    let centerValue = random.nextInt(81);
+    const centers = [0, 0, 0, 0];
+    for (let index = 0; index < 4; index += 1) {
+        centers[index] = centerValue % 3;
+        centerValue = (centerValue / 3) | 0;
+    }
+    // 4 random tips from one uniform value in [0, 81)
+    let tipValue = random.nextInt(81);
+    const tips = [0, 0, 0, 0];
+    for (let index = 0; index < 4; index += 1) {
+        tips[index] = tipValue % 3;
+        tipValue = (tipValue / 3) | 0;
     }
-    // 6 edges orientation (sum must be even)
-    const edgesOrient = Array(6).fill(0);
+    // 6 edges permutation, even parity, uniform over the 360 even permutations
+    const edgesPerm = permutationFromCompact(random.nextInt(360));
+    // 6 edges orientation (sum must be even): 5 free bits + parity digit
+    let orientationValue = random.nextInt(32);
+    const edgesOrient = [0, 0, 0, 0, 0, 0];
     let sumOrient = 0;
-    for (let i = 0; i < 5; i++) {
-        const val = random.nextInt(2);
-        edgesOrient[i] = val;
-        sumOrient += val;
+    for (let index = 0; index < 5; index += 1) {
+        edgesOrient[index] = orientationValue & 1;
+        sumOrient += orientationValue & 1;
+        orientationValue >>= 1;
     }
-    edgesOrient[5] = sumOrient % 2 === 0 ? 0 : 1;
+    edgesOrient[5] = sumOrient & 1;
     return {
         centers,
         edgesPerm,
@@ -44,13 +74,17 @@ function createLegalRandomState(random) {
         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;
+const FACTORIALS = [1, 1, 2, 6, 24, 120, 720];
+function permutationFromCompact(compact) {
+    let full = COMPACT_TO_FULL[compact];
+    const permutation = [0, 0, 0, 0, 0, 0];
+    const remaining = [0, 1, 2, 3, 4, 5];
+    for (let position = 0; position < 6; position += 1) {
+        const divisor = FACTORIALS[5 - position];
+        const choice = (full / divisor) | 0;
+        full -= choice * divisor;
+        permutation[position] = remaining[choice];
+        remaining.splice(choice, 1);
     }
-    return values;
+    return permutation;
 }