@cubingcenter/scrambler 0.5.1 → 0.5.3

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/browser-loader.js

@@ -22,12 +22,12 @@ async function loadBrowserTables(baseUrl) {
     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)
+        fetchUint8Table(resolved, manifest.files.policy, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.policy.entries)
     ]);
     cachedBrowserTables = {
         permutationTable: permTable,
         orientationTable: orientTable,
-        distances: dist
+        policyTable: dist
     };
     return cachedBrowserTables;
 }

package/dist-cjs/puzzles/cube2/solver/generated/manifest.json

@@ -11,10 +11,10 @@
       "entries": 6561,
       "checksum": 1566738619
     },
-    "distances": {
-      "file": "distances.bin",
+    "policy": {
+      "file": "policy.bin",
       "entries": 1837080,
-      "checksum": 2959532459,
+      "checksum": 2042005723,
       "maxDepth": 11
     }
   }

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.POLICY_TABLE = 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, "POLICY_TABLE", { enumerable: true, get: function () { return tables_js_1.POLICY_TABLE; } });
+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/node-loader.js

@@ -17,11 +17,11 @@ function readGeneratedCube2SolverTables() {
     }
     const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.permutationTable.checksum);
     const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.orientationTable.checksum);
-    const distances = readUint8Table(assetDirectory, manifest.files.distances, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.distances.checksum);
+    const policyTable = readUint8Table(assetDirectory, manifest.files.policy, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.policy.checksum);
     return {
         permutationTable,
         orientationTable,
-        distances
+        policyTable
     };
 }
 function readUint16Table(assetDirectory, entry, expectedChecksum) {

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

@@ -1,57 +1,57 @@
 "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.POLICY_TABLE) {
+        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.");
     }
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
-    const distances = tables_js_1.DISTANCES;
+    const policy = tables_js_1.POLICY_TABLE;
     let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
     const moves = [];
-    // High-performance branchless inlined lookup
-    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)() };
-    }
-    while (distance > 0) {
-        let foundNext = false;
-        const permOffset = permIndex * tables_js_1.MOVE_COUNT;
-        const orientOffset = orientIndex * tables_js_1.MOVE_COUNT;
-        const nextDistance = distance - 1;
-        for (let m = 0; m < tables_js_1.BFS_MOVES.length; m++) {
-            const nextPerm = permTable[permOffset + m];
-            const nextOrient = orientTable[orientOffset + m];
-            // High-performance branchless inlined lookup
-            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]);
-                permIndex = nextPerm;
-                orientIndex = nextOrient;
-                distance = nextDistance;
-                foundNext = true;
-                break;
-            }
-        }
-        if (!foundNext) {
-            throw new Error("BFS distance table corrupted or unreachable state.");
-        }
+    // Direct policy walk: the precomputed optimal move per state, so no
+    // candidate scanning (the old BFS-distance gradient walk) is needed.
+    let combined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
+    while (combined !== 0) {
+        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        moves.push(m);
+        permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];
+        combined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     }
-    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 +79,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/table-metadata.js

@@ -10,9 +10,9 @@ exports.CUBE2_SOLVER_TABLE_METADATA = {
         entries: 6561,
         checksum: 1566738619
     },
-    distances: {
+    policy: {
         entries: 1837080,
-        checksum: 2959532459,
+        checksum: 2042005723,
         maxDepth: 11
     }
 };

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BFS_MOVES = exports.DISTANCES = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.BFS_MOVES = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.areCube2TablesLoaded = areCube2TablesLoaded;
 exports.getDistance = getDistance;
 exports.getPermutationTransition = getPermutationTransition;
 exports.getOrientationTransition = getOrientationTransition;
@@ -14,19 +15,31 @@ exports.MOVE_COUNT = 9;
 // ---------------------------------------------------------------------------
 // Coordinate encoding / decoding
 // ---------------------------------------------------------------------------
