@cubingcenter/scrambler 0.5.0 → 0.5.2

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

@@ -3,12 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pyraminxScrambleGenerator = void 0;
 exports.generatePyraminxScramble = generatePyraminxScramble;
 const random_state_js_1 = require("./random-state.js");
-const moves_js_1 = require("./moves.js");
 const index_js_1 = require("./solver/index.js");
 const facelets_js_1 = require("./facelets.js");
 const types_js_1 = require("./types.js");
-// Face -> tip index (U,L,R,B order, same as PYRAMINX_TIPS).
-const FACE_TIP_INDEX = { U: 0, L: 1, R: 2, B: 3 };
+const TIP_INVERSE = ["u'", "l'", "r'", "b'"];
 exports.pyraminxScrambleGenerator = {
     info: {
         eventId: "pymx",
@@ -24,47 +22,58 @@ exports.pyraminxScrambleGenerator = {
 };
 async function generatePyraminxScramble(options = {}) {
     const state = (0, random_state_js_1.generateRandomPyraminxState)(options);
-    // Solve the core edges and centers
-    const solution = await (0, index_js_1.solvePyraminx)(state);
-    const scrambleMoves = (0, moves_js_1.invertPyraminxAlgorithm)(solution);
-    // Append tips: layer moves already rotate tips, so we need the delta
-    // between the target tips and the tips produced by the core scramble.
-    // Computed arithmetically from the move sequence (no state replay).
+    // Solve the core edges and centers as move indices (0..7). For index m the
+    // inverse is m ^ 1, the face is m >> 1 (0=U, 1=L, 2=R, 3=B) and the
+    // direction is m & 1 (1 = clockwise, 0 = counter-clockwise).
+    const solution = (0, index_js_1.arePyraminxTablesLoaded)()
+        ? (0, index_js_1.solvePyraminxIndicesSync)(state)
+        : await (0, index_js_1.solvePyraminxIndices)(state);
+    const depth = solution.length;
+    // Single pass over the solution (reversed): build the scramble move strings
+    // while accumulating the tips rotated by the layer moves arithmetically
+    // (no state replay, no string parsing).
+    const moves = new Array(depth + 4);
     const coreTips = [0, 0, 0, 0];
-    for (const move of scrambleMoves) {
-        const isInverse = move.endsWith("'");
-        const face = isInverse ? move.slice(0, -1) : move;
-        const tipIndex = FACE_TIP_INDEX[face];
-        if (tipIndex !== undefined) {
-            coreTips[tipIndex] = (coreTips[tipIndex] + (isInverse ? 2 : 1)) % 3;
-        }
+    let count = 0;
+    for (let index = depth - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        moves[count++] = index_js_1.PYRAMINX_MOVES[m];
+        const face = m >> 1;
+        coreTips[face] = (coreTips[face] + (m & 1 ? 2 : 1)) % 3;
     }
-    const finalMoves = [...scrambleMoves];
-    for (let i = 0; i < 4; i++) {
+    const tipMoves = [];
+    for (let i = 0; i < 4; i += 1) {
         const delta = (state.tips[i] - coreTips[i] + 3) % 3;
         if (delta === 1) {
-            finalMoves.push(types_js_1.PYRAMINX_TIPS[i]);
+            moves[count++] = types_js_1.PYRAMINX_TIPS[i];
+            tipMoves.push(i * 2);
         }
         else if (delta === 2) {
-            finalMoves.push(`${types_js_1.PYRAMINX_TIPS[i]}'`);
+            moves[count++] = TIP_INVERSE[i];
+            tipMoves.push(i * 2 + 1);
         }
     }
-    if (!options.skipValidation && !(0, index_js_1.verifyPyraminxScramble)(state, finalMoves)) {
+    moves.length = count;
+    if (!options.skipValidation && !(0, index_js_1.verifyPyraminxScrambleIndices)(state, solution, tipMoves)) {
         throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
     }
     const facelets = (0, facelets_js_1.toPyraminxFacelets)(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = index_js_1.PYRAMINX_MOVES[solution[index]];
+    }
     return {
         eventId: "pymx",
-        scramble: finalMoves.join(" "),
-        moves: finalMoves,
+        scramble: moves.join(" "),
+        moves,
         quality: "random-state",
         generator: "pyraminx-optimal",
         metadata: {
             state,
             facelets,
             faceletString: (0, facelets_js_1.formatPyraminxFacelets)(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length
+            solutionMoves,
+            solutionDepth: depth
         }
     };
 }

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solvePyraminx = solvePyraminx;
 exports.solvePyraminxWithInfo = solvePyraminxWithInfo;
+exports.solvePyraminxIndices = solvePyraminxIndices;
+exports.solvePyraminxIndicesSync = solvePyraminxIndicesSync;
 exports.solvePyraminxSync = solvePyraminxSync;
 exports.verifyPyraminxScramble = verifyPyraminxScramble;
+exports.verifyPyraminxScrambleIndices = verifyPyraminxScrambleIndices;
 const tables_js_1 = require("./tables.js");
 async function solvePyraminx(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
@@ -13,7 +16,25 @@ async function solvePyraminxWithInfo(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
     return solveWithTables(state);
 }
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..7) in walk order. The inverse of index m is m ^ 1 (moves are
+// paired U/U', L/L', R/R', B/B'), its face is m >> 1 and its direction is
+// m & 1 (1 = clockwise, 0 = counter-clockwise).
+async function solvePyraminxIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solvePyraminxIndicesSync(state) {
+    if (!tables_js_1.POLICY_TABLE)
+        throw new Error("Pyraminx tables not loaded");
+    return solveWithTablesIndices(state);
+}
 function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => tables_js_1.PYRAMINX_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
     const centersTable = tables_js_1.CENTERS_TABLE;
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
@@ -23,17 +44,20 @@ function solveWithTables(state) {
     let o = (0, tables_js_1.getOrientationIndex)(state.edgesOrient);
     let stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
     if (stateIndex === 0)
-        return { moves: [], depth: 0 };
+        return [];
     const moves = [];
     while (stateIndex !== 0) {
-        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, stateIndex);
-        moves.push(tables_js_1.PYRAMINX_MOVES[m]);
+        const bits = stateIndex * 3;
+        const byteIndex = bits >> 3;
+        const offset = bits & 7;
+        const m = ((policy[byteIndex] | ((policy[byteIndex + 1] ?? 0) << 8)) >> offset) & 0x07;
+        moves.push(m);
         c = centersTable[c * tables_js_1.MOVE_COUNT + m];
         p = permTable[p * tables_js_1.MOVE_COUNT + m];
         o = orientTable[o * tables_js_1.MOVE_COUNT + m];
         stateIndex = c + 81 * (p + tables_js_1.PERMUTATION_COUNT * o);
     }
-    return { moves, depth: moves.length };
+    return moves;
 }
 // Synchronous variant for scripts that have already ensured tables are loaded
 function solvePyraminxSync(state) {
@@ -86,3 +110,37 @@ function verifyPyraminxScramble(state, finalMoves) {
         tips[2] === state.tips[2] &&
         tips[3] === state.tips[3]);
 }
+// Numeric verification for the hot scramble path: replays the scramble
+// (solution reversed with m ^ 1 inverses, tip moves as tipIndex * 2 + dir
+// with dir 0 = clockwise, 1 = counter-clockwise) without any string parsing.
+function verifyPyraminxScrambleIndices(state, solution, tipMoves) {
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    if (!centersTable || !permTable || !orientTable) {
+        throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let c = 0;
+    let p = 0;
+    let o = 0;
+    const tips = [0, 0, 0, 0];
+    for (let index = solution.length - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        c = centersTable[c * tables_js_1.MOVE_COUNT + m];
+        p = permTable[p * tables_js_1.MOVE_COUNT + m];
+        o = orientTable[o * tables_js_1.MOVE_COUNT + m];
+        const face = m >> 1;
+        tips[face] = (tips[face] + (m & 1 ? 2 : 1)) % 3;
+    }
+    for (const tipMove of tipMoves) {
+        const tipIndex = tipMove >> 1;
+        tips[tipIndex] = (tips[tipIndex] + (tipMove & 1 ? 2 : 1)) % 3;
+    }
+    return (c === (0, tables_js_1.getCentersIndex)(state.centers) &&
+        p === (0, tables_js_1.getPermutationCompactIndex)(state.edgesPerm) &&
+        o === (0, tables_js_1.getOrientationIndex)(state.edgesOrient) &&
+        tips[0] === state.tips[0] &&
+        tips[1] === state.tips[1] &&
+        tips[2] === state.tips[2] &&
+        tips[3] === state.tips[3]);
+}

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

@@ -20,6 +20,7 @@ exports.generateOrientationTable = generateOrientationTable;
 exports.generatePolicyTable = generatePolicyTable;
 exports.checksum = checksum;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.arePyraminxTablesLoaded = arePyraminxTablesLoaded;
 exports.getPolicyMove = getPolicyMove;
 exports.getCentersTransition = getCentersTransition;
 exports.getPermutationTransition = getPermutationTransition;
@@ -298,6 +299,9 @@ async function ensureTablesLoaded() {
     exports.POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
+function arePyraminxTablesLoaded() {
+    return tablesLoaded;
+}
 function getPolicyMove(stateIndex) {
     if (!exports.POLICY_TABLE)
         throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");

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

@@ -21,18 +21,32 @@ exports.skewbScrambleGenerator = {
 };
 async function generateSkewbScramble(options = {}) {
     const state = await (0, random_state_js_1.generateRandomSkewbState)(options);
-    const solution = await (0, index_js_1.solveSkewb)(state);
-    const scrambleMoves = (0, moves_js_1.invertSkewbAlgorithm)(solution);
+    // generateRandomSkewbState guarantees the tables are loaded, so use the
+    // sync solve on every call after the first (no extra microtask).
+    const solution = (0, index_js_1.areSkewbTablesLoaded)()
+        ? (0, index_js_1.solveSkewbIndicesSync)(state)
+        : await (0, index_js_1.solveSkewbIndices)(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed. For index m the inverse is
+    // m ^ 1 (moves are paired R/R', U/U', L/L', B/B').
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = index_js_1.SKEWB_MOVES[solution[depth - 1 - index] ^ 1];
+    }
     if (!options.skipValidation) {
         // If the scramble reproduces the target state, its inverse (the
         // solution) solves it by construction, so a single walk suffices.
-        if (!(0, index_js_1.verifySkewbScramble)(state, scrambleMoves)) {
+        if (!(0, index_js_1.verifySkewbScrambleIndices)(state, solution)) {
             throw new Error("Generated Skewb scramble does not reproduce the target random state.");
         }
         if (scrambleMoves.length < 2)
             throw new Error("Generated Skewb scramble is too short.");
     }
     const facelets = (0, facelets_js_1.toSkewbFacelets)(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = index_js_1.SKEWB_MOVES[solution[index]];
+    }
     const result = {
         eventId: "skwb",
         scramble: (0, moves_js_1.formatSkewbAlgorithm)(scrambleMoves),
@@ -43,8 +57,8 @@ async function generateSkewbScramble(options = {}) {
             state,
             facelets,
             faceletString: (0, facelets_js_1.formatSkewbFacelets)(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length,
+            solutionMoves,
+            solutionDepth: depth,
         },
     };
     if (options.seed !== undefined)

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solveSkewb = solveSkewb;
 exports.solveSkewbWithInfo = solveSkewbWithInfo;
+exports.solveSkewbIndices = solveSkewbIndices;
+exports.solveSkewbIndicesSync = solveSkewbIndicesSync;
 exports.solveSkewbSync = solveSkewbSync;
 exports.verifySkewbScramble = verifySkewbScramble;
+exports.verifySkewbScrambleIndices = verifySkewbScrambleIndices;
 exports.verifySkewbSolution = verifySkewbSolution;
 const tables_js_1 = require("./tables.js");
 async function solveSkewb(state) {
@@ -14,6 +17,19 @@ async function solveSkewbWithInfo(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
     return solveWithTables(state);
 }
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..7) in walk order. The inverse of index m is m ^ 1 (moves are
+// paired R/R', U/U', L/L', B/B').
+async function solveSkewbIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solveSkewbIndicesSync(state) {
+    if (!tables_js_1.POLICY_TABLE) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
 // Synchronous variant for scripts that have already ensured tables are loaded
 function solveSkewbSync(state) {
     if (!tables_js_1.POLICY_TABLE) {
@@ -22,6 +38,11 @@ function solveSkewbSync(state) {
     return solveWithTables(state).moves;
 }
 function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => tables_js_1.SKEWB_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
     const policy = tables_js_1.POLICY_TABLE;
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
@@ -35,18 +56,18 @@ function solveWithTables(state) {
     let rC = (0, tables_js_1.getCenterIndex)(state.centers);
     let rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
     if (rank === tables_js_1.SOLVED_RANK) {
-        return { moves: [], depth: 0 };
+        return [];
     }
     const moves = [];
     while (rank !== tables_js_1.SOLVED_RANK) {
         const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, rank);
-        moves.push(tables_js_1.SKEWB_MOVES[m]);
+        moves.push(m);
         r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
         rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
         rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
         rank = (0, tables_js_1.rankFromComponents)(r7, rO, rC);
     }
-    return { moves, depth: moves.length };
+    return moves;
 }
 // ---------------------------------------------------------------------------
 // Coordinate-walking verification (no full state clones)
@@ -77,6 +98,28 @@ function verifySkewbScramble(state, scrambleMoves) {
         final.rO === (0, tables_js_1.getOrientationIndex)(state.corners.orientation) &&
         final.rC === (0, tables_js_1.getCenterIndex)(state.centers));
 }
+// Numeric verification for the hot scramble path: replays the scramble (the
+// solution reversed with m ^ 1 inverses) without any string parsing.
+function verifySkewbScrambleIndices(state, solution) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const centersTable = tables_js_1.CENTERS_TABLE;
+    if (!permTable || !orientTable || !centersTable) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let r7 = 0;
+    let rO = 0;
+    let rC = 0;
+    for (let index = solution.length - 1; index >= 0; index -= 1) {
+        const m = solution[index] ^ 1;
+        r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
+        rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];
+        rC = centersTable[rC * tables_js_1.MOVE_COUNT + m];
+    }
+    return (r7 === (0, tables_js_1.getPerm7Index)(state.corners.permutation) &&
+        rO === (0, tables_js_1.getOrientationIndex)(state.corners.orientation) &&
+        rC === (0, tables_js_1.getCenterIndex)(state.centers));
+}
 function verifySkewbSolution(state, solutionMoves) {
     const final = walkSkewbCoordinates({
         r7: (0, tables_js_1.getPerm7Index)(state.corners.permutation),

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

@@ -12,6 +12,7 @@ exports.getStateFromIndex = getStateFromIndex;
 exports.getPerm7Index = getPerm7Index;
 exports.getPerm7FromIndex = getPerm7FromIndex;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.areSkewbTablesLoaded = areSkewbTablesLoaded;
 exports.assignTables = assignTables;
 exports.resetTablesForTests = resetTablesForTests;
 exports.rankFromComponents = rankFromComponents;
@@ -187,6 +188,9 @@ async function ensureTablesLoaded() {
     const tables = await (0, generated_assets_js_1.loadGeneratedSkewbSolverTables)();
     assignTables(tables);
 }
+function areSkewbTablesLoaded() {
+    return tablesLoaded;
+}
 function assignTables(tables) {
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;

package/dist-cjs/random/prng.js

@@ -2,9 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRandomSource = createRandomSource;
 const node_crypto_1 = require("node:crypto");
+// 4096 bytes per refill (~682 values per syscall).
+const CRYPTO_BUFFER_BYTES = 4096;
+// Shared unseeded source: the crypto refill costs a syscall per buffer, so a
+// per-call source would pay ~one syscall per scramble. Seeded calls stay
+// isolated (deterministic streams must never be shared).
+let sharedCryptoSource = null;
 function createRandomSource(seed) {
     if (seed === undefined) {
-        return new CryptoRandomSource();
+        sharedCryptoSource ??= new CryptoRandomSource();
+        return sharedCryptoSource;
     }
     return new SeededRandomSource(hashSeed(seed));
 }
@@ -14,12 +21,19 @@ class CryptoRandomSource {
     next() {
         // Batch the crypto calls: one randomBytes per move is ~2 orders of
         // magnitude slower in Node (syscall per call). Refill lazily.
-        if (this.buffer === null || this.offset + 6 > 256) {
-            this.buffer = (0, node_crypto_1.randomBytes)(256);
+        if (this.buffer === null || this.offset + 6 > CRYPTO_BUFFER_BYTES) {
+            this.buffer = (0, node_crypto_1.randomBytes)(CRYPTO_BUFFER_BYTES);
             this.offset = 0;
         }
-        const value = this.buffer.readUIntBE(this.offset, 6);
+        const bytes = this.buffer;
+        const offset = this.offset;
         this.offset += 6;
+        const value = bytes[offset] * 0x10000000000 +
+            bytes[offset + 1] * 0x100000000 +
+            bytes[offset + 2] * 0x1000000 +
+            bytes[offset + 3] * 0x10000 +
+            bytes[offset + 4] * 0x100 +
+            bytes[offset + 5];
         return value / 0x1000000000000;
     }
     nextInt(maxExclusive) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubingcenter/scrambler",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Extensible scramble generation toolkit for CubingCenter projects.",
   "type": "module",
   "license": "MIT",