@cubingcenter/scrambler 0.5.1 → 0.5.2

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

@@ -1 +1 @@
-{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA4BrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAehE;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/cube2/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AAgErF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAqBhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}

package/dist/puzzles/cube2/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"],
@@ -19,12 +21,48 @@ const CORNER_POSITION_SLOTS = [
     [["D", 2], ["B", 3], ["L", 2]],
     [["D", 3], ["R", 3], ["B", 2]]
 ];
-export 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;
+}
+export 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;
 }
@@ -34,20 +72,3 @@ export function formatCube2Facelets(facelets) {
 export 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/puzzles/cube2/random-state.d.ts.map

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

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

@@ -1,51 +1,61 @@
 import { createRandomSource } from "../../random/index.js";
-import { CORNER_COUNT } from "./types.js";
-import { isAllowedRandomCube2State } from "./validation.js";
+import { isTrivialSamplingCube2State } from "./validation.js";
+import { encodePermutation, encodeOrientation } from "./solver/tables.js";
 export function generateRandomCube2State(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 (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). Coordinates are
+        // encoded once for both checks.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || isAllowedRandomCube2State(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        const p = encodePermutation(state.corners.permutation);
+        const o = encodeOrientation(state.corners.orientation);
+        if (!isTrivialSamplingCube2State(p, o)) {
             return state;
         }
     }
     throw new Error("Unable to generate a non-trivial random 2x2 state.");
 }
 function createLegalRandomState(random) {
-    const perm7 = shuffledRange(CORNER_COUNT - 1, random);
-    const mappedPerm = perm7.map((val) => (val >= 6 ? val + 1 : val));
-    mappedPerm.splice(6, 0, 6);
-    const orient7 = randomOrientations(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
+        }
+    };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAS9F,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,CAwCzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAiB9F,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,CAqDzB"}

package/dist/puzzles/cube2/scrambler.js

@@ -1,7 +1,10 @@
-import { formatCube2Algorithm, invertCube2Algorithm } from "./moves.js";
+import { formatCube2Algorithm } from "./moves.js";
 import { generateRandomCube2State } from "./random-state.js";
 import { formatCube2Facelets, toCube2Facelets } from "./facelets.js";
