@cubingcenter/scrambler 0.5.0 → 0.5.1

package/dist/puzzles/pyraminx/facelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAUhD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AA6DhF,wBAAgB,4BAA4B,IAAI,gBAAgB,CAO/D;AAyBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAiCzE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED,wBAAgB,oBAAoB,IAAI,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAEzE"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAUhD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAsGhF,wBAAgB,4BAA4B,IAAI,gBAAgB,CAO/D;AAoBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAezE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED,wBAAgB,oBAAoB,IAAI,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAEzE"}

package/dist/puzzles/pyraminx/facelets.js

@@ -1,4 +1,6 @@
 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
@@ -48,6 +50,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;
+}
 export function createSolvedPyraminxFacelets() {
     return {
         F: Array.from({ length: 9 }, () => "F"),
@@ -56,36 +85,33 @@ export 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]];
     }
 }
 export 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/puzzles/pyraminx/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG5E,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAYnG"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/random-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA2B5E,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAenG"}

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

@@ -1,39 +1,69 @@
 import { createRandomSource } from "../../random/index.js";
-import { isAllowedRandomPyraminxState, permutationParity } from "./validation.js";
+import { isSolvedPyraminxState } from "./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;
+        }
+    }
+})();
 export function generateRandomPyraminxState(options = {}) {
     const random = 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 || isAllowedRandomPyraminxState(state)) {
+        if (!rejectTrivial || !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 (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,
@@ -41,13 +71,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/puzzles/pyraminx/scrambler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAW9F,eAAO,MAAM,yBAAyB,EAAE,iBAYvC,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAkDzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/pyraminx/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAe9F,eAAO,MAAM,yBAAyB,EAAE,iBAYvC,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CA8DzB"}

package/dist/puzzles/pyraminx/scrambler.js

@@ -1,10 +1,8 @@
 import { generateRandomPyraminxState } from "./random-state.js";
-import { invertPyraminxAlgorithm } from "./moves.js";
-import { solvePyraminx, verifyPyraminxScramble } from "./solver/index.js";
+import { arePyraminxTablesLoaded, solvePyraminxIndices, solvePyraminxIndicesSync, verifyPyraminxScrambleIndices, PYRAMINX_MOVES } from "./solver/index.js";
 import { formatPyraminxFacelets, toPyraminxFacelets } from "./facelets.js";
 import { PYRAMINX_TIPS } from "./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'"];
 export const pyraminxScrambleGenerator = {
     info: {
         eventId: "pymx",
@@ -20,47 +18,58 @@ export const pyraminxScrambleGenerator = {
 };
 export async function generatePyraminxScramble(options = {}) {
     const state = generateRandomPyraminxState(options);
-    // Solve the core edges and centers
-    const solution = await solvePyraminx(state);
-    const scrambleMoves = 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 = arePyraminxTablesLoaded()
+        ? solvePyraminxIndicesSync(state)
+        : await 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++] = 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(PYRAMINX_TIPS[i]);
+            moves[count++] = PYRAMINX_TIPS[i];
+            tipMoves.push(i * 2);
         }
         else if (delta === 2) {
-            finalMoves.push(`${PYRAMINX_TIPS[i]}'`);
+            moves[count++] = TIP_INVERSE[i];
+            tipMoves.push(i * 2 + 1);
         }
     }
-    if (!options.skipValidation && !verifyPyraminxScramble(state, finalMoves)) {
+    moves.length = count;
+    if (!options.skipValidation && !verifyPyraminxScrambleIndices(state, solution, tipMoves)) {
         throw new Error("Generated Pyraminx scramble does not reproduce the target random state.");
     }
     const facelets = toPyraminxFacelets(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = 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: formatPyraminxFacelets(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length
+            solutionMoves,
+            solutionDepth: depth
         }
     };
 }

package/dist/puzzles/pyraminx/solver/search.d.ts

@@ -5,6 +5,9 @@ export interface PyraminxSolution {
 }
 export declare function solvePyraminx(state: PyraminxState): Promise<PyraminxMove[]>;
 export declare function solvePyraminxWithInfo(state: PyraminxState): Promise<PyraminxSolution>;
+export declare function solvePyraminxIndices(state: PyraminxState): Promise<number[]>;
+export declare function solvePyraminxIndicesSync(state: PyraminxState): number[];
 export declare function solvePyraminxSync(state: PyraminxState): PyraminxMove[];
 export declare function verifyPyraminxScramble(state: PyraminxState, finalMoves: readonly PyraminxMove[]): boolean;
+export declare function verifyPyraminxScrambleIndices(state: PyraminxState, solution: readonly number[], tipMoves: readonly number[]): boolean;
 //# sourceMappingURL=search.d.ts.map

package/dist/puzzles/pyraminx/solver/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAgB/D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAGjF;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG3F;AA8BD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,EAAE,CAGtE;AAaD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAsCzG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAe/D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAGjF;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG3F;AAMD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGlF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,EAAE,CAGvE;AAuCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,EAAE,CAGtE;AAaD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAsCzG;AAKD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,CAmCT"}

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

@@ -1,4 +1,4 @@
-import { POLICY_TABLE, CENTERS_TABLE, PERMUTATION_TABLE, ORIENTATION_TABLE, PYRAMINX_MOVES, MOVE_COUNT, PERMUTATION_COUNT, getCentersIndex, getOrientationIndex, getPermutationCompactIndex, getPolicyMoveFromPacked, ensureTablesLoaded } from "./tables.js";
+import { POLICY_TABLE, CENTERS_TABLE, PERMUTATION_TABLE, ORIENTATION_TABLE, PYRAMINX_MOVES, MOVE_COUNT, PERMUTATION_COUNT, getCentersIndex, getOrientationIndex, getPermutationCompactIndex, ensureTablesLoaded } from "./tables.js";
 export async function solvePyraminx(state) {
     await ensureTablesLoaded();
     return solveWithTables(state).moves;
@@ -7,7 +7,25 @@ export async function solvePyraminxWithInfo(state) {
     await 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).
+export async function solvePyraminxIndices(state) {
+    await ensureTablesLoaded();
+    return solveWithTablesIndices(state);
+}
+export function solvePyraminxIndicesSync(state) {
+    if (!POLICY_TABLE)
+        throw new Error("Pyraminx tables not loaded");
+    return solveWithTablesIndices(state);
+}
 function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => PYRAMINX_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
     const centersTable = CENTERS_TABLE;
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
@@ -17,17 +35,20 @@ function solveWithTables(state) {
     let o = getOrientationIndex(state.edgesOrient);
     let stateIndex = c + 81 * (p + PERMUTATION_COUNT * o);
     if (stateIndex === 0)
-        return { moves: [], depth: 0 };
+        return [];
     const moves = [];
     while (stateIndex !== 0) {
-        const m = getPolicyMoveFromPacked(policy, stateIndex);
-        moves.push(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 * MOVE_COUNT + m];
         p = permTable[p * MOVE_COUNT + m];
         o = orientTable[o * MOVE_COUNT + m];
         stateIndex = c + 81 * (p + PERMUTATION_COUNT * o);
     }
-    return { moves, depth: moves.length };
+    return moves;
 }
 // Synchronous variant for scripts that have already ensured tables are loaded
 export function solvePyraminxSync(state) {
@@ -80,3 +101,37 @@ export 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.
+export function verifyPyraminxScrambleIndices(state, solution, tipMoves) {
+    const centersTable = CENTERS_TABLE;
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = 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 * MOVE_COUNT + m];
+        p = permTable[p * MOVE_COUNT + m];
+        o = orientTable[o * 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 === getCentersIndex(state.centers) &&
+        p === getPermutationCompactIndex(state.edgesPerm) &&
+        o === 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/puzzles/pyraminx/solver/tables.d.ts

@@ -35,6 +35,7 @@ export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint8Array | null;
 export declare let POLICY_TABLE: Uint8Array | null;
 export declare function ensureTablesLoaded(): Promise<void>;
+export declare function arePyraminxTablesLoaded(): boolean;
 export declare function getPolicyMove(stateIndex: number): number;
 export declare function getCentersTransition(centerIdx: number, move: number): number;
 export declare function getPermutationTransition(permIdx: number, move: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/tables.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWnE;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,CAMrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAElE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ3D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAIjE;AAGD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,eAAe,yBAAkD,CAAC;AAC/E,eAAO,MAAM,eAAe,0BAAqC,CAAC;AAalE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAK1E;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAK1D;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAatE;AAMD,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,WAAW,QAA6C,CAAC;AACtE,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAGtE,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAMtF;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAEjD,CAAC;AAMF,wBAAgB,oBAAoB,IAAI,UAAU,CAgBjD;AAED,wBAAgB,wBAAwB,IAAI,WAAW,CAkBtD;AAED,wBAAgB,wBAAwB,IAAI,UAAU,CAgBrD;AAKD,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,UAAU,EACxB,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,UAAU,GACtB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA8C1C;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAO1D;AAOD,eAAO,IAAI,aAAa,EAAE,UAAU,GAAG,IAAW,CAAC;AACnD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,UAAU,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAElD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQxD;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5E;AACD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9E;AACD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhF;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/tables.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWnE;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,CAMrE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAElE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ3D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAIjE;AAGD,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,eAAe,yBAAkD,CAAC;AAC/E,eAAO,MAAM,eAAe,0BAAqC,CAAC;AAalE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAK1E;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAK1D;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAatE;AAMD,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,WAAW,QAA6C,CAAC;AACtE,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AAGtE,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAMtF;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAEjD,CAAC;AAMF,wBAAgB,oBAAoB,IAAI,UAAU,CAgBjD;AAED,wBAAgB,wBAAwB,IAAI,WAAW,CAkBtD;AAED,wBAAgB,wBAAwB,IAAI,UAAU,CAgBrD;AAKD,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,UAAU,EACxB,SAAS,EAAE,WAAW,EACtB,WAAW,EAAE,UAAU,GACtB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA8C1C;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAO1D;AAOD,eAAO,IAAI,aAAa,EAAE,UAAU,GAAG,IAAW,CAAC;AACnD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,UAAU,GAAG,IAAW,CAAC;AACvD,eAAO,IAAI,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAElD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQxD;AAED,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5E;AACD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9E;AACD,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhF;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}

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

@@ -271,6 +271,9 @@ export async function ensureTablesLoaded() {
     POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
+export function arePyraminxTablesLoaded() {
+    return tablesLoaded;
+}
 export function getPolicyMove(stateIndex) {
     if (!POLICY_TABLE)
         throw new Error("Pyraminx solver tables not loaded. Call ensureTablesLoaded() first.");

package/dist/puzzles/skewb/scrambler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CA+BzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAa9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,eAAe,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3D,OAAO,CAAC,cAAc,CAAC,CAgDzB"}

package/dist/puzzles/skewb/scrambler.js

@@ -1,6 +1,6 @@
 import { generateRandomSkewbState } from "./random-state.js";
-import { formatSkewbAlgorithm, invertSkewbAlgorithm } from "./moves.js";
-import { solveSkewb, verifySkewbScramble } from "./solver/index.js";
+import { formatSkewbAlgorithm } from "./moves.js";
+import { areSkewbTablesLoaded, solveSkewbIndices, solveSkewbIndicesSync, verifySkewbScrambleIndices, SKEWB_MOVES } from "./solver/index.js";
 import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
 export const skewbScrambleGenerator = {
     info: {
@@ -17,18 +17,32 @@ export const skewbScrambleGenerator = {
 };
 export async function generateSkewbScramble(options = {}) {
     const state = await generateRandomSkewbState(options);
-    const solution = await solveSkewb(state);
-    const scrambleMoves = invertSkewbAlgorithm(solution);
+    // generateRandomSkewbState guarantees the tables are loaded, so use the
+    // sync solve on every call after the first (no extra microtask).
+    const solution = areSkewbTablesLoaded()
+        ? solveSkewbIndicesSync(state)
+        : await 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] = 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 (!verifySkewbScramble(state, scrambleMoves)) {
+        if (!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 = toSkewbFacelets(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = SKEWB_MOVES[solution[index]];
+    }
     const result = {
         eventId: "skwb",
         scramble: formatSkewbAlgorithm(scrambleMoves),
@@ -39,8 +53,8 @@ export async function generateSkewbScramble(options = {}) {
             state,
             facelets,
             faceletString: formatSkewbFacelets(facelets),
-            solutionMoves: solution,
-            solutionDepth: solution.length,
+            solutionMoves,
+            solutionDepth: depth,
         },
     };
     if (options.seed !== undefined)

package/dist/puzzles/skewb/solver/search.d.ts

@@ -5,7 +5,10 @@ export interface SkewbSolution {
 }
 export declare function solveSkewb(state: SkewbState): Promise<SkewbMove[]>;
 export declare function solveSkewbWithInfo(state: SkewbState): Promise<SkewbSolution>;
+export declare function solveSkewbIndices(state: SkewbState): Promise<number[]>;
+export declare function solveSkewbIndicesSync(state: SkewbState): number[];
 export declare function solveSkewbSync(state: SkewbState): SkewbMove[];
 export declare function verifySkewbScramble(state: SkewbState, scrambleMoves: readonly SkewbMove[]): boolean;
+export declare function verifySkewbScrambleIndices(state: SkewbState, solution: readonly number[]): boolean;
 export declare function verifySkewbSolution(state: SkewbState, solutionMoves: readonly SkewbMove[]): boolean;
 //# sourceMappingURL=search.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiBzD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAGxE;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAGlF;AAGD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CAK7D;AAsED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/skewb/solver/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiBzD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAGxE;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAGlF;AAKD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAG5E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKjE;AAGD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,EAAE,CAK7D;AA4ED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAID,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAwBlG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG"}

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

@@ -7,6 +7,19 @@ export async function solveSkewbWithInfo(state) {
     await 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').
+export async function solveSkewbIndices(state) {
+    await ensureTablesLoaded();
+    return solveWithTablesIndices(state);
+}
+export function solveSkewbIndicesSync(state) {
+    if (!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
 export function solveSkewbSync(state) {
     if (!POLICY_TABLE) {
@@ -15,6 +28,11 @@ export function solveSkewbSync(state) {
     return solveWithTables(state).moves;
 }
 function solveWithTables(state) {
+    const indices = solveWithTablesIndices(state);
+    const moves = indices.map((index) => SKEWB_MOVES[index]);
+    return { moves, depth: moves.length };
+}
+function solveWithTablesIndices(state) {
     const policy = POLICY_TABLE;
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
@@ -28,18 +46,18 @@ function solveWithTables(state) {
     let rC = getCenterIndex(state.centers);
     let rank = rankFromComponents(r7, rO, rC);
     if (rank === SOLVED_RANK) {
-        return { moves: [], depth: 0 };
+        return [];
     }
     const moves = [];
     while (rank !== SOLVED_RANK) {
         const m = getPolicyMoveFromPacked(policy, rank);
-        moves.push(SKEWB_MOVES[m]);
+        moves.push(m);
         r7 = permTable[r7 * MOVE_COUNT + m];
         rO = orientTable[rO * MOVE_COUNT + m];
         rC = centersTable[rC * MOVE_COUNT + m];
         rank = rankFromComponents(r7, rO, rC);
     }
-    return { moves, depth: moves.length };
+    return moves;
 }
 // ---------------------------------------------------------------------------
 // Coordinate-walking verification (no full state clones)
@@ -70,6 +88,28 @@ export function verifySkewbScramble(state, scrambleMoves) {
         final.rO === getOrientationIndex(state.corners.orientation) &&
         final.rC === getCenterIndex(state.centers));
 }
+// Numeric verification for the hot scramble path: replays the scramble (the
+// solution reversed with m ^ 1 inverses) without any string parsing.
+export function verifySkewbScrambleIndices(state, solution) {
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const centersTable = 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 * MOVE_COUNT + m];
+        rO = orientTable[rO * MOVE_COUNT + m];
+        rC = centersTable[rC * MOVE_COUNT + m];
+    }
+    return (r7 === getPerm7Index(state.corners.permutation) &&
+        rO === getOrientationIndex(state.corners.orientation) &&
+        rC === getCenterIndex(state.centers));
+}
 export function verifySkewbSolution(state, solutionMoves) {
     const final = walkSkewbCoordinates({
         r7: getPerm7Index(state.corners.permutation),

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

@@ -31,6 +31,7 @@ export declare let PERM7_UNRANK: Uint8Array | null;
 export declare let CENTER_UNRANK: Uint8Array | null;
 export declare let SOLVED_RANK: number;
 export declare function ensureTablesLoaded(): Promise<void>;
+export declare function areSkewbTablesLoaded(): boolean;
 export declare function assignTables(tables: {
     permutationTable: Uint16Array;
     orientationTable: Uint16Array;