@cubingcenter/scrambler 0.6.3 → 0.7.0

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

@@ -4,9 +4,9 @@
  * the reduction solver (phases 1-4), and invert the solution. The scramble
  * always reproduces the sampled target state and facelets exactly.
  *
- * If the solver fails after 5 attempts it falls back to cubing.js
- * `randomScrambleForEvent("444")` (also random-state). If that also fails,
- * a WCA-compatible random-moves sequence (40 moves) is returned.
+ * Reduction-only, no resampling: each call runs one round of up to `bestOf`
+ * independent attempts and returns the shortest success (ties keep the
+ * lowest job index). If every attempt fails, the last error is thrown.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -44,100 +44,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cube4ScrambleGenerator = void 0;
 exports.generateCube4Scramble = generateCube4Scramble;
+exports.generateCube4Attempt = generateCube4Attempt;
 const moves_js_1 = require("./moves.js");
 const random_state_js_1 = require("./random-state.js");
 const state_js_1 = require("./state.js");
 const facelets_js_1 = require("./facelets.js");
 const solve_js_1 = require("./reduction/solve.js");
 const index_js_1 = require("../cube3/solver/index.js");
-const index_js_2 = require("../../random/index.js");
-// ────────────────────────────────────────────────────────────
-// cubing.js fallback (random-state, WCA-compliant)
-// ────────────────────────────────────────────────────────────
-/**
- * Try to generate a 4x4 scramble using cubing.js `randomScrambleForEvent`.
- * Uses a dynamic import so browser bundles can tree-shake it when unused.
- * Returns null if cubing.js is unavailable.
- */
-async function generateCube4WithCubingJs() {
-    try {
-        const { randomScrambleForEvent } = await Promise.resolve().then(() => __importStar(require(
-        /* webpackIgnore: true */
-        /* @vite-ignore */
-        "cubing/scramble")));
-        const alg = await randomScrambleForEvent("444");
-        const scramble = alg.toString();
-        const moves = scramble.trim().split(/\s+/);
-        return {
-            eventId: "444",
-            scramble,
-            moves,
-            quality: "random-state",
-            generator: "cubing-js",
-            metadata: {
-                generator: "cubing-js",
-                distribution: "random-state",
-                note: "Generated by cubing.js randomScrambleForEvent as fallback."
-            }
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ────────────────────────────────────────────────────────────
-// Last-resort: random-moves (no external dep, always works)
-// ────────────────────────────────────────────────────────────
-const CUBE4_FACES = ["U", "R", "F", "D", "L", "B"];
-// Opposite face indices (U↔D, R↔L, F↔B)
-const CUBE4_OPPOSITE = { U: "D", D: "U", R: "L", L: "R", F: "B", B: "F" };
-const CUBE4_SUFFIXES = ["", "2", "'"];
-const CUBE4_WIDE_FACES = ["Uw", "Rw", "Fw", "Dw", "Lw", "Bw"];
-// Opposite wide-move faces
-const CUBE4_WIDE_OPPOSITE = {
-    Uw: "Dw", Dw: "Uw", Rw: "Lw", Lw: "Rw", Fw: "Bw", Bw: "Fw"
-};
-// All available move bases (outer + wide). Outer and wide turns are treated
-// independently for the same-face/opposite-face check using their base letter.
-const ALL_MOVE_BASES = [...CUBE4_FACES, ...CUBE4_WIDE_FACES];
-function generateCube4RandomMoves(options = {}) {
-    const rng = (0, index_js_2.createRandomSource)(options.seed);
-    const moveCount = 40;
-    const moves = [];
-    let lastFace = null;
-    let secondLastFace = null;
-    const getBaseLetter = (face) => face.length > 1 ? face[0] : face;
-    for (let i = 0; i < moveCount; i++) {
-        let face;
-        // Reject same face as last or opposite face when the last two moves
-        // share the same axis (to avoid redundant move pairs like R L R).
-        do {
-            face = ALL_MOVE_BASES[rng.nextInt(ALL_MOVE_BASES.length)];
-        } while (face === lastFace ||
-            (lastFace !== null &&
-                (CUBE4_OPPOSITE[face] === lastFace || CUBE4_WIDE_OPPOSITE[face] === lastFace) &&
-                secondLastFace !== null &&
-                getBaseLetter(secondLastFace) === getBaseLetter(face)));
-        const suffix = CUBE4_SUFFIXES[rng.nextInt(3)];
-        moves.push(`${face}${suffix}`);
-        secondLastFace = lastFace;
-        lastFace = face;
-    }
-    const scramble = moves.join(" ");
-    return {
-        eventId: "444",
-        scramble,
-        moves,
-        quality: "random-moves",
-        generator: "cube4-random-moves-fallback",
-        metadata: {
-            generator: "cube4-random-moves-fallback",
-            distribution: "random-moves",
-            note: "Reduction solver and cubing.js both failed; using random-moves.",
-            ...options.metadata
-        }
-    };
-}
+const tables_js_1 = require("../cube3/solver/tables.js");
+const pair_tables_js_1 = require("../cube3/solver/pair-tables.js");
 // ────────────────────────────────────────────────────────────
 let cachedTables;
 async function loadCube4Tables(baseUrl) {
@@ -177,98 +92,234 @@ exports.cube4ScrambleGenerator = {
         puzzle: "cube-4x4",
         quality: "random-state",
         generator: "cube4-reduction",
-        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish). Falls back to random-moves if the solver fails."
+        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish)."
     },
     generate(options = {}) {
         return generateCube4Scramble(options);
     }
 };
+function invertRotationSequence(rotSeq) {
+    return rotSeq.slice().reverse().map((r) => (r.endsWith("'") ? r.slice(0, -1) : r.endsWith("2") ? r : `${r}'`));
+}
+/** Shortest-first pick (ties keep `a`, i.e. the lowest job index). */
+function shorterScramble(a, b) {
+    if (!a || b.moves.length < a.moves.length)
+        return b;
+    return a;
+}
+function seedForBestJob(options, job) {
+    if (job === 0)
+        return options;
+    const next = { ...options };
+    if (options.seed !== undefined) {
+        next.seed = `${options.seed}:best${job}`;
+    }
+    else {
+        delete next.seed;
+    }
+    return next;
+}
+function isRetryableCube4Error(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const isPhase2Error = typeof error?.name === "string" &&
+        error.name.includes("Cube3Phase2");
+    return (error instanceof Error &&
+        (msg.includes("reduction failed") ||
+            msg.includes("failed to convert") ||
+            msg.includes("no valid phase 2") ||
+            msg.includes("timeout") ||
+            isPhase2Error ||
+            msg.includes("Phase 2 solution not found")));
+}
 async function generateCube4Scramble(options = {}) {
+    const bestOf = Math.max(1, Math.floor(options.bestOf ?? 1) || 1);
     let tables;
+    let pairTables;
     try {
-        tables = await loadCube4Tables();
+        const [loadedTables, cube3P1Tables, loadedPairTables] = await Promise.all([
+            loadCube4Tables(),
+            (0, tables_js_1.loadCube3Phase1Tables)(),
+            (0, pair_tables_js_1.loadCube3PairTables)()
+        ]);
+        tables = loadedTables;
+        tables.cube3Phase1 = cube3P1Tables;
+        tables.pairTables = loadedPairTables;
+        pairTables = loadedPairTables;
     }
     catch (error) {
-        console.warn("[cube4-scrambler] Failed to load reduction tables; using fallback.", error);
-        const cubingJsResult = await generateCube4WithCubingJs();
-        if (cubingJsResult)
-            return cubingJsResult;
-        return generateCube4RandomMoves(options);
+        throw new Error("[cube4-scrambler] Failed to load reduction tables; run pnpm cube4:center1:tables etc. " +
+            `(${error instanceof Error ? error.message : String(error)})`);
     }
+    const totalRestarts = Math.max(1, Math.floor(options.restarts ?? options.bestOf ?? 1) || 1);
     let lastError;
-    // Retry with different states if the solver fails to find a physical
-    // reduction (some random states are outside the solver's effective
-    // horizon with the current candidate/length caps).
-    for (let attempt = 0; attempt < 5; attempt++) {
-        let attemptOptions;
-        if (attempt === 0) {
-            attemptOptions = options;
+    try {
+        return await generateCube4Attempt(tables, pairTables, {
+            ...options,
+            restarts: totalRestarts
+        });
+    }
+    catch (error) {
+        if (!isRetryableCube4Error(error))
+            throw error;
+        lastError = error;
+    }
+    if (!options.deep) {
+        try {
+            return await generateCube4Attempt(tables, pairTables, {
+                ...options,
+                restarts: totalRestarts,
+                deep: true
+            });
         }
-        else {
-            attemptOptions = { ...options };
-            if (options.seed !== undefined) {
-                attemptOptions.seed = `${options.seed}:retry${attempt}`;
-            }
-            else {
-                delete attemptOptions.seed;
-            }
+        catch (error) {
+            if (isRetryableCube4Error(error))
+                lastError = error;
+            else
+                throw error;
         }
-        const attemptState = (0, random_state_js_1.generateRandomCube4State)(attemptOptions);
+    }
+    throw lastError instanceof Error
+        ? lastError
+        : new Error(`[cube4-scrambler] Reduction solver failed for restarts=${totalRestarts}: ${String(lastError)}`);
+}
+/**
+ * Single-attempt 444 solve: samples ONE state (from `options.seed`) and
+ * solves it with the reduction solver. Throws on failure — no resampling.
+ * Fan-out primitive for hosts: run with seeds `seed`, `seed:bestN`, ...
+ * across workers and keep the shortest valid result.
+ */
+async function generateCube4Attempt(tables, pairTables, options = {}) {
+    const attemptState = (0, random_state_js_1.generateRandomCube4State)(options);
+    const axes = options.threeAxes ? [[], ["z"], ["y'"]] : [[]];
+    let bestScrambleMoves = null;
+    let bestSolutionMoves = null;
+    let bestPhases;
+    let bestNodes;
+    let bestTimings;
+    let bestReductionLen;
+    let lastError;
+    const tAttemptStart = performance.now();
+    const finishOpts = options.finish ?? {};
+    for (const rot of axes) {
         try {
-            const solvePromise = (0, solve_js_1.solveCube4State)(attemptState, tables, (cube3State) => (0, index_js_1.solveCube3State)(cube3State));
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("4x4 solve: timeout")), 20000));
-            const { scramble: scrambleMoves } = await Promise.race([solvePromise, timeoutPromise]);
-            if (!options.skipValidation) {
-                const scrambledState = (0, moves_js_1.applyCube4Algorithm)((0, state_js_1.createSolvedCube4State)(), scrambleMoves);
-                if (!(0, state_js_1.cube4StatesEqual)(scrambledState, attemptState)) {
-                    throw new Error("Generated 4x4 scramble does not reproduce the target random state.");
+            const sRot = rot.length === 0 ? attemptState : (0, solve_js_1.applyCubeRotation)(attemptState, rot);
+            // The reduction search is bounded by deterministic work caps (see
+            // solve.ts), so these timeouts are only wall-clock backstops for
+            // pathological cases.
+            const solvePromise = (0, solve_js_1.solveCube4State)(sRot, tables, async (cube3State) => {
+                // Single solver-side best-of-orientations finish call with
+                // extra phase-1 improvement: same lengths as the former
+                // hand-rolled UD/X/Z triple at a fraction of the cost.
+                const solveFinish = async (timeBudget, phase2Budget) => {
+                    const solution = await (0, index_js_1.solveCube3State)(cube3State, {
+                        orientations: finishOpts.orientations ?? 3,
+                        phase1ExtraDepth: finishOpts.phase1ExtraDepth ?? 1,
+                        phase1SolutionLimit: finishOpts.phase1SolutionLimit ?? 24,
+                        targetLength: finishOpts.targetLength ?? 20,
+                        timeoutMs: timeBudget,
+                        // The 54MB pair tables are skipped for the 444 finish: pair
+                        // pruning changes nothing measurable here (identical lengths
+                        // on a 44-state corpus, zero extra finish retries), and
+                        // loading them dominates cold-start I/O. Hosts that already
+                        // hold pairTables can still pass them via generateCube4Attempt.
+                        phase2: { pairTables, skipPairTables: pairTables === undefined, timeoutMs: phase2Budget }
+                    });
+                    return { moves: solution.moves };
+                };
+                // The first call seeds everything, so a flaky finish gets one
+                // budgeted retry before the whole finish is declared failed.
+                try {
+                    return await solveFinish(finishOpts.timeoutMs ?? 150, finishOpts.phase2TimeoutMs ?? 50);
+                }
+                catch {
+                    return await solveFinish(finishOpts.retryTimeoutMs ?? 300, finishOpts.retryPhase2TimeoutMs ?? 100);
                 }
+            }, {
+                timeoutMs: 75000,
+                deep: options.deep === true,
+                deepPolish: options.deepPolish ?? options.threeAxes,
+                ...(options.finishTries !== undefined ? { finishTries: options.finishTries } : {}),
+                ...(options.centersBeam !== undefined ? { centersBeam: options.centersBeam } : {}),
+                ...(options.edgesPerCenter !== undefined ? { edgesPerCenter: options.edgesPerCenter } : {}),
+                ...(options.phase1ExtraDepths !== undefined ? { phase1ExtraDepths: options.phase1ExtraDepths } : {}),
+                ...(options.phase1Cap !== undefined ? { phase1Cap: options.phase1Cap } : {}),
+                ...(options.center2Wide !== undefined ? { center2Wide: options.center2Wide } : {}),
+                ...(options.restarts !== undefined ? { restarts: options.restarts } : {}),
+                ...(options.prepCap !== undefined ? { prepCap: options.prepCap } : {}),
+                ...(options.p1CandCap !== undefined ? { p1CandCap: options.p1CandCap } : {}),
+                ...(options.stagnationCut !== undefined ? { stagnationCut: options.stagnationCut } : {}),
+                maxReductionLen: bestReductionLen
+            });
+            let timeoutHandle;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new Error("4x4 solve: timeout")), 90000);
+            });
+            let solveOutcome;
+            try {
+                solveOutcome = await Promise.race([solvePromise, timeoutPromise]);
+            }
+            finally {
+                // The search is work-capped and always settles first: clearing the
+                // backstop avoids leaking a live 90s timer per axis (which kept the
+                // event loop — and CLI/test processes — alive needlessly).
+                clearTimeout(timeoutHandle);
             }
-            const facelets = (0, facelets_js_1.toCube4Facelets)(attemptState);
-            const result = {
-                eventId: "444",
-                scramble: (0, moves_js_1.formatCube4Algorithm)(scrambleMoves),
-                moves: scrambleMoves,
-                quality: "random-state",
-                generator: "cube4-reduction",
-                metadata: {
-                    generator: "cube4-reduction",
-                    state: attemptState,
-                    facelets,
-                    faceletString: (0, facelets_js_1.formatCube4Facelets)(facelets),
-                    distribution: "random-state",
-                    ...options.metadata
+            const { scramble: scrambleMoves, moves: solutionMoves, phases, timings, nodes } = solveOutcome;
+            const invRot = rot.length === 0 ? [] : invertRotationSequence(rot);
+            const fullScramble = rot.length === 0 ? scrambleMoves : (0, solve_js_1.rotateAlgorithm)(scrambleMoves, invRot);
+            const fullSolution = rot.length === 0 ? solutionMoves : (0, solve_js_1.rotateAlgorithm)(solutionMoves, invRot);
+            if (!bestScrambleMoves || fullScramble.length < bestScrambleMoves.length) {
+                bestScrambleMoves = fullScramble;
+                bestSolutionMoves = fullSolution;
+                bestPhases = phases;
+                bestTimings = timings;
+                bestNodes = nodes;
+                if (phases) {
+                    bestReductionLen = phases.length12 + phases.length3;
                 }
-            };
-            if (options.seed !== undefined) {
-                result.seed = options.seed;
             }
-            return result;
         }
-        catch (error) {
-            lastError = error;
-            // Retry on deterministic reduction / 3x3 failures (some random states are
-            // outside the solver's horizon with the current caps).
-            const msg = error instanceof Error ? error.message : String(error);
-            const isPhase2Error = typeof error?.name === "string" &&
-                error.name.includes("Cube3Phase2");
-            if (error instanceof Error &&
-                (msg.includes("reduction failed") ||
-                    msg.includes("failed to convert") ||
-                    msg.includes("no valid phase 2") ||
-                    msg.includes("timeout") ||
-                    isPhase2Error ||
-                    msg.includes("Phase 2 solution not found"))) {
-                continue;
-            }
-            throw error;
+        catch (err) {
+            lastError = err;
+        }
+    }
+    if (!bestScrambleMoves || !bestSolutionMoves) {
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    const scrambleMoves = bestScrambleMoves;
+    const solutionMoves = bestSolutionMoves;
+    const scrambledState = (0, moves_js_1.applyCube4Algorithm)((0, state_js_1.createSolvedCube4State)(), scrambleMoves);
+    if (!options.skipValidation) {
+        const solvedCheck = (0, moves_js_1.applyCube4Algorithm)(scrambledState, solutionMoves);
+        if (!(0, state_js_1.isSolvedCube4State)(solvedCheck)) {
+            throw new Error("Generated 4x4 scramble does not solve back to solved state.");
+        }
+    }
+    const facelets = (0, facelets_js_1.toCube4Facelets)(scrambledState);
+    const result = {
+        eventId: "444",
+        scramble: (0, moves_js_1.formatCube4Algorithm)(scrambleMoves),
+        moves: scrambleMoves,
+        quality: "random-state",
+        generator: "cube4-reduction",
+        metadata: {
+            generator: "cube4-reduction",
+            state: scrambledState,
+            facelets,
+            faceletString: (0, facelets_js_1.formatCube4Facelets)(facelets),
+            distribution: "random-state",
+            solutionMoves: (0, moves_js_1.invertCube4Algorithm)(scrambleMoves),
+            // Winning-reduction breakdown (unsimplified lengths) + wall-clock
+            // split, for tuning and A/B comparisons.
+            phases: bestPhases,
+            phaseTimings: bestTimings,
+            nodes: bestNodes,
+            attemptMs: performance.now() - tAttemptStart,
+            ...options.metadata
         }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
     }
-    // All solver attempts exhausted — try cubing.js first, then random-moves.
-    console.warn("[cube4-scrambler] Reduction solver failed after 5 attempts; trying cubing.js fallback.", lastError);
-    const cubingJsResult = await generateCube4WithCubingJs();
-    if (cubingJsResult)
-        return cubingJsResult;
-    console.warn("[cube4-scrambler] cubing.js fallback also failed; using random-moves.");
-    return generateCube4RandomMoves(options);
+    return result;
 }

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

@@ -44,8 +44,11 @@ function cube4StatesEqual(a, b) {
         typedArrayEqual(a.wp, b.wp) &&
         typedArrayEqual(a.centers, b.centers));
 }
+// Read-only canonical solved state for comparisons (never mutated, so a
+// single shared instance is safe and avoids allocating 4 arrays per call).
+const SOLVED_STATE = createSolvedCube4State();
 function isSolvedCube4State(state) {
-    return cube4StatesEqual(state, createSolvedCube4State());
+    return cube4StatesEqual(state, SOLVED_STATE);
 }
 // ---------------------------------------------------------------------------
 // Helpers

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

@@ -38,7 +38,7 @@ function solveWithTablesIndices(state) {
     const centersTable = tables_js_1.CENTERS_TABLE;
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
-    const policy = tables_js_1.POLICY_TABLE;
+    const policy = tables_js_1.POLICY_TABLE_EXPANDED;
     let c = (0, tables_js_1.getCentersIndex)(state.centers);
     let p = (0, tables_js_1.getPermutationCompactIndex)(state.edgesPerm);
     let o = (0, tables_js_1.getOrientationIndex)(state.edgesOrient);
@@ -47,10 +47,7 @@ function solveWithTablesIndices(state) {
         return [];
     const moves = [];
     while (stateIndex !== 0) {
-        const bits = stateIndex * 3;
-        const byteIndex = bits >> 3;
-        const offset = bits & 7;
-        const m = ((policy[byteIndex] | ((policy[byteIndex + 1] ?? 0) << 8)) >> offset) & 0x07;
+        const m = policy[stateIndex];
         moves.push(m);
         c = centersTable[c * tables_js_1.MOVE_COUNT + m];
         p = permTable[p * tables_js_1.MOVE_COUNT + m];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.CENTERS_TABLE = exports.PYRAMINX_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.CENTERS_COUNT = exports.PERM_360_TO_720 = exports.PERM_720_TO_360 = exports.PERMUTATION_COUNT = exports.PERMUTATION_FULL_COUNT = void 0;
+exports.POLICY_TABLE_EXPANDED = exports.POLICY_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.CENTERS_TABLE = exports.PYRAMINX_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.CENTERS_COUNT = exports.PERM_360_TO_720 = exports.PERM_720_TO_360 = exports.PERMUTATION_COUNT = exports.PERMUTATION_FULL_COUNT = void 0;
 exports.getPermutationIndex = getPermutationIndex;
 exports.getPermutationFromIndex = getPermutationFromIndex;
 exports.getOrientationIndex = getOrientationIndex;
@@ -289,6 +289,12 @@ exports.CENTERS_TABLE = null;
 exports.PERMUTATION_TABLE = null;
 exports.ORIENTATION_TABLE = null;
 exports.POLICY_TABLE = null;
+/**
+ * Byte-expanded policy (one optimal move per state, no bit-unpacking in
+ * the hot walk). Built at load from the 3-bit packed table: +0.9 MB RAM,
+ * zero wire/format change.
+ */
+exports.POLICY_TABLE_EXPANDED = null;
 async function ensureTablesLoaded() {
     if (tablesLoaded)
         return;
@@ -297,8 +303,18 @@ async function ensureTablesLoaded() {
     exports.PERMUTATION_TABLE = tables.permutationTable;
     exports.ORIENTATION_TABLE = tables.orientationTable;
     exports.POLICY_TABLE = tables.policyTable;
+    exports.POLICY_TABLE_EXPANDED = expandPolicy3Bit(tables.policyTable, exports.STATE_COUNT);
     tablesLoaded = true;
 }
+function expandPolicy3Bit(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const bits = index * 3;
+        const byteIndex = bits >> 3;
+        expanded[index] = (((packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> (bits & 7)) & 0x07);
+    }
+    return expanded;
+}
 function arePyraminxTablesLoaded() {
     return tablesLoaded;
 }
@@ -328,4 +344,5 @@ function resetTablesForTests() {
     exports.PERMUTATION_TABLE = null;
     exports.ORIENTATION_TABLE = null;
     exports.POLICY_TABLE = null;
+    exports.POLICY_TABLE_EXPANDED = null;
 }

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

@@ -43,7 +43,7 @@ function solveWithTables(state) {
     return { moves, depth: moves.length };
 }
 function solveWithTablesIndices(state) {
-    const policy = tables_js_1.POLICY_TABLE;
+    const policy = tables_js_1.POLICY_TABLE_EXPANDED;
     const permTable = tables_js_1.PERMUTATION_TABLE;
     const orientTable = tables_js_1.ORIENTATION_TABLE;
     const centersTable = tables_js_1.CENTERS_TABLE;
@@ -60,7 +60,7 @@ function solveWithTablesIndices(state) {
     }
     const moves = [];
     while (rank !== tables_js_1.SOLVED_RANK) {
-        const m = (0, tables_js_1.getPolicyMoveFromPacked)(policy, rank);
+        const m = policy[rank];
         moves.push(m);
         r7 = permTable[r7 * tables_js_1.MOVE_COUNT + m];
         rO = orientTable[rO * tables_js_1.MOVE_COUNT + m];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SOLVED_RANK = exports.ORIENT_UNRANK = exports.CENTER_UNRANK = exports.PERM7_UNRANK = exports.R7_SETS = exports.ORIENT_CLASS = exports.EVEN_CENTER_FULL = exports.EVEN_CENTER_RANK = exports.POLICY_TABLE = exports.CENTERS_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.SKEWB_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.PER_SET_SIZE = exports.ORIENT_CLASS_COUNT = exports.EVEN_CENTER_COUNT = exports.CENTER_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.SOLVED_RANK = exports.ORIENT_UNRANK = exports.CENTER_UNRANK = exports.PERM7_UNRANK = exports.R7_SETS = exports.ORIENT_CLASS = exports.EVEN_CENTER_FULL = exports.EVEN_CENTER_RANK = exports.POLICY_TABLE_EXPANDED = exports.POLICY_TABLE = exports.CENTERS_TABLE = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.SKEWB_MOVES = exports.POLICY_PACKED_ENTRIES = exports.STATE_COUNT = exports.MOVE_COUNT = exports.PER_SET_SIZE = exports.ORIENT_CLASS_COUNT = exports.EVEN_CENTER_COUNT = exports.CENTER_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
 exports.getPermutationIndex = getPermutationIndex;
 exports.getPermutationFromIndex = getPermutationFromIndex;
 exports.getOrientationIndex = getOrientationIndex;
@@ -175,6 +175,12 @@ exports.PERMUTATION_TABLE = null; // r7 * MOVE_COUNT + m
 exports.ORIENTATION_TABLE = null; // rO * MOVE_COUNT + m
 exports.CENTERS_TABLE = null; // rC * MOVE_COUNT + m
 exports.POLICY_TABLE = null; // optimal move per rank, 3-bit packed
+/**
+ * Byte-expanded policy (one optimal move per rank, no bit-unpacking in
+ * the hot walk). Built at load from the 3-bit packed table: +3.1 MB RAM,
+ * zero wire/format change.
+ */
+exports.POLICY_TABLE_EXPANDED = null;
 exports.EVEN_CENTER_RANK = null; // rC -> compact 0..359 (65535 = odd)
 exports.EVEN_CENTER_FULL = null; // compact 0..359 -> rC (derived at load)
 exports.ORIENT_CLASS = null; // rO -> class 0..8
@@ -224,9 +230,19 @@ function assignTables(tables) {
         for (let i = 0; i < 7; i++)
             exports.ORIENT_UNRANK[rO * 7 + i] = orient[i + 1];
     }
+    exports.POLICY_TABLE_EXPANDED = expandPolicy3Bit(tables.policyTable, exports.STATE_COUNT);
     exports.SOLVED_RANK = rankFromComponents(0, 0, 0);
     tablesLoaded = true;
 }
+function expandPolicy3Bit(packed, count) {
+    const expanded = new Uint8Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const bits = index * 3;
+        const byteIndex = bits >> 3;
+        expanded[index] = (((packed[byteIndex] | ((packed[byteIndex + 1] ?? 0) << 8)) >> (bits & 7)) & 0x07);
+    }
+    return expanded;
+}
 function resetTablesForTests() {
     tablesLoaded = false;
     exports.PERMUTATION_TABLE = null;
@@ -240,6 +256,7 @@ function resetTablesForTests() {
     exports.PERM7_UNRANK = null;
     exports.CENTER_UNRANK = null;
     exports.ORIENT_UNRANK = null;
+    exports.POLICY_TABLE_EXPANDED = null;
 }
 // ---------------------------------------------------------------------------
 // Compact rank helpers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubingcenter/scrambler",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Extensible scramble generation toolkit for CubingCenter projects.",
   "type": "module",
   "license": "MIT",
@@ -57,12 +57,19 @@
     "tsx": "^4.20.0",
     "typescript": "^5.9.0"
   },
-  "dependencies": {
-    "cubing": "^0.63.4"
-  },
   "scripts": {
     "build": "node scripts/clean.cjs && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/write-cjs-package.cjs && node scripts/copy-assets.cjs",
-    "test": "node --test --import tsx test/*.test.ts",
+    "test": "node --test --import tsx",
+    "test:all": "node --test --import tsx test/*.test.ts",
+    "test:skewb": "node --test --import tsx test/skewb*.test.ts",
+    "test:pyraminx": "node --test --import tsx test/pyraminx*.test.ts",
+    "test:sq1": "node --test --import tsx test/sq1*.test.ts",
+    "test:fto": "node --test --import tsx test/fto*.test.ts",
+    "test:cube2": "node --test --import tsx test/cube2*.test.ts",
+    "test:cube3": "node --test --import tsx test/cube3*.test.ts",
+    "test:cube4": "node --test --import tsx test/cube4*.test.ts test/center*.test.ts test/edge3.test.ts test/pairing-coordinate.test.ts test/phase*.test.ts",
+    "test:big": "node --test --import tsx test/big-cubes*.test.ts",
+    "test:watch": "node --test --watch --import tsx",
     "lint": "tsc -p tsconfig.json --noEmit",
     "package:check": "pnpm build && node scripts/check-package.cjs",
     "verify": "pnpm lint && pnpm test && pnpm build && pnpm cube3:tables:check && pnpm cube2:tables:check && pnpm pyraminx:tables:check && pnpm skewb:tables:check && pnpm sq1:tables:check && pnpm package:check",
@@ -83,6 +90,8 @@
     "cube4:center2:tables:check": "node --import tsx scripts/check-center2-solver-tables.ts",
     "cube4:center3:tables": "node --import tsx scripts/generate-center3-solver-tables.ts",
     "cube4:center3:tables:check": "node --import tsx scripts/check-center3-solver-tables.ts",
+    "cube4:hc:tables": "node --import tsx scripts/generate-hc-pdb-table.ts",
+    "cube4:hc:tables:check": "node --import tsx scripts/check-hc-pdb-table.ts",
     "cube4:edge3:tables": "node --import tsx scripts/generate-edge3-solver-tables.ts",
     "cube4:edge3:tables:check": "node --import tsx scripts/check-edge3-solver-tables.ts",
     "tables:web:sync": "node --import tsx scripts/sync-web-tables.ts",