@cubingcenter/scrambler 0.7.0 → 0.8.0

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

@@ -41,6 +41,12 @@ export const CENTER2_GOAL_RL = [0, 18, 28, 46, 54, 56];
 export const CENTER2_CT_STATES = 6435;
 export const CENTER2_RL_STATES = 70;
 export const CENTER2_STATES = CENTER2_CT_STATES * CENTER2_RL_STATES;
+const CENTER2_GOAL_FLAGS = (() => {
+    const flags = new Uint8Array(CENTER2_RL_STATES);
+    for (const rl of CENTER2_GOAL_RL)
+        flags[rl] = 1;
+    return flags;
+})();
 // ct positions: U(0-3), D(12-15), F(8-11), B(20-23) — the reference's face
 // order {U, D, F, B}, in this repo's face-major numbering.
 const CT_POS = [0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11, 20, 21, 22, 23];
@@ -104,7 +110,7 @@ export function encodeCenter2(state) {
     return { ct: ctRank, rl: rlRank };
 }
 export function isCenter2Goal(ct, rl) {
-    return ct === 0 && CENTER2_GOAL_RL.includes(rl);
+    return ct === 0 && CENTER2_GOAL_FLAGS[rl] === 1;
 }
 /**
  * The phase-2 coordinate is only valid for states where exactly 8 of the
@@ -292,6 +298,98 @@ export function generateCenter2Tables() {
     }
     return { ctMove, rlMove, pruning, pruningWide };
 }
+// ---------------------------------------------------------------------------
+// Chiral (absolute-ct) phase-2 tables
+// ---------------------------------------------------------------------------
+/**
+ * The ct rank above is RELATIVE to ct[15], so `ct == 0` accepts both
+ * assignments of the two non-R/L axes to the U/D and F/B face-pairs. Only
+ * one of them survives the downstream chirality gate (`axisDet`: the U, R, F
+ * axes must form a right-handed frame, i.e. U/D must hold axis (a + 2) % 3
+ * when R/L holds axis a). The chiral coordinate ranks the ABSOLUTE pattern
+ * "which of the 16 U/D/F/B positions hold the U/D-bound axis" (C(16,8) =
+ * 12,870) and its pruning measures the distance to the chirality-correct
+ * goals only, so the phase-2 search never walks wrong-chirality goal paths.
+ * Same goal set as `ct == 0 && axisDet == 1`; generated at runtime (~1.6 MB).
+ */
+export const CENTER2_CHIRAL_CT_STATES = 12870;
+export const CENTER2_CHIRAL_STATES = CENTER2_CHIRAL_CT_STATES * CENTER2_RL_STATES;
+function rankSubset16(bits) {
+    let idx = 0;
+    let r = 8;
+    for (let i = 15; i >= 0 && r > 0; i--) {
+        if (bits[i] === 1) {
+            idx += CNK[i][r];
+            r--;
+        }
+    }
+    return idx;
+}
+function unrankSubset16(idx) {
+    const bits = new Uint8Array(16);
+    let r = 8;
+    for (let i = 15; i >= 0 && r > 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            bits[i] = 1;
+            r--;
+        }
+    }
+    return bits;
+}
+/** Chiral ct rank of a coordinate-invariant (bridged) phase-2 state. */
+export function encodeCenter2ChiralCt(state) {
+    const rlAxis = state.centers[RL_POS[0]] % 3;
+    const udAxis = (rlAxis + 2) % 3;
+    const bits = new Uint8Array(16);
+    for (let i = 0; i < 16; i++)
+        bits[i] = state.centers[CT_POS[i]] % 3 === udAxis ? 1 : 0;
+    return rankSubset16(bits);
+}
+export function generateCenter2ChiralTables(rlMove) {
+    const moveMaps = buildMovePositionMaps();
+    const nMoves = CENTER2_MOVES.length;
+    const ctMove = new Uint16Array(CENTER2_CHIRAL_CT_STATES * nMoves);
+    const full = new Uint8Array(24);
+    const bits = new Uint8Array(16);
+    for (let ct = 0; ct < CENTER2_CHIRAL_CT_STATES; ct++) {
+        const pattern = unrankSubset16(ct);
+        full.fill(0);
+        for (let i = 0; i < 16; i++)
+            full[CT_POS[i]] = pattern[i];
+        for (let m = 0; m < nMoves; m++) {
+            for (let i = 0; i < 16; i++)
+                bits[i] = full[moveMaps[m * 24 + CT_POS[i]]];
+            ctMove[ct * nMoves + m] = rankSubset16(bits);
+        }
+    }
+    const goalBits = new Uint8Array(16);
+    for (let i = 0; i < 8; i++)
+        goalBits[i] = 1; // CT_POS[0..7] = U and D faces
+    const goalCt = rankSubset16(goalBits);
+    const pruning = new Uint8Array(CENTER2_CHIRAL_STATES).fill(0xff);
+    const queue = new Int32Array(CENTER2_CHIRAL_STATES);
+    let tail = 0;
+    for (const rl of CENTER2_GOAL_RL) {
+        const idx = goalCt * CENTER2_RL_STATES + rl;
+        pruning[idx] = 0;
+        queue[tail++] = idx;
+    }
+    for (let head = 0; head < tail; head++) {
+        const idx = queue[head];
+        const ct = (idx / CENTER2_RL_STATES) | 0;
+        const rl = idx - ct * CENTER2_RL_STATES;
+        const d = pruning[idx] + 1;
+        for (let m = 0; m < CENTER2_SEARCH_MOVES.length; m++) {
+            const next = ctMove[ct * nMoves + m] * CENTER2_RL_STATES + rlMove[rl * nMoves + m];
+            if (pruning[next] === 0xff) {
+                pruning[next] = d;
+                queue[tail++] = next;
+            }
+        }
+    }
+    return { ctMove, pruning, goalCt };
+}
 // The reference's cancellation rule (ckmv over move2std): skip the same base
 // move, or the same axis-class when the previous move's standard index is
 // larger than the current's.

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

