@cubingcenter/scrambler 0.5.0 → 0.5.1

package/dist/puzzles/skewb/solver/tables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/tables.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/tables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAazD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAanE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAY1E;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAOrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWjE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAE1D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOvD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAY3D;AAYD,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,WAAW,QAAuD,CAAC;AAChF,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAEtE,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAAiD,CAAC;AAE9F,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAa7D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAYzD;AAOD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,aAAa,EAAE,WAAW,GAAG,IAAW,CAAC;AACpD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD,eAAO,IAAI,gBAAgB,EAAE,WAAW,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,gBAAgB,EAAE,WAAW,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD,eAAO,IAAI,OAAO,EAAE,WAAW,GAAG,IAAW,CAAC;AAC9C,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAClD,eAAO,IAAI,aAAa,EAAE,UAAU,GAAG,IAAW,CAAC;AACnD,eAAO,IAAI,WAAW,QAAI,CAAC;AAE3B,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAIxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE;IACnC,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,UAAU,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;CACrB,GAAG,IAAI,CAyBP;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAY1C;AAMD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAc7E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWtD;AAID,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA0BzD;AAGD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAMrF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK9E;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK5E;AAMD,wBAAgB,wBAAwB,IAAI,WAAW,CActD;AAED,wBAAgB,wBAAwB,IAAI,WAAW,CActD;AAED,wBAAgB,oBAAoB,IAAI,WAAW,CAclD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQjE;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,WAAW,CAAC;IAC5B,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,WAAW,CAAC;IACpB,cAAc,EAAE,WAAW,CAAC;CAC7B;AAMD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,WAAW,GACxB,iBAAiB,CAwFnB;AAKD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,WAAW,EACzB,OAAO,EAAE,iBAAiB,GACzB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiE1C;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAO1D"}

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

@@ -156,6 +156,9 @@ export async function ensureTablesLoaded() {
     const tables = await loadGeneratedSkewbSolverTables();
     assignTables(tables);
 }
+export function areSkewbTablesLoaded() {
+    return tablesLoaded;
+}
 export function assignTables(tables) {
     PERMUTATION_TABLE = tables.permutationTable;
     ORIENTATION_TABLE = tables.orientationTable;

package/dist/random/prng.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAMvE"}
+{"version":3,"file":"prng.d.ts","sourceRoot":"","sources":["../../src/random/prng.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;CACnC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAOvE"}

package/dist/random/prng.js

@@ -1,7 +1,14 @@
 import { randomBytes } from "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;
 export function createRandomSource(seed) {
     if (seed === undefined) {
-        return new CryptoRandomSource();
+        sharedCryptoSource ??= new CryptoRandomSource();
+        return sharedCryptoSource;
     }
     return new SeededRandomSource(hashSeed(seed));
 }
@@ -11,12 +18,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 = randomBytes(256);
+        if (this.buffer === null || this.offset + 6 > CRYPTO_BUFFER_BYTES) {
+            this.buffer = 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/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;
 }

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),