@cubingcenter/scrambler 0.6.3 → 0.7.0

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

@@ -3,16 +3,107 @@
  * (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 { applyCube4Algorithm, invertCube4Algorithm, simplifyCube4Algorithm } from "../moves.js";
+import { center1Mask, getCenter1Distance, applyCenter1Move, CENTER1_MOVES, CENTER1_GOAL_MASKS } from "./center1.js";
+import { center2Bridge, getWingMoveMaps, isCenter2Goal, CENTER2_MOVES, CENTER2_SEARCH_MOVES, CENTER2_SEARCH_MOVES_WIDE, CENTER2_RL_STATES } from "./center2.js";
 import { encodeCenter3 } from "./center3.js";
-import { encodePairingState } from "./pairing-coordinate.js";
+import { encodePairingState, hasPairingTransversal } from "./pairing-coordinate.js";
+import { encodeHcPdb } from "./hc-pdb.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 { checkCube4Reduction, toCube3State } from "./phase4.js";
+import { encodeCornerOrientation, encodeEdgeOrientation, encodeUdSlice } from "../../cube3/solver/coordinates.js";
 import { createSolvedCube4State } from "../state.js";
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function hashCube4State(state) {
+    let h = 0x811c9dc5;
+    for (const arr of [state.cp, state.co, state.wp, state.centers]) {
+        for (let i = 0; i < arr.length; i++) {
+            h ^= arr[i] & 0xff;
+            h = Math.imul(h, 0x01000193);
+        }
+    }
+    return h >>> 0;
+}
+/**
+ * Fisher-Yates order, or identity when rng is null (restarts=1 keeps the
+ * legacy deterministic traversal bit-identical).
+ */
+function restartOrder(n, rng) {
+    const order = Array.from({ length: n }, (_, i) => i);
+    if (rng) {
+        for (let i = n - 1; i > 0; i--) {
+            const j = Math.floor(rng() * (i + 1));
+            const t = order[i];
+            order[i] = order[j];
+            order[j] = t;
+        }
+    }
+    return order;
+}
+/**
+ * Fisher-Yates within equal-key runs of a key-sorted array, so the
+ * caller's sorted early-break (`value > length123`) stays valid.
+ */
+function shuffleTies(arr, key, rng) {
+    if (!rng)
+        return;
+    let run = 0;
+    for (let i = 1; i <= arr.length; i++) {
+        if (i < arr.length && key(arr[i]) === key(arr[run]))
+            continue;
+        for (let k = i - 1; k > run; k--) {
+            const j = run + Math.floor(rng() * (k - run + 1));
+            const t = arr[k];
+            arr[k] = arr[j];
+            arr[j] = t;
+        }
+        run = i;
+    }
+}
+function getCube3Phase1Heuristic(cube3State, tables) {
+    const co = encodeCornerOrientation(cube3State);
+    const eo = encodeEdgeOrientation(cube3State);
+    const ud = encodeUdSlice(cube3State);
+    const combined = (co << 11) + eo;
+    const coeo = (tables.pruningTables.cornerOrientationEdgeOrientation.values[combined >> 1] >>
+        ((combined & 1) << 2)) &
+        0x0f;
+    const udd = (tables.pruningTables.udSlice.values[ud >> 1] >> ((ud & 1) << 2)) & 0x0f;
+    return Math.max(coeo, udd);
+}
+function getTriAxialCube3Heuristic(standardReduced, tables) {
+    const s0 = toCube3State(standardReduced);
+    if (!s0)
+        return 99;
+    let minH = getCube3Phase1Heuristic(s0, tables);
+    if (minH <= 3)
+        return minH;
+    const sx = toCube3State(applyCubeRotation(standardReduced, ["x"]));
+    if (sx) {
+        const hx = getCube3Phase1Heuristic(sx, tables);
+        if (hx < minH)
+            minH = hx;
+        if (minH <= 3)
+            return minH;
+    }
+    const sz = toCube3State(applyCubeRotation(standardReduced, ["z"]));
+    if (sz) {
+        const hz = getCube3Phase1Heuristic(sz, tables);
+        if (hz < minH)
+            minH = hz;
+    }
+    return minH;
+}
 function cornerPermutationParity(cp) {
     let parity = 0;
     const seen = new Array(8).fill(false);
@@ -30,13 +121,48 @@ function cornerPermutationParity(cp) {
     }
     return parity;
 }
+/**
+ * Computes the spatial determinant (+1 for valid 3D rotations, -1 for reflections)
+ * of the 3 axes defined by the center colors on faces U, R, F.
+ */
+function getOrientationDet(uColor, rColor, fColor) {
+    const vec = (c) => {
+        switch (c) {
+            case 0: return [0, 0, 1];
+            case 3: return [0, 0, -1];
+            case 1: return [1, 0, 0];
+            case 4: return [-1, 0, 0];
+            case 2: return [0, 1, 0];
+            case 5: return [0, -1, 0];
+            default: return [0, 0, 0];
+        }
+    };
+    const [ux, uy, uz] = vec(uColor);
+    const [rx, ry, rz] = vec(rColor);
+    const [fx, fy, fz] = vec(fColor);
+    const cx = ry * fz - rz * fy;
+    const cy = rz * fx - rx * fz;
+    const cz = rx * fy - ry * fx;
+    return cx * ux + cy * uy + cz * uz;
+}
+function axisDet(uAxis, rAxis, fAxis) {
+    if ((uAxis === 0 && rAxis === 1 && fAxis === 2) ||
+        (uAxis === 1 && rAxis === 2 && fAxis === 0) ||
+        (uAxis === 2 && rAxis === 0 && fAxis === 1)) {
+        return 1;
+    }
+    return -1;
+}
 const ROT_MOVES = {
     "x": ["Rw", "Lw'"],
     "y": ["Uw", "Dw'"],
     "z": ["Fw", "Bw'"],
     "x'": ["Rw'", "Lw"],
     "y'": ["Uw'", "Dw"],
-    "z'": ["Fw'", "Bw"]
+    "z'": ["Fw'", "Bw"],
+    "x2": ["Rw2", "Lw2"],
+    "y2": ["Uw2", "Dw2"],
+    "z2": ["Fw2", "Bw2"]
 };
 const VALID_24_ORIENTATIONS = (() => {
     const map = new Map();
@@ -63,12 +189,16 @@ const ROT_MAP = {
     "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" }
+    "z'": { "U": "L", "R": "U", "F": "F", "D": "R", "L": "D", "B": "B" },
+    "x2": { "U": "D", "R": "R", "F": "B", "D": "U", "L": "L", "B": "F" },
+    "y2": { "U": "U", "R": "L", "F": "B", "D": "D", "L": "R", "B": "F" },
+    "z2": { "U": "D", "R": "L", "F": "F", "D": "U", "L": "R", "B": "B" }
 };
 const INVERT_ROT = {
     "x": "x'", "x'": "x",
     "y": "y'", "y'": "y",
-    "z": "z'", "z'": "z"
+    "z": "z'", "z'": "z",
+    "x2": "x2", "y2": "y2", "z2": "z2"
 };
 function rotateMove(move, rot) {
     const map = ROT_MAP[rot];
@@ -76,17 +206,22 @@ function rotateMove(move, rot) {
     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;
+export function rotateAlgorithm(alg, rotSeq) {
+    // Single pass over the algorithm (one allocation): applying the rotation
+    // sequence per move instead of re-mapping the whole array per rotation.
+    if (rotSeq.length === 0)
+        return [...alg];
+    return alg.map((move) => {
+        let current = move;
+        for (const rot of rotSeq)
+            current = rotateMove(current, rot);
+        return current;
+    });
 }
-function invertRotationSequence(rotSeq) {
+export function invertRotationSequence(rotSeq) {
     return [...rotSeq].reverse().map((r) => INVERT_ROT[r]);
 }
-function applyCubeRotation(state, rotSeq) {
+export function applyCubeRotation(state, rotSeq) {
     let s = state;
     for (const r of rotSeq) {
         s = applyCube4Algorithm(s, ROT_MOVES[r]);
@@ -116,196 +251,800 @@ function isCancelled(previous, 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))
+// Precomputed phase-2 cancellation matrix over CENTER2_SEARCH_MOVES: the
+// search evaluates isCancelled per child per node (~0.3M nodes × 23 moves
+// per attempt with regex + Map lookups); the table makes it one boolean
+// read with a bit-identical traversal.
+export const P2_CANCEL = CENTER2_SEARCH_MOVES.map((previous) => CENTER2_SEARCH_MOVES.map((current) => isCancelled(previous, current)));
+// Same over the wide 28-move set (used when `center2Wide` is set).
+const P2_CANCEL_WIDE = CENTER2_SEARCH_MOVES_WIDE.map((previous) => CENTER2_SEARCH_MOVES_WIDE.map((current) => isCancelled(previous, current)));
+const SKIP_AXIS_2 = new Int32Array(CENTER2_SEARCH_MOVES.length);
+for (let i = 0; i < CENTER2_SEARCH_MOVES.length; i++) {
+    const m1 = CENTER2_SEARCH_MOVES[i];
+    const face1 = m1.replace(/2|'|w/g, "");
+    const isWide1 = m1.includes("w");
+    SKIP_AXIS_2[i] = CENTER2_SEARCH_MOVES.length;
+    for (let j = i + 1; j < CENTER2_SEARCH_MOVES.length; j++) {
+        const m2 = CENTER2_SEARCH_MOVES[j];
+        const face2 = m2.replace(/2|'|w/g, "");
+        const isWide2 = m2.includes("w");
+        if (face1 !== face2 || isWide1 !== isWide2) {
+            SKIP_AXIS_2[i] = j;
             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) {
+/** Temporary instrumentation for F2 goal statistics (CUBE4_F2_STATS=1). */
+export const f2Stats = { goals: 0, transversalPass: 0, axisRejects: 0, minTransversalL2: 99, minChiralL2: 99 };
+export function resetF2Stats() {
+    f2Stats.goals = 0;
+    f2Stats.transversalPass = 0;
+    f2Stats.axisRejects = 0;
+    f2Stats.minTransversalL2 = 99;
+    f2Stats.minChiralL2 = 99;
+}
+/** Trigger rate for the stagnationCut early-stop (checks vs actual cuts). */
+export const stagnationStats = { checks: 0, cuts: 0 };
+export function resetStagnationStats() {
+    stagnationStats.checks = 0;
+    stagnationStats.cuts = 0;
+}
+export async function solveCube4State(state, tables, solveCube3, options) {
+    // NOTE: no wall-clock deadline inside the search — all loops are bounded
+    // by deterministic work caps (node counts, candidate counts, length
+    // caps), so the same state always takes the same path. The caller keeps
+    // its own backstop (`timeoutMs` handled at the call site).
     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
+    phase3Solver.resetEpochNodes();
+    const totalRestarts = Math.max(1, Math.floor(options?.restarts ?? 1));
+    // Cross-restart work accumulators (reported in nodes/timings).
+    let accP2 = 0;
+    let accF3calls = 0;
+    let accF1Ms = 0;
+    let accF2Ms = 0;
+    let accF3Ms = 0;
+    let accFinishMs = 0;
+    let accPolishMs = 0;
+    const runOnce = async (rng) => {
+        const tR0 = performance.now();
+        const p1Sols = [];
+        let minOverallH = 99;
+        const urfDistances = [];
+        for (const urf of [0, 1, 2]) {
+            const mask = center1Mask(state.centers, urf);
+            const h = getCenter1Distance(mask, tables.center1);
+            urfDistances.push(h);
+            if (h < minOverallH)
+                minOverallH = h;
+        }
+        const path = [];
+        const p1Extra = options?.phase1ExtraDepths ?? 3;
+        const p1Cap = options?.phase1Cap ?? 400;
+        // Per-restart DFS traversal order (identity when rng is null).
+        const p1Order = restartOrder(CENTER1_MOVES.length, rng);
+        for (let maxD = minOverallH; maxD <= minOverallH + p1Extra; maxD++) {
+            for (const urf of [0, 1, 2]) {
+                const minH = urfDistances[urf];
+                if (maxD < minH)
+                    continue;
+                const mask = center1Mask(state.centers, urf);
+                let axisCount = 0;
+                const dfs = (m, depth, lm) => {
+                    if (axisCount >= p1Cap)
+                        return true;
+                    const h = getCenter1Distance(m, tables.center1);
+                    if (h === 0) {
+                        let rotAlign = [];
+                        if (m === CENTER1_GOAL_MASKS.rl) {
+                            rotAlign = [];
+                        }
+                        else if (m === CENTER1_GOAL_MASKS.ud) {
+                            rotAlign = ["z"];
+                        }
+                        else if (m === CENTER1_GOAL_MASKS.fb) {
+                            rotAlign = ["y'"];
+                        }
+                        else {
+                            return false;
+                        }
+                        axisCount++;
+                        p1Sols.push({
+                            moves: path.slice(0, depth).map((mv) => CENTER1_MOVES[mv]),
+                            length: depth,
+                            rotAlign
                         });
-                        if (candidates.length >= 60)
+                        return false;
+                    }
+                    if (depth + h > maxD)
+                        return false;
+                    for (let mi = 0; mi < CENTER1_MOVES.length; mi++) {
+                        const mv = p1Order[mi];
+                        if (lm >= 0 && Math.floor(lm / 3) === Math.floor(mv / 3))
+                            continue;
+                        const next = applyCenter1Move(m, tables.center1.moveMaps, mv);
+                        path[depth] = mv;
+                        if (dfs(next, depth + 1, mv))
                             return true;
                     }
+                    return false;
+                };
+                dfs(mask, 0, -1);
+            }
+            if (p1Sols.length >= p1Cap)
+                break;
+        }
+        p1Sols.sort((a, b) => a.moves.length - b.moves.length);
+        const minP1 = p1Sols[0]?.moves.length ?? 0;
+        const tF1End = performance.now();
+        const candidates = [];
+        const moveLog = new Array(25);
+        // Incremental wing tracking stack for phase-2 goal transversal checks:
+        // avoids full 6-7 move replaying from scratch across hundreds of thousands of candidate goals.
+        const wpStack = Array.from({ length: 24 }, () => new Uint8Array(24));
+        let validWpDepth = 0;
+        const wingMaps = getWingMoveMaps();
+        /**
+         * Anti-hang work cap for the phase-2 search (successful attempts use
+         * ~0.1-0.3M nodes; this only aborts pathological explorations).
+         * Exceeding it degrades gracefully: the call returns false and the
+         * remaining (prep, length2) combinations still run.
+         */
+        const deep = options?.deep === true;
+        // Wide phase-2 set (28 moves) + its pruning table. Both sets are
+        // prefixes of CENTER2_MOVES, so search indices stay valid move-table
+        // indices in either mode.
+        const c2Wide = options?.center2Wide === true;
+        const C2_SEARCH = c2Wide ? CENTER2_SEARCH_MOVES_WIDE : CENTER2_SEARCH_MOVES;
+        const C2_CANCEL = c2Wide ? P2_CANCEL_WIDE : P2_CANCEL;
+        // Per-restart child order (identity when rng is null). Entries stay
+        // original move-table indices, so all table lookups are unaffected.
+        const p2Order = restartOrder(C2_SEARCH.length, rng);
+        let c2pruning = tables.center2.pruning;
+        if (c2Wide) {
+            if (!tables.center2.pruningWide) {
+                throw new Error("4x4 solve: center2Wide requested but pruningWide tables are not loaded — regenerate center2 tables.");
+            }
+            c2pruning = tables.center2.pruningWide;
+        }
+        const P2_MAX_NODES = deep ? 24_000_000 : 8_000_000;
+        // Smaller pool + shorter extension (was 180/100/14/12 on the fast path):
+        // the deep length2 levels are where F2 tails burn. Validated on a 44-state
+        // corpus: -16% nodes, identical average length (one +1 in 44).
+        const CAND_CAP = deep ? 300 : 120;
+        const CAND_MIN = deep ? 180 : 35;
+        const P2_MAX_ABS = deep ? 18 : 14;
+        const P2_MAX_MIN = deep ? 16 : 10;
+        const L123_CAP = options?.maxReductionLen
+            ? Math.min(options.maxReductionLen, deep ? 48 : 45)
+            : (deep ? 48 : 45);
+        const EXT_MX = deep ? 20 : 16;
+        let p2nodes = 0;
+        let f3calls = 0;
+        function searchPhase2(c, r, maxl, lm, depth, bridgeState, prep) {
+            p2nodes++;
+            if (p2nodes > P2_MAX_NODES)
+                return false;
+            if (isCenter2Goal(c, r)) {
+                if (maxl === 0) {
+                    while (validWpDepth < depth) {
+                        const m = moveLog[validWpDepth];
+                        const base = m * 24;
+                        const src = wpStack[validWpDepth];
+                        const dst = wpStack[validWpDepth + 1];
+                        for (let i = 0; i < 24; i++)
+                            dst[i] = src[wingMaps[base + i]];
+                        validWpDepth++;
+                    }
+                    const goalWp = wpStack[depth];
+                    if (process.env.CUBE4_F2_STATS === "1")
+                        f2Stats.goals++;
+                    if (!hasPairingTransversal(goalWp))
+                        return false;
+                    if (process.env.CUBE4_F2_STATS === "1")
+                        f2Stats.transversalPass++;
+                    const moves2 = moveLog.slice(0, depth).map((m) => CENTER2_MOVES[m]);
+                    const s2 = applyCube4Algorithm(bridgeState, moves2);
+                    const uAxis = s2.centers[0] % 3;
+                    const rAxis = s2.centers[4] % 3;
+                    const fAxis = s2.centers[8] % 3;
+                    if (process.env.CUBE4_F2_STATS === "1") {
+                        if (depth < f2Stats.minTransversalL2)
+                            f2Stats.minTransversalL2 = depth;
+                    }
+                    if (axisDet(uAxis, rAxis, fAxis) !== 1) {
+                        if (process.env.CUBE4_F2_STATS === "1")
+                            f2Stats.axisRejects++;
+                        return false;
+                    }
+                    if (process.env.CUBE4_F2_STATS === "1") {
+                        if (depth < f2Stats.minChiralL2)
+                            f2Stats.minChiralL2 = depth;
+                    }
+                    const pairing = encodePairingState(s2.wp);
+                    if (pairing) {
+                        const s2CornerParity = cornerPermutationParity(s2.cp);
+                        const eXc = (pairing.parity ^ s2CornerParity);
+                        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.length >= 31006080
+                                ? tables.edge3.distances[symIdx >> 3]
+                                : (tables.edge3.distances[(symIdx >> 3) >> 1] >>
+                                    (((symIdx >> 3) & 1) * 4)) &
+                                    0x0f;
+                            const moves2Remapped = prep.totalRot.length === 0
+                                ? moves2
+                                : rotateAlgorithm(moves2, invertRotationSequence(prep.totalRot));
+                            const hcCoord = tables.hc ? tables.hc.index[encodeHcPdb(s2.centers)] : -1;
+                            const hcRaw = hcCoord >= 0 && tables.hc ? tables.hc.distances[hcCoord] : 0;
+                            const hdist = hcRaw === 0x0f ? 0 : hcRaw;
+                            let pdist = 0;
+                            let pdistHigh = 0;
+                            if (tables.c3PairDist) {
+                                const c3Base = ct3 * 144;
+                                for (let s = 0; s < 12; s++) {
+                                    const idx = c3Base + s * 12 + pairing.edge[s];
+                                    const d = (idx & 1) === 0 ? (tables.c3PairDist[idx >> 1] & 0x0f) : (tables.c3PairDist[idx >> 1] >> 4);
+                                    if (d > pdist)
+                                        pdist = d;
+                                    if (d >= 8)
+                                        pdistHigh++;
+                                }
+                            }
+                            const cand = {
+                                moves12: [...prep.prefix, ...moves2Remapped],
+                                length12: prep.prefix.length + moves2.length,
+                                ct3,
+                                cdist,
+                                edge: pairing.edge,
+                                edist,
+                                hdist,
+                                pdist,
+                                hcCoord,
+                                rotCost: 0,
+                                value: prep.prefix.length + moves2.length + Math.max(cdist, edist, hdist, pdist) + (pdistHigh >= 4 ? 2 : (pdistHigh >= 2 ? 1 : 0)),
+                                state: s2,
+                                p1: prep.p1,
+                                totalRot: prep.totalRot
+                            };
+                            if (candidates.length < CAND_CAP) {
+                                candidates.push(cand);
+                                if (candidates.length === CAND_CAP) {
+                                    candidates.sort((a, b) => a.value - b.value);
+                                }
+                            }
+                            else if (cand.value < candidates[candidates.length - 1].value) {
+                                candidates[candidates.length - 1] = cand;
+                                for (let j = candidates.length - 1; j > 0 && candidates[j].value < candidates[j - 1].value; j--) {
+                                    const tmp = candidates[j];
+                                    candidates[j] = candidates[j - 1];
+                                    candidates[j - 1] = tmp;
+                                }
+                            }
+                            p1CandCount++;
+                            const maxP1Cand = options?.p1CandCap !== undefined ? options.p1CandCap : (deep ? 96 : 64);
+                            if (p1CandCount >= maxP1Cand)
+                                return true;
+                        }
+                    }
                 }
+                return false;
+            }
+            if (maxl === 0)
+                return false;
+            const c2ctMove = tables.center2.ctMove;
+            const c2rlMove = tables.center2.rlMove;
+            const c2RowC = c * CENTER2_MOVES.length;
+            const c2RowR = r * CENTER2_MOVES.length;
+            for (let mi = 0; mi < C2_SEARCH.length; mi++) {
+                const m = p2Order[mi];
+                if (lm >= 0 && C2_CANCEL[lm][m]) {
+                    continue;
+                }
+                const nc = c2ctMove[c2RowC + m];
+                const nr = c2rlMove[c2RowR + m];
+                const prun = c2pruning[nc * CENTER2_RL_STATES + nr];
+                if (prun >= maxl) {
+                    if (prun > maxl && rng === null && !c2Wide) {
+                        mi = SKIP_AXIS_2[m] - 1;
+                    }
+                    continue;
+                }
+                moveLog[depth] = m;
+                if (validWpDepth > depth)
+                    validWpDepth = depth;
+                if (searchPhase2(nc, nr, maxl - 1, m, depth + 1, bridgeState, prep))
+                    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])) {
+        let p1CandCount = 0;
+        let MAX_P2 = 8;
+        // Phase-1 application + the phase-2 bridge depend only on the phase-1
+        // solution, not on the phase-2 target length: compute them once instead
+        // of redoing the work for every length12 iteration.
+        // Alignment is treated purely as a coordinate frame rotation (matching
+        // csTimer's sym frame remapping), adding 0 physical moves to prefix.
+        const preps = [];
+        for (const p1 of p1Sols) {
+            const s1 = applyCube4Algorithm(state, p1.moves);
+            const s1Aligned = p1.rotAlign.length === 0 ? s1 : applyCubeRotation(s1, p1.rotAlign);
+            const bridge = center2Bridge(s1Aligned);
+            if (!bridge)
                 continue;
+            const totalRot = [...p1.rotAlign, ...bridge.rotation];
+            const prefix = p1.moves;
+            const prun = c2pruning[bridge.encoded.ct * CENTER2_RL_STATES + bridge.encoded.rl];
+            // Paired wings lookahead: check how many wings are already paired in bridge.state
+            let pairedWings = 0;
+            const wp = bridge.state.wp;
+            for (let pair = 0; pair < 12; pair++) {
+                if (Math.floor(wp[pair * 2] / 2) === Math.floor(wp[pair * 2 + 1] / 2)) {
+                    pairedWings++;
+                }
             }
-            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;
+            // Lookahead composite score: total estimated centers penalized by already-paired wings
+            const estCenters = prefix.length + prun;
+            const score = estCenters * 2 - Math.min(4, pairedWings);
+            preps.push({ p1, prefix, bridgeState: bridge.state, totalRot, ct: bridge.encoded.ct, rl: bridge.encoded.rl, prun, score });
         }
-        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;
+        // Ascending lookahead score (lowest total estimated center moves + wing bonus),
+        // tie-broken by lower phase-2 pruning bound then shorter prefix length
+        preps.sort((a, b) => (a.score - b.score) || (a.prun - b.prun) || (a.prefix.length - b.prefix.length));
+        // Filter: keep the best preps to avoid wasting phase-2 DFS work on suboptimal centers
+        const PREP_CAP = options?.prepCap !== undefined ? options.prepCap : (deep ? 160 : 100);
+        if (preps.length > PREP_CAP) {
+            preps.length = PREP_CAP;
+        }
+        // Per-restart tie order only (the ascending order above is preserved).
+        shuffleTies(preps, (p) => p.score, rng);
+        // Passes after the first one only extend MAX_P2 by one: every smaller
+        // length2 was already searched (deterministic — rerunning would push the
+        // same goals again as duplicates and crowd the 45 cap), so skip them.
+        // Tracked exactly per (prep, length2): this also fills holes left when a
+        // pass breaks early at the 45 cap, and is reused by the diversity
+        // extension below.
+        const searchedL2 = new Set();
+        let lastBestValue = 999;
+        let stagnantLengths = 0;
+        do {
+            OUTER: for (let length12 = minP1; length12 < minP1 + 16; length12++) {
+                for (let pi = 0; pi < preps.length; pi++) {
+                    const prep = preps[pi];
+                    if (prep.prefix.length > length12)
+                        continue;
+                    const length2 = length12 - prep.prefix.length;
+                    if (length2 > MAX_P2 || length2 < 0)
+                        continue;
+                    if (prep.prun > length2)
+                        continue;
+                    const key = pi * 64 + length2;
+                    if (searchedL2.has(key))
+                        continue;
+                    searchedL2.add(key);
+                    p1CandCount = 0;
+                    wpStack[0].set(prep.bridgeState.wp);
+                    validWpDepth = 0;
+                    searchPhase2(prep.ct, prep.rl, length2, -1, 0, prep.bridgeState, prep);
+                    if (candidates.length >= CAND_CAP &&
+                        candidates[0].value <= length12 + 9 &&
+                        (candidates[0].edist <= 10 || length12 >= minP1 + 3)) {
+                        break OUTER;
+                    }
+                }
+                if (options?.stagnationCut !== false && candidates.length >= CAND_MIN) {
+                    stagnationStats.checks++;
+                    // NOTE: candidates is only sorted once it reaches CAND_CAP, so
+                    // candidates[0] is NOT the best below the cap — scan the true min.
+                    let curBest = Infinity;
+                    for (let ci = 0; ci < candidates.length; ci++) {
+                        const v = candidates[ci].value;
+                        if (v < curBest)
+                            curBest = v;
+                    }
+                    if (curBest >= lastBestValue) {
+                        stagnantLengths++;
+                        if (stagnantLengths >= 2) {
+                            stagnationStats.cuts++;
+                            break OUTER;
+                        }
+                    }
+                    else {
+                        lastBestValue = curBest;
+                        stagnantLengths = 0;
+                    }
                 }
             }
+            MAX_P2++;
+        } while ((candidates.length === 0 && MAX_P2 <= P2_MAX_ABS) || (candidates.length < CAND_MIN && MAX_P2 <= P2_MAX_MIN));
+        if (candidates.length === 0) {
+            throw new Error("4x4 solve: no valid phase 2 candidates found.");
         }
-        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)
+        const tF2End = performance.now();
+        const validReductions = [];
+        /**
+         * Per-candidate IDA* proofs shared across all sweep stages: the greatest
+         * phase-3 length exhaustively proved empty for that candidate. Entries
+         * are only written on clean proofs (no cap abort, no goal seen, no TT
+         * hit, complete excess info), so skipping those lengths is exact.
+         */
+        const p3Proven = new Map();
+        /**
+         * Sync downstream chain for a phase-3 goal sequence: reduction check,
+         * orientation remap, 3x3 conversion + phase-1 heuristic. Returns the
+         * ValidReduction or null. Shared by the sweep validator and the polish
+         * pass (which retries the winner one length shorter).
+         */
+        function buildValidReduction(cand, moves3) {
+            const reduced = applyCube4Algorithm(cand.state, moves3);
+            if (checkCube4Reduction(reduced) !== null)
+                return null;
+            const totalRot = cand.totalRot;
+            const invTotalRot = totalRot.length === 0 ? [] : invertRotationSequence(totalRot);
+            const moves3Remapped = totalRot.length === 0 ? moves3 : rotateAlgorithm(moves3, invTotalRot);
+            const reducedOriginal = totalRot.length === 0 ? reduced : applyCubeRotation(reduced, invTotalRot);
+            const key = `${reducedOriginal.centers[0]},${reducedOriginal.centers[4]},${reducedOriginal.centers[8]}`;
+            const path = VALID_24_ORIENTATIONS.get(key);
+            if (!path)
+                return null;
+            const rotToStandard = invertRotationSequence(path);
+            const standardReduced = applyCubeRotation(reducedOriginal, rotToStandard);
+            const cube3State = toCube3State(standardReduced);
+            if (!cube3State) {
+                console.log("    toCube3State failed!");
+                return null;
+            }
+            const h3 = tables.cube3Phase1 ? getTriAxialCube3Heuristic(standardReduced, tables.cube3Phase1) : 0;
+            const reductionMoves = [
+                ...rotateAlgorithm(cand.moves12, rotToStandard),
+                ...rotateAlgorithm(moves3Remapped, rotToStandard)
+            ];
+            const simplifiedReduction = simplifyCube4Algorithm(reductionMoves);
+            return {
+                cand,
+                moves3,
+                moves3Remapped,
+                rotPath: path,
+                rotToStandard,
+                rotMoves: rotToStandard.flatMap((r) => ROT_MOVES[r]),
+                standardReduced,
+                h3,
+                totalEst: simplifiedReduction.length + h3
+            };
+        }
+        const centersBeam = Math.max(1, options?.centersBeam ?? 3);
+        const edgesPerCenter = Math.max(1, options?.edgesPerCenter ?? 3);
+        const maxReductionsTarget = options?.finishTries !== undefined
+            ? Math.max(1, options.finishTries)
+            : (centersBeam * edgesPerCenter);
+        /**
+         * One exact-length sweep over a value-sorted pool: tries increasing
+         * totals, collects up to maxReductionsTarget valid reductions using
+         * hierarchical beam search (centersBeam distinct centers x edgesPerCenter edge pairings).
+         * Shared across all stages below.
+         *
+         * Bounded by `maxCalls` solveLength calls (not wall-clock): easy states
+         * use ~100, so adversarial pools fail fast deterministically on any
+         * machine instead of grinding through the whole pool.
+         */
+        function sweepPool(pool, cfg) {
+            const candReductions = new Map();
+            const distinctCenters = new Set();
+            let foundAtLength = null;
+            OUTER_P3: for (let length123 = pool[0].value; length123 < L123_CAP; length123++) {
+                if (foundAtLength !== null && length123 > foundAtLength + 1)
                     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)
+                // Sweep the whole (sorted) pool: see sortTop rationale.
+                for (let i = 0; i < pool.length; i++) {
+                    const cand = pool[i];
+                    if (cand.value > length123)
+                        break;
+                    const length3 = length123 - cand.length12;
+                    const minL3 = Math.max(cand.edist, cand.cdist, cand.hdist, cand.pdist ?? 0);
+                    if (length3 > cfg.maxLength3 || length3 < minL3)
                         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)
+                    // IDA* threshold propagation: a previous exact-length call may have
+                    // exhaustively proved this candidate empty through a longer length.
+                    if ((p3Proven.get(cand) ?? -1) >= length3)
                         continue;
-                    solvedCand = cand;
-                    solvedMoves3 = moves3;
-                    rotPath = path;
-                    rotToStandard = invertRotationSequence(rotPath);
-                    standardReduced = applyCubeRotation(reduced, rotToStandard);
-                    break;
+                    const candCount = candReductions.get(cand) ?? 0;
+                    if (candCount >= edgesPerCenter)
+                        continue;
+                    if (distinctCenters.size >= centersBeam && !distinctCenters.has(cand))
+                        continue;
+                    if (cand.edist <= length3 && cand.cdist <= length3 && cand.hdist <= length3 && (cand.pdist ?? 0) <= length3) {
+                        const nodeLimit = length3 <= 12 ? 80000 : Math.max(45000, cfg.maxNodes);
+                        f3calls++;
+                        const validsBefore = validReductions.length;
+                        const needed = edgesPerCenter - candCount;
+                        const candReductionsBuffer = [];
+                        const maxToCollect = Math.min(16, needed + 3);
+                        const result = phase3Solver.solveLengthProven(cand.edge, cand.ct3, cand.edist, length3, tables.center3, tables.edge3.distances, nodeLimit, 16, (moves3) => {
+                            const red = buildValidReduction(cand, moves3);
+                            if (!red)
+                                return false;
+                            candReductionsBuffer.push(red);
+                            if (foundAtLength === null)
+                                foundAtLength = length123;
+                            return candReductionsBuffer.length >= maxToCollect;
+                        }, 
+                        // hc mid-search prune disabled: on a 44-state corpus the per-node
+                        // hc lookups cost more than they prune, and the altered
+                        // capped/success pattern shifts the stop-at-3 valid selection
+                        // toward shorter reductions (which finish as well or better on
+                        // average). The exact hdist call gate above, the candidate hdist
+                        // ranking, and the polish-pass hc bounds below all stay.
+                        undefined, -1, tables.c3PairDist);
+                        if (candReductionsBuffer.length > 0) {
+                            // Sort solutions for this center candidate by totalEst (cancellation-aware length + tri-axial 3x3 heuristic)
+                            candReductionsBuffer.sort((a, b) => a.totalEst - b.totalEst);
+                            const toAdd = candReductionsBuffer.slice(0, needed);
+                            for (const red of toAdd) {
+                                validReductions.push(red);
+                            }
+                            candReductions.set(cand, candCount + toAdd.length);
+                            distinctCenters.add(cand);
+                        }
+                        const proven = result.provenThrough;
+                        if (process.env.CUBE4_SWEEP_STATS === "1") {
+                            // eslint-disable-next-line no-console
+                            console.log(`sweep l12=${cand.length12} l3=${length3} nodes=${result.nodesUsed}/${nodeLimit} ` +
+                                `valid=${validReductions.length > validsBefore} proven=${proven} ` +
+                                `c=${cand.cdist} e=${cand.edist} h=${cand.hdist}`);
+                        }
+                        if (result.moves === null && proven >= length3) {
+                            const prev = p3Proven.get(cand) ?? -1;
+                            if (proven > prev)
+                                p3Proven.set(cand, proven);
+                        }
+                        // The finish loop attempts reductions up to maxReductionsTarget
+                        if (validReductions.length >= maxReductionsTarget) {
+                            break OUTER_P3;
+                        }
+                    }
                 }
             }
-            if (solvedCand)
+        }
+        const sortTop = (arr) => {
+            // No truncation: value misranks solvability (short bounds, hard joints),
+            // and truncating demonstrably discards winners (corpus-18/49). Cost lands
+            // only on hard states (early-stop rules); easy states stop early anyway.
+            const sorted = [...arr].sort((a, b) => a.value - b.value);
+            // Per-restart tie order only (ascending value order is preserved, so the
+            // sweep's `value > length123` break stays valid).
+            shuffleTies(sorted, (c) => c.value, rng);
+            return sorted;
+        };
+        // Sweeps with growing budgets; longitudes extend dynamically (reference
+        // style) while nothing is found, instead of fixed caps. Easy states only
+        // pay the first sweep.
+        // Sweeps with growing budgets; longitudes extend dynamically (reference
+        // style) while nothing is found, instead of fixed caps. Easy states only
+        // pay the first sweep.
+        // NOTE: lowering these caps was tried (20k/16k) and reverted: capped calls
+        // change which valids are found (±2 moves on the corpus). Only admissible
+        // heuristic strengthenings are length-safe here.
+        sweepPool(sortTop(candidates), { maxNodes: 30000, maxLength3: 14 });
+        if (validReductions.length === 0) {
+            sweepPool(sortTop(candidates), { maxNodes: 30000, maxLength3: 16 });
+        }
+        if (validReductions.length === 0) {
+            sweepPool(sortTop(candidates), { maxNodes: 30000, maxLength3: 18 });
+        }
+        if (validReductions.length === 0) {
+            sweepPool(sortTop(candidates), { maxNodes: 30000, maxLength3: 20 });
+        }
+        if (validReductions.length === 0) {
+            sweepPool(sortTop(candidates), { maxNodes: 30000, maxLength3: 24 });
+        }
+        if (validReductions.length === 0 && deep) {
+            sweepPool(sortTop(candidates), { maxNodes: 60000, maxLength3: 27 });
+        }
+        // Diversity extension (only when both sweeps found nothing): the pool's
+        // joints are jointly hard, so gather DEEPER phase-2 solutions (longer
+        // length2 = different wings) and sweep those. Only hard states pay this.
+        if (validReductions.length === 0 && !options?.maxReductionLen) {
+            const poolStart = candidates.length;
+            let MX = MAX_P2;
+            EXTEND: while (candidates.length - poolStart < 40 && MX <= EXT_MX) {
+                for (let length12 = minP1; length12 < minP1 + 18; length12++) {
+                    for (let pi = 0; pi < preps.length; pi++) {
+                        const prep = preps[pi];
+                        if (prep.prefix.length > length12)
+                            break;
+                        const length2 = length12 - prep.prefix.length;
+                        if (length2 > MX || length2 < 0)
+                            continue;
+                        if (prep.prun > length2)
+                            continue;
+                        const key = pi * 64 + length2;
+                        if (searchedL2.has(key))
+                            continue;
+                        searchedL2.add(key);
+                        p1CandCount = 0;
+                        wpStack[0].set(prep.bridgeState.wp);
+                        validWpDepth = 0;
+                        searchPhase2(prep.ct, prep.rl, length2, -1, 0, prep.bridgeState, prep);
+                        if (candidates.length - poolStart >= 40)
+                            break EXTEND;
+                    }
+                }
+                MX++;
+            }
+            const fresh = sortTop(candidates.slice(poolStart));
+            if (fresh.length > 0) {
+                sweepPool(fresh, { maxNodes: 15000, maxLength3: 18 });
+            }
+            if (validReductions.length === 0 && fresh.length > 0) {
+                sweepPool(fresh, { maxNodes: 30000, maxLength3: 20 });
+            }
+        }
+        if (validReductions.length === 0) {
+            throw new Error("4x4 solve: reduction failed across all candidates.");
+        }
+        // Sort reductions by Total Estimated Moves (Reduction length + 3x3 Phase 1 lower bound)
+        validReductions.sort((a, b) => a.totalEst - b.totalEst);
+        const tFinishStart = performance.now();
+        let bestSolution = null;
+        let minTotalMoves = 999;
+        let bestPhases;
+        let bestRed = null;
+        // Best-of among the first two (as before); any further reductions are
+        // only attempted when those both failed, so a flaky 3x3 finish cannot
+        // sink the whole attempt while the common case costs nothing extra.
+        // Best-of among the first three (phase-4 is cheap now); further
+        // reductions are only attempted when those all failed.
+        const finishTries = options?.finishTries ?? maxReductionsTarget;
+        for (let i = 0; i < validReductions.length; i++) {
+            if (i >= finishTries && bestSolution)
                 break;
+            const red = validReductions[i];
+            const cube3State = toCube3State(red.standardReduced);
+            if (!cube3State)
+                continue;
+            let cube3Solution;
+            try {
+                cube3Solution = await solveCube3(cube3State);
+            }
+            catch {
+                continue;
+            }
+            // Rotate the solve algorithm so it is performed from the standard orientation ("hacer los movimientos desde otro lado").
+            // This allows the solve to transition directly to the standard solved state WITHOUT ANY WHOLE-CUBE ROTATIONS (rotMoves)!
+            const rotatedFullSolution = [
+                ...rotateAlgorithm(red.cand.moves12, red.rotToStandard),
+                ...rotateAlgorithm(red.moves3Remapped, red.rotToStandard),
+                ...cube3Solution.moves
+            ];
+            const simplified = simplifyCube4Algorithm(rotatedFullSolution);
+            if (simplified.length < minTotalMoves) {
+                minTotalMoves = simplified.length;
+                bestSolution = simplified;
+                bestPhases = {
+                    length12: red.cand.length12,
+                    length1: red.cand.p1.moves.length,
+                    length2: red.cand.length12 - red.cand.p1.moves.length,
+                    length3: red.moves3.length,
+                    finish: cube3Solution.moves.length
+                };
+                bestRed = red;
+            }
+        }
+        if (!bestSolution || !bestRed) {
+            throw new Error("4x4 solve: reduction failed across all candidates.");
+        }
+        // Polish pass: the sweep takes the first valid sequence per exact
+        // length, which is often one above optimal. Retry the winner one length
+        // shorter with a large budget (up to 2 iterations). Gated on totals
+        // above target so easy states never pay it.
+        const tPolishStart = performance.now();
+        // Polish the winner plus the runner-up by totalEst (was: winner only).
+        // Runner-up shortenings get their own finish and can only lower the min
+        // over finished totals; easy states skip the inner loop via the length
+        // gate below, so the extra pass costs ~nothing there.
+        const redToPolish = options?.deepPolish
+            ? validReductions.slice(0, 3)
+            : [bestRed, ...validReductions.filter((r) => r !== bestRed)].slice(0, 2);
+        for (const r of redToPolish) {
+            let curRed = r;
+            // The runner-up gets a cheap probe budget: its shortening is a bonus,
+            // and a full 150k grind on tail states cost seconds for nothing. It is
+            // also skipped entirely unless the total is high enough to matter.
+            const polishBudget = r === bestRed ? 150000 : 30000;
+            for (let iter = 0; iter < 4 && (minTotalMoves > 43 || curRed.moves3.length > 11); iter++) {
+                const cand = curRed.cand;
+                const shorterLen = curRed.moves3.length - 1;
+                if (shorterLen < cand.edist || shorterLen < cand.cdist || shorterLen < cand.hdist || shorterLen < (cand.pdist ?? 0))
+                    break;
+                f3calls++;
+                const shorter = phase3Solver.solveLengthValid(cand.edge, cand.ct3, cand.edist, shorterLen, tables.center3, tables.edge3.distances, polishBudget, 64, (moves3) => buildValidReduction(cand, moves3) !== null, tables.hc, cand.hcCoord, tables.c3PairDist);
+                if (!shorter)
+                    break;
+                const red = buildValidReduction(cand, shorter);
+                if (!red)
+                    break;
+                const cube3State = toCube3State(red.standardReduced);
+                if (!cube3State)
+                    break;
+                let cube3Solution;
+                try {
+                    cube3Solution = await solveCube3(cube3State);
+                }
+                catch {
+                    break;
+                }
+                const simplified = simplifyCube4Algorithm([
+                    ...rotateAlgorithm(red.cand.moves12, red.rotToStandard),
+                    ...rotateAlgorithm(red.moves3Remapped, red.rotToStandard),
+                    ...cube3Solution.moves
+                ]);
+                if (simplified.length < minTotalMoves) {
+                    minTotalMoves = simplified.length;
+                    bestSolution = simplified;
+                    curRed = red;
+                    bestPhases = {
+                        length12: red.cand.length12,
+                        length1: red.cand.p1.moves.length,
+                        length2: red.cand.length12 - red.cand.p1.moves.length,
+                        length3: red.moves3.length,
+                        finish: cube3Solution.moves.length
+                    };
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        accP2 += p2nodes;
+        accF3calls += f3calls;
+        accF1Ms += tF1End - tR0;
+        accF2Ms += tF2End - tF1End;
+        accF3Ms += tFinishStart - tF2End;
+        accFinishMs += tPolishStart - tFinishStart;
+        accPolishMs += performance.now() - tPolishStart;
+        return { moves: bestSolution, phases: bestPhases };
+    };
+    let bestMoves = null;
+    let bestPhasesOverall;
+    let lastRestartError = null;
+    for (let restart = 0; restart < totalRestarts; restart++) {
+        FastPhase3Solver.nextEpoch();
+        const rng = totalRestarts > 1
+            ? mulberry32((hashCube4State(state) ^ Math.imul(restart + 1, 0x9e3779b9)) >>> 0)
+            : null;
+        try {
+            const one = await runOnce(rng);
+            if (!bestMoves || one.moves.length < bestMoves.length) {
+                bestMoves = one.moves;
+                bestPhasesOverall = one.phases;
+            }
+        }
+        catch (error) {
+            lastRestartError = error;
         }
-        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);
+    if (!bestMoves) {
+        throw lastRestartError instanceof Error
+            ? lastRestartError
+            : new Error(`4x4 solve: all ${totalRestarts} restarts failed: ${String(lastRestartError)}`);
     }
-    catch (error) {
-        if (error instanceof Cube3Phase2SearchError) {
-            throw error;
+    const scramble = invertCube4Algorithm(bestMoves);
+    const result = {
+        moves: bestMoves,
+        scramble,
+        nodes: { p2: accP2, p3: phase3Solver.epochNodes, f3calls: accF3calls },
+        timings: {
+            reductionMs: accF1Ms + accF2Ms + accF3Ms,
+            f1Ms: accF1Ms,
+            f2Ms: accF2Ms,
+            f3Ms: accF3Ms,
+            finishMs: accFinishMs,
+            polishMs: accPolishMs
         }
-        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 };
+    };
+    if (bestPhasesOverall)
+        result.phases = bestPhasesOverall;
+    return result;
 }