@cubingcenter/scrambler 0.5.1 → 0.5.3

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;AAGtE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAiB1F"}

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

@@ -1,51 +1,55 @@
 import { createRandomSource } from "../../random/index.js";
-import { CORNER_COUNT } from "./types.js";
-import { isAllowedRandomCube2State } from "./validation.js";
+import { isTrivialCube2State } from "./validation.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), compared by
+        // arrays — no coordinate encodings in this hot path.
         const state = createLegalRandomState(random);
-        if (!rejectTrivial || isAllowedRandomCube2State(state)) {
+        if (!rejectTrivial || !isTrivialCube2State(state)) {
             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/browser-loader.d.ts

@@ -1,12 +1,12 @@
 export declare function getCachedBrowserTables(): {
     permutationTable: Uint16Array;
     orientationTable: Uint16Array;
-    distances: Uint8Array;
+    policyTable: Uint8Array;
 } | undefined;
 export declare function clearCachedBrowserTables(): void;
 export declare function loadBrowserTables(baseUrl?: string): Promise<{
     permutationTable: Uint16Array;
     orientationTable: Uint16Array;
-    distances: Uint8Array;
+    policyTable: Uint8Array;
 }>;
 //# sourceMappingURL=browser-loader.d.ts.map

package/dist/puzzles/cube2/solver/browser-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB;sBALlB,WAAW;sBACX,WAAW;eAClB,UAAU;cAKtB;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAAC,CAqBD"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/browser-loader.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB;sBALlB,WAAW;sBACX,WAAW;iBAChB,UAAU;cAKxB;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjE,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAqBD"}

package/dist/puzzles/cube2/solver/browser-loader.js

@@ -17,12 +17,12 @@ export async function loadBrowserTables(baseUrl) {
     const [permTable, orientTable, dist] = await Promise.all([
         fetchUint16Table(resolved, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable.entries),
         fetchUint16Table(resolved, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.entries),
-        fetchUint8Table(resolved, manifest.files.distances, CUBE2_SOLVER_TABLE_METADATA.distances.entries)
+        fetchUint8Table(resolved, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy.entries)
     ]);
     cachedBrowserTables = {
         permutationTable: permTable,
         orientationTable: orientTable,
-        distances: dist
+        policyTable: dist
     };
     return cachedBrowserTables;
 }

package/dist/puzzles/cube2/solver/generated/manifest.json

@@ -11,10 +11,10 @@
       "entries": 6561,
       "checksum": 1566738619
     },
-    "distances": {
-      "file": "distances.bin",
+    "policy": {
+      "file": "policy.bin",
       "entries": 1837080,
-      "checksum": 2959532459,
+      "checksum": 2042005723,
       "maxDepth": 11
     }
   }

package/dist/puzzles/cube2/solver/generated-assets.d.ts

@@ -1,6 +1,6 @@
 export declare function loadGeneratedCube2SolverTables(): Promise<{
     permutationTable: Uint16Array;
     orientationTable: Uint16Array;
-    distances: Uint8Array;
+    policyTable: Uint8Array;
 }>;
 //# sourceMappingURL=generated-assets.d.ts.map

package/dist/puzzles/cube2/solver/generated-assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAAC,CAeD"}
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC,CAeD"}

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, POLICY_TABLE, 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,YAAY,EACZ,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, POLICY_TABLE, ensureTablesLoaded, encodePermutation, encodeOrientation, getDistance, getPermutationTransition, getOrientationTransition, MOVE_COUNT, ORIENTATION_COUNT, ORIENTATION_TABLE, PERMUTATION_TABLE } from "./tables.js";

package/dist/puzzles/cube2/solver/node-loader.d.ts

@@ -1,6 +1,6 @@
 export declare function readGeneratedCube2SolverTables(): {
     permutationTable: Uint16Array;
     orientationTable: Uint16Array;
-    distances: Uint8Array;
+    policyTable: Uint8Array;
 };
 //# sourceMappingURL=node-loader.d.ts.map

