@cubingcenter/scrambler 0.5.1 → 0.5.3

package/dist/puzzles/cube2/state.js

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

package/dist/puzzles/cube2/validation.d.ts

@@ -1,6 +1,8 @@
 import type { Cube2State, Cube2ValidationResult } from "./types.js";
+export declare function isTrivialCube2State(state: Cube2State): boolean;
 export declare function validateCube2State(state: Cube2State): Cube2ValidationResult;
 export declare function isOneMoveFromSolvedCube2State(state: Cube2State): boolean;
+export declare function isTrivialSamplingCube2State(p: number, o: number): boolean;
 export declare function isAllowedRandomCube2State(state: Cube2State): boolean;
 export declare function permutationParity(permutation: readonly number[]): 0 | 1;
 //# sourceMappingURL=validation.d.ts.map

package/dist/puzzles/cube2/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAgBpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAwBpE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAuB9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIxE;AAKD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}

package/dist/puzzles/cube2/validation.js

@@ -2,16 +2,47 @@ import { CUBE2_MOVES, CORNER_COUNT } from "./types.js";
 import { applyCube2Move } from "./moves.js";
 import { createSolvedCube2State, isSolvedCube2State } from "./state.js";
 import { encodeOrientation, encodePermutation } from "./solver/tables.js";
+// The 18 single-move states, precomputed once so the hot random-state path
+// checks "solved or one move from solved" with pure array comparisons
+// (no coordinate encodings per generated state).
+const ONE_MOVE_FROM_SOLVED_STATES = CUBE2_MOVES.map((move) => applyCube2Move(createSolvedCube2State(), move));
 // Precomputed coordinate encodings of every single-move state, so the
 // "one move from solved" check is a couple of O(n) encodings + 18 comparisons
 // instead of 18 full state applications.
