@cubingcenter/scrambler 0.5.2 → 0.5.3

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":"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"}
+{"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,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,CA8BP;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAa1C;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,CAuBzD;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"}

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/random-state.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRandomCube2State = generateRandomCube2State;
 const index_js_1 = require("../../random/index.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;
@@ -11,15 +10,10 @@ function generateRandomCube2State(options = {}) {
         // 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.
+        // single-move states (scrambles shorter than 2 moves), compared by
+        // arrays — no coordinate encodings in this hot path.
         const state = createLegalRandomState(random);
-        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)) {
+        if (!rejectTrivial || !(0, validation_js_1.isTrivialCube2State)(state)) {
             return state;
         }
     }

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

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

package/dist-cjs/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-cjs/puzzles/cube2/solver/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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.POLICY_TABLE = 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; } });
@@ -11,7 +11,7 @@ Object.defineProperty(exports, "verifyCube2SolutionIndices", { enumerable: true,
 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, "POLICY_TABLE", { enumerable: true, get: function () { return tables_js_1.POLICY_TABLE; } });
 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; } });

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

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

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

@@ -25,7 +25,7 @@ async function solveCube2StateIndices(state) {
     return solveWithTablesIndices(state);
 }
 function solveCube2StateIndicesSync(state) {
-    if (!tables_js_1.DISTANCES) {
+    if (!tables_js_1.POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
     return solveWithTablesIndices(state);
@@ -37,39 +37,19 @@ function solveWithTablesIndices(state) {
     }
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
-    const distances = tables_js_1.DISTANCES;
+    const policy = tables_js_1.POLICY_TABLE;
     let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
     let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
     const moves = [];
-    // High-performance branchless inlined lookup
-    const initialCombined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
-    let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
-    if (distance === 0) {
-        return moves;
-    }
-    while (distance > 0) {
-        let foundNext = false;
-        const permOffset = permIndex * tables_js_1.MOVE_COUNT;
-        const orientOffset = orientIndex * tables_js_1.MOVE_COUNT;
-        const nextDistance = distance - 1;
-        for (let m = 0; m < tables_js_1.BFS_MOVES.length; m++) {
-            const nextPerm = permTable[permOffset + m];
-            const nextOrient = orientTable[orientOffset + m];
-            // High-performance branchless inlined lookup
-            const combined = nextPerm * tables_js_1.ORIENTATION_COUNT + nextOrient;
-            const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
-            if (nextDist === nextDistance) {
-                moves.push(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 * tables_js_1.ORIENTATION_COUNT + orientIndex;
+    while (combined !== 0) {
+        const m = (policy[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        moves.push(m);
+        permIndex = permTable[permIndex * tables_js_1.MOVE_COUNT + m];
+        orientIndex = orientTable[orientIndex * tables_js_1.MOVE_COUNT + m];
+        combined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
     }
     return moves;
 }

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

@@ -10,9 +10,9 @@ exports.CUBE2_SOLVER_TABLE_METADATA = {
         entries: 6561,
         checksum: 1566738619
     },
-    distances: {
+    policy: {
         entries: 1837080,
-        checksum: 2959532459,
+        checksum: 2042005723,
         maxDepth: 11
     }
 };

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BFS_MOVES = exports.DISTANCES = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.BFS_MOVES = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
 exports.encodePermutation = encodePermutation;
 exports.encodeOrientation = encodeOrientation;
 exports.ensureTablesLoaded = ensureTablesLoaded;
@@ -15,19 +15,31 @@ exports.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];
 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;
+}
 function encodeOrientation(orientation) {
     const orient7 = orientation.filter((_, i) => i !== 6);
     let index = 0;
@@ -51,7 +63,7 @@ function factorialSmall(n) {
 let tablesLoaded = false;
 exports.PERMUTATION_TABLE = null;
 exports.ORIENTATION_TABLE = null;
-exports.DISTANCES = null;
+exports.POLICY_TABLE = null;
 async function ensureTablesLoaded() {
     if (tablesLoaded) {
         return;
@@ -59,7 +71,7 @@ async function ensureTablesLoaded() {
     const tables = await (0, generated_assets_js_1.loadGeneratedCube2SolverTables)();
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;
-    exports.DISTANCES = tables.distances;
+    exports.POLICY_TABLE = tables.policyTable;
     tablesLoaded = true;
 }
 function areCube2TablesLoaded() {
@@ -69,12 +81,23 @@ function areCube2TablesLoaded() {
 // Public API
 // ---------------------------------------------------------------------------
 function getDistance(permIndex, orientIndex) {
-    if (!exports.DISTANCES) {
+    if (!exports.POLICY_TABLE) {
         throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
     }
-    const combined = permIndex * exports.ORIENTATION_COUNT + orientIndex;
-    const byteValue = exports.DISTANCES[combined >> 1];
-    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+    const permTable = exports.PERMUTATION_TABLE;
+    const orientTable = exports.ORIENTATION_TABLE;
+    let p = permIndex;
+    let o = orientIndex;
+    let combined = p * exports.ORIENTATION_COUNT + o;
+    let distance = 0;
+    while (combined !== 0) {
+        const m = (exports.POLICY_TABLE[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+        p = permTable[p * exports.MOVE_COUNT + m];
+        o = orientTable[o * exports.MOVE_COUNT + m];
+        combined = p * exports.ORIENTATION_COUNT + o;
+        distance += 1;
+    }
+    return distance;
 }
 function getPermutationTransition(move, permIndex) {
     if (!exports.PERMUTATION_TABLE) {

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

@@ -25,8 +25,10 @@ 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();
 function isSolvedCube2State(state) {
-    return cube2StatesEqual(state, createSolvedCube2State());
+    return cube2StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrivialCube2State = isTrivialCube2State;
 exports.validateCube2State = validateCube2State;
 exports.isOneMoveFromSolvedCube2State = isOneMoveFromSolvedCube2State;
 exports.isTrivialSamplingCube2State = isTrivialSamplingCube2State;
@@ -9,16 +10,47 @@ const types_js_1 = require("./types.js");
 const moves_js_1 = require("./moves.js");
 const state_js_1 = require("./state.js");
 const tables_js_1 = require("./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 = types_js_1.CUBE2_MOVES.map((move) => (0, moves_js_1.applyCube2Move)((0, state_js_1.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 = types_js_1.CUBE2_MOVES.map((move) => {
-    const state = (0, moves_js_1.applyCube2Move)((0, state_js_1.createSolvedCube2State)(), move);
-    return {
-        p: (0, tables_js_1.encodePermutation)(state.corners.permutation),
-        o: (0, tables_js_1.encodeOrientation)(state.corners.orientation)
-    };
-});
+const ONE_MOVE_FROM_SOLVED_ENCODED = ONE_MOVE_FROM_SOLVED_STATES.map((state) => ({
+    p: (0, tables_js_1.encodePermutation)(state.corners.permutation),
+    o: (0, tables_js_1.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).
+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 (0, state_js_1.isSolvedCube2State)(state);
+}
 function validateCube2State(state) {
     const errors = [
         ...validatePermutation("corner", state.corners.permutation, types_js_1.CORNER_COUNT),

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

@@ -4,6 +4,8 @@ exports.toCube3Facelets = toCube3Facelets;
 exports.formatCube3Facelets = formatCube3Facelets;
 exports.getCube3FaceOrder = getCube3FaceOrder;
 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"],
@@ -52,20 +54,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]];
+    }
+}
 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;
 }
@@ -75,20 +117,3 @@ function formatCube3Facelets(facelets) {
 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-cjs/puzzles/cube3/random-state.js

@@ -4,6 +4,7 @@ exports.generateRandomCube3State = generateRandomCube3State;
 const index_js_1 = require("../../random/index.js");
 const types_js_1 = require("./types.js");
 const validation_js_1 = require("./validation.js");
+const state_js_1 = require("./state.js");
 const subset_state_js_1 = require("./subset-state.js");
 function generateRandomCube3State(options = {}) {
     const random = (0, index_js_1.createRandomSource)(options.seed);
@@ -12,8 +13,14 @@ function generateRandomCube3State(options = {}) {
         return (0, subset_state_js_1.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 || (0, validation_js_1.isAllowedRandomCube3State)(state)) {
+        if (!rejectTrivial) {
+            return state;
+        }
+        if (!(0, state_js_1.isSolvedCube3State)(state) && !(0, validation_js_1.isOneMoveFromSolvedCube3State)(state)) {
             return state;
         }
     }

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

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

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

@@ -17,6 +17,9 @@ 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();
 function cloneCube3State(state) {
     return {
         corners: {
@@ -36,7 +39,7 @@ function cube3StatesEqual(left, right) {
         arraysEqual(left.edges.orientation, right.edges.orientation));
 }
 function isSolvedCube3State(state) {
-    return cube3StatesEqual(state, createSolvedCube3State());
+    return cube3StatesEqual(state, SOLVED_STATE);
 }
 function range(length) {
     return Array.from({ length }, (_, index) => index);