+// Lehmer encoding of the 7 free corners (DBL at index 6 is fixed), with a
+// bitmask instead of array removal: available values tracked as bits, the
+// rank of a value = the popcount of the bits below it.
+const PERM7_FACT = [720, 120, 24, 6, 2, 1, 1];
 function encodePermutation(permutation) {
-    const perm7 = permutation.filter((_, i) => i !== 6);
-    const mapped = perm7.map((x) => (x > 6 ? x - 1 : x));
     let index = 0;
-    const available = [0, 1, 2, 3, 4, 5, 6];
+    let available = 0b1111111;
     for (let position = 0; position < 7; position += 1) {
-        const value = mapped[position];
-        const selected = available.indexOf(value);
-        index += selected * factorialSmall(6 - position);
-        available.splice(selected, 1);
+        const permPosition = position < 6 ? position : position + 1;
+        const piece = permutation[permPosition];
+        const value = piece > 6 ? piece - 1 : piece;
+        const rank = popcount(available & ((1 << value) - 1));
+        index += rank * PERM7_FACT[position];
+        available &= ~(1 << value);
     }
     return index;
 }
+function popcount(x) {
+    let count = 0;
+    while (x !== 0) {
+        x &= x - 1;
+        count += 1;
+    }
+    return count;
+}
 function encodeOrientation(orientation) {
     const orient7 = orientation.filter((_, i) => i !== 6);
     let index = 0;
@@ -50,7 +63,7 @@ function factorialSmall(n) {
 let tablesLoaded = false;
 exports.PERMUTATION_TABLE = null;
 exports.ORIENTATION_TABLE = null;
-exports.DISTANCES = null;
+exports.POLICY_TABLE = null;
 async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -58,19 +71,33 @@ async function ensureTablesLoaded() {
     const tables = await (0, generated_assets_js_1.loadGeneratedCube2SolverTables)();
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;
-    exports.DISTANCES = tables.distances;
+    exports.POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
+function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 function getDistance(permIndex, orientIndex) {
-    if (!exports.DISTANCES) {
+    if (!exports.POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
-    const combined = permIndex * exports.ORIENTATION_COUNT + orientIndex;
-    const byteValue = exports.DISTANCES[combined >> 1];
-    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+    const permTable = exports.PERMUTATION_TABLE;
+    const orientTable = exports.ORIENTATION_TABLE;
+    let p = permIndex;
+    let o = orientIndex;
+    let combined = p * exports.ORIENTATION_COUNT + o;
+    let distance = 0;
+    while (combined !== 0) {
+        const m = (exports.POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        p = permTable[p * exports.MOVE_COUNT + m];
+        o = orientTable[o * exports.MOVE_COUNT + m];
+        combined = p * exports.ORIENTATION_COUNT + o;
+        distance += 1;
+    }
+    return distance;
 }
 function getPermutationTransition(move, permIndex) {
     if (!exports.PERMUTATION_TABLE) {

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

@@ -25,8 +25,10 @@ function cube2StatesEqual(left, right) {
     return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
         arraysEqual(left.corners.orientation, right.corners.orientation));
 }
+// Read-only canonical solved state for comparisons (never mutated).
+const SOLVED_STATE = createSolvedCube2State();
 function isSolvedCube2State(state) {
-    return cube2StatesEqual(state, createSolvedCube2State());
+    return cube2StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);

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

@@ -1,23 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrivialCube2State = isTrivialCube2State;
 exports.validateCube2State = validateCube2State;
 exports.isOneMoveFromSolvedCube2State = isOneMoveFromSolvedCube2State;
+exports.isTrivialSamplingCube2State = isTrivialSamplingCube2State;
 exports.isAllowedRandomCube2State = isAllowedRandomCube2State;
 exports.permutationParity = permutationParity;
 const types_js_1 = require("./types.js");
 const moves_js_1 = require("./moves.js");
 const state_js_1 = require("./state.js");
 const tables_js_1 = require("./solver/tables.js");
+// The 18 single-move states, precomputed once so the hot random-state path
+// checks "solved or one move from solved" with pure array comparisons
+// (no coordinate encodings per generated state).
+const ONE_MOVE_FROM_SOLVED_STATES = types_js_1.CUBE2_MOVES.map((move) => (0, moves_js_1.applyCube2Move)((0, state_js_1.createSolvedCube2State)(), move));
 // Precomputed coordinate encodings of every single-move state, so the
 // "one move from solved" check is a couple of O(n) encodings + 18 comparisons
 // instead of 18 full state applications.
-const ONE_MOVE_FROM_SOLVED_ENCODED = types_js_1.CUBE2_MOVES.map((move) => {
-    const state = (0, moves_js_1.applyCube2Move)((0, state_js_1.createSolvedCube2State)(), move);
-    return {
-        p: (0, tables_js_1.encodePermutation)(state.corners.permutation),
-        o: (0, tables_js_1.encodeOrientation)(state.corners.orientation)
-    };
-});
+const ONE_MOVE_FROM_SOLVED_ENCODED = ONE_MOVE_FROM_SOLVED_STATES.map((state) => ({
+    p: (0, tables_js_1.encodePermutation)(state.corners.permutation),
+    o: (0, tables_js_1.encodeOrientation)(state.corners.orientation)
+}));
+// Cheap trivial check for random-state sampling: solved + the 18 single-move
+// states, compared by arrays with early exit (a random state differs from
+// each candidate within the first couple of permutation entries, so the
+// typical cost is tens of comparisons — no coordinate encodings).
+function isTrivialCube2State(state) {
+    const cp = state.corners.permutation;
+    const co = state.corners.orientation;
+    for (const candidate of ONE_MOVE_FROM_SOLVED_STATES) {
+        const p = candidate.corners.permutation;
+        const o = candidate.corners.orientation;
+        let match = true;
+        for (let i = 0; i < 8; i += 1) {
+            if (cp[i] !== p[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        for (let i = 0; i < 8; i += 1) {
+            if (co[i] !== o[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return (0, state_js_1.isSolvedCube2State)(state);
+}
 function validateCube2State(state) {
     const errors = [
         ...validatePermutation("corner", state.corners.permutation, types_js_1.CORNER_COUNT),
@@ -37,7 +70,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/cube3/facelets.js

@@ -4,6 +4,8 @@ exports.toCube3Facelets = toCube3Facelets;
 exports.formatCube3Facelets = formatCube3Facelets;
 exports.getCube3FaceOrder = getCube3FaceOrder;
 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"],
@@ -52,20 +54,60 @@ const EDGE_POSITION_SLOTS = [
     [["B", 5], ["L", 3]],
     [["B", 3], ["R", 5]]
 ];
+const CORNER_CELLS = buildCells(CORNER_POSITION_SLOTS, CORNER_PIECE_STICKERS, 3);
+const EDGE_CELLS = buildCells(EDGE_POSITION_SLOTS, EDGE_PIECE_STICKERS, 2);
+function buildCells(slots, stickersTable, orientationCount) {
+    const cells = [];
+    for (let position = 0; position < slots.length; position += 1) {
+        const byPiece = [];
+        for (let piece = 0; piece < stickersTable.length; 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(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+function placeCells(faces, cells) {
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+        faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+    }
+}
 function toCube3Facelets(state) {
-    const facelets = createEmptyFacelets();
-    for (const face of FACE_ORDER) {
-        facelets[face][4] = face;
+    const facelets = {
+        U: Array(9),
+        R: Array(9),
+        F: Array(9),
+        D: Array(9),
+        L: Array(9),
+        B: Array(9)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    // Centers (fixed, since no center permutation on the 3x3)
+    for (let face = 0; face < 6; face += 1) {
+        faces[face][4] = STICKERS[face];
     }
-    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 cornerPermutation = state.corners.permutation;
+    const cornerOrientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        placeCells(faces, CORNER_CELLS[position][cornerPermutation[position]][cornerOrientation[position]]);
     }
-    for (let position = 0; position < EDGE_POSITION_SLOTS.length; position += 1) {
-        const piece = state.edges.permutation[position];
-        const orientation = state.edges.orientation[position];
-        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    const edgePermutation = state.edges.permutation;
+    const edgeOrientation = state.edges.orientation;
+    for (let position = 0; position < EDGE_CELLS.length; position += 1) {
+        placeCells(faces, EDGE_CELLS[position][edgePermutation[position]][edgeOrientation[position]]);
     }
     return facelets;
 }
@@ -75,20 +117,3 @@ function formatCube3Facelets(facelets) {
 function getCube3FaceOrder() {
     return FACE_ORDER;
 }
-function createEmptyFacelets() {
-    return {
-        U: Array(9).fill("U"),
-        R: Array(9).fill("R"),
-        F: Array(9).fill("F"),
-        D: Array(9).fill("D"),
-        L: Array(9).fill("L"),
-        B: Array(9).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/cube3/random-state.js

@@ -4,6 +4,7 @@ exports.generateRandomCube3State = generateRandomCube3State;
 const index_js_1 = require("../../random/index.js");
 const types_js_1 = require("./types.js");
 const validation_js_1 = require("./validation.js");
+const state_js_1 = require("./state.js");
 const subset_state_js_1 = require("./subset-state.js");
 function generateRandomCube3State(options = {}) {
     const random = (0, index_js_1.createRandomSource)(options.seed);
@@ -12,8 +13,14 @@ function generateRandomCube3State(options = {}) {
         return (0, subset_state_js_1.generateSubsetCube3State)(options.subset, random);
     }
     for (let attempt = 0; attempt < 100; attempt += 1) {
+        // The state is legal by construction (permutations shuffled, orientation
+        // sums fixed, parity matched), so the only meaningful rejection is the
+        // trivial set (solved + 18 single-move states) — no full re-validation.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube3State)(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        if (!(0, state_js_1.isSolvedCube3State)(state) && !(0, validation_js_1.isOneMoveFromSolvedCube3State)(state)) {
             return state;
         }
     }

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

@@ -48,7 +48,7 @@ async function generateCube3Scramble(options = {}) {
             generatorVersion: "1.0.0",
             facelets,
             faceletString: (0, facelets_js_1.formatCube3Facelets)(facelets),
-            state: JSON.parse(JSON.stringify(state)),
+            state,
             solutionMoves: solution.moves,
             solutionDepth: solution.depth,
             phase1Depth: solution.phase1.depth,

package/dist-cjs/puzzles/cube3/state.js

@@ -17,6 +17,9 @@ function createSolvedCube3State() {
         }
     };
 }
+// Read-only canonical solved state for comparisons (never mutated, so a
+// single shared instance is safe and avoids allocating per call).
+const SOLVED_STATE = createSolvedCube3State();
 function cloneCube3State(state) {
     return {
         corners: {
@@ -36,7 +39,7 @@ function cube3StatesEqual(left, right) {
         arraysEqual(left.edges.orientation, right.edges.orientation));
 }
 function isSolvedCube3State(state) {
-    return cube3StatesEqual(state, createSolvedCube3State());
+    return cube3StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);

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

@@ -34,9 +34,12 @@ function validateCube3State(state) {
         errors
     };
 }
+// The 18 single-move states, precomputed once so the hot random-state path
+// checks "one move from solved" with pure comparisons instead of 18 full
+// move applications per generated state.
+const ONE_MOVE_FROM_SOLVED_STATES = types_js_1.CUBE3_MOVES.map((move) => (0, moves_js_1.applyCube3Move)((0, state_js_1.createSolvedCube3State)(), move));
 function isOneMoveFromSolvedCube3State(state) {
-    const solved = (0, state_js_1.createSolvedCube3State)();
-    return types_js_1.CUBE3_MOVES.some((move) => (0, state_js_1.cube3StatesEqual)((0, moves_js_1.applyCube3Move)(solved, move), state));
+    return ONE_MOVE_FROM_SOLVED_STATES.some((candidate) => (0, state_js_1.cube3StatesEqual)(candidate, state));
 }
 function isAllowedRandomCube3State(state) {
     return validateCube3State(state).valid &&

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

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomSkewbState = generateRandomSkewbState;
+exports.generateRandomSkewbStateSync = generateRandomSkewbStateSync;
 const index_js_1 = require("../../random/index.js");
 const index_js_2 = require("./solver/index.js");
 async function generateRandomSkewbState(options = {}) {
     await (0, index_js_2.ensureTablesLoaded)();
+    return generateRandomSkewbStateSync(options);
+}
+// Synchronous variant for callers that have already ensured the tables are
+// loaded (e.g. the scrambler after the first call): no per-call await hop.
+function generateRandomSkewbStateSync(options = {}) {
+    if (!(0, index_js_2.areSkewbTablesLoaded)()) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
     const random = (0, index_js_1.createRandomSource)(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
     const trivialRanks = rejectTrivial ? getTrivialRanks() : null;