@cubingcenter/scrambler 0.7.0 → 0.8.0

package/dist/puzzles/cube4/reduction/phase3-search.js

@@ -34,6 +34,17 @@ for (let i = 0; i < 20; i++) {
         }
     }
 }
+/** Popcount of 12-bit masks (the inlined sym-coordinate rank). */
+const POPC12 = new Uint8Array(4096);
+for (let i = 1; i < 4096; i++)
+    POPC12[i] = POPC12[i >> 1] + (i & 1);
+/** Flat row-major ckmv3 (21x20) + typed skipAxis3 for the hot recursion. */
+const ckmv3Flat = new Uint8Array(21 * 20);
+for (let i = 0; i < 21; i++) {
+    for (let j = 0; j < 20; j++)
+        ckmv3Flat[i * 20 + j] = ckmv3[i][j] ? 1 : 0;
+}
+const skipAxis3Fast = Int32Array.from(skipAxis3);
 const F_SLOT_MAP = [
     [4, 5, 2, 3, 1, 0, 6, 7, 8, 9, 10, 11],
     [1, 0, 2, 3, 5, 4, 6, 7, 8, 9, 10, 11],
@@ -76,52 +87,59 @@ export class FastPhase3Solver {
     tempep;
     moveLog;
     sym;
-    /** Transposition Table size: 2^21 = 2,097,152 entries (24 MB in RAM).
-     *  NOTE: doubling to 4M was tried and reverted (-0.07% nodes on the
-     *  corpus — the 2M working set already captures the hit locality). */
-    static TT_SIZE = 1 << 21;
+    /** Transposition Table size: 2^20 = 1,048,576 entries (12 MiB per solve).
+     * The previous 2M table used 24 MiB per process, plus a separate 8 MiB
+     * generation array. The compact 1M table leaves room for concurrent
+     * solvers under the 150 MiB reduction-table budget. */
+    static TT_SIZE = 1 << 20;
     static TT_MASK = FastPhase3Solver.TT_SIZE - 1;
-    static tt = new Uint32Array(FastPhase3Solver.TT_SIZE * 3);
-    static epoch = 1;
-    /**
-     * Per-slot exact-length-call tag (8 MB transient). TT pruning stays
-     * epoch-scoped (unchanged traversal), but threshold proofs only trust
-     * same-call hits: a hit from another call may have validated under a
-     * different candidate, so it still prunes yet marks the proof dirty.
-     */
-    static ttGen = new Uint32Array(FastPhase3Solver.TT_SIZE);
-    static callSeq = 1;
+    tt = new Uint32Array(FastPhase3Solver.TT_SIZE * 3);
+    // TT info packs (call id:20, previous move:5, remaining depth:6), avoiding
+    // a separate 8 MiB generation array while retaining exact proof tracking.
+    static CALL_ID_LIMIT = 1 << 20;
+    callSeq = 1;
     callId = 0;
-    /** Reset the per-attempt cumulative node counter. */
+    contextCenter3;
+    contextEdge3;
+    /** Reset this solver's cumulative node counter (legacy method name). */
     resetEpochNodes() {
         this.epochNodes = 0;
     }
-    static nextEpoch() {
-        FastPhase3Solver.epoch = (FastPhase3Solver.epoch + 1) & 0xffff;
-        if (FastPhase3Solver.epoch === 0) {
-            FastPhase3Solver.tt.fill(0);
-            FastPhase3Solver.ttGen.fill(0);
-            FastPhase3Solver.callSeq = 1;
-            FastPhase3Solver.epoch = 1;
-        }
+    clearTranspositionTable() {
+        this.tt.fill(0);
+        this.callSeq = 1;
+    }
+    setTableContext(center3, edge3Distances) {
+        if (this.contextCenter3 === center3 && this.contextEdge3 === edge3Distances)
+            return;
+        this.clearTranspositionTable();
+        this.contextCenter3 = center3;
+        this.contextEdge3 = edge3Distances;
     }
-    /** Fresh per-call id for TT-generation tagging (epoch wrap resets it). */
-    static nextCallId() {
-        const id = FastPhase3Solver.callSeq++;
-        if (FastPhase3Solver.callSeq > 0xfffffffe) {
-            FastPhase3Solver.ttGen.fill(0);
-            FastPhase3Solver.callSeq = 1;
-            return 1;
+    /** Fresh per-call id for TT-generation tagging. */
+    nextCallId() {
+        const id = this.callSeq++;
+        if (this.callSeq >= FastPhase3Solver.CALL_ID_LIMIT) {
+            this.tt.fill(0);
+            this.callSeq = 1;
         }
         return id;
     }
     constructor() {
-        this.tempep = Array.from({ length: 30 }, () => new Uint8Array(12));
-        this.moveLog = new Array(30);
+        // Preallocated to well above the deepest phase-3 sweep (maxLength3 <= 27):
+        // `ensureDepth` stays as a fallback for out-of-band callers.
+        this.tempep = Array.from({ length: 48 }, () => new Uint8Array(12));
+        this.moveLog = new Array(48);
         this.sym = getSymTables();
     }
+    ensureDepth(depth) {
+        while (this.tempep.length <= depth) {
+            this.tempep.push(new Uint8Array(12));
+            this.moveLog.push(0);
+        }
+    }
     nodeCount = 0;
-    /** Cumulative nodes across calls (reset per attempt via resetEpochNodes). */
+    /** Cumulative nodes across calls (reset per solve generation). */
     epochNodes = 0;
     /**
      * Proof bookkeeping for IDA* threshold propagation (reset per exact-length
@@ -133,9 +151,8 @@ export class FastPhase3Solver {
      * - `sawGoal`: a goal was reached (even if the validator rejected it —
      *   a nearby length may still validate, so only step L+1).
      * - `ttTouched`: a transposition-table hit from ANOTHER exact-length call
-     *   skipped a subtree (same-call hits replay this call's own exhausted
-     *   subtree and stay clean; other calls may validate under a different
-     *   candidate, so their stored proof does not transfer).
+     *   skipped a subtree, and the hit was not certified goal-free across
+     *   candidate validators.
      * Bound-based axis skips need no flag: the skipped siblings are
      * same-face turns, so noteExcess records their triangle-inequality bound.
      */
@@ -144,11 +161,13 @@ export class FastPhase3Solver {
     sawGoal = false;
     ttTouched = false;
     minExcess = 0;
-    getPrun(distances, idx) {
-        return distances.length >= 31006080
-            ? distances[idx]
-            : (distances[idx >> 1] >> ((idx & 1) * 4)) & 0x0f;
-    }
+    /**
+     * Root-length coverage of the tightest TT hit this call (depth +
+     * storedDepth): the pruned subtree proves no goal at or below that root
+     * length under the call's predicate. `Number.MAX_SAFE_INTEGER` when no hit
+     * pruned anything. Feeds `validatedThrough`.
+     */
+    ttCoverage = Number.MAX_SAFE_INTEGER;
     /**
      * Recursive IDA* worker on table transitions with Transposition Table pruning.
      */
@@ -159,18 +178,38 @@ export class FastPhase3Solver {
             this.capped = true;
             return false;
         }
-        if (maxl === 0) {
+        // Goal test at EVERY node (any length <= maxl), not only at maxl === 0
+        // leaves: a goal is (edge paired AND center3 at goal) — both PDB
+        // distances zero (the parent's gates guarantee leaves are goals, so this
+        // strictly generalizes the old leaf test). Exact-length-only detection
+        // made shorter goals on the same path invisible ("a nearby length may
+        // still validate"), which both blocked proofs on any raw goal and hid
+        // shorter solutions.
+        if (prun === 0 && center3Tables.pruning[ct] === 0) {
+            this.sawGoal = true;
             if (!collect)
                 return true;
-            this.sawGoal = true;
             collect.examined++;
             const moves = this.moveLog.slice(0, depth).map((m) => SEARCH_MOVES[m]);
             if (collect.validate(moves))
                 return true;
-            if (collect.examined >= collect.limit)
+            if (collect.examined >= collect.limit) {
                 this.limitHit = true;
-            return collect.examined >= collect.limit;
+                return true;
+            }
+            // A rejected goal is not a goal for the validator's predicate: keep
+            // exploring the subtree — validated goals may sit deeper on the same
+            // branches. At the fringe (maxl === 0) there is no subtree left, so
+            // record the branch's coverage claim here (nothing below `depth` on
+            // this branch was searched): "no validated goal at <= depth".
+            if (maxl === 0 && depth < this.minExcess)
+                this.minExcess = depth + 1;
+        }
+        else if (maxl === 0) {
+            return false;
         }
+        if (depth >= this.tempep.length)
+            this.ensureDepth(depth);
         const sym = this.sym;
         const symMvrot = sym.mvrot;
         const symMvroto = sym.mvroto;
@@ -184,25 +223,37 @@ export class FastPhase3Solver {
         else {
             ep.set(eplast);
         }
-        // TT lookup (for depths >= 2 where TT hit prunes multi-move subtrees)
-        const keyHigh = ((ct << 16) | (ep[8] | (ep[9] << 4) | (ep[10] << 8) | (ep[11] << 12))) >>> 0;
-        const keyLow = (ep[0] | (ep[1] << 4) | (ep[2] << 8) | (ep[3] << 12) |
-            (ep[4] << 16) | (ep[5] << 20) | (ep[6] << 24) | (ep[7] << 28)) >>> 0;
-        const slot = (((keyLow ^ Math.imul(keyHigh, 0x9e3779b9)) & FastPhase3Solver.TT_MASK) * 3) >>> 0;
-        if (maxl >= 2) {
-            const storedHigh = FastPhase3Solver.tt[slot];
-            const storedLow = FastPhase3Solver.tt[slot + 1];
-            const storedInfo = FastPhase3Solver.tt[slot + 2];
+        const hasHc = hc !== undefined && hcCoord >= 0 && hc.moves.length > 0;
+        // HC pruning depends on a second coordinate not represented in the TT
+        // key. The root c3-pair check also varies only at depth zero. Do not reuse
+        // entries in those contexts; all other phase-3 state is key-complete.
+        const useTt = !hasHc && !(depth === 0 && c3PairDist !== undefined);
+        // TT: entries claim "no RAW goal at any length <= maxl from (ep, lm)" —
+        // coordinate-complete and predicate-independent (the validator's
+        // full-state checks are NOT coordinate-complete, so no validator-scoped
+        // claims may be cached). Hits are `<=`-claims and therefore
+        // proof-compatible for `validatedThrough`/`provenThrough` coverage.
+        const ttActive = useTt && maxl >= 2;
+        let keyHigh = 0;
+        let keyLow = 0;
+        let slot = 0;
+        if (ttActive) {
+            keyHigh = ((ct << 16) | (ep[8] | (ep[9] << 4) | (ep[10] << 8) | (ep[11] << 12))) >>> 0;
+            keyLow = (ep[0] | (ep[1] << 4) | (ep[2] << 8) | (ep[3] << 12) |
+                (ep[4] << 16) | (ep[5] << 20) | (ep[6] << 24) | (ep[7] << 28)) >>> 0;
+            slot = (((keyLow ^ Math.imul(keyHigh, 0x9e3779b9)) & FastPhase3Solver.TT_MASK) * 3) >>> 0;
+            const storedHigh = this.tt[slot];
+            const storedLow = this.tt[slot + 1];
+            const storedInfo = this.tt[slot + 2];
             if (storedHigh === keyHigh && storedLow === keyLow) {
-                const storedEpoch = storedInfo >>> 16;
-                const storedLm = (storedInfo >> 8) & 0xff;
-                const storedDepth = storedInfo & 0xff;
-                if (storedEpoch === FastPhase3Solver.epoch && storedDepth >= maxl && storedLm === lm) {
-                    // Same-call hits replay this call's own exhausted subtree (proof
-                    // stays clean); cross-call hits still prune but dirty the proof.
-                    // NOTE: ignoring cross-call entries was tried and reverted — they
-                    // carry most of the pruning power (3.82s vs 2.39s on the corpus).
-                    if (FastPhase3Solver.ttGen[(slot / 3) | 0] !== this.callId)
+                const storedCallId = (storedInfo >>> 11) & 0xfffff;
+                const storedLm = (storedInfo >>> 6) & 0x1f;
+                const storedDepth = storedInfo & 0x3f;
+                if (storedDepth >= maxl && storedLm === lm) {
+                    const coverage = depth + storedDepth;
+                    if (coverage < this.ttCoverage)
+                        this.ttCoverage = coverage;
+                    if (storedCallId !== this.callId)
                         this.ttTouched = true;
                     return false;
                 }
@@ -214,15 +265,16 @@ export class FastPhase3Solver {
         const sym2Raw = sym.sym2Raw;
         const sym2Mask = sym.sym2Mask;
         const raw2Sym = sym.raw2Sym;
-        const hasHc = hc !== undefined && hcCoord >= 0 && hc.moves.length > 0;
         const hcMoves = hasHc ? hc.moves : null;
         const hcDist = hasHc ? hc.distances : null;
         const hcRow = hasHc ? hcCoord * HC_PDB_MOVES.length : 0;
         // Byte-expanded (tests/generators) vs nibble-packed (loaders) distances.
         const edgeUnpacked = edge3Distances.length >= 31006080;
+        const examined0 = collect === undefined ? 0 : collect.examined;
+        const ckmvRow = lm * 20;
         for (let m = 0; m < 17; m++) {
-            if (ckmv3[lm][m]) {
-                m = skipAxis3[m];
+            if (ckmv3Flat[ckmvRow + m]) {
+                m = skipAxis3Fast[m];
                 continue;
             }
             const nc = c3Move[c3Row + m];
@@ -230,9 +282,11 @@ export class FastPhase3Solver {
                 continue;
             const prun1 = c3Prun[nc];
             if (prun1 >= maxl) {
-                this.noteExcess(depth, prun1, prun1 > maxl && m < 14);
+                const ex1 = (prun1 > maxl && m < 14) ? depth + prun1 : depth + 1 + prun1;
+                if (ex1 < this.minExcess)
+                    this.minExcess = ex1;
                 if (prun1 > maxl && m < 14)
-                    m = skipAxis3[m];
+                    m = skipAxis3Fast[m];
                 continue;
             }
             let nhc = -1;
@@ -241,9 +295,11 @@ export class FastPhase3Solver {
                 if (nhc >= 0) {
                     const prunh = hcDist[nhc];
                     if (prunh >= maxl) {
-                        this.noteExcess(depth, prunh, prunh > maxl && m < 14);
+                        const exH = (prunh > maxl && m < 14) ? depth + prunh : depth + 1 + prunh;
+                        if (exH < this.minExcess)
+                            this.minExcess = exH;
                         if (prunh > maxl && m < 14)
-                            m = skipAxis3[m];
+                            m = skipAxis3Fast[m];
                         continue;
                     }
                 }
@@ -264,13 +320,36 @@ export class FastPhase3Solver {
                         prunPair = d;
                 }
                 if (prunPair >= maxl) {
-                    this.noteExcess(depth, prunPair, prunPair > maxl && m < 14);
+                    const exP = (prunPair > maxl && m < 14) ? depth + prunPair : depth + 1 + prunPair;
+                    if (exP < this.minExcess)
+                        this.minExcess = exP;
                     if (prunPair > maxl && m < 14)
-                        m = skipAxis3[m];
+                        m = skipAxis3Fast[m];
                     continue;
                 }
             }
-            const symIdx = getMvSymFrom(ep, ep, m, sym2Raw, sym2Mask, raw2Sym, symMvrot, symMvroto);
+            // Inlined getMvSymFrom(ep, ep, m, ...) (bit-identical; masks here are
+            // 12-bit, so one popcount lookup replaces bitCount's three).
+            let mrIdx = m << 3;
+            let movoBase = mrIdx * 12;
+            let raw = 0;
+            let bits = 0;
+            for (let i = 0; i < 4; i++) {
+                const val = symMvroto[movoBase + ep[symMvrot[movoBase + i]]];
+                raw = raw * (12 - i) + val - POPC12[bits & ((1 << val) - 1)];
+                bits |= 1 << val;
+            }
+            const symBase = raw2Sym[raw];
+            mrIdx |= symBase & 7;
+            let symOut = symBase >> 3;
+            bits = sym2Mask[symOut];
+            movoBase = mrIdx * 12;
+            for (let i = 4; i < 10; i++) {
+                const val = symMvroto[movoBase + ep[symMvrot[movoBase + i]]];
+                symOut = symOut * (12 - i) + val - POPC12[bits & ((1 << val) - 1)];
+                bits |= 1 << val;
+            }
+            const symIdx = ((symOut << 3) | (mrIdx & 7)) >>> 0;
             // Format-aware read: loaders keep the nibble-packed table (15.5MB);
             // tests and generators may pass byte-expanded buffers instead.
             const eIdx = symIdx >> 3;
@@ -278,9 +357,11 @@ export class FastPhase3Solver {
                 ? edge3Distances[eIdx]
                 : (edge3Distances[eIdx >> 1] >> ((eIdx & 1) * 4)) & 0x0f;
             if (prunx >= maxl) {
-                this.noteExcess(depth, prunx, prunx > maxl && m < 14);
+                const exE = (prunx > maxl && m < 14) ? depth + prunx : depth + 1 + prunx;
+                if (exE < this.minExcess)
+                    this.minExcess = exE;
                 if (prunx > maxl && m < 14)
-                    m = skipAxis3[m];
+                    m = skipAxis3Fast[m];
                 continue;
             }
             this.moveLog[depth] = m;
@@ -288,36 +369,38 @@ export class FastPhase3Solver {
                 return true;
             }
         }
-        // Record failure in TT if node didn't abort due to node cap
-        if (this.nodeCount <= maxNodes && maxl >= 2) {
-            FastPhase3Solver.tt[slot] = keyHigh;
-            FastPhase3Solver.tt[slot + 1] = keyLow;
-            FastPhase3Solver.tt[slot + 2] = (FastPhase3Solver.epoch << 16) | (lm << 8) | maxl;
-            FastPhase3Solver.ttGen[(slot / 3) | 0] = this.callId;
+        // Cache only subtrees with NO raw goal reached in them (the examined
+        // count is the goal counter — rejections included, since the claim is
+        // raw). Goal-free subtrees are safe to reuse across calls, candidates
+        // and predicates.
+        if (ttActive &&
+            this.nodeCount <= maxNodes &&
+            (collect?.examined ?? 0) === examined0) {
+            this.tt[slot] = keyHigh;
+            this.tt[slot + 1] = keyLow;
+            this.tt[slot + 2] = ((this.callId << 11) | (lm << 6) | maxl) >>> 0;
         }
         return false;
     }
     /**
-     * Record an IDA* bound prune: the child at `depth + 1` needs at least
-     * `childBound` more moves, so no solution exists through this branch
-     * below root threshold `depth + 1 + childBound`. When a bound-based axis
-     * skip also fires, the skipped siblings are same-face turns (verified:
-     * every non-empty skipAxis3 run under m < 14 is a same-base triple),
-     * hence at most 1 legal move apart — their bound is at least
+     * Record an IDA* bound prune (inlined at the four gate sites): the child at
+     * `depth + 1` needs at least `childBound` more moves, so no solution exists
+     * through this branch below root threshold `depth + 1 + childBound`. When a
+     * bound-based axis skip also fires, the skipped siblings are same-face turns
+     * (verified: every non-empty skipAxis3 run under m < 14 is a same-base
+     * triple), hence at most 1 legal move apart — their bound is at least
      * `childBound - 1` by the triangle inequality on the exact PDBs, so the
      * recorded excess `depth + childBound` stays a true lower bound.
      */
-    noteExcess(depth, childBound, skippedSiblings) {
-        const excess = skippedSiblings ? depth + childBound : depth + 1 + childBound;
-        if (excess < this.minExcess)
-            this.minExcess = excess;
-    }
     /**
      * Search for a phase-3 solution with exact target length (first found).
      */
     solveLength(edge, ct3, edist, length3, center3Tables, edge3Distances, maxNodes = 15000, hc, hcCoord = -1, c3PairDist) {
+        this.setTableContext(center3Tables, edge3Distances);
         this.tempep[0].set(edge);
         this.nodeCount = 0;
+        this.callId = this.nextCallId();
+        this.ttCoverage = Number.MAX_SAFE_INTEGER;
         if (this.search(this.tempep[0], ct3, edist, length3, 20, 0, center3Tables, edge3Distances, maxNodes, undefined, hc, hcCoord, c3PairDist)) {
             return this.moveLog.slice(0, length3).map((m) => SEARCH_MOVES[m]);
         }
@@ -343,6 +426,7 @@ export class FastPhase3Solver {
      * it is `length3 - 1` at most (only the attempted length is settled).
      */
     solveLengthProven(edge, ct3, edist, length3, center3Tables, edge3Distances, maxNodes = 15000, limit = 16, validate, hc, hcCoord = -1, c3PairDist) {
+        this.setTableContext(center3Tables, edge3Distances);
         if (c3PairDist) {
             const c3Base = ct3 * 144;
             let maxPairDist = 0;
@@ -353,7 +437,7 @@ export class FastPhase3Solver {
                     maxPairDist = d;
             }
             if (maxPairDist > length3) {
-                return { moves: null, provenThrough: maxPairDist - 1, nodesUsed: 0 };
+                return { moves: null, provenThrough: maxPairDist - 1, validatedThrough: maxPairDist - 1, nodesUsed: 0 };
             }
         }
         this.tempep[0].set(edge);
@@ -363,7 +447,8 @@ export class FastPhase3Solver {
         this.sawGoal = false;
         this.ttTouched = false;
         this.minExcess = Number.MAX_SAFE_INTEGER;
-        this.callId = FastPhase3Solver.nextCallId();
+        this.ttCoverage = Number.MAX_SAFE_INTEGER;
+        this.callId = this.nextCallId();
         let accepted = null;
         const collect = {
             limit,
@@ -373,15 +458,15 @@ export class FastPhase3Solver {
                     accepted = moves;
                     return true;
                 }
-                if (!accepted)
-                    accepted = moves;
+                // A rejected goal is not a validated solution. Enumeration callers
+                // may collect it themselves, but cannot use it as a search proof.
                 return false;
             }
         };
         this.search(this.tempep[0], ct3, edist, length3, 20, 0, center3Tables, edge3Distances, maxNodes, collect, hc, hcCoord, c3PairDist);
         if (accepted)
-            return { moves: accepted, provenThrough: length3, nodesUsed: this.nodeCount };
-        if (process.env.CUBE4_PROOF_STATS === "1") {
+            return { moves: accepted, provenThrough: length3, validatedThrough: length3, nodesUsed: this.nodeCount };
+        if (typeof process !== "undefined" && process.env?.CUBE4_PROOF_STATS === "1") {
             proofStats.total++;
             if (this.capped)
                 proofStats.capped++;
@@ -392,19 +477,41 @@ export class FastPhase3Solver {
             if (this.ttTouched)
                 proofStats.ttTouched++;
         }
+        // `provenThrough` keeps its conservative raw-goal contract: it may only
+        // claim a depth when NO raw goal was reached at all (a rejected goal IS
+        // a raw goal), no TT hit intervened, and the bound prunes cover past the
+        // attempted length.
+        let provenThrough = -1;
         if (!this.capped &&
             !this.limitHit &&
             !this.sawGoal &&
             !this.ttTouched &&
             this.minExcess > length3 &&
             this.minExcess !== Number.MAX_SAFE_INTEGER) {
-            if (process.env.CUBE4_PROOF_STATS === "1") {
+            if (typeof process !== "undefined" && process.env?.CUBE4_PROOF_STATS === "1") {
                 proofStats.clean++;
                 proofStats.jumpSum += this.minExcess - 1 - length3;
             }
-            return { moves: null, provenThrough: this.minExcess - 1, nodesUsed: this.nodeCount };
+            provenThrough = this.minExcess - 1;
+        }
+        // `validatedThrough` is scoped to THIS call's validator predicate (all
+        // calls sharing one solver instance use one predicate): rejected raw
+        // goals are not goals for it, and TT hits are proof-compatible (entries
+        // mean "no goal under the call's predicate at any length <= stored").
+        // Every walked branch leaves a claim: bound prunes record their
+        // threshold (noteExcess), fringe rejections record `length3 + 1` below,
+        // and TT-hit subtrees record `ttCoverage`.
+        let validatedThrough = -1;
+        if (!this.capped && !this.limitHit) {
+            let bound = length3;
+            if (this.minExcess !== Number.MAX_SAFE_INTEGER && this.minExcess - 1 > bound) {
+                bound = this.minExcess - 1;
+            }
+            if (this.ttCoverage < bound)
+                bound = this.ttCoverage;
+            validatedThrough = bound;
         }
-        return { moves: null, provenThrough: length3, nodesUsed: this.nodeCount };
+        return { moves: null, provenThrough, validatedThrough, nodesUsed: this.nodeCount };
     }
 }
 /** Temporary instrumentation for proof-statistics (CUBE4_PROOF_STATS=1). */
@@ -426,11 +533,11 @@ export function resetProofStats() {
     proofStats.clean = 0;
     proofStats.jumpSum = 0;
 }
-const defaultSolver = new FastPhase3Solver();
 /**
  * Solve Phase 3 with iterative deepening on a single Phase3Start.
  */
-export async function solvePhase3(start, center3Tables, edge3Tables, maxLength = 20) {
+export async function solvePhase3(start, center3Tables, edge3Tables, maxLength = 20, maxNodes = 80_000) {
+    const solver = new FastPhase3Solver();
     const sym = getSymTables();
     const symIdx = getMvSymFrom(start.edge, start.edge, 20, sym.sym2Raw, sym.sym2Mask, sym.raw2Sym, sym.mvrot, sym.mvroto);
     const edist = (edge3Tables.distances[(symIdx >> 3) >> 1] >> (((symIdx >> 3) & 1) * 4)) & 0x0f;
@@ -439,7 +546,7 @@ export async function solvePhase3(start, center3Tables, edge3Tables, maxLength =
         return null;
     const minLength = Math.max(cdist, edist);
     for (let l = minLength; l <= maxLength; l++) {
-        const moves = await defaultSolver.solveLength(start.edge, start.ct3, edist, l, center3Tables, edge3Tables.distances);
+        const moves = solver.solveLength(start.edge, start.ct3, edist, l, center3Tables, edge3Tables.distances, maxNodes);
         if (moves) {
             return {
                 moves,

package/dist/puzzles/cube4/reduction/rotation-fix.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Placement of the whole-cube rotation fix inside a 4x4 solution.
+ *
+ * The reduction ends with the cube solved in some orientation, so the solve
+ * is `P ++ W(R) ++ Q` where `W(R)` are the 2-4 wide moves of the rotation R
+ * (`x` = `Rw Lw'`, ...). A rotation commutes with any move sequence once the
+ * sequence's faces are re-mapped:
+ *
+ *   X ++ W(R)  ≡  W(R) ++ rotateAlgorithm(X, R)
+ *
+ * so the fix can sit at ANY point of the solution (with the moves after it
+ * re-mapped), and a two-rotation fix can be split across two points. The
+ * total is unchanged except at the insertion junctions, where the fix can
+ * cancel against same-axis wide moves (`Uw2 · y2` = `Uw2 · Uw2 Dw2` = `Dw2`).
+ * `placeRotationFix` picks the placement with the shortest simplified total.
+ */
+import type { Cube4Move } from "../types.js";
+/** Wide-move words of the 9 single rotations. */
+export declare const ROTATION_WORDS: Readonly<Record<string, readonly Cube4Move[]>>;
+/**
+ * Shortest simplified solution equivalent to `prefix ++ W(rotation) ++
+ * suffix` (same effect on every state), over every run-boundary insertion
+ * point of the fix and every minimal factorization of the rotation. Only
+ * run boundaries matter: the fix can only merge with runs on its own axis,
+ * and re-mapping preserves the run structure of what follows it.
+ */
+export declare function placeRotationFix(prefix: readonly Cube4Move[], rotation: readonly string[], suffix: readonly Cube4Move[]): Cube4Move[];
+//# sourceMappingURL=rotation-fix.d.ts.map

package/dist/puzzles/cube4/reduction/rotation-fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation-fix.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/rotation-fix.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,iDAAiD;AACjD,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC,CAUzE,CAAC;AA0FF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,MAAM,EAAE,SAAS,SAAS,EAAE,GAC3B,SAAS,EAAE,CA0Fb"}