@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist/puzzles/cube4/reduction/phase4.js

@@ -0,0 +1,82 @@
+/**
+ * Phase 4: reduce the solved-centers + paired-wings 4x4 state to a 3x3
+ * cubie state and solve it with the existing cube3 two-phase solver.
+ *
+ * The corner permutation/orientation carry over directly (same numbering as
+ * the cube3). The 12 paired edges: each slot holds one 3x3 edge; the edge
+ * permutation = the pair id and the orientation = the chirality flip (which
+ * wing of the pair sits at the slot's first-half position).
+ */
+import { applyCube4Algorithm } from "../moves.js";
+import { PAIRING_SLOTS } from "./pairing-coordinate.js";
+// The "right-chiral" wing/position classes (same set as facelets.ts).
+const RIGHT_GROUP = new Set([1, 2, 4, 6, 8, 11, 13, 15, 16, 19, 20, 23]);
+// For each 3x3 edge position p (positions 2p, 2p+1), the pairing slot whose
+// first-half position belongs to that pair.
+const SLOT_OF_EDGE = (() => {
+    const table = new Array(12);
+    for (let slot = 0; slot < 12; slot++) {
+        const pair = PAIRING_SLOTS[slot][0] >> 1;
+        table[pair] = slot;
+    }
+    return table;
+})();
+/** Verify the reduction preconditions (the reference's `to333Facelet` check). */
+export function checkCube4Reduction(state) {
+    for (let face = 0; face < 6; face++) {
+        const color = state.centers[face * 4];
+        for (let i = 1; i < 4; i++) {
+            if (state.centers[face * 4 + i] !== color) {
+                return { wingsPaired: false, centersSolved: false };
+            }
+        }
+    }
+    for (const [f, s] of PAIRING_SLOTS) {
+        if ((state.wp[f] >> 1) !== (state.wp[s] >> 1)) {
+            return { wingsPaired: false, centersSolved: true };
+        }
+    }
+    return null;
+}
+/**
+ * Build the 3x3 cubie state from a reduced 4x4 state. Returns null if the
+ * reduction preconditions are not met.
+ */
+export function toCube3State(state) {
+    if (checkCube4Reduction(state) !== null)
+        return null;
+    const edges = { permutation: new Array(12), orientation: new Array(12) };
+    for (let edge = 0; edge < 12; edge++) {
+        // the 3x3 edge positions are the position pairs (2p, 2p+1); the slot of
+        // the edge p is the slot whose first-half position belongs to that pair.
+        const slot = SLOT_OF_EDGE[edge];
+        const first = PAIRING_SLOTS[slot][0];
+        const wing = state.wp[first];
+        edges.permutation[edge] = wing >> 1;
+        // the chirality flip: the derived edge is flipped when the wing and the
+        // slot-half have opposite chirality (the facelets.ts RIGHT_GROUP rule)
+        edges.orientation[edge] = RIGHT_GROUP.has(wing) !== RIGHT_GROUP.has(first) ? 1 : 0;
+    }
+    return {
+        corners: {
+            permutation: Array.from(state.cp),
+            orientation: Array.from(state.co)
+        },
+        edges
+    };
+}
+/**
+ * Full solve: run the reduction phases (1-3) + the 3x3 finish. The caller
+ * provides the phase-3 solution; this applies it and finishes with the cube3
+ * solver, returning the complete move sequence.
+ */
+export async function solveReduced4x4(phase3End, phase3Moves, solveCube3) {
+    const state = applyCube4Algorithm(phase3End, phase3Moves);
+    const reductionError = checkCube4Reduction(state);
+    if (reductionError !== null) {
+        throw new Error(`4x4 reduction failed: wingsPaired=${reductionError.wingsPaired} centersSolved=${reductionError.centersSolved}`);
+    }
+    const cube3State = toCube3State(state);
+    const solution = await solveCube3(cube3State);
+    return { moves: [...phase3Moves, ...solution.moves] };
+}

