@cubingcenter/scrambler 0.6.0 → 0.6.2

package/dist/puzzles/cube3/solver/phase2.js

@@ -4,6 +4,7 @@ import { encodePermutation, encodeSlicePermutation, encodeUdEdgePermutation } fr
 import { isCube3Phase1Solved, solveCube3Phase1 } from "./phase1.js";
 import { loadCube3Phase1Tables, loadCube3Phase2Tables, CUBE3_PHASE1_MOVES, CUBE3_PHASE2_MOVES } from "./tables.js";
 import { getMoveFace, getMoveFaceByIndex, shouldSkipCube3SearchMove } from "./search-utils.js";
+import { loadCube3PairTables, pairBound } from "./pair-tables.js";
 export class Cube3Phase2SearchError extends Error {
     visitedNodes;
     constructor(message, visitedNodes) {
@@ -40,11 +41,13 @@ export async function solveCube3Phase2(state, options = {}) {
         throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
     }
     const tables = options.tables ?? await loadCube3Phase2Tables();
+    const pairTables = options.pairTables ?? await loadCube3PairTables();
     const maxDepth = options.maxDepth ?? 18;
     const start = encodeCube3Phase2Coordinates(state);
     const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
     const context = {
         tables,
+        pairTables,
         deadline,
         visitedNodes: 0,
         timedOut: false
@@ -56,7 +59,13 @@ export async function solveCube3Phase2(state, options = {}) {
     const combinedEPIndex = start.udEdgePermutation * spRange + start.slicePermutation;
     const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
     const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
-    const minDepth = cpDist > epDist ? cpDist : epDist;
+    let minDepth = cpDist > epDist ? cpDist : epDist;
+    if (pairTables) {
+        const pair = pairBound(pairTables, start.cornerPermutation, start.udEdgePermutation);
+        if (pair > minDepth) {
+            minDepth = pair;
+        }
+    }
     const initialPreviousFace = options.previousFace ?? -1;
     const initialPreviousPreviousFace = options.previousPreviousFace ?? -1;
     for (let depth = minDepth; depth <= maxDepth; depth += 1) {
@@ -151,6 +160,38 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
     const cpOffset = cornerPermutation * moveCount;
     const epOffset = udEdgePermutation * moveCount;
     const spOffset = slicePermutation * moveCount;
+    // Without the pair tables (the default npm package), keep the exact
+    // reference traversal — zero overhead. With them (turbo tier), collect the
+    // children with the pair-distance bound and explore in ascending bound
+    // order (stable: ties keep the reference move order): same depth-minimal
+    // solutions, far fewer nodes.
+    if (context.pairTables === undefined) {
+        for (let i = 0; i < validMoves.length; i += 1) {
+            const moveIndex = validMoves[i];
+            const nextCornerPermutation = cpTable[cpOffset + moveIndex];
+            const nextUdEdgePermutation = epTable[epOffset + moveIndex];
+            const nextSlicePermutation = spTable[spOffset + moveIndex];
+            const combinedCPIndex = nextCornerPermutation * spRange + nextSlicePermutation;
+            const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
+            const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+            const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+            const nextLowerBound = cpDist > epDist ? cpDist : epDist;
+            if (nextLowerBound > remainingDepth - 1) {
+                continue;
+            }
+            path.push(context.tables.phase2Moves[moveIndex]);
+            if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, PHASE2_MOVE_FACES[moveIndex], previousFace, remainingDepth - 1, path, context)) {
+                return true;
+            }
+            path.pop();
+            if (context.timedOut) {
+                return false;
+            }
+        }
+        return false;
+    }
+    const pairTables = context.pairTables;
+    const children = [];
     for (let i = 0; i < validMoves.length; i += 1) {
         const moveIndex = validMoves[i];
         const nextCornerPermutation = cpTable[cpOffset + moveIndex];
@@ -160,13 +201,29 @@ function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, pr
         const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
         const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
         const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
-        const nextLowerBound = cpDist > epDist ? cpDist : epDist;
+        let nextLowerBound = cpDist > epDist ? cpDist : epDist;
         if (nextLowerBound > remainingDepth - 1) {
             continue;
         }
-        const face = PHASE2_MOVE_FACES[moveIndex];
-        path.push(context.tables.phase2Moves[moveIndex]);
-        if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, face, previousFace, remainingDepth - 1, path, context)) {
+        const pair = pairBound(pairTables, nextCornerPermutation, nextUdEdgePermutation);
+        if (pair > nextLowerBound) {
+            nextLowerBound = pair;
+        }
+        if (nextLowerBound > remainingDepth - 1) {
+            continue;
+        }
+        children.push({
+            moveIndex,
+            lowerBound: nextLowerBound,
+            cornerPermutation: nextCornerPermutation,
+            udEdgePermutation: nextUdEdgePermutation,
+            slicePermutation: nextSlicePermutation
+        });
+    }
+    children.sort((left, right) => left.lowerBound - right.lowerBound);
+    for (const child of children) {
+        path.push(context.tables.phase2Moves[child.moveIndex]);
+        if (searchPhase2(child.cornerPermutation, child.udEdgePermutation, child.slicePermutation, PHASE2_MOVE_FACES[child.moveIndex], previousFace, remainingDepth - 1, path, context)) {
             return true;
         }
         path.pop();
@@ -217,6 +274,7 @@ function searchPhase1Interleaved(cornerOrientation, edgeOrientation, udSlice, pr
         const maxPhase2Depth = 6;
         const phase2Context = {
             tables: context.phase2Tables,
+            pairTables: undefined,
             deadline: context.deadline,
             visitedNodes: 0,
             timedOut: false

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

@@ -40,6 +40,20 @@ export interface Cube3SolverTables {
         cornerPermutationSlicePermutation: Cube3PruningTable;
         udEdgePermutationSlicePermutation: Cube3PruningTable;
     };
+    jointTables: Cube3JointTables | undefined;
+}
+/**
+ * Phase-1 joint tables (ud x co / ud x eo): exact distances to the ud-slice
+ * solved together with the corner/edge orientations. Tighten the phase-1
+ * bound from max(coeo, ud) to max(coeo, ud, udco, udeo) — a ~7x speedup
+ * (the starting minDepth becomes exact, eliminating failing depth
+ * iterations). Part of the standard tables (~1 MB).
+ */
+export interface Cube3JointTables {
+    /** 495 x 2187, 4-bit packed: index = ud * 2187 + cornerOrientation. */
+    jointUdCo: Uint8Array;
+    /** 495 x 2048, 4-bit packed: index = ud * 2048 + edgeOrientation. */
+    jointUdEo: Uint8Array;
 }
 export interface Cube3Phase1Tables {
     phase1Moves: readonly Cube3Move[];
@@ -47,6 +61,8 @@ export interface Cube3Phase1Tables {
     pruningTables: Pick<Cube3SolverTables["pruningTables"], "cornerOrientation" | "edgeOrientation" | "udSlice"> & {
         cornerOrientationEdgeOrientation: Cube3PruningTable;
     };
+    /** Present when the manifest ships the joint tables (default). */
+    jointTables: Cube3JointTables | undefined;
 }
 export interface Cube3Phase2Tables {
     phase2Moves: readonly Cube3Move[];

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

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

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

@@ -46,7 +46,8 @@ export function generateCube3Phase1Tables() {
             edgeOrientation: generateCube3PruningTable(edgeOrientation),
             udSlice: generateCube3PruningTable(udSlice),
             cornerOrientationEdgeOrientation: generateCube3CombinedPruningTable(cornerOrientation, edgeOrientation)
-        }
+        },
+        jointTables: undefined
     };
 }
 export function generateCube3SolverTables() {
@@ -73,7 +74,8 @@ export function generateCube3SolverTables() {
             slicePermutation: phase2Tables.pruningTables.slicePermutation,
             cornerPermutationSlicePermutation: phase2Tables.pruningTables.cornerPermutationSlicePermutation,
             udEdgePermutationSlicePermutation: phase2Tables.pruningTables.udEdgePermutationSlicePermutation
-        }
+        },
+        jointTables: undefined
     };
 }
 export function generateCube3Phase2Tables() {

package/dist/puzzles/cube4/scrambler.d.ts

@@ -2,9 +2,12 @@
  * The 4x4 scramble generator: sample a uniform random state, solve it with
  * 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.
  */
 import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
-export declare function isCube4TablesLoaded(): boolean;
 export declare const cube4ScrambleGenerator: ScrambleGenerator;
 export declare function generateCube4Scramble(options?: ScrambleOptions & {
     skipValidation?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/scrambler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AA4C9F,wBAAgB,mBAAmB,IAAI,OAAO,CAU7C;AAED,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,CAkFzB"}
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/scrambler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAmJ9F,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,CAyFzB"}

package/dist/puzzles/cube4/scrambler.js

@@ -2,6 +2,10 @@
  * The 4x4 scramble generator: sample a uniform random state, solve it with
  * 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.
  */
 import { formatCube4Algorithm, applyCube4Algorithm } from "./moves.js";
 import { generateRandomCube4State } from "./random-state.js";
@@ -9,6 +13,95 @@ import { createSolvedCube4State, cube4StatesEqual } from "./state.js";
 import { formatCube4Facelets, toCube4Facelets } from "./facelets.js";
 import { solveCube4State } from "./reduction/solve.js";
 import { solveCube3State } from "../cube3/solver/index.js";
+import { createRandomSource } from "../../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 import(
+        /* 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 = 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
+        }
+    };
+}
+// ────────────────────────────────────────────────────────────
 let cachedTables;
 async function loadCube4Tables(baseUrl) {
     if (cachedTables)
@@ -40,18 +133,6 @@ async function loadCube4Tables(baseUrl) {
     cachedTables = tables;
     return tables;
 }
-export function isCube4TablesLoaded() {
-    // For the scrambler retry logic, we need to know if tables are already
-    // loaded to avoid re-loading on every attempt.
-    try {
-        // @ts-ignore
-        const loader = globalThis;
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
 export const cube4ScrambleGenerator = {
     info: {
         eventId: "444",
@@ -59,7 +140,7 @@ export const cube4ScrambleGenerator = {
         puzzle: "cube-4x4",
         quality: "random-state",
         generator: "cube4-reduction",
-        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish)."
+        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish). Falls back to random-moves if the solver fails."
     },
     generate(options = {}) {
         return generateCube4Scramble(options);
@@ -136,5 +217,11 @@ export async function generateCube4Scramble(options = {}) {
             throw error;
         }
     }
-    throw lastError;
+    // 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);
 }

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

@@ -53,10 +53,35 @@ async function loadBrowserTables(baseUrl) {
             slicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.slicePermutation),
             cornerPermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.cornerPermutationSlicePermutation),
             udEdgePermutationSlicePermutation: await fetchPruningTable(resolvedBase, manifest.pruningTables.udEdgePermutationSlicePermutation)
-        }
+        },
+        jointTables: await fetchJointTables(resolvedBase, manifest.jointTables)
     };
     return browserTables;
 }
+async function fetchJointTables(baseUrl, entries) {
+    if (!entries?.udCo || !entries.udEo) {
+        return undefined;
+    }
+    const fetchJoint = async (entry) => {
+        const buffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, TABLES_DIR, entry.file, {
+            cacheName: CACHE_NAME,
+            compressed: entry.compressed !== false
+        });
+        const expectedBytes = Math.ceil((entry.rangeA * entry.rangeB) / 2);
+        if (buffer.byteLength !== expectedBytes) {
+            throw new Error(`Invalid byte size for ${entry.file}.`);
+        }
+        const values = new Uint8Array(buffer);
+        if (checksum(values) !== entry.checksum) {
+            throw new Error(`Checksum mismatch for ${entry.file}.`);
+        }
+        return values;
+    };
+    return {
+        jointUdCo: await fetchJoint(entries.udCo),
+        jointUdEo: await fetchJoint(entries.udEo)
+    };
+}
 async function fetchManifest(baseUrl) {
     const url = `${baseUrl}/puzzles/cube3/solver/generated/manifest.json`;
     const response = await fetch(url);

package/dist-cjs/puzzles/cube3/solver/generated/manifest.json

@@ -400,5 +400,19 @@
       "checksum": 2840452350,
       "maxDepth": 12
     }
+  },
+  "jointTables": {
+    "udCo": {
+      "file": "phase1-udco.bin",
+      "rangeA": 495,
+      "rangeB": 2187,
+      "checksum": 1999233281
+    },
+    "udEo": {
+      "file": "phase1-udeo.bin",
+      "rangeA": 495,
+      "rangeB": 2048,
+      "checksum": 4017545214
+    }
   }
 }