-const ONE_MOVE_FROM_SOLVED_ENCODED = CUBE2_MOVES.map((move) => {
-    const state = applyCube2Move(createSolvedCube2State(), move);
-    return {
-        p: encodePermutation(state.corners.permutation),
-        o: encodeOrientation(state.corners.orientation)
-    };
-});
+const ONE_MOVE_FROM_SOLVED_ENCODED = ONE_MOVE_FROM_SOLVED_STATES.map((state) => ({
+    p: encodePermutation(state.corners.permutation),
+    o: encodeOrientation(state.corners.orientation)
+}));
+// Cheap trivial check for random-state sampling: solved + the 18 single-move
+// states, compared by arrays with early exit (a random state differs from
+// each candidate within the first couple of permutation entries, so the
+// typical cost is tens of comparisons — no coordinate encodings).
+export function isTrivialCube2State(state) {
+    const cp = state.corners.permutation;
+    const co = state.corners.orientation;
+    for (const candidate of ONE_MOVE_FROM_SOLVED_STATES) {
+        const p = candidate.corners.permutation;
+        const o = candidate.corners.orientation;
+        let match = true;
+        for (let i = 0; i < 8; i += 1) {
+            if (cp[i] !== p[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        for (let i = 0; i < 8; i += 1) {
+            if (co[i] !== o[i]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return isSolvedCube2State(state);
+}
 export function validateCube2State(state) {
     const errors = [
         ...validatePermutation("corner", state.corners.permutation, CORNER_COUNT),
@@ -31,7 +62,13 @@ export function validateCube2State(state) {
 export function isOneMoveFromSolvedCube2State(state) {
     const p = encodePermutation(state.corners.permutation);
     const o = encodeOrientation(state.corners.orientation);
-    return ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
+    return isTrivialSamplingCube2State(p, o);
+}
+// Cheap trivial check for random-state sampling: the caller has already
+// encoded the coordinates once. True for the solved state and the 18
+// single-move states (which would produce scrambles shorter than 2 moves).
+export function isTrivialSamplingCube2State(p, o) {
+    return (p === 0 && o === 0) || ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
 }
 export function isAllowedRandomCube2State(state) {
     return validateCube2State(state).valid &&

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

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA0DrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CA8BhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AAyGrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CA6BhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}

package/dist/puzzles/cube3/facelets.js

@@ -1,4 +1,6 @@
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const STICKERS = ["U", "R", "F", "D", "L", "B"];
+const STICKER_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 const CORNER_PIECE_STICKERS = [
     ["U", "R", "F"],
     ["U", "F", "L"],
@@ -47,20 +49,60 @@ const EDGE_POSITION_SLOTS = [
     [["B", 5], ["L", 3]],
     [["B", 3], ["R", 5]]
 ];
+const CORNER_CELLS = buildCells(CORNER_POSITION_SLOTS, CORNER_PIECE_STICKERS, 3);
+const EDGE_CELLS = buildCells(EDGE_POSITION_SLOTS, EDGE_PIECE_STICKERS, 2);
+function buildCells(slots, stickersTable, orientationCount) {
+    const cells = [];
+    for (let position = 0; position < slots.length; position += 1) {
+        const byPiece = [];
+        for (let piece = 0; piece < stickersTable.length; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < orientationCount; orientation += 1) {
+                const stickers = stickersTable[piece];
+                const slotList = slots[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+function placeCells(faces, cells) {
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+        faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+    }
+}
 export function toCube3Facelets(state) {
-    const facelets = createEmptyFacelets();
-    for (const face of FACE_ORDER) {
-        facelets[face][4] = face;
+    const facelets = {
+        U: Array(9),
+        R: Array(9),
+        F: Array(9),
+        D: Array(9),
+        L: Array(9),
+        B: Array(9)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    // Centers (fixed, since no center permutation on the 3x3)
+    for (let face = 0; face < 6; face += 1) {
+        faces[face][4] = STICKERS[face];
     }
-    for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
-        const piece = state.corners.permutation[position];
-        const orientation = state.corners.orientation[position];
-        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+    const cornerPermutation = state.corners.permutation;
+    const cornerOrientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        placeCells(faces, CORNER_CELLS[position][cornerPermutation[position]][cornerOrientation[position]]);
     }
-    for (let position = 0; position < EDGE_POSITION_SLOTS.length; position += 1) {
-        const piece = state.edges.permutation[position];
-        const orientation = state.edges.orientation[position];
-        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    const edgePermutation = state.edges.permutation;
+    const edgeOrientation = state.edges.orientation;
+    for (let position = 0; position < EDGE_CELLS.length; position += 1) {
+        placeCells(faces, EDGE_CELLS[position][edgePermutation[position]][edgeOrientation[position]]);
     }
     return facelets;
 }
@@ -70,20 +112,3 @@ export function formatCube3Facelets(facelets) {
 export function getCube3FaceOrder() {
     return FACE_ORDER;
 }
-function createEmptyFacelets() {
-    return {
-        U: Array(9).fill("U"),
-        R: Array(9).fill("R"),
-        F: Array(9).fill("F"),
-        D: Array(9).fill("D"),
-        L: Array(9).fill("L"),
-        B: Array(9).fill("B")
-    };
-}
-function placeOrientedStickers(facelets, slots, stickers, orientation) {
-    for (let index = 0; index < slots.length; index += 1) {
-        const [face, stickerIndex] = slots[index];
-        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
-        facelets[face][stickerIndex] = sticker;
-    }
-}

package/dist/puzzles/cube3/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/random-state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAItE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAiB1F"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/random-state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAKtE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAsB1F"}

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

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

package/dist/puzzles/cube3/scrambler.js

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

package/dist/puzzles/cube3/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAWnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAWnD;AAMD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAO7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}

package/dist/puzzles/cube3/state.js

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

package/dist/puzzles/cube3/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAGxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CA+B3E;AASD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAExE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}

package/dist/puzzles/cube3/validation.js

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

package/dist/puzzles/skewb/random-state.d.ts

@@ -1,3 +1,4 @@
 import type { SkewbRandomStateOptions, SkewbState } from "./types.js";
 export declare function generateRandomSkewbState(options?: SkewbRandomStateOptions): Promise<SkewbState>;
+export declare function generateRandomSkewbStateSync(options?: SkewbRandomStateOptions): SkewbState;
 //# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/skewb/random-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAatE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,UAAU,CAAC,CAiBrB"}
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/skewb/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AActE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,UAAU,CAAC,CAGrB;AAID,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAmB9F"}

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

@@ -1,7 +1,15 @@
 import { createRandomSource } from "../../random/index.js";
-import { ensureTablesLoaded, getCentersTransition, getOrientationTransition, getPermutationTransition, getStateFromRank, MOVE_COUNT, rankFromComponents, SOLVED_RANK, STATE_COUNT, } from "./solver/index.js";
+import { ensureTablesLoaded, areSkewbTablesLoaded, getCentersTransition, getOrientationTransition, getPermutationTransition, getStateFromRank, MOVE_COUNT, rankFromComponents, SOLVED_RANK, STATE_COUNT, } from "./solver/index.js";
 export async function generateRandomSkewbState(options = {}) {
     await ensureTablesLoaded();
+    return generateRandomSkewbStateSync(options);
+}
+// Synchronous variant for callers that have already ensured the tables are
+// loaded (e.g. the scrambler after the first call): no per-call await hop.
+export function generateRandomSkewbStateSync(options = {}) {
+    if (!areSkewbTablesLoaded()) {
+        throw new Error("Skewb solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
     const random = createRandomSource(options.seed);
     const rejectTrivial = options.rejectTrivial ?? true;
     const trivialRanks = rejectTrivial ? getTrivialRanks() : null;

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;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"}
+{"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,CAoDzB"}

package/dist/puzzles/skewb/scrambler.js

@@ -1,4 +1,4 @@
-import { generateRandomSkewbState } from "./random-state.js";
+import { generateRandomSkewbState, generateRandomSkewbStateSync } from "./random-state.js";
 import { formatSkewbAlgorithm } from "./moves.js";
 import { areSkewbTablesLoaded, solveSkewbIndices, solveSkewbIndicesSync, verifySkewbScrambleIndices, SKEWB_MOVES } from "./solver/index.js";
 import { formatSkewbFacelets, toSkewbFacelets } from "./facelets.js";
@@ -16,7 +16,11 @@ export const skewbScrambleGenerator = {
     },
 };
 export async function generateSkewbScramble(options = {}) {
-    const state = await generateRandomSkewbState(options);
+    // generateRandomSkewbStateSync guarantees the tables are loaded, so use
+    // the sync state generation on every call after the first (no await hop).
+    const state = areSkewbTablesLoaded()
+        ? generateRandomSkewbStateSync(options)
+        : await generateRandomSkewbState(options);
     // generateRandomSkewbState guarantees the tables are loaded, so use the
     // sync solve on every call after the first (no extra microtask).
     const solution = areSkewbTablesLoaded()

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

@@ -29,6 +29,7 @@ export declare let ORIENT_CLASS: Uint8Array | null;
 export declare let R7_SETS: Uint16Array | null;
 export declare let PERM7_UNRANK: Uint8Array | null;
 export declare let CENTER_UNRANK: Uint8Array | null;
+export declare let ORIENT_UNRANK: Uint8Array | null;
 export declare let SOLVED_RANK: number;
 export declare function ensureTablesLoaded(): Promise<void>;
 export declare function areSkewbTablesLoaded(): boolean;

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

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

@@ -149,6 +149,7 @@ export let ORIENT_CLASS = null; // rO -> class 0..8
 export let R7_SETS = null; // (rC_even * 9 + class) * 4 + i
 export let PERM7_UNRANK = null; // r7 * 7 + i -> piece at corner i+1 (derived at load)
 export let CENTER_UNRANK = null; // rC * 6 + i -> center piece (derived at load)
+export let ORIENT_UNRANK = null; // rO * 7 + i -> orientation of corner i+1 (derived at load)
 export let SOLVED_RANK = 0;
 export async function ensureTablesLoaded() {
     if (tablesLoaded)
@@ -185,6 +186,12 @@ export function assignTables(tables) {
         for (let i = 0; i < 6; i++)
             CENTER_UNRANK[rC * 6 + i] = centers[i];
     }
+    ORIENT_UNRANK = new Uint8Array(ORIENTATION_COUNT * 7);
+    for (let rO = 0; rO < ORIENTATION_COUNT; rO++) {
+        const orient = getOrientationFromIndex(rO);
+        for (let i = 0; i < 7; i++)
+            ORIENT_UNRANK[rO * 7 + i] = orient[i + 1];
+    }
     SOLVED_RANK = rankFromComponents(0, 0, 0);
     tablesLoaded = true;
 }
@@ -200,6 +207,7 @@ export function resetTablesForTests() {
     R7_SETS = null;
     PERM7_UNRANK = null;
     CENTER_UNRANK = null;
+    ORIENT_UNRANK = null;
 }
 // ---------------------------------------------------------------------------
 // Compact rank helpers
@@ -245,11 +253,9 @@ export function getStateFromRank(rank) {
         perm[i + 1] = PERM7_UNRANK[permBase + i];
     const orient = new Array(8);
     orient[0] = 0;
-    let val = rO;
-    for (let i = 1; i < 8; i++) {
-        orient[i] = val % 3;
-        val = Math.floor(val / 3);
-    }
+    const orientBase = rO * 7;
+    for (let i = 1; i < 8; i++)
+        orient[i] = ORIENT_UNRANK[orientBase + i - 1];
     const centers = new Array(6);
     const centerBase = EVEN_CENTER_FULL[even] * 6;
     for (let i = 0; i < 6; i++)

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

@@ -4,6 +4,8 @@ exports.toCube2Facelets = toCube2Facelets;
 exports.formatCube2Facelets = formatCube2Facelets;
 exports.getCube2FaceOrder = getCube2FaceOrder;
 const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const STICKERS = ["U", "R", "F", "D", "L", "B"];
+const STICKER_INDEX = { U: 0, R: 1, F: 2, D: 3, L: 4, B: 5 };
 const CORNER_PIECE_STICKERS = [
     ["U", "R", "F"],
     ["U", "F", "L"],
@@ -24,12 +26,48 @@ const CORNER_POSITION_SLOTS = [
     [["D", 2], ["B", 3], ["L", 2]],
     [["D", 3], ["R", 3], ["B", 2]]
 ];
-function toCube2Facelets(state) {
-    const facelets = createEmptyFacelets();
+const CORNER_CELLS = buildCells();
+function buildCells() {
+    const cells = [];
     for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
-        const piece = state.corners.permutation[position];
-        const orientation = state.corners.orientation[position];
-        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+        const byPiece = [];
+        for (let piece = 0; piece < CORNER_PIECE_STICKERS.length; piece += 1) {
+            const byOrientation = [];
+            for (let orientation = 0; orientation < 3; orientation += 1) {
+                const stickers = CORNER_PIECE_STICKERS[piece];
+                const slotList = CORNER_POSITION_SLOTS[position];
+                const cell = [];
+                for (let index = 0; index < slotList.length; index += 1) {
+                    const [face, stickerIndex] = slotList[index];
+                    cell.push(FACE_ORDER.indexOf(face));
+                    cell.push(stickerIndex);
+                    cell.push(STICKER_INDEX[stickers[(index - orientation + stickers.length) % stickers.length]]);
+                }
+                byOrientation.push(cell);
+            }
+            byPiece.push(byOrientation);
+        }
+        cells.push(byPiece);
+    }
+    return cells;
+}
+function toCube2Facelets(state) {
+    const facelets = {
+        U: Array(4),
+        R: Array(4),
+        F: Array(4),
+        D: Array(4),
+        L: Array(4),
+        B: Array(4)
+    };
+    const faces = [facelets.U, facelets.R, facelets.F, facelets.D, facelets.L, facelets.B];
+    const permutation = state.corners.permutation;
+    const orientation = state.corners.orientation;
+    for (let position = 0; position < CORNER_CELLS.length; position += 1) {
+        const cells = CORNER_CELLS[position][permutation[position]][orientation[position]];
+        for (let cellIndex = 0; cellIndex < cells.length; cellIndex += 3) {
+            faces[cells[cellIndex]][cells[cellIndex + 1]] = STICKERS[cells[cellIndex + 2]];
+        }
     }
     return facelets;
 }
@@ -39,20 +77,3 @@ function formatCube2Facelets(facelets) {
 function getCube2FaceOrder() {
     return FACE_ORDER;
 }
-function createEmptyFacelets() {
-    return {
-        U: Array(4).fill("U"),
-        R: Array(4).fill("R"),
-        F: Array(4).fill("F"),
-        D: Array(4).fill("D"),
-        L: Array(4).fill("L"),
-        B: Array(4).fill("B")
-    };
-}
-function placeOrientedStickers(facelets, slots, stickers, orientation) {
-    for (let index = 0; index < slots.length; index += 1) {
-        const [face, stickerIndex] = slots[index];
-        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
-        facelets[face][stickerIndex] = sticker;
-    }
-}

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

@@ -2,53 +2,57 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomCube2State = generateRandomCube2State;
 const index_js_1 = require("../../random/index.js");
-const types_js_1 = require("./types.js");
 const validation_js_1 = require("./validation.js");
 function generateRandomCube2State(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 (DBL corner fixed, even
+        // permutation, orientation sum divisible by 3, values in range), so the
+        // only meaningful rejection is the trivial set: solved + the 18
+        // single-move states (scrambles shorter than 2 moves), compared by
+        // arrays — no coordinate encodings in this hot path.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube2State)(state)) {
+        if (!rejectTrivial || !(0, validation_js_1.isTrivialCube2State)(state)) {
             return state;
         }
     }
     throw new Error("Unable to generate a non-trivial random 2x2 state.");
 }
 function createLegalRandomState(random) {
-    const perm7 = shuffledRange(types_js_1.CORNER_COUNT - 1, random);
-    const mappedPerm = perm7.map((val) => (val >= 6 ? val + 1 : val));
-    mappedPerm.splice(6, 0, 6);
-    const orient7 = randomOrientations(types_js_1.CORNER_COUNT - 1, 3, random);
-    orient7.splice(6, 0, 0);
-    return {
-        corners: {
-            permutation: mappedPerm,
-            orientation: orient7
-        }
-    };
-}
-function shuffledRange(length, random) {
-    const values = Array.from({ length }, (_, index) => index);
-    for (let index = values.length - 1; index > 0; index -= 1) {
+    // 7 free corners (piece 6 = DBL stays fixed at position 6)
+    const perm7 = [0, 1, 2, 3, 4, 5, 6];
+    for (let index = 6; index > 0; index -= 1) {
         const swapIndex = random.nextInt(index + 1);
-        swap(values, index, swapIndex);
+        if (swapIndex < index) {
+            const temporary = perm7[index];
+            perm7[index] = perm7[swapIndex];
+            perm7[swapIndex] = temporary;
+        }
     }
-    return values;
-}
-function randomOrientations(length, modulo, random) {
-    const orientations = Array(length).fill(0);
+    // Map the shuffle domain {0..6} to {0..5,7} and insert 6 at position 6
+    // (DBL fixed). Single allocation, no intermediate arrays.
+    const last = perm7[6] >= 6 ? perm7[6] + 1 : perm7[6];
+    const permutation = new Array(8);
+    for (let index = 0; index < 6; index += 1) {
+        const value = perm7[index];
+        permutation[index] = value >= 6 ? value + 1 : value;
+    }
+    permutation[6] = 6;
+    permutation[7] = last;
+    // 7 free orientations with sum divisible by 3; DBL stays oriented
+    const orientation = [0, 0, 0, 0, 0, 0, 0, 0];
     let total = 0;
-    for (let index = 0; index < length - 1; index += 1) {
-        const orientation = random.nextInt(modulo);
-        orientations[index] = orientation;
-        total += orientation;
+    for (let index = 0; index < 6; index += 1) {
+        const value = random.nextInt(3);
+        orientation[index] = value;
+        total += value;
     }
-    orientations[length - 1] = (modulo - (total % modulo)) % modulo;
-    return orientations;
-}
-function swap(values, left, right) {
-    const temporary = values[left];
-    values[left] = values[right];
-    values[right] = temporary;
+    orientation[7] = (3 - (total % 3)) % 3;
+    return {
+        corners: {
+            permutation,
+            orientation
+        }
+    };
 }