@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -12,7 +12,9 @@
  *  - goal: ct == 0 and rl in the 6 reference goal patterns (even parity);
  *  - the 28-move set keeps the ct and rl position sets separate, so the move
  *    tables factor: ctmv (6,435×28) and rlmv (70×28);
- *  - the search explores the first 23 moves (face moves + Uw2/Rw/Rw2/Rw').
+ *  - the search explores the first 23 moves (face moves + Uw2/Rw/Rw2/Rw')
+ *    by default; the wide set (`CENTER2_SEARCH_MOVES_WIDE`, all 28, with
+ *    the `pruningWide` table) additionally tries Dw2/Lw/Lw2/Lw'/Bw2.
  *
  * The phase-1 → phase-2 bridge (alignment + encode) is in `reduction.ts`.
  */
@@ -21,6 +23,12 @@ import type { Cube4State, Cube4Move } from "../types.js";
 export declare const CENTER2_MOVES: readonly Cube4Move[];
 /** The search's exploration set (the first 23 of CENTER2_MOVES). */
 export declare const CENTER2_SEARCH_MOVES: readonly Cube4Move[];
+/**
+ * The wide exploration set: all 28 moves (adds Dw2/Lw/Lw2/Lw'/Bw2).
+ * Searches over this set must use the `pruningWide` table — the
+ * 23-move pruning distances are inadmissible here (they overestimate).
+ */
+export declare const CENTER2_SEARCH_MOVES_WIDE: readonly Cube4Move[];
 /** The 6 reference goal rl patterns (full 70-space values, even parity). */
 export declare const CENTER2_GOAL_RL: readonly number[];
 export declare const CENTER2_CT_STATES = 6435;
@@ -34,9 +42,12 @@ export declare function wingPermutationParity(wp: Uint8Array): 0 | 1;
 /** Encode a full 4x4 state to the (ct, rl) coordinate (0..450,449). */
 export declare function encodeCenter2(state: Cube4State): Center2Encoded;
 export declare function isCenter2Goal(ct: number, rl: number): boolean;
+export declare const ALIGNMENT_ROTATIONS: readonly (readonly string[])[];
 export interface Center2BridgeResult {
     /** Alignment moves (0-2). */
     alignment: Cube4Move[];
+    /** Alignment rotation sequence (0-1 rotations: [], ["z"], or ["y"]). */
+    rotation: string[];
     /** The aligned state (invariant). */
     state: Cube4State;
     /** The (ct, rl) coordinate of the aligned state. */
@@ -57,10 +68,39 @@ export interface Center2Tables {
     ctMove: Int32Array;
     /** 70 × 28 — rl rank (parity included) after each move. */
     rlMove: Int32Array;
-    /** 450,450 exact BFS distances from the goal. */
+    /** 450,450 exact BFS distances from the goal (23-move set). */
     pruning: Uint8Array;
+    /**
+     * 450,450 exact BFS distances from the goal (wide 28-move set).
+     * Optional in memory (older assets); required for wide searches.
+     */
+    pruningWide?: Uint8Array | undefined;
 }
 export declare function generateCenter2Tables(): Center2Tables;
+/**
+ * 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 declare const CENTER2_CHIRAL_CT_STATES = 12870;
+export declare const CENTER2_CHIRAL_STATES: number;
+export interface Center2ChiralTables {
+    /** 12,870 × 28 — chiral ct rank after each move. */
+    ctMove: Uint16Array;
+    /** 900,900 exact BFS distances to the chiral goals (23-move set). */
+    pruning: Uint8Array;
+    /** Chiral ct rank of the goal pattern (U/D positions all U/D-bound). */
+    goalCt: number;
+}
+/** Chiral ct rank of a coordinate-invariant (bridged) phase-2 state. */
+export declare function encodeCenter2ChiralCt(state: Cube4State): number;
+export declare function generateCenter2ChiralTables(rlMove: Int32Array): Center2ChiralTables;
 export interface Center2Phase2Result {
     /** Phase-2 solution moves (standard 4x4 moves). */
     moves: Cube4Move[];
@@ -77,6 +117,7 @@ export declare function solveCenter2(startCt: number, startRl: number, tables: C
  * (transversal + even wing permutation), which most states fail.
  */
 export declare function solveCenter2All(startCt: number, startRl: number, tables: Center2Tables, maxLength?: number, cap?: number): Center2Phase2Result[];
+export declare function getWingMoveMaps(): Int32Array;
 /**
  * Solve Center 2 gated for an exact target length.
  */
@@ -87,5 +128,5 @@ export declare function solveCenter2GatedLength(startCt: number, startRl: number
  * transversal (the phase-3 entry gate).
  */
 export declare function solveCenter2Gated(startCt: number, startRl: number, startWp: Uint8Array, tables: Center2Tables, isGateEligible: (wp: Uint8Array) => boolean, maxLength?: number): Center2Phase2Result | null;
-export declare function verifyCenter2(tables: Center2Tables): string[];
+export declare function verifyCenter2(tables: Center2Tables, pruning?: Uint8Array, moves?: readonly Cube4Move[]): string[];
 //# sourceMappingURL=center2.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"center2.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/center2.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"center2.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/center2.ts"],"names":[],"mappings":"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"}

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

@@ -12,7 +12,9 @@
  *  - goal: ct == 0 and rl in the 6 reference goal patterns (even parity);
  *  - the 28-move set keeps the ct and rl position sets separate, so the move
  *    tables factor: ctmv (6,435×28) and rlmv (70×28);
- *  - the search explores the first 23 moves (face moves + Uw2/Rw/Rw2/Rw').
+ *  - the search explores the first 23 moves (face moves + Uw2/Rw/Rw2/Rw')
+ *    by default; the wide set (`CENTER2_SEARCH_MOVES_WIDE`, all 28, with
+ *    the `pruningWide` table) additionally tries Dw2/Lw/Lw2/Lw'/Bw2.
  *
  * The phase-1 → phase-2 bridge (alignment + encode) is in `reduction.ts`.
  */
@@ -28,11 +30,23 @@ export const CENTER2_MOVES = [
 ];
 /** The search's exploration set (the first 23 of CENTER2_MOVES). */
 export const CENTER2_SEARCH_MOVES = CENTER2_MOVES.slice(0, 23);
+/**
+ * The wide exploration set: all 28 moves (adds Dw2/Lw/Lw2/Lw'/Bw2).
+ * Searches over this set must use the `pruningWide` table — the
+ * 23-move pruning distances are inadmissible here (they overestimate).
+ */
+export const CENTER2_SEARCH_MOVES_WIDE = CENTER2_MOVES;
 /** The 6 reference goal rl patterns (full 70-space values, even parity). */
 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];
@@ -96,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
@@ -112,6 +126,11 @@ const ALIGNMENT_CANDIDATES = [
     ["Uw", "Dw'"]
 ];
 function center2InvariantDiffs(centers) {
+    const rlAxis = centers[RL_POS[7]] % 3;
+    for (let i = 0; i < 7; i++) {
+        if (centers[RL_POS[i]] % 3 !== rlAxis)
+            return { ctDiff: -1, rlDiff: -1 };
+    }
     let ctDiff = 0;
     let rlDiff = 0;
     for (let i = 0; i < 15; i++) {
@@ -124,12 +143,18 @@ function center2InvariantDiffs(centers) {
     }
     return { ctDiff, rlDiff };
 }
+export const ALIGNMENT_ROTATIONS = [
+    [],
+    ["z"],
+    ["y"]
+];
 /**
  * Phase-1 → phase-2 bridge: apply the shortest alignment candidate that
  * makes the state coordinate-invariant, then encode.
  */
 export function center2Bridge(state) {
-    for (const alignment of ALIGNMENT_CANDIDATES) {
+    for (let idx = 0; idx < ALIGNMENT_CANDIDATES.length; idx++) {
+        const alignment = ALIGNMENT_CANDIDATES[idx];
         const aligned = alignment.length === 0
             ? state
             : applyCube4Algorithm(state, alignment);
@@ -137,6 +162,7 @@ export function center2Bridge(state) {
         if (ctDiff === 8 && rlDiff === 4) {
             return {
                 alignment: [...alignment],
+                rotation: [...ALIGNMENT_ROTATIONS[idx]],
                 state: aligned,
                 encoded: encodeCenter2(aligned)
             };
@@ -246,7 +272,123 @@ export function generateCenter2Tables() {
             }
         }
     }
-    return { ctMove, rlMove, pruning };
+    // Wide pruning BFS: same goals, all 28 moves (exact distances for the
+    // wide search; the 23-move table overestimates there).
+    const pruningWide = new Uint8Array(CENTER2_STATES).fill(0xff);
+    const wideQueue = [];
+    for (const rl of CENTER2_GOAL_RL) {
+        pruningWide[rl] = 0;
+        wideQueue.push(rl);
+    }
+    let wideHead = 0;
+    while (wideHead < wideQueue.length) {
+        const idx = wideQueue[wideHead++];
+        const ct = Math.floor(idx / CENTER2_RL_STATES);
+        const rl = idx % CENTER2_RL_STATES;
+        const d = pruningWide[idx];
+        for (let m = 0; m < CENTER2_SEARCH_MOVES_WIDE.length; m++) {
+            const nextCt = ctMove[ct * CENTER2_MOVES.length + m];
+            const nextRl = rlMove[rl * CENTER2_MOVES.length + m];
+            const next = nextCt * CENTER2_RL_STATES + nextRl;
+            if (pruningWide[next] === 0xff) {
+                pruningWide[next] = d + 1;
+                wideQueue.push(next);
+            }
+        }
+    }
+    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
@@ -320,7 +462,7 @@ export function solveCenter2All(startCt, startRl, tables, maxLength = 40, cap =
     }
 }
 let cachedWingMaps = null;
-function getWingMoveMaps() {
+export function getWingMoveMaps() {
     if (!cachedWingMaps) {
         cachedWingMaps = buildWingMoveMaps();
     }
@@ -421,24 +563,24 @@ function buildWingMoveMaps() {
 // ---------------------------------------------------------------------------
 // Verification gates
 // ---------------------------------------------------------------------------
-export function verifyCenter2(tables) {
+export function verifyCenter2(tables, pruning = tables.pruning, moves = CENTER2_SEARCH_MOVES) {
     const errors = [];
     for (const rl of CENTER2_GOAL_RL) {
-        if (tables.pruning[rl] !== 0) {
+        if (pruning[rl] !== 0) {
             errors.push(`Goal rl ${rl} must have pruning 0.`);
         }
     }
     let maxDepth = 0;
     for (let idx = 0; idx < CENTER2_STATES; idx++) {
-        const d = tables.pruning[idx];
+        const d = pruning[idx];
         if (d > maxDepth)
             maxDepth = d;
         const ct = Math.floor(idx / CENTER2_RL_STATES);
         const rl = idx % CENTER2_RL_STATES;
-        for (let m = 0; m < CENTER2_SEARCH_MOVES.length; m++) {
+        for (let m = 0; m < moves.length; m++) {
             const nc = tables.ctMove[ct * CENTER2_MOVES.length + m];
             const nr = tables.rlMove[rl * CENTER2_MOVES.length + m];
-            const nd = tables.pruning[nc * CENTER2_RL_STATES + nr];
+            const nd = pruning[nc * CENTER2_RL_STATES + nr];
             if (nd < d - 1 || nd > d + 1) {
                 errors.push(`Pruning inconsistency at ${idx} move ${CENTER2_MOVES[m]}: ${d} -> ${nd}.`);
                 break;

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

@@ -80,6 +80,10 @@ export interface Edge3Tables {
  * `maxDepthCap` stops the BFS early (validation only).
  */
 export declare function generateEdge3Tables(maxDepthCap?: number): Edge3Tables;
+/**
+ * Unpack 4-bit nibble-packed distances into a byte-expanded Uint8Array (1 byte per state).
+ */
+export declare function unpackEdge3Distances(packed: Uint8Array): Uint8Array;
 /**
  * The distance lookup over a loaded distances buffer: builds the sym
  * machinery once (cached) and returns a closure from the std-form edge

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

@@ -1 +1 @@
-{"version":3,"file":"edge3.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/edge3.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAWH,mEAAmE;AACnE,eAAO,MAAM,WAAW,WAAa,CAAC;AACtC,eAAO,MAAM,aAAa,OAAO,CAAC;AAClC,eAAO,MAAM,WAAW,QAAS,CAAC;AAGlC,qEAAqE;AACrE,eAAO,MAAM,eAAe,KAAK,CAAC;AAUlC,+EAA+E;AAC/E,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAEtC,CAAC;AAaF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAkCD;;;;;GAKG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CA2G3E;AAkCD,iFAAiF;AACjF,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAO3E;AAMD;;;;GAIG;AACH,iBAAS,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,MAAM,CAS3E;AAED;;;GAGG;AACH,iBAAS,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAmBhD;AAOD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,oEAAoE;IACpE,QAAQ,EAAE,WAAW,CAAC;IACtB,gDAAgD;IAChD,OAAO,EAAE,WAAW,CAAC;IACrB,iFAAiF;IACjF,QAAQ,EAAE,WAAW,CAAC;IACtB,qFAAqF;IACrF,OAAO,EAAE,WAAW,CAAC;CACtB;AAID,wBAAgB,YAAY,IAAI,SAAS,CAKxC;AAED,wBAAgB,cAAc,IAAI,SAAS,CAoE1C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA6BR;AAMD,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,SAAS,EAAE,UAAU,CAAC;IACtB,0DAA0D;IAC1D,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,SAAK,GAAG,WAAW,CAkEjE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,UAAU,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CASvF;AAMD,uBAAuB;AACvB,wBAAgB,gBAAgB;;;;;;;EAE/B;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,CAgBzD"}
+{"version":3,"file":"edge3.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/edge3.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAWH,mEAAmE;AACnE,eAAO,MAAM,WAAW,WAAa,CAAC;AACtC,eAAO,MAAM,aAAa,OAAO,CAAC;AAClC,eAAO,MAAM,WAAW,QAAS,CAAC;AAGlC,qEAAqE;AACrE,eAAO,MAAM,eAAe,KAAK,CAAC;AAUlC,+EAA+E;AAC/E,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAEtC,CAAC;AAaF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAkCD;;;;;GAKG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CA2G3E;AAkCD,iFAAiF;AACjF,iBAAS,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAO3E;AAMD;;;;GAIG;AACH,iBAAS,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,MAAM,CAS3E;AAED;;;GAGG;AACH,iBAAS,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAmBhD;AAOD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,oEAAoE;IACpE,QAAQ,EAAE,WAAW,CAAC;IACtB,gDAAgD;IAChD,OAAO,EAAE,WAAW,CAAC;IACrB,iFAAiF;IACjF,QAAQ,EAAE,WAAW,CAAC;IACtB,qFAAqF;IACrF,OAAO,EAAE,WAAW,CAAC;CACtB;AAID,wBAAgB,YAAY,IAAI,SAAS,CAKxC;AAED,wBAAgB,cAAc,IAAI,SAAS,CAoE1C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA6BR;AAMD,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,SAAS,EAAE,UAAU,CAAC;IACtB,0DAA0D;IAC1D,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,SAAK,GAAG,WAAW,CAmEjE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CASnE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,UAAU,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAWvF;AAMD,uBAAuB;AACvB,wBAAgB,gBAAgB;;;;;;;EAE/B;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,CAkBzD"}

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

@@ -468,8 +468,23 @@ export function generateEdge3Tables(maxDepthCap = -1) {
         frontier = next;
         depth++;
     }
-    const distanceOfEdge = edge3DistanceLookup(distances);
-    return { distances, distanceOfEdge };
+    const unpacked = unpackEdge3Distances(distances);
+    const distanceOfEdge = edge3DistanceLookup(unpacked);
+    return { distances: unpacked, distanceOfEdge };
+}
+/**
+ * Unpack 4-bit nibble-packed distances into a byte-expanded Uint8Array (1 byte per state).
+ */
+export function unpackEdge3Distances(packed) {
+    if (packed.length >= EDGE3_TOTAL)
+        return packed;
+    const unpacked = new Uint8Array(EDGE3_TOTAL);
+    for (let i = 0; i < packed.length; i++) {
+        const b = packed[i];
+        unpacked[i << 1] = b & 0x0f;
+        unpacked[(i << 1) | 1] = b >> 4;
+    }
+    return unpacked;
 }
 /**
  * The distance lookup over a loaded distances buffer: builds the sym
@@ -480,9 +495,12 @@ export function edge3DistanceLookup(distances) {
     const t = symTables ?? buildSymTables();
     const { sym2Raw, sym2Mask, raw2Sym, mvrot, mvroto } = t;
     const identity = Uint8Array.from({ length: 12 }, (_, i) => i);
+    const isUnpacked = distances.length >= EDGE3_TOTAL;
     return (e) => {
         const std = normalizePairingState(e, identity).edge;
         const idx = getMvSymFrom(std, identity, 20, sym2Raw, sym2Mask, raw2Sym, mvrot, mvroto) >> 3;
+        if (isUnpacked)
+            return distances[idx];
         return (distances[idx >> 1] >> ((idx & 1) * 4)) & 0x0f;
     };
 }
@@ -500,8 +518,10 @@ export function verifyEdge3(tables) {
         errors.push("Solved state must have distance 0.");
     }
     let seen = 0;
+    const isUnpacked = tables.distances.length >= EDGE3_TOTAL;
     for (let i = 0; i < EDGE3_TOTAL; i++) {
-        if (((tables.distances[i >> 1] >> ((i & 1) * 4)) & 0x0f) !== 0x0f)
+        const d = isUnpacked ? tables.distances[i] : ((tables.distances[i >> 1] >> ((i & 1) * 4)) & 0x0f);
+        if (d !== 0x0f)
             seen++;
     }
     if (seen !== EDGE3_TOTAL) {

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"}