-import { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./solver/index.js";
+import { areCube2TablesLoaded, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2SolutionIndices, BFS_MOVES } from "./solver/index.js";
+// BFS_MOVES = [U, U2, U', R, R2, R', F, F2, F'] — the inverse of index m is
+// CUBE2_MOVE_INVERSE[m] (U2/R2/F2 are self-inverse, so m ^ 1 does not apply).
+const CUBE2_MOVE_INVERSE = [2, 1, 0, 5, 4, 3, 8, 7, 6];
 export const cube2ScrambleGenerator = {
     info: {
         eventId: "222",
@@ -17,20 +20,31 @@ export const cube2ScrambleGenerator = {
 };
 export async function generateCube2Scramble(options = {}) {
     const state = generateRandomCube2State(options);
-    const solution = await solveCube2State(state);
-    const scrambleMoves = invertCube2Algorithm(solution.moves);
+    const solution = areCube2TablesLoaded()
+        ? solveCube2StateIndicesSync(state)
+        : await solveCube2StateIndices(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed.
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = BFS_MOVES[CUBE2_MOVE_INVERSE[solution[depth - 1 - index]]];
+    }
     if (!options.skipValidation) {
-        if (!verifyCube2Scramble(state, scrambleMoves)) {
+        // The scramble is the exact inverse of the solution, so verifying that
+        // the solution solves the target state is equivalent to verifying that
+        // the scramble reproduces it — a single numeric walk suffices.
+        if (!verifyCube2SolutionIndices(state, solution)) {
             throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
         }
-        if (!verifyCube2Solution(state, solution.moves)) {
-            throw new Error("Generated 2x2 solution does not solve the target random state.");
-        }
         if (scrambleMoves.length < 2) {
             throw new Error("Generated 2x2 scramble is too short.");
         }
     }
     const facelets = toCube2Facelets(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = BFS_MOVES[solution[index]];
+    }
     const result = {
         eventId: "222",
         scramble: formatCube2Algorithm(scrambleMoves),
@@ -41,8 +55,8 @@ export async function generateCube2Scramble(options = {}) {
             state,
             facelets,
             faceletString: formatCube2Facelets(facelets),
-            solutionMoves: solution.moves,
-            solutionDepth: solution.depth
+            solutionMoves,
+            solutionDepth: depth
         }
     };
     if (options.seed !== undefined) {

package/dist/puzzles/cube2/solver/index.d.ts

@@ -1,3 +1,4 @@
-export { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./search.js";
+export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
 export type { Cube2Solution } from "./search.js";
+export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/puzzles/cube2/solver/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC"}

package/dist/puzzles/cube2/solver/index.js

@@ -1 +1,2 @@
-export { solveCube2State, verifyCube2Scramble, verifyCube2Solution } from "./search.js";
+export { solveCube2State, solveCube2StateIndices, solveCube2StateIndicesSync, verifyCube2Scramble, verifyCube2Solution, verifyCube2SolutionIndices } from "./search.js";
+export { areCube2TablesLoaded, BFS_MOVES, DISTANCES, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";

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

@@ -5,6 +5,9 @@ export interface Cube2Solution {
     state: Cube2State;
 }
 export declare function solveCube2State(state: Cube2State): Promise<Cube2Solution>;
+export declare function solveCube2StateIndices(state: Cube2State): Promise<number[]>;
+export declare function solveCube2StateIndicesSync(state: Cube2State): number[];
 export declare function verifyCube2Scramble(state: Cube2State, scrambleMoves: readonly Cube2Move[]): boolean;
 export declare function verifyCube2Solution(state: Cube2State, solutionMoves: readonly Cube2Move[]): boolean;
+export declare function verifyCube2SolutionIndices(state: Cube2State, solution: readonly number[]): boolean;
 //# sourceMappingURL=search.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CA6D/E;AAoBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAQ/E;AAKD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAKtE;AA6ED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAUnG;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAOnG;AAMD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAclG"}

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

@@ -2,6 +2,27 @@ import { createSolvedCube2State } from "../state.js";
 import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, DISTANCES, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
 export async function solveCube2State(state) {
     await ensureTablesLoaded();
+    const indices = solveWithTablesIndices(state);
+    return {
+        moves: indices.map((index) => BFS_MOVES[index]),
+        depth: indices.length,
+        state: createSolvedCube2State()
+    };
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..8) in walk order. The inverse of index m is CUBE2_MOVE_INVERSE[m]
+// (U2/R2/F2 are self-inverse, so m ^ 1 does not apply here).
+export async function solveCube2StateIndices(state) {
+    await ensureTablesLoaded();
+    return solveWithTablesIndices(state);
+}
+export function solveCube2StateIndicesSync(state) {
+    if (!DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+function solveWithTablesIndices(state) {
     if (state.corners.permutation[6] !== 6 || state.corners.orientation[6] !== 0) {
         throw new Error("The 2x2 solver requires the DBL corner (index 6) to be solved " +
             "as the frame of reference. Please normalize the state before solving.");
@@ -16,7 +37,7 @@ export async function solveCube2State(state) {
     const initialCombined = permIndex * ORIENTATION_COUNT + orientIndex;
     let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
     if (distance === 0) {
-        return { moves, depth: 0, state: createSolvedCube2State() };
+        return moves;
     }
     while (distance > 0) {
         let foundNext = false;
@@ -30,7 +51,7 @@ export async function solveCube2State(state) {
             const combined = nextPerm * ORIENTATION_COUNT + nextOrient;
             const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
             if (nextDist === nextDistance) {
-                moves.push(BFS_MOVES[m]);
+                moves.push(m);
                 permIndex = nextPerm;
                 orientIndex = nextOrient;
                 distance = nextDistance;
@@ -42,11 +63,7 @@ export async function solveCube2State(state) {
             throw new Error("BFS distance table corrupted or unreachable state.");
         }
     }
-    return {
-        moves,
-        depth: moves.length,
-        state: createSolvedCube2State()
-    };
+    return moves;
 }
 const MOVE_INDEX = {};
 for (let i = 0; i < BFS_MOVES.length; i++) {
@@ -74,3 +91,21 @@ export function verifyCube2Solution(state, solutionMoves) {
     const { permIndex, orientIndex } = walkCube2Coordinates(encodePermutation(state.corners.permutation), encodeOrientation(state.corners.orientation), solutionMoves);
     return permIndex === 0 && orientIndex === 0;
 }
+// Numeric verification for the hot scramble path: walks the solution (move
+// indices, walk order) from the target state to solved. The scramble is the
+// exact inverse of the solution, so this is equivalent to verifying that the
+// scramble reproduces the target state — one walk, no string parsing.
+export function verifyCube2SolutionIndices(state, solution) {
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    if (!permTable || !orientTable) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let permIndex = encodePermutation(state.corners.permutation);
+    let orientIndex = encodeOrientation(state.corners.orientation);
+    for (const m of solution) {
+        permIndex = permTable[permIndex * MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * MOVE_COUNT + m];
+    }
+    return permIndex === 0 && orientIndex === 0;
+}

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

@@ -7,6 +7,7 @@ export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
 export declare let DISTANCES: Uint8Array | null;
 export declare function ensureTablesLoaded(): Promise<void>;
+export declare function areCube2TablesLoaded(): boolean;
 export declare function getDistance(permIndex: number, orientIndex: number): number;
 export declare function getPermutationTransition(move: number, permIndex: number): number;
 export declare function getOrientationTransition(move: number, orientIndex: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}

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

@@ -52,6 +52,9 @@ export async function ensureTablesLoaded() {
     DISTANCES = tables.distances;
     tablesLoaded = true;
 }
+export function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

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

@@ -1,6 +1,7 @@
 import type { Cube2State, Cube2ValidationResult } from "./types.js";
 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":"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;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

@@ -31,7 +31,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-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,63 @@
 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");
+const tables_js_1 = require("./solver/tables.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). Coordinates are
+        // encoded once for both checks.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || (0, validation_js_1.isAllowedRandomCube2State)(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        const p = (0, tables_js_1.encodePermutation)(state.corners.permutation);
+        const o = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
+        if (!(0, validation_js_1.isTrivialSamplingCube2State)(p, o)) {
             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
+        }
+    };
 }

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

@@ -6,6 +6,9 @@ const moves_js_1 = require("./moves.js");
 const random_state_js_1 = require("./random-state.js");
 const facelets_js_1 = require("./facelets.js");
 const index_js_1 = require("./solver/index.js");
+// BFS_MOVES = [U, U2, U', R, R2, R', F, F2, F'] — the inverse of index m is
+// CUBE2_MOVE_INVERSE[m] (U2/R2/F2 are self-inverse, so m ^ 1 does not apply).
+const CUBE2_MOVE_INVERSE = [2, 1, 0, 5, 4, 3, 8, 7, 6];
 exports.cube2ScrambleGenerator = {
     info: {
         eventId: "222",
@@ -21,20 +24,31 @@ exports.cube2ScrambleGenerator = {
 };
 async function generateCube2Scramble(options = {}) {
     const state = (0, random_state_js_1.generateRandomCube2State)(options);
-    const solution = await (0, index_js_1.solveCube2State)(state);
-    const scrambleMoves = (0, moves_js_1.invertCube2Algorithm)(solution.moves);
+    const solution = (0, index_js_1.areCube2TablesLoaded)()
+        ? (0, index_js_1.solveCube2StateIndicesSync)(state)
+        : await (0, index_js_1.solveCube2StateIndices)(state);
+    const depth = solution.length;
+    // Scramble = inverse of the solution, reversed.
+    const scrambleMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        scrambleMoves[index] = index_js_1.BFS_MOVES[CUBE2_MOVE_INVERSE[solution[depth - 1 - index]]];
+    }
     if (!options.skipValidation) {
-        if (!(0, index_js_1.verifyCube2Scramble)(state, scrambleMoves)) {
+        // The scramble is the exact inverse of the solution, so verifying that
+        // the solution solves the target state is equivalent to verifying that
+        // the scramble reproduces it — a single numeric walk suffices.
+        if (!(0, index_js_1.verifyCube2SolutionIndices)(state, solution)) {
             throw new Error("Generated 2x2 scramble does not reproduce the target random state.");
         }
-        if (!(0, index_js_1.verifyCube2Solution)(state, solution.moves)) {
-            throw new Error("Generated 2x2 solution does not solve the target random state.");
-        }
         if (scrambleMoves.length < 2) {
             throw new Error("Generated 2x2 scramble is too short.");
         }
     }
     const facelets = (0, facelets_js_1.toCube2Facelets)(state);
+    const solutionMoves = new Array(depth);
+    for (let index = 0; index < depth; index += 1) {
+        solutionMoves[index] = index_js_1.BFS_MOVES[solution[index]];
+    }
     const result = {
         eventId: "222",
         scramble: (0, moves_js_1.formatCube2Algorithm)(scrambleMoves),
@@ -45,8 +59,8 @@ async function generateCube2Scramble(options = {}) {
             state,
             facelets,
             faceletString: (0, facelets_js_1.formatCube2Facelets)(facelets),
-            solutionMoves: solution.moves,
-            solutionDepth: solution.depth
+            solutionMoves,
+            solutionDepth: depth
         }
     };
     if (options.seed !== undefined) {

package/dist-cjs/puzzles/cube2/solver/index.js

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyCube2Solution = exports.verifyCube2Scramble = exports.solveCube2State = void 0;
+exports.PERMUTATION_TABLE = exports.ORIENTATION_TABLE = exports.ORIENTATION_COUNT = exports.MOVE_COUNT = exports.getOrientationTransition = exports.getPermutationTransition = exports.getDistance = exports.encodeOrientation = exports.encodePermutation = exports.ensureTablesLoaded = exports.DISTANCES = exports.BFS_MOVES = exports.areCube2TablesLoaded = exports.verifyCube2SolutionIndices = exports.verifyCube2Solution = exports.verifyCube2Scramble = exports.solveCube2StateIndicesSync = exports.solveCube2StateIndices = exports.solveCube2State = void 0;
 var search_js_1 = require("./search.js");
 Object.defineProperty(exports, "solveCube2State", { enumerable: true, get: function () { return search_js_1.solveCube2State; } });
+Object.defineProperty(exports, "solveCube2StateIndices", { enumerable: true, get: function () { return search_js_1.solveCube2StateIndices; } });
+Object.defineProperty(exports, "solveCube2StateIndicesSync", { enumerable: true, get: function () { return search_js_1.solveCube2StateIndicesSync; } });
 Object.defineProperty(exports, "verifyCube2Scramble", { enumerable: true, get: function () { return search_js_1.verifyCube2Scramble; } });
 Object.defineProperty(exports, "verifyCube2Solution", { enumerable: true, get: function () { return search_js_1.verifyCube2Solution; } });
+Object.defineProperty(exports, "verifyCube2SolutionIndices", { enumerable: true, get: function () { return search_js_1.verifyCube2SolutionIndices; } });
+var tables_js_1 = require("./tables.js");
+Object.defineProperty(exports, "areCube2TablesLoaded", { enumerable: true, get: function () { return tables_js_1.areCube2TablesLoaded; } });
+Object.defineProperty(exports, "BFS_MOVES", { enumerable: true, get: function () { return tables_js_1.BFS_MOVES; } });
+Object.defineProperty(exports, "DISTANCES", { enumerable: true, get: function () { return tables_js_1.DISTANCES; } });
+Object.defineProperty(exports, "ensureTablesLoaded", { enumerable: true, get: function () { return tables_js_1.ensureTablesLoaded; } });
+Object.defineProperty(exports, "encodePermutation", { enumerable: true, get: function () { return tables_js_1.encodePermutation; } });
+Object.defineProperty(exports, "encodeOrientation", { enumerable: true, get: function () { return tables_js_1.encodeOrientation; } });
+Object.defineProperty(exports, "getDistance", { enumerable: true, get: function () { return tables_js_1.getDistance; } });
+Object.defineProperty(exports, "getPermutationTransition", { enumerable: true, get: function () { return tables_js_1.getPermutationTransition; } });
+Object.defineProperty(exports, "getOrientationTransition", { enumerable: true, get: function () { return tables_js_1.getOrientationTransition; } });
+Object.defineProperty(exports, "MOVE_COUNT", { enumerable: true, get: function () { return tables_js_1.MOVE_COUNT; } });
+Object.defineProperty(exports, "ORIENTATION_COUNT", { enumerable: true, get: function () { return tables_js_1.ORIENTATION_COUNT; } });
+Object.defineProperty(exports, "ORIENTATION_TABLE", { enumerable: true, get: function () { return tables_js_1.ORIENTATION_TABLE; } });
+Object.defineProperty(exports, "PERMUTATION_TABLE", { enumerable: true, get: function () { return tables_js_1.PERMUTATION_TABLE; } });

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

@@ -1,12 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solveCube2State = solveCube2State;
+exports.solveCube2StateIndices = solveCube2StateIndices;
+exports.solveCube2StateIndicesSync = solveCube2StateIndicesSync;
 exports.verifyCube2Scramble = verifyCube2Scramble;
 exports.verifyCube2Solution = verifyCube2Solution;
+exports.verifyCube2SolutionIndices = verifyCube2SolutionIndices;
 const state_js_1 = require("../state.js");
 const tables_js_1 = require("./tables.js");
 async function solveCube2State(state) {
     await (0, tables_js_1.ensureTablesLoaded)();
+    const indices = solveWithTablesIndices(state);
+    return {
+        moves: indices.map((index) => tables_js_1.BFS_MOVES[index]),
+        depth: indices.length,
+        state: (0, state_js_1.createSolvedCube2State)()
+    };
+}
+// Index-based solve for the hot scramble path: returns the solution as move
+// indices (0..8) in walk order. The inverse of index m is CUBE2_MOVE_INVERSE[m]
+// (U2/R2/F2 are self-inverse, so m ^ 1 does not apply here).
+async function solveCube2StateIndices(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    return solveWithTablesIndices(state);
+}
+function solveCube2StateIndicesSync(state) {
+    if (!tables_js_1.DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return solveWithTablesIndices(state);
+}
+function solveWithTablesIndices(state) {
     if (state.corners.permutation[6] !== 6 || state.corners.orientation[6] !== 0) {
         throw new Error("The 2x2 solver requires the DBL corner (index 6) to be solved " +
             "as the frame of reference. Please normalize the state before solving.");
@@ -21,7 +45,7 @@ async function solveCube2State(state) {
     const initialCombined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
     if (distance === 0) {
-        return { moves, depth: 0, state: (0, state_js_1.createSolvedCube2State)() };
+        return moves;
     }
     while (distance > 0) {
         let foundNext = false;
@@ -35,7 +59,7 @@ async function solveCube2State(state) {
             const combined = nextPerm * tables_js_1.ORIENTATION_COUNT + nextOrient;
             const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
             if (nextDist === nextDistance) {
-                moves.push(tables_js_1.BFS_MOVES[m]);
+                moves.push(m);
                 permIndex = nextPerm;
                 orientIndex = nextOrient;
                 distance = nextDistance;
@@ -47,11 +71,7 @@ async function solveCube2State(state) {
             throw new Error("BFS distance table corrupted or unreachable state.");
         }
     }
-    return {
-        moves,
-        depth: moves.length,
-        state: (0, state_js_1.createSolvedCube2State)()
-    };
+    return moves;
 }
 const MOVE_INDEX = {};
 for (let i = 0; i < tables_js_1.BFS_MOVES.length; i++) {
@@ -79,3 +99,21 @@ function verifyCube2Solution(state, solutionMoves) {
     const { permIndex, orientIndex } = walkCube2Coordinates((0, tables_js_1.encodePermutation)(state.corners.permutation), (0, tables_js_1.encodeOrientation)(state.corners.orientation), solutionMoves);
     return permIndex === 0 && orientIndex === 0;
 }
+// Numeric verification for the hot scramble path: walks the solution (move
+// indices, walk order) from the target state to solved. The scramble is the
+// exact inverse of the solution, so this is equivalent to verifying that the
+// scramble reproduces the target state — one walk, no string parsing.
+function verifyCube2SolutionIndices(state, solution) {
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    if (!permTable || !orientTable) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
+    let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
+    for (const m of solution) {
+        permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];
+    }
+    return permIndex === 0 && orientIndex === 0;
+}

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

@@ -4,6 +4,7 @@ exports.BFS_MOVES = exports.DISTANCES = exports.ORIENTATION_TABLE = exports.PERM
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.areCube2TablesLoaded = areCube2TablesLoaded;
 exports.getDistance = getDistance;
 exports.getPermutationTransition = getPermutationTransition;
 exports.getOrientationTransition = getOrientationTransition;
@@ -61,6 +62,9 @@ async function ensureTablesLoaded() {
     exports.DISTANCES = tables.distances;
     tablesLoaded = true;
 }
+function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCube2State = validateCube2State;
 exports.isOneMoveFromSolvedCube2State = isOneMoveFromSolvedCube2State;
+exports.isTrivialSamplingCube2State = isTrivialSamplingCube2State;
 exports.isAllowedRandomCube2State = isAllowedRandomCube2State;
 exports.permutationParity = permutationParity;
 const types_js_1 = require("./types.js");
@@ -37,7 +38,13 @@ function validateCube2State(state) {
 function isOneMoveFromSolvedCube2State(state) {
     const p = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     const o = (0, tables_js_1.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).
+function isTrivialSamplingCube2State(p, o) {
+    return (p === 0 && o === 0) || ONE_MOVE_FROM_SOLVED_ENCODED.some((entry) => entry.p === p && entry.o === o);
 }
 function isAllowedRandomCube2State(state) {
     return validateCube2State(state).valid &&

package/package.json

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