@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -4,15 +4,131 @@
  * 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 { center1Mask, getCenter1Distance, applyCenter1Move, CENTER1_MOVES, CENTER1_GOAL_MASKS } from "./center1.js";
+import { center2Bridge, getWingMoveMaps, CENTER2_GOAL_RL, CENTER2_MOVES, CENTER2_SEARCH_MOVES, CENTER2_SEARCH_MOVES_WIDE, CENTER2_RL_STATES, encodeCenter2ChiralCt, generateCenter2ChiralTables } from "./center2.js";
 import { encodeCenter3 } from "./center3.js";
-import { encodePairingState } from "./pairing-coordinate.js";
+import { encodePairingState, PAIRING_SECOND_HALVES } from "./pairing-coordinate.js";
+import { encodeHcPdb, hcDenseIndex } 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 { createSolvedCube4State } from "../state.js";
+import { placeRotationFix } from "./rotation-fix.js";
+import { getTransversalPairPdb, getWingPositionMoves, PAIR_INDEX, PAIR_STATES } from "./pair-transversal.js";
+import { checkCube4Reduction, toCube3State } from "./phase4.js";
+import { encodeCornerOrientation, encodeEdgeOrientation, encodeUdSlice } from "../../cube3/solver/coordinates.js";
+import { createSolvedCube4State, isSolvedCube4State } 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;
+}
+class Cube4SolveError extends Error {
+}
+export class Cube4Phase2CapError extends Cube4SolveError {
+    code = "cube4-phase2-cap";
+    constructor(message) {
+        super(message);
+        this.name = "Cube4Phase2CapError";
+    }
+}
+export class Cube4Phase3CapError extends Cube4SolveError {
+    code = "cube4-phase3-cap";
+    constructor(message) {
+        super(message);
+        this.name = "Cube4Phase3CapError";
+    }
+}
+export class Cube4FinishCapError extends Cube4SolveError {
+    code = "cube4-finish-cap";
+    constructor(message) {
+        super(message);
+        this.name = "Cube4FinishCapError";
+    }
+}
 function cornerPermutationParity(cp) {
     let parity = 0;
     const seen = new Array(8).fill(false);
@@ -30,13 +146,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();
@@ -57,18 +208,24 @@ const VALID_24_ORIENTATIONS = (() => {
     }
     return map;
 })();
+/** Centers of the solved state — used to verify a full (not just partial) standard orientation. */
+const SOLVED_CENTERS = createSolvedCube4State().centers;
 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" }
+    "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 +233,26 @@ 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;
+    });
+}
+/** Physical wide-move sequence implementing a whole-cube rotation. */
+export function cubeRotationMoves(rotSeq) {
+    return rotSeq.flatMap((rotation) => ROT_MOVES[rotation]);
 }
-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 +282,1051 @@ 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)));
+/** Flat (row-major) cancel tables for the hot DFS loop; same semantics. */
+function flattenCancel(table) {
+    const n = table.length;
+    const flat = new Uint8Array(n * n);
+    for (let i = 0; i < n; i++) {
+        const row = table[i];
+        for (let j = 0; j < n; j++)
+            flat[i * n + j] = row[j] ? 1 : 0;
+    }
+    return flat;
+}
+const P2_CANCEL_FLAT = flattenCancel(P2_CANCEL);
+const P2_CANCEL_WIDE_FLAT = flattenCancel(P2_CANCEL_WIDE);
+/**
+ * Wing transversal mask: bit k set iff pair k occupies a second-half slot.
+ * `hasPairingTransversal(wp)` is equivalent to `pairingMaskOf(wp) === 0xfff`
+ * (12 slots, 12 pair ids in 0..11: all distinct ⟺ all 12 bits set). The mask
+ * form is O(1) at the millions of phase-2 goal leaves.
+ */
+function pairingMaskOf(wp) {
+    let mask = 0;
+    for (let i = 0; i < 12; i++) {
+        mask |= 1 << (wp[PAIRING_SECOND_HALVES[i]] >> 1);
+    }
+    return mask;
+}
+/** rl side of the phase-2 goal test (same flags as `isCenter2Goal`). */
+const P2_GOAL_RL = (() => {
+    const flags = new Uint8Array(CENTER2_RL_STATES);
+    for (const rl of CENTER2_GOAL_RL)
+        flags[rl] = 1;
+    return flags;
+})();
+/** Chiral phase-2 tables, generated once per loaded center2 table set. */
+const chiralTablesCache = new WeakMap();
+function getCenter2ChiralTables(center2) {
+    let chiral = chiralTablesCache.get(center2);
+    if (!chiral) {
+        chiral = generateCenter2ChiralTables(center2.rlMove);
+        chiralTablesCache.set(center2, chiral);
+    }
+    return chiral;
+}
+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();
+/** 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;
+}
 /**
- * Solve a 4x4 state with the reduction solver + the cube3 two-phase finish.
- * `solveCube3` is injected (the cube3 solver loads its tables lazily).
+ * Temporary instrumentation for the finish-skip bound (CUBE4_FINISH_STATS=1):
+ * `gap = totalEst - finalLen` per finished reduction. A skip
+ * `totalEst - SLACK >= minTotalMoves` is only sound while SLACK covers the
+ * observed gap maximum (junction cancellation + finish-vs-h3 slack).
  */