@@ -0,0 +1,53 @@
+/**
+ * Continuous two-phase 3x3 solver for the 4x4 finish (Kociemba-style).
+ *
+ * Unlike the batch solver in `cube3/solver` (collect phase-1 solutions,
+ * then solve phase 2 for each), this is the classic continuous search: an
+ * iterative-deepening phase 1 where EVERY phase-1 solution immediately runs
+ * phase 2 under the remaining length budget, and every solution found
+ * tightens the bound for the rest of the search. Optional legal views are
+ * searched interleaved by phase-1 depth — up to 3 relabelled axes
+ * (identity, x, z) × {state, inverse} — which is what makes short solutions
+ * cheap to find (the existing cube3 solver's rotation/inverse trick).
+ *
+ * Tables: the already-loaded cube3 tables (phase-1: twist/flip/slice move
+ * tables + twist×flip, slice×twist, slice×flip pruning; phase-2: cp/ep/sp
+ * move tables + cp×sp, ep×sp pruning). Nothing is generated here.
+ *
+ * Deterministic: the only stopping rules are node counts and lengths, so
+ * the result is a pure function of (state, options).
+ */
+import type { Cube3Move, Cube3State } from "../../cube3/types.js";
+import { type Cube3Phase1Tables, type Cube3Phase2Tables } from "../../cube3/solver/tables.js";
+export interface Finish3Tables {
+    phase1: Cube3Phase1Tables;
+    phase2: Cube3Phase2Tables;
+}
+export interface Finish3Options {
+    /** Stop as soon as a solution of at most this length is found (default 0 = never). */
+    targetLength?: number;
+    /**
+     * Node budget (phase-1 + phase-2 nodes) after which the best solution so
+     * far is returned (default 200_000). The search always runs until a first
+     * solution exists, bounded by `hardMaxNodes`.
+     */
+    maxNodes?: number;
+    /** Absolute node cap; exceeding it without any solution throws (default 20M). */
+    hardMaxNodes?: number;
+    /** Views searched: 1 (as is), 2 (+inverse), 6 (3 axes × inverse). */
+    views?: 1 | 2 | 6;
+    /** @deprecated Ignored: views are built by cubie conjugation. */
+    viewScramble?: readonly Cube3Move[];
+    /** Longest phase-2 segment considered (default 12). */
+    maxPhase2Length?: number;
+}
+export interface Finish3Result {
+    moves: Cube3Move[];
+    nodes: number;
+}
+export declare class Finish3SearchError extends Error {
+    readonly code: "cube4-finish3-cap";
+    constructor(message: string);
+}
+export declare function solveFinish3(state: Cube3State, tables: Finish3Tables, options?: Finish3Options): Finish3Result;
+//# sourceMappingURL=finish3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"finish3.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/finish3.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAalE,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,8BAA8B,CAAC;AAMtC,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,sFAAsF;IACtF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,iEAAiE;IACjE,YAAY,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACpC,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAG,mBAAmB,CAAU;gBAEjC,OAAO,EAAE,MAAM;CAI5B;AAsKD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAuMf"}

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