package/dist/puzzles/cube4/reduction/solve.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Full 4x4 solve orchestration: reduction (phases 1-3) + the 3x3 finish
+ * (phase 4), returning the move sequence that solves the given state.
+ * The scramble for a sampled state is the inverted solution.
+ */
+import type { Cube4State, Cube4Move } from "../types.js";
+import { type Center1Tables } from "./center1.js";
+import { type Center2Tables } from "./center2.js";
+import { type Center3Tables } from "./center3.js";
+import { type Edge3Tables } from "./edge3.js";
+import type { Cube3State, Cube3Move } from "../../cube3/types.js";
+export interface Cube4SolveTables {
+    center1: Center1Tables;
+    center2: Center2Tables;
+    center3: Center3Tables;
+    edge3: Edge3Tables;
+}
+export interface Cube4SolveResult {
+    /** The complete solve sequence (solves the input state). */
+    moves: Cube4Move[];
+    /** The scramble (the inverted solution). */
+    scramble: Cube4Move[];
+}
+/**
+ * Solve a 4x4 state with the reduction solver + the cube3 two-phase finish.
+ * `solveCube3` is injected (the cube3 solver loads its tables lazily).
+ */
+export declare function solveCube4State(state: Cube4State, tables: Cube4SolveTables, solveCube3: (state: Cube3State) => Promise<{
+    moves: Cube3Move[];
+}>): Promise<Cube4SolveResult>;
+//# sourceMappingURL=solve.d.ts.map

package/dist/puzzles/cube4/reduction/solve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/solve.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAKjE,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIlE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,4CAA4C;IAC5C,QAAQ,EAAE,SAAS,EAAE,CAAC;CACvB;AAuKD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC;IAAE,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,GACjE,OAAO,CAAC,gBAAgB,CAAC,CAqL3B"}

package/dist/puzzles/cube4/reduction/solve.js