-export async function solveCube4State(state, tables, solveCube3) {
+export const finishStats = {
+    gapMin: 99,
+    gapMax: -99,
+    gapSum: 0,
+    gapN: 0,
+    finishes: 0,
+    skipped: 0
+};
+/**
+ * Temporary instrumentation for the rotMoves cost (CUBE4_ROT_STATS=1):
+ * per built reduction records the prep frame rotation, the derived
+ * normalization rotation and the emitted fix length.
+ */
+export const rotStats = [];
+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.
     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
+    // All mutable phase-3 state (TT, epoch-node count, call IDs and search
+    // stacks) belongs to this invocation. The same instance spans its
+    // deterministic restarts, retaining useful goal-free TT entries without
+    // allowing concurrent solves to contaminate one another.
+    const phase3Solver = new FastPhase3Solver();
+    phase3Solver.resetEpochNodes();
+    const collectF2Stats = typeof process !== "undefined" && process.env?.CUBE4_F2_STATS === "1";
+    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 (null = identity fast path when rng is null).
+        const p1Order = rng === null ? null : Int32Array.from(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 === null ? mi : 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 Int32Array(48);
+        // 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.
+        // `wpMaskStack[d]` = pairingMaskOf(wpStack[d]) maintained in the same lazy
+        // fill, so the per-leaf transversal test is a single compare.
+        const wpStack = Array.from({ length: 32 }, () => new Uint8Array(24));
+        const wpMaskStack = new Int32Array(32);
+        let validWpDepth = 0;
+        const wingMaps = getWingMoveMaps();
+        // Transversal pruning (see pair-transversal.ts): wing positions per DFS
+        // depth (`posStack[d][wing]`), checked against the two-pair PDB over 6
+        // disjoint pair-of-pairs in the last TRANSVERSAL_DEPTH levels (the PDB's
+        // maximum). Prunes only branches with no transversal goal, so the
+        // accepted candidates are unchanged.
+        const posStack = Array.from({ length: 33 }, () => new Uint8Array(24));
+        const wingPosMove = getWingPositionMoves();
+        const TRANSVERSAL_DEPTH = 3;
+        let validPosDepth = 0;
+        /**
+         * 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 cancelFlat = c2Wide ? P2_CANCEL_WIDE_FLAT : P2_CANCEL_FLAT;
+        const c2Stride = C2_SEARCH.length;
+        const transversalPdb = getTransversalPairPdb(C2_SEARCH.length);
+        const canSkipAxis = rng === null && !c2Wide;
+        // Per-restart child order (null = identity fast path). Entries stay
+        // original move-table indices, so all table lookups are unaffected.
+        const p2Order = rng === null ? null : Int32Array.from(restartOrder(C2_SEARCH.length, rng));
+        // Default set: chiral tables (goal = ct == 0 && axisDet == 1 exactly, so
+        // wrong-chirality goal paths are pruned instead of enumerated). The wide
+        // set keeps the relative tables + the axisDet filter at the goal.
+        const chiral = c2Wide ? null : getCenter2ChiralTables(tables.center2);
+        const c2ctMove = chiral ? chiral.ctMove : tables.center2.ctMove;
+        const c2rlMove = tables.center2.rlMove;
+        const c2GoalCt = chiral ? chiral.goalCt : 0;
+        let c2pruning = chiral ? chiral.pruning : 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;
+        // Hoisted out of the goal path (was read per goal leaf).
+        const maxP1Cand = options?.p1CandCap !== undefined ? options.p1CandCap : (deep ? 24 : 16);
+        // 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;
+        // Bound the whole sweep, not just each individual IDA* call. A hard
+        // candidate pool can otherwise spend thousands of capped calls before
+        // reaching the deep retry (corpus-73: 114M nodes in the fast attempt).
+        const phase3StartNodes = phase3Solver.epochNodes;
+        const phase3NodeBudget = deep ? 16_000_000 : 4_000_000;
+        function searchPhase2(c, r, maxl, lm, depth, bridgeState, prep) {
+            p2nodes++;
+            if (p2nodes > P2_MAX_NODES)
+                return false;
+            if (c === c2GoalCt && P2_GOAL_RL[r] === 1) {
+                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]];
+                        wpMaskStack[validWpDepth + 1] = pairingMaskOf(dst);
+                        validWpDepth++;
+                    }
+                    if (collectF2Stats)
+                        f2Stats.goals++;
+                    // Bit-identical to `hasPairingTransversal(goalWp)`: all 12 pair bits
+                    // distinct ⟺ the 12-bit mask is full (0xfff).
+                    if (wpMaskStack[depth] !== 0xfff)
+                        return false;
+                    if (collectF2Stats)
+                        f2Stats.transversalPass++;
+                    const moves2 = [];
+                    for (let i = 0; i < depth; i++)
+                        moves2.push(CENTER2_MOVES[moveLog[i]]);
+                    const s2 = applyCube4Algorithm(bridgeState, moves2);
+                    const uAxis = s2.centers[0] % 3;
+                    const rAxis = s2.centers[4] % 3;
+                    const fAxis = s2.centers[8] % 3;
+                    if (collectF2Stats) {
+                        if (depth < f2Stats.minTransversalL2)
+                            f2Stats.minTransversalL2 = depth;
+                    }
+                    if (axisDet(uAxis, rAxis, fAxis) !== 1) {
+                        if (collectF2Stats)
+                            f2Stats.axisRejects++;
+                        return false;
+                    }
+                    if (collectF2Stats) {
+                        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 ? hcDenseIndex(tables.hc, 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++;
+                            if (p1CandCount >= maxP1Cand)
+                                return true;
+                        }
+                    }
                 }
+                return false;
+            }
+            if (maxl === 0)
+                return false;
+            const c2RowC = c * CENTER2_MOVES.length;
+            const c2RowR = r * CENTER2_MOVES.length;
+            for (let mi = 0; mi < C2_SEARCH.length; mi++) {
+                const m = p2Order === null ? mi : p2Order[mi];
+                if (lm >= 0 && cancelFlat[lm * c2Stride + 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 && canSkipAxis) {
+                        mi = SKIP_AXIS_2[m] - 1;
+                    }
+                    continue;
+                }
+                let childPosValid = false;
+                if (maxl - 1 < TRANSVERSAL_DEPTH) {
+                    // Lazy fill (like wpStack): replay the path down to this node.
+                    while (validPosDepth < depth) {
+                        const src = posStack[validPosDepth];
+                        const dst = posStack[validPosDepth + 1];
+                        const row = moveLog[validPosDepth] * 24;
+                        for (let w = 0; w < 24; w++)
+                            dst[w] = wingPosMove[row + src[w]];
+                        validPosDepth++;
+                    }
+                    const parentPos = posStack[depth];
+                    const childPos = posStack[depth + 1];
+                    const posRow = m * 24;
+                    const limit = maxl - 1;
+                    let blocked = false;
+                    // Group by group (4 wings = 2 pairs each), so a blocked child only
+                    // pays for the groups actually checked.
+                    for (let q = 0; q < 24; q += 4) {
+                        const a0 = wingPosMove[posRow + parentPos[q]];
+                        const a1 = wingPosMove[posRow + parentPos[q + 1]];
+                        const b0 = wingPosMove[posRow + parentPos[q + 2]];
+                        const b1 = wingPosMove[posRow + parentPos[q + 3]];
+                        if (transversalPdb[PAIR_INDEX[a0 * 24 + a1] * PAIR_STATES + PAIR_INDEX[b0 * 24 + b1]] > limit) {
+                            blocked = true;
+                            break;
+                        }
+                        childPos[q] = a0;
+                        childPos[q + 1] = a1;
+                        childPos[q + 2] = b0;
+                        childPos[q + 3] = b1;
+                    }
+                    if (blocked)
+                        continue;
+                    childPosValid = true;
+                }
+                moveLog[depth] = m;
+                if (validWpDepth > depth)
+                    validWpDepth = depth;
+                if (validPosDepth > depth)
+                    validPosDepth = depth;
+                if (childPosValid)
+                    validPosDepth = depth + 1;
+                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 ct = chiral ? encodeCenter2ChiralCt(bridge.state) : bridge.encoded.ct;
+            const prun = c2pruning[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, 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 ? 48 : 32);
+        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);
+                    for (let p = 0; p < 24; p++)
+                        posStack[0][prep.bridgeState.wp[p]] = p;
+                    validPosDepth = 0;
+                    wpMaskStack[0] = pairingMaskOf(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 Cube4Phase2CapError("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();
+        // Cheap-fix goal filter (see Cube4SolveOptions.maxFixMoves). The deep
+        // fallback widens it back to 4 (legacy, always satisfiable) so a hard
+        // state can never fail on the filter alone.
+        const maxFixMoves = (options?.maxFixMoves ?? 4) + (deep ? 2 : 0);
+        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 rotMoves = rotToStandard.flatMap((r) => ROT_MOVES[r]);
+            if (rotMoves.length > maxFixMoves)
+                return null;
+            if (typeof process !== "undefined" && process.env?.CUBE4_ROT_STATS === "1" && rotStats.length < 200) {
+                rotStats.push({
+                    totalRot: totalRot.join(","),
+                    rotToStandard: rotToStandard.join(","),
+                    rotLen: rotToStandard.reduce((n, rr) => n + ROT_MOVES[rr].length, 0)
+                });
+            }
+            // The orientation key only covers 3 of the 24 center slots. A reduced
+            // arrangement outside the rotation orbit (e.g. a reflected one) can
+            // collide with a rotation's key, in which case rotating by `path` does
+            // NOT leave standard centers — the 3x3 finish would solve a different
+            // color scheme and the resulting solution would be garbage. Reject.
+            for (let i = 0; i < 24; i++) {
+                if (standardReduced.centers[i] !== SOLVED_CENTERS[i])
+                    return null;
+            }
+            const cube3State = toCube3State(standardReduced);
+            if (!cube3State)
+                return null;
+            const h3 = tables.cube3Phase1 ? getTriAxialCube3Heuristic(standardReduced, tables.cube3Phase1) : 0;
+            // The reduction + rotation prefix as it will be emitted (original frame):
+            // apply(state, [...moves12, ...moves3Remapped ... rotMoves]) = standardReduced.
+            // Priced with the fix at its best position (see placeRotationFix).
+            const simplifiedReduction = placeRotationFix([...cand.moves12, ...moves3Remapped], rotToStandard, []);
+            return {
+                cand,
+                moves3,
+                moves3Remapped,
+                rotPath: path,
+                rotToStandard,
+                rotMoves,
+                standardReduced,
+                h3,
+                totalEst: simplifiedReduction.length + h3
+            };
+        }
+        // Defaults 1 × 5 (was 3 × 3): with the continuous finish, extra center
+        // candidates stopped paying. cc:0..31: 45.19 moves @ 673 ms vs 45.16 @
+        // 1042 ms (2×3: 45.25 @ 799; 1×8: 45.25 @ 691).
+        const centersBeam = Math.max(1, options?.centersBeam ?? 1);
+        const edgesPerCenter = Math.max(1, options?.edgesPerCenter ?? 5);
+        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;
+            // The rotation fix (rotMoves) is priced INTO totalEst and varies 2-4
+            // moves per goal PATH (the end scheme depends on the path). A goal one
+            // total-step deeper with a 2-move fix beats a shallow goal with a 4-move
+            // fix, so keep collecting a few steps past the first find and let
+            // totalEst decide (was: foundAtLength + 1 with needed + 3 goals per
+            // call, which discarded fix-cheap alternatives).
+            OUTER_P3: for (let length123 = pool[0].value; length123 < L123_CAP; length123++) {
+                if (foundAtLength !== null && length123 > foundAtLength + 3)
                     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 remainingNodes = phase3NodeBudget - (phase3Solver.epochNodes - phase3StartNodes);
+                        if (remainingNodes <= 0) {
+                            if (validReductions.length > 0)
+                                return;
+                            throw new Cube4Phase3CapError("4x4 solve: phase 3 total node budget exhausted.");
+                        }
+                        const nodeLimit = Math.min(remainingNodes, length3 <= 12 ? 80000 : Math.max(45000, cfg.maxNodes));
+                        f3calls++;
+                        const needed = edgesPerCenter - candCount;
+                        const candReductionsBuffer = [];
+                        // Collect beyond `needed`: goal paths at the same length carry
+                        // different rotation fixes (2 vs 4 moves), and the totalEst sort
+                        // below needs the variety to pick a cheap-fix end.
+                        const maxToCollect = Math.min(24, needed + 9);
+                        const result = phase3Solver.solveLengthProven(cand.edge, cand.ct3, cand.edist, length3, tables.center3, tables.edge3.distances, nodeLimit, 
+                        // Goal budget per call: with the cheap-fix filter most goal ends
+                        // are rejected, so the walk must be allowed to examine more of
+                        // them before giving up on this (candidate, length3).
+                        48, (moves3) => {
+                            const red = buildValidReduction(cand, moves3);
+                            if (!red)
+                                return false;
+                            candReductionsBuffer.push(red);
+                            // <=-search: goals may land shorter than the length3 bound —
+                            // track the true total for the post-find collection window.
+                            const total = cand.length12 + moves3.length;
+                            if (foundAtLength === null || total < foundAtLength)
+                                foundAtLength = total;
+                            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);
+                        }
+                        // Predicate-scoped proof (same buildValidReduction filter for this
+                        // candidate across all its calls): skip every settled length.
+                        const proven = result.validatedThrough;
+                        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
+                        // (with a wider collection cap so cheap-fix ends at later length
+                        // steps can still displace expensive-fix ones by totalEst).
+                        if (validReductions.length >= maxReductionsTarget + 9) {
+                            break OUTER_P3;
+                        }
+                    }
+                }
+            }
+        }
+        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. The length3 caps are NOT redundant re-walks: the
+        // ladder widens the pairing cap ONLY when nothing was found at all, and the
+        // narrower caps keep early sweeps on short pairings (measured: a single
+        // merged sweep with maxLength3 24 is ~20% SLOWER with identical output).
+        // 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);
+                        for (let p = 0; p < 24; p++)
+                            posStack[0][prep.bridgeState.wp[p]] = p;
+                        validPosDepth = 0;
+                        wpMaskStack[0] = pairingMaskOf(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 Cube4Phase3CapError("4x4 solve: phase 3 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;
+        const collectFinishStats = typeof process !== "undefined" && process.env?.CUBE4_FINISH_STATS === "1";
+        // Empirical finish lower bound (see finishStats): every observed finish
+        // ran 11-16 moves ABOVE `totalEst` (continuous finish: 67 finishes over 16
+        // seeds, gap = totalEst - finalLen in [-16, -11]; the legacy finish was
+        // [-16, -12]) because `h3` only bounds the cube3 PHASE-1 length while the
+        // finish is two-phase. A reduction whose totalEst + 11 cannot strictly
+        // beat the current best therefore cannot win, and its finish is skipped
+        // entirely. If a state ever lands a finish within 11 of the phase-1 bound,
+        // this degrades to a slightly longer (still exact,
+        // still valid) scramble for that state — never an incorrect one.
+        const FINISH_LB_BIAS = 11;
+        const screenTop = Math.max(0, Math.floor(options?.finishScreenTop ?? 0));
+        const screened = [];
+        /** Finishes one reduction; records it as the best when shorter. */
+        async function finishReduction(red, effort) {
+            const cube3State = toCube3State(red.standardReduced);
+            if (!cube3State)
+                return null;
+            let cube3Solution;
+            try {
+                cube3Solution = await solveCube3(cube3State, effort);
+            }
+            catch {
+                return null;
+            }
+            // Frame invariant (verified): apply(state, [...moves12, ...moves3Remapped])
+            // is exactly `reducedOriginal`, and `reducedOriginal · rotMoves(r)`
+            // (= applyCubeRotation(_, r)) is `standardReduced`, which the cube3
+            // finish C solves. So the solution in the ORIGINAL frame is
+            //   X ++ rotMoves(r) ++ C.
+            // Two previously-tried assemblies are WRONG:
+            //  - [rot_r(X), C] solves ρ_r(state), not state (the observed adaptive
+            //    whole-cube-rotation bug: apply(solved, invert(moves)) = ρ_r(T));
+            //  - [X, rot_{-r}(C)] lands on ρ_{-r}(solved) ≠ solved, because a
+            //    whole-cube rotation does NOT leave the canonical solved state
+            //    invariant (it permutes face colors in the absolute frame).
+            // `placeRotationFix` keeps that effect but may move the rotMoves(r)
+            // block anywhere in the sequence (re-mapping what follows it) where it
+            // cancels against adjacent wide moves.
+            const simplified = placeRotationFix([...red.cand.moves12, ...red.moves3Remapped], red.rotToStandard, cube3Solution.moves);
+            if (collectFinishStats) {
+                finishStats.finishes++;
+                const gap = red.totalEst - simplified.length;
+                if (gap < finishStats.gapMin)
+                    finishStats.gapMin = gap;
+                if (gap > finishStats.gapMax)
+                    finishStats.gapMax = gap;
+                finishStats.gapSum += gap;
+                finishStats.gapN++;
             }
-            if (solvedCand)
+            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;
+            }
+            return simplified;
+        }
+        for (let i = 0; i < validReductions.length; i++) {
+            if (i >= finishTries && bestSolution)
                 break;
+            const red = validReductions[i];
+            if (bestSolution !== null && red.totalEst + FINISH_LB_BIAS >= minTotalMoves) {
+                finishStats.skipped++;
+                continue;
+            }
+            const done = await finishReduction(red, screenTop > 0 ? "screen" : "full");
+            if (done)
+                screened.push({ red, total: done.length });
+        }
+        // Stage 2: the best screened reductions get the full-effort finish.
+        if (screenTop > 0) {
+            screened.sort((a, b) => a.total - b.total);
+            for (const { red } of screened.slice(0, screenTop)) {
+                if (red.totalEst + FINISH_LB_BIAS >= minTotalMoves)
+                    continue;
+                await finishReduction(red, "full");
+            }
+        }
+        if (!bestSolution || !bestRed) {
+            throw new Cube4FinishCapError("4x4 solve: reduction failed during the 3x3 finish across all valid reductions.");
+        }
+        // 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;
+            // NOTE: with the <=-length phase-3 search the sweep already enumerates
+            // shorter goals, so the polish is a second-chance pass only (measured:
+            // a wider gate/budget found nothing and cost +32% p3 nodes).
+            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++;
+                // Unified polish: accept any goal path with a strictly better
+                // totalEst at the same or shorter length — covers both a shorter
+                // phase-3 path and a cheaper rotation fix (the fix is priced into
+                // totalEst and varies 2-4 moves per goal path).
+                const shorter = phase3Solver.solveLengthValid(cand.edge, cand.ct3, cand.edist, curRed.moves3.length, tables.center3, tables.edge3.distances, polishBudget, 64, (moves3) => {
+                    const nr = buildValidReduction(cand, moves3);
+                    return nr !== null && nr.totalEst < curRed.totalEst;
+                }, 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;
+                }
+                // Same frame invariant as the finish loop: X ++ rotMoves(r) ++ C.
+                const simplified = placeRotationFix([...red.cand.moves12, ...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;
+        // Final invariant: the emitted solution must solve the INPUT state
+        // exactly (no rotation tolerance). Fail loudly rather than return a
+        // solution that does not resolve. One replay of ~45 moves — negligible
+        // next to the search cost.
+        if (!isSolvedCube4State(applyCube4Algorithm(state, bestSolution))) {
+            throw new Error("4x4 solve: internal verification failed — the solution does not solve the input state.");
+        }
+        return { moves: bestSolution, phases: bestPhases };
+    };
+    let bestMoves = null;
+    let bestPhasesOverall;
+    let lastRestartError = null;
+    for (let restart = 0; restart < totalRestarts; restart++) {
+        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;
 }