@@ -0,0 +1,393 @@
+/**
+ * Continuous two-phase 3x3 solver for the 4x4 finish (Kociemba-style).
+ *
+ * Unlike the batch solver in `cube3/solver` (collect phase-1 solutions,
+ * then solve phase 2 for each), this is the classic continuous search: an
+ * iterative-deepening phase 1 where EVERY phase-1 solution immediately runs
+ * phase 2 under the remaining length budget, and every solution found
+ * tightens the bound for the rest of the search. Optional legal views are
+ * searched interleaved by phase-1 depth — up to 3 relabelled axes
+ * (identity, x, z) × {state, inverse} — which is what makes short solutions
+ * cheap to find (the existing cube3 solver's rotation/inverse trick).
+ *
+ * Tables: the already-loaded cube3 tables (phase-1: twist/flip/slice move
+ * tables + twist×flip, slice×twist, slice×flip pruning; phase-2: cp/ep/sp
+ * move tables + cp×sp, ep×sp pruning). Nothing is generated here.
+ *
+ * Deterministic: the only stopping rules are node counts and lengths, so
+ * the result is a pure function of (state, options).
+ */
+import { CUBE3_MOVES } from "../../cube3/types.js";
+import { applyCube3Move } from "../../cube3/moves.js";
+import { createSolvedCube3State } from "../../cube3/state.js";
+import { applyCube4Algorithm } from "../moves.js";
+import { createSolvedCube4State } from "../state.js";
+import { toCube3State } from "./phase4.js";
+import { encodeCornerOrientation, encodeEdgeOrientation, encodeUdSlice } from "../../cube3/solver/coordinates.js";
+import { CUBE3_PHASE2_MOVES } from "../../cube3/solver/tables.js";
+import { invertCube3RotationSequence, rotateCube3AlgorithmBySequence } from "../../cube3/solver/symmetry.js";
+export class Finish3SearchError extends Error {
+    code = "cube4-finish3-cap";
+    constructor(message) {
+        super(message);
+        this.name = "Finish3SearchError";
+    }
+}
+function toCubie(state) {
+    return {
+        cp: Int8Array.from(state.corners.permutation),
+        co: Int8Array.from(state.corners.orientation),
+        ep: Int8Array.from(state.edges.permutation),
+        eo: Int8Array.from(state.edges.orientation)
+    };
+}
+function toState(cubie) {
+    return {
+        corners: { permutation: Array.from(cubie.cp), orientation: Array.from(cubie.co) },
+        edges: { permutation: Array.from(cubie.ep), orientation: Array.from(cubie.eo) }
+    };
+}
+function inverse(a) {
+    const out = { cp: new Int8Array(8), co: new Int8Array(8), ep: new Int8Array(12), eo: new Int8Array(12) };
+    for (let i = 0; i < 8; i++) {
+        out.cp[a.cp[i]] = i;
+        out.co[a.cp[i]] = (3 - a.co[i]) % 3;
+    }
+    for (let i = 0; i < 12; i++) {
+        out.ep[a.ep[i]] = i;
+        out.eo[a.ep[i]] = a.eo[i];
+    }
+    return out;
+}
+/** Per-move permutation effects, as the solved state with the move applied. */
+const MOVE_CUBIES = CUBE3_MOVES.map((move) => toCubie(applyCube3Move(createSolvedCube3State(), move)));
+const MOVE_CP = Int8Array.from(MOVE_CUBIES.flatMap((c) => Array.from(c.cp)));
+const MOVE_EP = Int8Array.from(MOVE_CUBIES.flatMap((c) => Array.from(c.ep)));
+/** Face (U0 D1 R2 L3 F4 B5) of each phase-1 move index. */
+const FACE = Int8Array.from(CUBE3_MOVES.map((_, m) => Math.floor(m / 3)));
+/** Phase-1 move index of each phase-2 move index. */
+const P2_TO_P1 = Int8Array.from(CUBE3_PHASE2_MOVES.map((move) => CUBE3_MOVES.indexOf(move)));
+/** Phase-1 moves that keep G1 (U, D, R2, L2, F2, B2). */
+const IS_P2_MOVE = new Uint8Array(18);
+for (const m of P2_TO_P1)
+    IS_P2_MOVE[m] = 1;
+/** Skip `face` after `last`: same face, or same axis in descending order. */
+const SKIP = new Uint8Array(7 * 6);
+for (let last = -1; last < 6; last++) {
+    for (let face = 0; face < 6; face++) {
+        SKIP[(last + 1) * 6 + face] =
+            last >= 0 && (face === last || ((face >> 1) === (last >> 1) && face < last)) ? 1 : 0;
+    }
+}
+const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320];
+/** Lehmer rank of values[offset..offset+n) (same order as `encodePermutation`). */
+function lehmer(values, offset, n, base) {
+    let rank = 0;
+    for (let i = 0; i < n; i++) {
+        const v = values[offset + i];
+        let smaller = 0;
+        for (let j = i + 1; j < n; j++)
+            if (values[offset + j] < v)
+                smaller++;
+        rank += smaller * FACT[n - 1 - i];
+    }
+    return rank - base * 0;
+}
+// ---------------------------------------------------------------------------
+// Views (relabelled scrambles and inverses)
+// ---------------------------------------------------------------------------
+const VIEW_ROTATIONS = [[], ["x"], ["z"]];
+function invertMoves(moves) {
+    return [...moves].reverse().map((move) => {
+        if (move.endsWith("2"))
+            return move;
+        if (move.endsWith("'"))
+            return move.slice(0, -1);
+        return `${move}'`;
+    });
+}
+function multiply(a, b) {
+    const out = { cp: new Int8Array(8), co: new Int8Array(8), ep: new Int8Array(12), eo: new Int8Array(12) };
+    for (let i = 0; i < 8; i++) {
+        out.cp[i] = a.cp[b.cp[i]];
+        out.co[i] = (a.co[b.cp[i]] + b.co[i]) % 3;
+    }
+    for (let i = 0; i < 12; i++) {
+        out.ep[i] = a.ep[b.ep[i]];
+        out.eo[i] = (a.eo[b.ep[i]] + b.eo[i]) % 2;
+    }
+    return out;
+}
+/** 3x3 cubies of the whole-cube rotations, read off the rotated 4x4 model. */
+const ROTATION_WORDS = {
+    x: ["Rw", "Lw'"],
+    z: ["Fw", "Bw'"]
+};
+const ROTATION_CUBIES = new Map(Object.entries(ROTATION_WORDS).map(([name, word]) => [
+    name,
+    toCubie(toCube3State(applyCube4Algorithm(createSolvedCube4State(), word)))
+]));
+/**
+ * Views of the state: conjugations by x / z and inverses. The x-view of S
+ * is R⁻¹·S·R (R = the rotation's cubie) — the same state the relabelled
+ * scramble `rotate(scramble(S), [x])` reaches (verified in
+ * test/cube4-finish3.test.ts), so a view solution maps back by relabelling
+ * with the inverse rotation. Conjugation preserves parity and legality.
+ */
+function buildViews(state, count) {
+    if (count !== 1 && count !== 2 && count !== 6) {
+        throw new RangeError(`finish3: unsupported view count ${count}`);
+    }
+    const base = toCubie(state);
+    const views = [];
+    const axes = count === 6 ? VIEW_ROTATIONS : [[]];
+    for (const rotation of axes) {
+        let viewCubie = base;
+        for (const r of rotation) {
+            const rc = ROTATION_CUBIES.get(r);
+            viewCubie = multiply(multiply(inverse(rc), viewCubie), rc);
+        }
+        const makeView = (inverted) => {
+            views.push({
+                cubie: inverted ? inverse(viewCubie) : viewCubie,
+                mapSolution: (moves) => {
+                    const direct = inverted ? invertMoves(moves) : [...moves];
+                    return rotation.length === 0
+                        ? direct
+                        : rotateCube3AlgorithmBySequence(direct, invertCube3RotationSequence(rotation));
+                }
+            });
+        };
+        makeView(false);
+        if (count >= 2)
+            makeView(true);
+    }
+    return views;
+}
+// ---------------------------------------------------------------------------
+// Search
+// ---------------------------------------------------------------------------
+export function solveFinish3(state, tables, options = {}) {
+    const targetLength = options.targetLength ?? 0;
+    const maxNodes = options.maxNodes ?? 200_000;
+    const hardMaxNodes = options.hardMaxNodes ?? 20_000_000;
+    const maxP2 = options.maxPhase2Length ?? 12;
+    const views = buildViews(state, options.views ?? 1);
+    const p1 = tables.phase1;
+    const coMove = p1.moveTables.cornerOrientation.values;
+    const eoMove = p1.moveTables.edgeOrientation.values;
+    const udMove = p1.moveTables.udSlice.values;
+    const udSolved = p1.moveTables.udSlice.solvedCoordinate;
+    const coeo = p1.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPrun = p1.pruningTables.udSlice.values;
+    const jointUdCo = p1.jointTables?.jointUdCo;
+    const jointUdEo = p1.jointTables?.jointUdEo;
+    const p2 = tables.phase2;
+    if (p2.phase2Moves.join(" ") !== CUBE3_PHASE2_MOVES.join(" ")) {
+        throw new Error("finish3: unexpected phase-2 move order");
+    }
+    const cpMove = p2.moveTables.cornerPermutation.values;
+    const epMove = p2.moveTables.udEdgePermutation.values;
+    const spMove = p2.moveTables.slicePermutation.values;
+    const cpsp = p2.pruningTables.cornerPermutationSlicePermutation.values;
+    const epsp = p2.pruningTables.udEdgePermutationSlicePermutation.values;
+    const nib = (table, index) => (table[index >> 1] >> ((index & 1) << 2)) & 0x0f;
+    const h1 = (co, eo, ud) => {
+        let h = nib(coeo, (co << 11) + eo);
+        if (jointUdCo !== undefined && jointUdEo !== undefined) {
+            const a = nib(jointUdCo, ud * 2187 + co);
+            if (a > h)
+                h = a;
+            const b = nib(jointUdEo, ud * 2048 + eo);
+            if (b > h)
+                h = b;
+        }
+        else {
+            const u = nib(udPrun, ud);
+            if (u > h)
+                h = u;
+        }
+        return h;
+    };
+    const h2 = (cp, ep, sp) => {
+        const a = nib(cpsp, cp * 24 + sp);
+        const b = nib(epsp, ep * 24 + sp);
+        return a > b ? a : b;
+    };
+    const path1 = new Int8Array(32);
+    const path2 = new Int8Array(32);
+    const cpScratch = new Int8Array(8);
+    const epScratch = new Int8Array(12);
+    const cpTmp = new Int8Array(8);
+    const epTmp = new Int8Array(12);
+    let nodes = 0;
+    let bound = 99; // best length found so far (solutions must be shorter)
+    let best = null;
+    let stop = false;
+    let view = views[0];
+    // Hot-path guard: `shouldStop` can only change its answer once `nodes`
+    // passes this limit (the other conditions are re-checked in `leaf`).
+    let nodeLimit = hardMaxNodes;
+    const hasJoint = jointUdCo !== undefined && jointUdEo !== undefined;
+    const shouldStop = () => {
+        if (nodes > hardMaxNodes) {
+            if (best === null) {
+                throw new Finish3SearchError("finish3: node cap exceeded without a solution");
+            }
+            stop = true;
+            return true;
+        }
+        if (best !== null)
+            nodeLimit = Math.min(maxNodes, hardMaxNodes);
+        if (best !== null && (nodes > maxNodes || bound <= targetLength)) {
+            stop = true;
+            return true;
+        }
+        return false;
+    };
+    const phase2 = (cp, ep, sp, depth, togo, last) => {
+        nodes++;
+        if (nodes > nodeLimit && shouldStop())
+            return false;
+        if (togo === 0)
+            return cp === 0 && ep === 0 && sp === 0;
+        const skipRow = (last + 1) * 6;
+        const limit = togo - 1;
+        const cpRow = cp * 10;
+        const epRow = ep * 10;
+        const spRow = sp * 10;
+        for (let i = 0; i < 10; i++) {
+            if (stop)
+                return false;
+            const m = P2_TO_P1[i];
+            if (SKIP[skipRow + FACE[m]])
+                continue;
+            const nsp = spMove[spRow + i];
+            const ncp = cpMove[cpRow + i];
+            const ia = ncp * 24 + nsp;
+            if (((cpsp[ia >> 1] >> ((ia & 1) << 2)) & 0x0f) > limit)
+                continue;
+            const nep = epMove[epRow + i];
+            const ib = nep * 24 + nsp;
+            if (((epsp[ib >> 1] >> ((ib & 1) << 2)) & 0x0f) > limit)
+                continue;
+            path2[depth] = m;
+            if (phase2(ncp, nep, nsp, depth + 1, togo - 1, FACE[m]))
+                return true;
+        }
+        return false;
+    };
+    /** Runs phase 2 on a phase-1 solution of length d1; true = stop searching. */
+    const leaf = (d1) => {
+        const base = view.cubie;
+        cpScratch.set(base.cp);
+        epScratch.set(base.ep);
+        for (let k = 0; k < d1; k++) {
+            const off = path1[k];
+            for (let i = 0; i < 8; i++)
+                cpTmp[i] = cpScratch[MOVE_CP[off * 8 + i]];
+            for (let i = 0; i < 12; i++)
+                epTmp[i] = epScratch[MOVE_EP[off * 12 + i]];
+            cpScratch.set(cpTmp);
+            epScratch.set(epTmp);
+        }
+        const cp = lehmer(cpScratch, 0, 8, 0);
+        const ep = lehmer(epScratch, 0, 8, 0);
+        for (let i = 8; i < 12; i++)
+            epTmp[i] = epScratch[i] - 8;
+        const sp = lehmer(epTmp, 8, 4, 0);
+        const lb = h2(cp, ep, sp);
+        const maxD2 = Math.min(bound - 1 - d1, maxP2);
+        if (lb > maxD2)
+            return false;
+        const last = d1 > 0 ? FACE[path1[d1 - 1]] : -1;
+        for (let d2 = lb; d2 <= maxD2; d2++) {
+            if (phase2(cp, ep, sp, 0, d2, last)) {
+                const moves = [];
+                for (let k = 0; k < d1; k++)
+                    moves.push(CUBE3_MOVES[path1[k]]);
+                for (let k = 0; k < d2; k++)
+                    moves.push(CUBE3_MOVES[path2[k]]);
+                best = view.mapSolution(moves);
+                bound = d1 + d2;
+                break;
+            }
+        }
+        return shouldStop();
+    };
+    const phase1 = (co, eo, ud, depth, togo, last) => {
+        nodes++;
+        if (togo === 0) {
+            // Only phase-1 solutions ending in a quarter turn of R/L/F/B: one
+            // ending in a G1 move is a shorter phase-1 solution plus phase 2.
+            if (depth > 0 && IS_P2_MOVE[path1[depth - 1]])
+                return false;
+            return leaf(depth);
+        }
+        if ((nodes & 1023) === 0 && shouldStop())
+            return true;
+        const skipRow = (last + 1) * 6;
+        const limit = togo - 1;
+        const lastLevel = togo === 1;
+        const coRow = co * 18;
+        const eoRow = eo * 18;
+        const udRow = ud * 18;
+        for (let m = 0; m < 18; m++) {
+            if (stop)
+                return true;
+            if (SKIP[skipRow + FACE[m]])
+                continue;
+            if (lastLevel && IS_P2_MOVE[m])
+                continue;
+            const nud = udMove[udRow + m];
+            const nco = coMove[coRow + m];
+            const neo = eoMove[eoRow + m];
+            if (hasJoint) {
+                const ia = nud * 2187 + nco;
+                if (((jointUdCo[ia >> 1] >> ((ia & 1) << 2)) & 0x0f) > limit)
+                    continue;
+                const ib = nud * 2048 + neo;
+                if (((jointUdEo[ib >> 1] >> ((ib & 1) << 2)) & 0x0f) > limit)
+                    continue;
+                const ic = (nco << 11) + neo;
+                if (((coeo[ic >> 1] >> ((ic & 1) << 2)) & 0x0f) > limit)
+                    continue;
+            }
+            else if (h1(nco, neo, nud) > limit)
+                continue;
+            path1[depth] = m;
+            if (phase1(nco, neo, nud, depth + 1, togo - 1, FACE[m]))
+                return true;
+        }
+        return false;
+    };
+    const roots = views.map((v) => {
+        const s = toState(v.cubie);
+        const co = encodeCornerOrientation(s);
+        const eo = encodeEdgeOrientation(s);
+        const ud = encodeUdSlice(s);
+        return { co, eo, ud, h: h1(co, eo, ud), solvedG1: co === 0 && eo === 0 && ud === udSolved };
+    });
+    let minDepth = 99;
+    for (const r of roots)
+        if (r.h < minDepth)
+            minDepth = r.h;
+    for (let d1 = minDepth; d1 < bound && !stop; d1++) {
+        for (let v = 0; v < views.length && !stop; v++) {
+            const r = roots[v];
+            if (r.h > d1)
+                continue;
+            view = views[v];
+            if (d1 === 0) {
+                if (r.solvedG1 && leaf(0))
+                    stop = true;
+                continue;
+            }
+            if (phase1(r.co, r.eo, r.ud, 0, d1, -1))
+                stop = true;
+        }
+    }
+    if (best === null)
+        throw new Finish3SearchError("finish3: no solution found");
+    return { moves: best, nodes };
+}

