@cubingcenter/scrambler 0.4.1 → 0.5.1

package/README.md

@@ -15,6 +15,7 @@ The package currently ships random-state scramblers for `222` (2x2x2), `333` (3x
 - 2x2 quality: random-state target + optimal table-guided solver + verified scramble inversion
 - 3x3 quality: random-state target + two-phase solver + verified scramble inversion
 - Pyraminx quality: random-state target + optimal policy-table solver (all 933,120 core states verified)
+- Skewb quality: random-state target + optimal policy-table solver (all 3,149,280 states; exact uniform sampling)
 - 4x4 quality: reduced 4x4 random-state target + existing 3x3 two-phase finish; full center/wing random-state reduction is isolated under `cube4.reduction`
 
 This library is intended for practice, training, and internal CubingCenter use. Do not present it as an official WCA competition scrambler; sanctioned competitions must use the official program required by the delegate/organization.
@@ -141,6 +142,26 @@ const solution = await pyraminx.solvePyraminx(state); // optimal, policy-table b
 
 The solver only covers the core (centers + edges); tips are appended by the scrambler. The `pyraminx.solver` namespace exposes the compact coordinates and the policy table; its optimality is verified exhaustively over all 933,120 core states (`pnpm verify:pyraminx:exhaustive`). Normal consumers should prefer `generateScramble("pymx")`.
 
+## Skewb Technical Module
+
+```ts
+import { skewb } from "@cubingcenter/scrambler";
+
+const solved = skewb.createSolvedSkewbState();
+const moved = skewb.applySkewbAlgorithm(solved, ["R", "U", "R'"]);
+const state = await skewb.generateRandomSkewbState({ seed: "demo" });
+const facelets = skewb.toSkewbFacelets(state);
+const faceletString = skewb.formatSkewbFacelets(facelets);
+const validation = skewb.validateSkewbState(state);
+const solution = await skewb.solveSkewb(state); // optimal, policy-table based
+```
+
+`generateRandomSkewbState` returns a legal random state, not a scramble sequence. It samples the compact group rank uniformly, so every one of the 3,149,280 reachable states is exactly as likely as any other.
+
+`toSkewbFacelets` returns six faces with five stickers each. `formatSkewbFacelets` produces a stable 30-character string.
+
+Both `generateRandomSkewbState` and `solveSkewb` are async: they need the solver tables, which load lazily in Node and are prefetched in the browser via `initializeScrambler(baseUrl, "skwb")` (or `skewb.solveSkewbSync` after preloading). The `skewb.solver` namespace exposes the compact rank coordinates and the 3-bit policy table (all 3,149,280 states, God's number 11). Normal consumers should prefer `generateScramble("skwb")`.
+
 ## 4x4 Technical Module
 
 ```ts

package/dist/core/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBrG;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,iBAAmC,GAC5C,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,GAAE,iBAAmC,GAAG,SAAS,EAAE,CAE7F;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,iBAAmC,GAC5C,SAAS,CAQX;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/core/api.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4BrG;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,iBAAmC,GAC5C,IAAI,CAEN;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,GAAE,iBAAmC,GAAG,SAAS,EAAE,CAE7F;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,GAAE,iBAAmC,GAC5C,SAAS,CAQX;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAAoB,EAC7B,QAAQ,GAAE,iBAAmC,GAC5C,OAAO,CAAC,cAAc,EAAE,CAAC,CAU3B"}

package/dist/core/api.js

@@ -30,11 +30,16 @@ export async function initializeScrambler(baseUrl, eventId) {
         const { loadBrowserTables } = await import("../puzzles/pyraminx/solver/browser-loader.js");
         await loadBrowserTables(baseUrl);
     }
+    else if (eventId === "skwb") {
+        const { loadBrowserTables } = await import("../puzzles/skewb/solver/browser-loader.js");
+        await loadBrowserTables(baseUrl);
+    }
     else if (!eventId) {
         await Promise.all([
             import("../puzzles/cube2/solver/browser-loader.js").then((m) => m.loadBrowserTables(baseUrl)),
             import("../puzzles/cube3/solver/browser-loader.js").then((m) => m.loadBrowserTables(baseUrl)),
-            import("../puzzles/pyraminx/solver/browser-loader.js").then((m) => m.loadBrowserTables(baseUrl))
+            import("../puzzles/pyraminx/solver/browser-loader.js").then((m) => m.loadBrowserTables(baseUrl)),
+            import("../puzzles/skewb/solver/browser-loader.js").then((m) => m.loadBrowserTables(baseUrl))
         ]);
     }
 }

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":"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"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/pyraminx/solver/tables.ts"],"names":[],"mappings":"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"}

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/facelets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAgC5D,wBAAgB,yBAAyB,IAAI,aAAa,CASzD;AAaD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAsBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA0D5D,wBAAgB,yBAAyB,IAAI,aAAa,CASzD;AAaD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAqBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD"}

package/dist/puzzles/skewb/facelets.js

@@ -1,6 +1,7 @@
 // Facelets model matching cubingcenter-viz/src/puzzles/skewb.ts
 // Each face has 5 stickers: 0=center, 1=TL,2=TR,3=BL,4=BR (net layout)
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const FACE_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 // Canonical sticker faces per corner position: [UD sticker, RL sticker, FB sticker]
 const CORNER_STICKERS = [
     ["U", "R", "F"],
@@ -23,43 +24,65 @@ const CORNER_SLOTS = [
     [["D", 4], ["R", 4], ["B", 3]],
     [["D", 3], ["L", 3], ["B", 4]],
 ];
+// For each (position, piece, orientation) the three facelet writes, flattened:
+// face index, sticker slot index and sticker color index, so the hot loop is
+// pure table lookups (no tuple destructuring, no modulo).
+const CORNER_WRITE_COUNT = 8 * 8 * 3 * 3;
+const WRITE_FACE = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_SLOT = new Int8Array(CORNER_WRITE_COUNT);
+const WRITE_COLOR = new Int8Array(CORNER_WRITE_COUNT);
+for (let pos = 0; pos < 8; pos++) {
+    const slots = CORNER_SLOTS[pos];
+    for (let piece = 0; piece < 8; piece++) {
+        const stickers = CORNER_STICKERS[piece];
+        for (let ori = 0; ori < 3; ori++) {
+            const base = ((pos * 8 + piece) * 3 + ori) * 3;
+            for (let i = 0; i < 3; i++) {
+                const [face, idx] = slots[i];
+                const color = stickers[(i + 3 - ori) % 3];
+                WRITE_FACE[base + i] = FACE_INDEX[face];
+                WRITE_SLOT[base + i] = idx;
+                WRITE_COLOR[base + i] = FACE_INDEX[color];
+            }
+        }
+    }
+}
 export function createSolvedSkewbFacelets() {
     return {
-        U: Array.from({ length: 5 }, () => "U"),
-        R: Array.from({ length: 5 }, () => "R"),
-        F: Array.from({ length: 5 }, () => "F"),
-        D: Array.from({ length: 5 }, () => "D"),
-        L: Array.from({ length: 5 }, () => "L"),
-        B: Array.from({ length: 5 }, () => "B"),
+        U: ["U", "U", "U", "U", "U"],
+        R: ["R", "R", "R", "R", "R"],
+        F: ["F", "F", "F", "F", "F"],
+        D: ["D", "D", "D", "D", "D"],
+        L: ["L", "L", "L", "L", "L"],
+        B: ["B", "B", "B", "B", "B"],
     };
 }
 function createEmptySkewbFacelets() {
     return {
-        U: Array(5).fill("?"),
-        R: Array(5).fill("?"),
-        F: Array(5).fill("?"),
-        D: Array(5).fill("?"),
-        L: Array(5).fill("?"),
-        B: Array(5).fill("?"),
+        U: ["?", "?", "?", "?", "?"],
+        R: ["?", "?", "?", "?", "?"],
+        F: ["?", "?", "?", "?", "?"],
+        D: ["?", "?", "?", "?", "?"],
+        L: ["?", "?", "?", "?", "?"],
+        B: ["?", "?", "?", "?", "?"],
     };
 }
 export function toSkewbFacelets(state) {
     const facelets = createEmptySkewbFacelets();
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const perm = state.corners.permutation;
+    const orient = state.corners.orientation;
+    const centers = state.centers;
     // centers
     for (let face = 0; face < 6; face++) {
-        const targetFace = FACE_ORDER[face];
-        facelets[targetFace][0] = FACE_ORDER[state.centers[face]];
+        faces[face][0] = FACE_ORDER[centers[face]];
     }
-    // corners
+    // corners (unrolled 3 writes per position)
     for (let pos = 0; pos < 8; pos++) {
-        const piece = state.corners.permutation[pos];
-        const ori = state.corners.orientation[pos];
-        const slots = CORNER_SLOTS[pos];
-        const stickers = CORNER_STICKERS[piece];
-        for (let i = 0; i < 3; i++) {
-            const [face, idx] = slots[i];
-            facelets[face][idx] = stickers[(i + 3 - ori) % 3];
-        }
+        const base = ((pos * 8 + perm[pos]) * 3 + orient[pos]) * 3;
+        faces[WRITE_FACE[base]][WRITE_SLOT[base]] = FACE_ORDER[WRITE_COLOR[base]];
+        faces[WRITE_FACE[base + 1]][WRITE_SLOT[base + 1]] = FACE_ORDER[WRITE_COLOR[base + 1]];
+        faces[WRITE_FACE[base + 2]][WRITE_SLOT[base + 2]] = FACE_ORDER[WRITE_COLOR[base + 2]];
     }
     return facelets;
 }