package/dist/puzzles/cube2/solver/node-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/node-loader.ts"],"names":[],"mappings":"AAgBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAmBA"}
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/node-loader.ts"],"names":[],"mappings":"AAgBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,WAAW,EAAE,UAAU,CAAC;CACzB,CAmBA"}

package/dist/puzzles/cube2/solver/node-loader.js

@@ -11,11 +11,11 @@ export function readGeneratedCube2SolverTables() {
     }
     const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, CUBE2_SOLVER_TABLE_METADATA.permutationTable.checksum);
     const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.checksum);
-    const distances = readUint8Table(assetDirectory, manifest.files.distances, CUBE2_SOLVER_TABLE_METADATA.distances.checksum);
+    const policyTable = readUint8Table(assetDirectory, manifest.files.policy, CUBE2_SOLVER_TABLE_METADATA.policy.checksum);
     return {
         permutationTable,
         orientationTable,
-        distances
+        policyTable
     };
 }
 function readUint16Table(assetDirectory, entry, expectedChecksum) {

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;AAoDD,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

@@ -1,52 +1,49 @@
 import { createSolvedCube2State } from "../state.js";
-import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, DISTANCES, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
+import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, POLICY_TABLE, 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 (!POLICY_TABLE) {
+        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.");
     }
     const permTable = PERMUTATION_TABLE;
     const orientTable = ORIENTATION_TABLE;
-    const distances = DISTANCES;
+    const policy = POLICY_TABLE;
     let permIndex = encodePermutation(state.corners.permutation);
     let orientIndex = encodeOrientation(state.corners.orientation);
     const moves = [];
-    // High-performance branchless inlined lookup
-    const initialCombined = permIndex * ORIENTATION_COUNT + orientIndex;
-    let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
-    if (distance === 0) {
-        return { moves, depth: 0, state: createSolvedCube2State() };
-    }
-    while (distance > 0) {
-        let foundNext = false;
-        const permOffset = permIndex * MOVE_COUNT;
-        const orientOffset = orientIndex * MOVE_COUNT;
-        const nextDistance = distance - 1;
-        for (let m = 0; m < BFS_MOVES.length; m++) {
-            const nextPerm = permTable[permOffset + m];
-            const nextOrient = orientTable[orientOffset + m];
-            // High-performance branchless inlined lookup
-            const combined = nextPerm * ORIENTATION_COUNT + nextOrient;
-            const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
-            if (nextDist === nextDistance) {
-                moves.push(BFS_MOVES[m]);
-                permIndex = nextPerm;
-                orientIndex = nextOrient;
-                distance = nextDistance;
-                foundNext = true;
-                break;
-            }
-        }
-        if (!foundNext) {
-            throw new Error("BFS distance table corrupted or unreachable state.");
-        }
+    // Direct policy walk: the precomputed optimal move per state, so no
+    // candidate scanning (the old BFS-distance gradient walk) is needed.
+    let combined = permIndex * ORIENTATION_COUNT + orientIndex;
+    while (combined !== 0) {
+        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        moves.push(m);
+        permIndex = permTable[permIndex * MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * MOVE_COUNT + m];
+        combined = permIndex * ORIENTATION_COUNT + orientIndex;
     }
-    return {
-        moves,
-        depth: moves.length,
-        state: createSolvedCube2State()
-    };
+    return moves;
 }
 const MOVE_INDEX = {};
 for (let i = 0; i < BFS_MOVES.length; i++) {
@@ -74,3 +71,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/table-metadata.d.ts

@@ -7,9 +7,9 @@ export declare const CUBE2_SOLVER_TABLE_METADATA: {
         readonly entries: 6561;
         readonly checksum: 1566738619;
     };
-    readonly distances: {
+    readonly policy: {
         readonly entries: 1837080;
-        readonly checksum: 2959532459;
+        readonly checksum: 2042005723;
         readonly maxDepth: 11;
     };
 };

package/dist/puzzles/cube2/solver/table-metadata.js

@@ -7,9 +7,9 @@ export const CUBE2_SOLVER_TABLE_METADATA = {
         entries: 6561,
         checksum: 1566738619
     },
-    distances: {
+    policy: {
         entries: 1837080,
-        checksum: 2959532459,
+        checksum: 2042005723,
         maxDepth: 11
     }
 };

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

@@ -5,8 +5,9 @@ export declare function encodePermutation(permutation: readonly number[]): numbe
 export declare function encodeOrientation(orientation: readonly number[]): number;
 export declare let PERMUTATION_TABLE: Uint16Array | null;
 export declare let ORIENTATION_TABLE: Uint16Array | null;
-export declare let DISTANCES: Uint8Array | null;
+export declare let POLICY_TABLE: 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;AAW5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYxE;AAWD,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,YAAY,EAAE,UAAU,GAAG,IAAW,CAAC;AAElD,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,CAkB1E;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

@@ -5,19 +5,31 @@ export const MOVE_COUNT = 9;
 // ---------------------------------------------------------------------------
 // Coordinate encoding / decoding
 // ---------------------------------------------------------------------------
+// Lehmer encoding of the 7 free corners (DBL at index 6 is fixed), with a
+// bitmask instead of array removal: available values tracked as bits, the
+// rank of a value = the popcount of the bits below it.
+const PERM7_FACT = [720, 120, 24, 6, 2, 1, 1];
 export function encodePermutation(permutation) {
-    const perm7 = permutation.filter((_, i) => i !== 6);
-    const mapped = perm7.map((x) => (x > 6 ? x - 1 : x));
     let index = 0;
-    const available = [0, 1, 2, 3, 4, 5, 6];
+    let available = 0b1111111;
     for (let position = 0; position < 7; position += 1) {
-        const value = mapped[position];
-        const selected = available.indexOf(value);
-        index += selected * factorialSmall(6 - position);
-        available.splice(selected, 1);
+        const permPosition = position < 6 ? position : position + 1;
+        const piece = permutation[permPosition];
+        const value = piece > 6 ? piece - 1 : piece;
+        const rank = popcount(available & ((1 << value) - 1));
+        index += rank * PERM7_FACT[position];
+        available &= ~(1 << value);
     }
     return index;
 }
+function popcount(x) {
+    let count = 0;
+    while (x !== 0) {
+        x &= x - 1;
+        count += 1;
+    }
+    return count;
+}
 export function encodeOrientation(orientation) {
     const orient7 = orientation.filter((_, i) => i !== 6);
     let index = 0;
@@ -41,7 +53,7 @@ function factorialSmall(n) {
 let tablesLoaded = false;
 export let PERMUTATION_TABLE = null;
 export let ORIENTATION_TABLE = null;
-export let DISTANCES = null;
+export let POLICY_TABLE = null;
 export async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -49,19 +61,33 @@ export async function ensureTablesLoaded() {
     const tables = await loadGeneratedCube2SolverTables();
     PERMUTATION_TABLE = tables.permutationTable;
     ORIENTATION_TABLE = tables.orientationTable;
-    DISTANCES = tables.distances;
+    POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
+export function areCube2TablesLoaded() {
+    return tablesLoaded;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 export function getDistance(permIndex, orientIndex) {
-    if (!DISTANCES) {
+    if (!POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
-    const combined = permIndex * ORIENTATION_COUNT + orientIndex;
-    const byteValue = DISTANCES[combined >> 1];
-    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+    const permTable = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    let p = permIndex;
+    let o = orientIndex;
+    let combined = p * ORIENTATION_COUNT + o;
+    let distance = 0;
+    while (combined !== 0) {
+        const m = (POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        p = permTable[p * MOVE_COUNT + m];
+        o = orientTable[o * MOVE_COUNT + m];
+        combined = p * ORIENTATION_COUNT + o;
+        distance += 1;
+    }
+    return distance;
 }
 export function getPermutationTransition(move, permIndex) {
     if (!PERMUTATION_TABLE) {

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

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