package/dist/puzzles/cube4/reduction/generated/hc-manifest.json

@@ -34,5 +34,11 @@
     "file": "hc-move.bin",
     "range": 999600,
     "checksum": "6bd1d8f36b77e0863425bced1dfb69df7a13dde4fb18ceeaeba00abf14519922"
+  },
+  "c3PairDist": {
+    "file": "c3_pair_dist.bin",
+    "range": 4233600,
+    "bytes": 2116800,
+    "checksum": "2d070dcd9cfa8ede09cf0def93b3b2ba05a7e7e5acf631d6bf25a65bf0057035"
   }
 }

package/dist/puzzles/cube4/reduction/hc-pdb.d.ts

@@ -35,16 +35,18 @@ export declare function generateHcPdb(onProgress?: (done: number, total: number)
 /** Number of reachable states (BFS orbit size). Fixed by the move set. */
 export declare const HC_REACHABLE = 58800;
 export interface HcDenseTables {
-    /** Full coordinate -> dense index, -1 if unreachable. */
-    index: Int32Array;
+    /** Sorted reachable full coordinates. Used with binary search (~0.23 MB). */
+    coordinates: Uint32Array;
     /** Dense moves: reachableCount x 17, dense indices. */
     moves: Int32Array;
     /** Dense distances (unpacked, 0x0f = unknown). */
     distances: Uint8Array;
     reachableCount: number;
 }
-/** Build the dense index + unpacked distances from nibble-packed BFS output. */
+/** Build the compact coordinate list + unpacked distances from the packed PDB. */
 export declare function buildHcDense(packed: Uint8Array): HcDenseTables;
+/** Full HC coordinate -> dense index, or -1 when it is unreachable. */
+export declare function hcDenseIndex(dense: Pick<HcDenseTables, "coordinates">, coordinate: number): number;
 /** Dense transition table: for each reachable state and move, dense index (or -1). */
 export declare function generateHcDenseMoves(dense: HcDenseTables): Int32Array;
 //# sourceMappingURL=hc-pdb.d.ts.map

package/dist/puzzles/cube4/reduction/hc-pdb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hc-pdb.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/hc-pdb.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA+B,CAAC;AAE1E,4BAA4B;AAC5B,eAAO,MAAM,aAAa,UAAU,CAAC;AAmBrC,oFAAoF;AACpF,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU3C;AAED,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc7C;AAED,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAMvD;AAoBD,wBAAgB,gBAAgB,IAAI,UAAU,CAG7C;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACjD,UAAU,CA+CZ;AAED,0EAA0E;AAC1E,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,KAAK,EAAE,UAAU,CAAC;IAClB,uDAAuD;IACvD,KAAK,EAAE,UAAU,CAAC;IAClB,kDAAkD;IAClD,SAAS,EAAE,UAAU,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,CAY9D;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAiBrE"}
+{"version":3,"file":"hc-pdb.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/hc-pdb.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA+B,CAAC;AAE1E,4BAA4B;AAC5B,eAAO,MAAM,aAAa,UAAU,CAAC;AAmBrC,oFAAoF;AACpF,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU3C;AAED,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc7C;AAED,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAMvD;AAoBD,wBAAgB,gBAAgB,IAAI,UAAU,CAG7C;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACjD,UAAU,CA+CZ;AAED,0EAA0E;AAC1E,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,WAAW,EAAE,WAAW,CAAC;IACzB,uDAAuD;IACvD,KAAK,EAAE,UAAU,CAAC;IAClB,kDAAkD;IAClD,SAAS,EAAE,UAAU,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,CAgB9D;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,EACzC,UAAU,EAAE,MAAM,GACjB,MAAM,CAWR;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAgBrE"}