@@ -0,0 +1,311 @@
+/**
+ * Full 4x4 solve orchestration: reduction (phases 1-3) + the 3x3 finish
+ * (phase 4), returning the move sequence that solves the given state.
+ * The scramble for a sampled state is the inverted solution.
+ */
+import { applyCube4Algorithm, invertCube4Algorithm } from "../moves.js";
+import { center1Mask, getCenter1Distance, applyCenter1Move, CENTER1_MOVES } from "./center1.js";
+import { center2Bridge, isCenter2Goal, CENTER2_MOVES, CENTER2_SEARCH_MOVES, CENTER2_RL_STATES } from "./center2.js";
+import { encodeCenter3 } from "./center3.js";
+import { encodePairingState } from "./pairing-coordinate.js";
+import { getSymTables, getMvSymFrom } from "./edge3.js";
+import { FastPhase3Solver } from "./phase3-search.js";
+import { toCube3State } from "./phase4.js";
+import { Cube3Phase2SearchError } from "../../cube3/solver/index.js";
+import { createSolvedCube4State } from "../state.js";
+function cornerPermutationParity(cp) {
+    let parity = 0;
+    const seen = new Array(8).fill(false);
+    for (let start = 0; start < 8; start++) {
+        if (seen[start] || cp[start] === start)
+            continue;
+        let length = 0;
+        let current = start;
+        while (!seen[current]) {
+            seen[current] = true;
+            current = cp[current];
+            length++;
+        }
+        parity ^= (length - 1) & 1;
+    }
+    return parity;
+}
+const ROT_MOVES = {
+    "x": ["Rw", "Lw'"],
+    "y": ["Uw", "Dw'"],
+    "z": ["Fw", "Bw'"],
+    "x'": ["Rw'", "Lw"],
+    "y'": ["Uw'", "Dw"],
+    "z'": ["Fw'", "Bw"]
+};
+const VALID_24_ORIENTATIONS = (() => {
+    const map = new Map();
+    const solved = createSolvedCube4State();
+    const queue = [{ state: solved, path: [] }];
+    map.set(`${solved.centers[0]},${solved.centers[4]},${solved.centers[8]}`, []);
+    while (queue.length > 0) {
+        const { state, path } = queue.shift();
+        for (const [rot, moves] of Object.entries(ROT_MOVES)) {
+            const nextState = applyCube4Algorithm(state, moves);
+            const key = `${nextState.centers[0]},${nextState.centers[4]},${nextState.centers[8]}`;
+            if (!map.has(key)) {
+                const nextPath = [...path, rot];
+                map.set(key, nextPath);
+                queue.push({ state: nextState, path: nextPath });
+            }
+        }
+    }
+    return map;
+})();
+const ROT_MAP = {
+    "x": { "U": "B", "R": "R", "F": "U", "D": "F", "L": "L", "B": "D" },
+    "x'": { "U": "F", "R": "R", "F": "D", "D": "B", "L": "L", "B": "U" },
+    "y": { "U": "U", "R": "F", "F": "L", "D": "D", "L": "B", "B": "R" },
+    "y'": { "U": "U", "R": "B", "F": "R", "D": "D", "L": "F", "B": "L" },
+    "z": { "U": "R", "R": "D", "F": "F", "D": "L", "L": "U", "B": "B" },
+    "z'": { "U": "L", "R": "U", "F": "F", "D": "R", "L": "D", "B": "B" }
+};
+const INVERT_ROT = {
+    "x": "x'", "x'": "x",
+    "y": "y'", "y'": "y",
+    "z": "z'", "z'": "z"
+};
+function rotateMove(move, rot) {
+    const map = ROT_MAP[rot];
+    const face = move[0];
+    const newFace = map[face];
+    return (newFace + move.slice(1));
+}
+function rotateAlgorithm(alg, rotSeq) {
+    let res = [...alg];
+    for (const r of rotSeq) {
+        res = res.map((m) => rotateMove(m, r));
+    }
+    return res;
+}
+function invertRotationSequence(rotSeq) {
+    return [...rotSeq].reverse().map((r) => INVERT_ROT[r]);
+}
+function applyCubeRotation(state, rotSeq) {
+    let s = state;
+    for (const r of rotSeq) {
+        s = applyCube4Algorithm(s, ROT_MOVES[r]);
+    }
+    return s;
+}
+const STANDARD_ORDER = [
+    "U", "U2", "U'", "R", "R2", "R'", "F", "F2", "F'", "D", "D2", "D'",
+    "L", "L2", "L'", "B", "B2", "B'",
+    "Uw", "Uw2", "Uw'", "Rw", "Rw2", "Rw'", "Fw", "Fw2", "Fw'",
+    "Dw", "Dw2", "Dw'", "Lw", "Lw2", "Lw'", "Bw", "Bw2", "Bw'"
+];
+const STD_INDEX = new Map(STANDARD_ORDER.map((m, i) => [m, i]));
+function baseOf(move) {
+    return move.replace(/[2']$/, "");
+}
+function axisClass(base) {
+    return { U: 0, D: 0, R: 1, L: 1, F: 2, B: 2 }[base];
+}
+function isCancelled(previous, current) {
+    const pb = baseOf(previous);
+    const cb = baseOf(current);
+    if (pb === cb)
+        return true;
+    if (axisClass(pb) === axisClass(cb)) {
+        return STD_INDEX.get(previous) > STD_INDEX.get(current);
+    }
+    return false;
+}
+function solveCenter1Diverse(centers, urf, tables, cap = 80) {
+    const startMask = center1Mask(centers, urf);
+    const solutions = [];
+    const path = [];
+    const minH = getCenter1Distance(startMask, tables);
+    for (let maxD = minH; maxD <= minH + 1; maxD++) {
+        const dfs = (mask, depth, lm) => {
+            if (solutions.length >= cap)
+                return true;
+            const h = getCenter1Distance(mask, tables);
+            if (h === 0) {
+                solutions.push({
+                    moves: path.slice(0, depth).map((m) => CENTER1_MOVES[m]),
+                    length: depth
+                });
+                return false;
+            }
+            if (depth + h > maxD)
+                return false;
+            for (let m = 0; m < CENTER1_MOVES.length; m++) {
+                if (lm >= 0 && Math.floor(lm / 3) === Math.floor(m / 3))
+                    continue;
+                const next = applyCenter1Move(mask, tables.moveMaps, m);
+                path[depth] = m;
+                if (dfs(next, depth + 1, m))
+                    return true;
+            }
+            return false;
+        };
+        if (dfs(startMask, 0, -1))
+            break;
+    }
+    return solutions;
+}
+const phase3Solver = new FastPhase3Solver();
+/**
+ * Solve a 4x4 state with the reduction solver + the cube3 two-phase finish.
+ * `solveCube3` is injected (the cube3 solver loads its tables lazily).
+ */
+export async function solveCube4State(state, tables, solveCube3) {
+    const sym = getSymTables();
+    const cornerParity = cornerPermutationParity(state.cp);
+    const p1Sols = solveCenter1Diverse(state.centers, 0, tables.center1, 80);
+    p1Sols.sort((a, b) => a.moves.length - b.moves.length);
+    const minP1 = p1Sols[0]?.moves.length ?? 0;
+    const candidates = [];
+    const moveLog = new Array(25);
+    function searchPhase2(c, r, maxl, lm, depth, bridgeState, p1Moves) {
+        if (isCenter2Goal(c, r)) {
+            if (maxl === 0) {
+                const moves2 = moveLog.slice(0, depth).map((m) => CENTER2_MOVES[m]);
+                const s2 = applyCube4Algorithm(bridgeState, moves2);
+                const pairing = encodePairingState(s2.wp);
+                if (pairing) {
+                    const eXc = (pairing.parity ^ cornerParity);
+                    const ct3 = encodeCenter3(s2, eXc).coordinate;
+                    const cdist = tables.center3.pruning[ct3];
+                    if (cdist !== 0xff && cdist !== undefined) {
+                        const symIdx = getMvSymFrom(pairing.edge, pairing.edge, 20, sym.sym2Raw, sym.sym2Mask, sym.raw2Sym, sym.mvrot, sym.mvroto);
+                        const edist = (tables.edge3.distances[(symIdx >> 3) >> 1] >>
+                            (((symIdx >> 3) & 1) * 4)) &
+                            0x0f;
+                        candidates.push({
+                            moves12: [...p1Moves, ...moves2],
+                            length12: p1Moves.length + moves2.length,
+                            ct3,
+                            cdist,
+                            edge: pairing.edge,
+                            edist,
+                            value: p1Moves.length + moves2.length + Math.max(cdist, edist),
+                            state: s2
+                        });
+                        if (candidates.length >= 60)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+        if (maxl === 0)
+            return false;
+        for (let m = 0; m < CENTER2_SEARCH_MOVES.length; m++) {
+            if (lm >= 0 && isCancelled(CENTER2_SEARCH_MOVES[lm], CENTER2_SEARCH_MOVES[m])) {
+                continue;
+            }
+            const nc = tables.center2.ctMove[c * CENTER2_MOVES.length + m];
+            const nr = tables.center2.rlMove[r * CENTER2_MOVES.length + m];
+            const prun = tables.center2.pruning[nc * CENTER2_RL_STATES + nr];
+            if (prun >= maxl)
+                continue;
+            moveLog[depth] = m;
+            if (searchPhase2(nc, nr, maxl - 1, m, depth + 1, bridgeState, p1Moves))
+                return true;
+        }
+        return false;
+    }
+    let MAX_P2 = 8;
+    do {
+        OUTER: for (let length12 = minP1; length12 < minP1 + 14; length12++) {
+            for (const p1 of p1Sols) {
+                if (p1.moves.length > length12)
+                    break;
+                const length2 = length12 - p1.moves.length;
+                if (length2 > MAX_P2 || length2 < 0)
+                    continue;
+                const s1 = applyCube4Algorithm(state, p1.moves);
+                const bridge = center2Bridge(s1);
+                if (!bridge)
+                    continue;
+                const prun = tables.center2.pruning[bridge.encoded.ct * CENTER2_RL_STATES + bridge.encoded.rl];
+                if (prun > length2)
+                    continue;
+                const fullP1Moves = [...p1.moves, ...bridge.alignment];
+                if (searchPhase2(bridge.encoded.ct, bridge.encoded.rl, length2, -1, 0, bridge.state, fullP1Moves)) {
+                    break OUTER;
+                }
+            }
+        }
+        MAX_P2++;
+    } while (candidates.length === 0 && MAX_P2 <= 14);
+    if (candidates.length === 0) {
+        throw new Error("4x4 solve: no valid phase 2 candidates found.");
+    }
+    candidates.sort((a, b) => a.value - b.value);
+    let solvedCand = null;
+    let solvedMoves3 = null;
+    let standardReduced = null;
+    let rotPath = [];
+    let rotToStandard = [];
+    let MAX_LENGTH3 = 13;
+    let yieldCounter = 0;
+    do {
+        for (let length123 = candidates[0].value; length123 < 45; length123++) {
+            for (let i = 0; i < Math.min(candidates.length, 60); i++) {
+                const cand = candidates[i];
+                if (cand.value > length123)
+                    break;
+                const length3 = length123 - cand.length12;
+                if (length3 > MAX_LENGTH3 || length3 < 0)
+                    continue;
+                if (cand.edist <= length3 && cand.cdist <= length3) {
+                    if (++yieldCounter % 100 === 0)
+                        await new Promise(r => setTimeout(r, 0));
+                    const moves3 = await phase3Solver.solveLength(cand.edge, cand.ct3, cand.edist, length3, tables.center3, tables.edge3.distances);
+                    if (!moves3)
+                        continue;
+                    const reduced = applyCube4Algorithm(cand.state, moves3);
+                    const key = `${reduced.centers[0]},${reduced.centers[4]},${reduced.centers[8]}`;
+                    const path = VALID_24_ORIENTATIONS.get(key);
+                    if (!path)
+                        continue;
+                    solvedCand = cand;
+                    solvedMoves3 = moves3;
+                    rotPath = path;
+                    rotToStandard = invertRotationSequence(rotPath);
+                    standardReduced = applyCubeRotation(reduced, rotToStandard);
+                    break;
+                }
+            }
+            if (solvedCand)
+                break;
+        }
+        MAX_LENGTH3++;
+    } while (!solvedCand && MAX_LENGTH3 <= 18);
+    if (!solvedCand || !solvedMoves3 || !standardReduced) {
+        throw new Error("4x4 solve: reduction failed across all candidates.");
+    }
+    const cube3State = toCube3State(standardReduced);
+    if (!cube3State) {
+        throw new Error("4x4 solve: failed to convert reduced 4x4 state to 3x3 state.");
+    }
+    let cube3Solution;
+    try {
+        cube3Solution = await solveCube3(cube3State);
+    }
+    catch (error) {
+        if (error instanceof Cube3Phase2SearchError) {
+            throw error;
+        }
+        throw error;
+    }
+    const fullSolInOriginal = [
+        ...solvedCand.moves12,
+        ...solvedMoves3,
+        ...rotateAlgorithm(cube3Solution.moves, rotPath)
+    ];
+    const fullSolToStandard = [
+        ...fullSolInOriginal,
+        ...rotToStandard.flatMap((r) => ROT_MOVES[r])
+    ];
+    const scramble = invertCube4Algorithm(fullSolToStandard);
+    return { moves: fullSolToStandard, scramble };
+}

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

@@ -1,4 +1,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.
+ */
 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): Promise<ScrambleResult>;
+export declare function generateCube4Scramble(options?: ScrambleOptions & {
+    skipValidation?: boolean;
+}): Promise<ScrambleResult>;
 //# sourceMappingURL=scrambler.d.ts.map

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,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAU9F,eAAO,MAAM,sBAAsB,EAAE,iBAYpC,CAAC;AAEF,wBAAsB,qBAAqB,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CA+BlG"}
+{"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"}

package/dist/puzzles/cube4/scrambler.js

@@ -1,98 +1,140 @@
-import { createSolvedCube4State } from "./state.js";
-import { applyCube4Algorithm } from "./moves.js";
-import { toCube4Facelets, formatCube4Facelets } from "./facelets.js";
-const SCRAMBLE_LENGTH = 40;
+/**
+ * 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.
+ */
+import { formatCube4Algorithm, applyCube4Algorithm } from "./moves.js";
+import { generateRandomCube4State } from "./random-state.js";
+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";
+let cachedTables;
+async function loadCube4Tables(baseUrl) {
+    if (cachedTables)
+        return cachedTables;
+    const isBrowser = typeof window !== "undefined" ||
+        typeof document !== "undefined" ||
+        (typeof self !== "undefined" && typeof self.importScripts === "function") ||
+        (typeof navigator !== "undefined" && /Moz|WebKit/.test(navigator.userAgent));
+    const isNode = typeof process !== "undefined" && process.versions?.node != null;
+    if (isBrowser && !isNode) {
+        const loader = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "./reduction/browser-loader.js");
+        const cached = loader.getCachedCube4Tables();
+        if (cached) {
+            cachedTables = cached;
+            return cached;
+        }
+        const tables = await loader.loadCube4ReductionTablesBrowser(baseUrl);
+        cachedTables = tables;
+        return tables;
+    }
+    const loader = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./reduction/node-loader.js");
+    const tables = await loader.loadCube4ReductionTables();
+    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",
         name: "4x4x4 Cube",
         puzzle: "cube-4x4",
         quality: "random-state",
-        generator: "cubing-scramble",
-        description: "Random-state 4x4 scramble generated by cubing.js."
+        generator: "cube4-reduction",
+        description: "Random-state 4x4 scramble via the reduction solver (centers + pairing + 3x3 finish)."
     },
     generate(options = {}) {
         return generateCube4Scramble(options);
     }
 };
 export async function generateCube4Scramble(options = {}) {
-    // Use cubing library for high-quality random-state 4x4 scrambles
-    const { randomScrambleForEvent } = await import("cubing/scramble");
-    const alg = await randomScrambleForEvent("444");
-    const scramble = alg.toString();
-    const moves = scramble.split(/\s+/);
-    const targetState = applyCube4Algorithm(createSolvedCube4State(), moves);
-    const faceletString = formatCube4Facelets(toCube4Facelets(targetState));
-    const result = {
-        eventId: "444",
-        scramble,
-        moves,
-        quality: "random-state",
-        generator: "cubing-scramble",
-        metadata: {
-            totalMoves: moves.length,
-            distribution: "random-state",
-            state: targetState,
-            facelets: toCube4Facelets(targetState),
-            faceletString
-        }
-    };
-    if (options.seed !== undefined) {
-        result.seed = options.seed;
-    }
-    return result;
-}
-const MAX_AXIS_BLOCK = 3;
-const ROTATION_PAIRS = {
-    "Uw": "Dw", "Dw": "Uw",
-    "Rw": "Lw", "Lw": "Rw",
-    "Fw": "Bw", "Bw": "Fw",
-};
-function getBaseMove(move) {
-    if (move.endsWith("2") || move.endsWith("'")) {
-        return move.slice(0, -1);
-    }
-    return move;
-}
-function getAxis(base) {
-    if (base.includes("R") || base.includes("L"))
-        return "X";
-    if (base.includes("U") || base.includes("D"))
-        return "Y";
-    if (base.includes("F") || base.includes("B"))
-        return "Z";
-    return "";
-}
-function isRedundant(moves, newMove) {
-    if (moves.length === 0)
-        return false;
-    const newBase = getBaseMove(newMove);
-    const newAxis = getAxis(newBase);
-    const lastBase = getBaseMove(moves[moves.length - 1]);
-    if (lastBase === newBase)
-        return true;
-    const lastAxis = getAxis(lastBase);
-    if (newAxis !== lastAxis)
-        return false;
-    const basesInBlock = new Set();
-    basesInBlock.add(lastBase);
-    let blockLength = 1;
-    for (let i = moves.length - 2; i >= 0; i--) {
-        const base = getBaseMove(moves[i]);
-        if (getAxis(base) === newAxis) {
-            basesInBlock.add(base);
-            blockLength++;
+    const tables = await loadCube4Tables();
+    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;
         }
         else {
-            break;
+            attemptOptions = { ...options };
+            if (options.seed !== undefined) {
+                attemptOptions.seed = `${options.seed}:retry${attempt}`;
+            }
+            else {
+                delete attemptOptions.seed;
+            }
+        }
+        const attemptState = generateRandomCube4State(attemptOptions);
+        try {
+            const solvePromise = solveCube4State(attemptState, tables, (cube3State) => 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 = applyCube4Algorithm(createSolvedCube4State(), scrambleMoves);
+                if (!cube4StatesEqual(scrambledState, attemptState)) {
+                    throw new Error("Generated 4x4 scramble does not reproduce the target random state.");
+                }
+            }
+            const facelets = toCube4Facelets(attemptState);
+            const result = {
+                eventId: "444",
+                scramble: formatCube4Algorithm(scrambleMoves),
+                moves: scrambleMoves,
+                quality: "random-state",
+                generator: "cube4-reduction",
+                metadata: {
+                    generator: "cube4-reduction",
+                    state: attemptState,
+                    facelets,
+                    faceletString: formatCube4Facelets(facelets),
+                    distribution: "random-state",
+                    ...options.metadata
+                }
+            };
+            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;
         }
     }
-    if (basesInBlock.has(newBase))
-        return true;
-    const complement = ROTATION_PAIRS[newBase];
-    if (complement && basesInBlock.has(complement))
-        return true;
-    if (blockLength >= MAX_AXIS_BLOCK)
-        return true;
-    return false;
+    throw lastError;
 }