@cubingcenter/scrambler 0.6.3 → 0.7.0

package/dist/puzzles/cube4/index.d.ts

@@ -1,8 +1,9 @@
 export { CORNER_COUNT, WING_COUNT, CENTER_COUNT, FACE_COUNT, CENTERS_PER_FACE, U, R, F, D, L, B, CUBE4_FACE_MOVES, CUBE4_ALL_MOVES, CUBE4_OUTER_MOVES } from "./types.js";
 export type { Cube4Face, Cube4FaceMove, Cube4Move, Cube4MoveSuffix, Cube4State, Cube4Sticker, Cube4Facelets, Cube4ValidationResult, Cube4RandomStateOptions } from "./types.js";
 export { createSolvedCube4State, cloneCube4State, cube4StatesEqual, isSolvedCube4State, areCentersReduced, areWingsPaired } from "./state.js";
-export { cube4ScrambleGenerator, generateCube4Scramble } from "./scrambler.js";
-export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
+export { cube4ScrambleGenerator, generateCube4Scramble, generateCube4Attempt } from "./scrambler.js";
+export type { Cube4ScrambleOptions } from "./scrambler.js";
+export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, simplifyCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
 export { generateRandomCube4State } from "./random-state.js";
 export { validateCube4State, isOneMoveFromSolvedCube4State, isTrivialCube4State, isAllowedRandomCube4State } from "./validation.js";
 export { toCube4Facelets, formatCube4Facelets, getCube4FaceOrder } from "./facelets.js";

package/dist/puzzles/cube4/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC"}

package/dist/puzzles/cube4/index.js

@@ -6,8 +6,8 @@ import { cube4ScrambleGenerator } from "./scrambler.js";
 registerScrambleGenerator(cube4ScrambleGenerator);
 export { CORNER_COUNT, WING_COUNT, CENTER_COUNT, FACE_COUNT, CENTERS_PER_FACE, U, R, F, D, L, B, CUBE4_FACE_MOVES, CUBE4_ALL_MOVES, CUBE4_OUTER_MOVES } from "./types.js";
 export { createSolvedCube4State, cloneCube4State, cube4StatesEqual, isSolvedCube4State, areCentersReduced, areWingsPaired } from "./state.js";
-export { cube4ScrambleGenerator, generateCube4Scramble } from "./scrambler.js";
-export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
+export { cube4ScrambleGenerator, generateCube4Scramble, generateCube4Attempt } from "./scrambler.js";
+export { applyCube4Move, applyCube4Algorithm, invertCube4Move, invertCube4Algorithm, simplifyCube4Algorithm, formatCube4Algorithm, parseCube4Algorithm, parseCube4Move, parseMove, FACE_MOVE_EFFECTS } from "./moves.js";
 export { generateRandomCube4State } from "./random-state.js";
 export { validateCube4State, isOneMoveFromSolvedCube4State, isTrivialCube4State, isAllowedRandomCube4State } from "./validation.js";
 export { toCube4Facelets, formatCube4Facelets, getCube4FaceOrder } from "./facelets.js";

package/dist/puzzles/cube4/moves.d.ts

@@ -33,5 +33,10 @@ export declare function invertCube4Algorithm(moves: readonly Cube4Move[]): Cube4
 export declare function formatCube4Algorithm(moves: readonly Cube4Move[]): string;
 export declare function parseCube4Algorithm(algorithm: string): Cube4Move[];
 export declare function parseCube4Move(value: string): Cube4Move;
+/**
+ * Simplifies a 4x4 algorithm by canceling inverse moves and merging redundant
+ * turns on the same face or across commuting parallel faces.
+ */
+export declare function simplifyCube4Algorithm(moves: readonly Cube4Move[]): Cube4Move[];
 export { FACE_MOVE_EFFECTS };
 //# sourceMappingURL=moves.d.ts.map

package/dist/puzzles/cube4/moves.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/moves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAQxF,UAAU,UAAU;IAClB,+DAA+D;IAC/D,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,yDAAyD;IACzD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,kFAAkF;IAClF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oDAAoD;IACpD,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA0KD,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,aAAa,EAAE,UAAU,CAGxD,CAAC;AA0BF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAc1G;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAS7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CAM9F;AAMD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAI1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAIlE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAMD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"moves.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube4/moves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAOxF,UAAU,UAAU;IAClB,+DAA+D;IAC/D,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,yDAAyD;IACzD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,kFAAkF;IAClF,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oDAAoD;IACpD,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA0KD,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,aAAa,EAAE,UAAU,CAGxD,CAAC;AAuDF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAc1G;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAK7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CA4C9F;AAKD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAI1D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAE7E;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAExE;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,CAIlE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAMvD;AAkCD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EAAE,CAsB/E;AAMD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/puzzles/cube4/moves.js

@@ -158,6 +158,32 @@ const FACE_MOVE_EFFECTS = {
     Uw: WIDE_Uw, Dw: WIDE_Dw, Rw: WIDE_Rw, Lw: WIDE_Lw, Fw: WIDE_Fw, Bw: WIDE_Bw
 };
 // ---------------------------------------------------------------------------
+// Precomposed total effect per move string ("R'" = R x3, "U2" = U x2),
+// built once at module load. applyCube4Algorithm then costs one lookup +
+// one pass per move: no per-move string parsing, no repeated
+// quarter-turn passes (average ~2 passes collapse into exactly 1).
+// ---------------------------------------------------------------------------
+function composePower(face, turns) {
+    const quarter = FACE_MOVE_EFFECTS[face];
+    if (turns === 2)
+        return composeEffects(quarter, quarter);
+    if (turns === 3)
+        return composeEffects(composeEffects(quarter, quarter), quarter);
+    return quarter;
+}
+const COMPOSED_EFFECTS = Object.fromEntries(CUBE4_ALL_MOVES.map((move) => {
+    const { face, turns } = parseMove(move);
+    return [move, composePower(face, turns)];
+}));
+/** Total effect for one move string (precomposed fast path + parse fallback). */
+function effectForMove(move) {
+    const hit = COMPOSED_EFFECTS[move];
+    if (hit !== undefined)
+        return hit;
+    const { face, turns } = parseMove(move);
+    return composePower(face, turns);
+}
+// ---------------------------------------------------------------------------
 // Apply a single move to a state
 // ---------------------------------------------------------------------------
 function applyEffect(state, effect) {
@@ -192,20 +218,52 @@ export function parseMove(move) {
     return { face: face, suffix, turns };
 }
 export function applyCube4Move(state, move) {
-    const { face, turns } = parseMove(move);
-    const effect = FACE_MOVE_EFFECTS[face];
-    let current = state;
-    for (let i = 0; i < turns; i++) {
-        current = applyEffect(current, effect);
-    }
-    return current;
+    // Single-pass fast path through the precomposed total effect: one lookup
+    // + one pass, no string re-parsing, no repeated quarter-turn passes, no
+    // intermediate states.
+    return applyEffect(state, effectForMove(move));
 }
 export function applyCube4Algorithm(state, moves) {
-    let current = state;
-    for (const move of moves) {
-        current = applyCube4Move(current, move);
+    if (moves.length === 0)
+        return state;
+    const bufA = {
+        cp: new Uint8Array(state.cp),
+        co: new Uint8Array(state.co),
+        wp: new Uint8Array(state.wp),
+        centers: new Uint8Array(state.centers)
+    };
+    const bufB = {
+        cp: new Uint8Array(8),
+        co: new Uint8Array(8),
+        wp: new Uint8Array(24),
+        centers: new Uint8Array(24)
+    };
+    let cur = bufA;
+    let nxt = bufB;
+    for (let mIdx = 0; mIdx < moves.length; mIdx++) {
+        const move = moves[mIdx];
+        const eff = effectForMove(move);
+        for (let i = 0; i < 8; i++) {
+            const from = eff.cperm[i];
+            nxt.cp[i] = cur.cp[from];
+            nxt.co[i] = (cur.co[from] + eff.corient[i]) % 3;
+        }
+        for (let i = 0; i < 24; i++) {
+            nxt.wp[i] = cur.wp[eff.wperm[i]];
+        }
+        for (let i = 0; i < 24; i++) {
+            nxt.centers[i] = cur.centers[eff.ctperm[i]];
+        }
+        const tmp = cur;
+        cur = nxt;
+        nxt = tmp;
     }
-    return current;
+    return {
+        cp: cur.cp,
+        co: cur.co,
+        wp: cur.wp,
+        centers: cur.centers
+    };
 }
 // ---------------------------------------------------------------------------
 // Move inversion
@@ -237,6 +295,57 @@ export function parseCube4Move(value) {
     }
     throw new Error(`Invalid 4x4 move: ${value}`);
 }
+function parse4Move(m) {
+    const match = m.match(/^([UDFBLR]w?)(2|')?$/);
+    if (!match)
+        throw new Error(`Invalid move format: ${m}`);
+    const base = match[1];
+    const suffix = match[2] ?? "";
+    const amount = suffix === "2" ? 2 : suffix === "'" ? 3 : 1;
+    const axis = (base[0] === "U" || base[0] === "D") ? 0 :
+        (base[0] === "R" || base[0] === "L") ? 1 : 2;
+    return { base, axis, amount };
+}
+function format4Move(base, amount) {
+    const amt = ((amount % 4) + 4) % 4;
+    if (amt === 0)
+        return null;
+    const suffix = amt === 1 ? "" : amt === 2 ? "2" : "'";
+    return (base + suffix);
+}
+function movesCommute4(a, b) {
+    return a.axis === b.axis && a.base !== b.base;
+}
+/**
+ * Simplifies a 4x4 algorithm by canceling inverse moves and merging redundant
+ * turns on the same face or across commuting parallel faces.
+ */
+export function simplifyCube4Algorithm(moves) {
+    // Single left-to-right pass with an output stack: each move merges with
+    // the nearest same-base entry across trailing commuting parallel-face
+    // moves (verified equivalent to the old restart-from-zero loop on 20000
+    // random algorithms). O(n·window) instead of O(n²) restarts with splices.
+    const out = [];
+    for (const move of moves) {
+        const current = parse4Move(move);
+        let index = out.length - 1;
+        while (index >= 0 && movesCommute4(out[index], current))
+            index--;
+        if (index >= 0 && out[index].base === current.base) {
+            const merged = (out[index].amount + current.amount) % 4;
+            if (merged === 0)
+                out.splice(index, 1);
+            else
+                out[index].amount = merged;
+        }
+        else {
+            out.push(current);
+        }
+    }
+    return out
+        .map((p) => format4Move(p.base, p.amount))
+        .filter((m) => m !== null);
+}
 // ---------------------------------------------------------------------------
 // Export the raw effects for use by the reduction solver
 // ---------------------------------------------------------------------------

package/dist/puzzles/cube4/reduction/browser-loader.d.ts

@@ -6,11 +6,14 @@ import type { Center1Tables } from "./center1.js";
 import type { Center2Tables } from "./center2.js";
 import type { Center3Tables } from "./center3.js";
 import type { Edge3Tables } from "./edge3.js";
+import { type HcDenseTables } from "./hc-pdb.js";
 export interface Cube4ReductionTables {
     center1: Center1Tables;
     center2: Center2Tables;
     center3: Center3Tables;
     edge3: Edge3Tables;
+    /** Half-class exact PDB distances (optional; absent = bound disabled). */
+    hc?: HcDenseTables;
 }
 export declare function getCachedCube4Tables(): Cube4ReductionTables | undefined;
 export declare function clearCachedCube4Tables(): void;

package/dist/puzzles/cube4/reduction/browser-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/browser-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;CACpB;AAOD,wBAAgB,oBAAoB,IAAI,oBAAoB,GAAG,SAAS,CAEvE;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAgBD,wBAAsB,+BAA+B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAarG"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/browser-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,0EAA0E;IAC1E,EAAE,CAAC,EAAE,aAAa,CAAC;CACpB;AAOD,wBAAgB,oBAAoB,IAAI,oBAAoB,GAAG,SAAS,CAEvE;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAgBD,wBAAsB,+BAA+B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAerG"}

package/dist/puzzles/cube4/reduction/browser-loader.js

@@ -4,6 +4,7 @@
  */
 import { edge3DistanceLookup } from "./edge3.js";
 import { fetchTableBuffer } from "../../shared/compressed-fetch.js";
+import { buildHcDense } from "./hc-pdb.js";
 const GENERATED_DIRECTORY = "puzzles/cube4/reduction/generated";
 const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
 let cachedTables;
@@ -31,13 +32,16 @@ export async function loadCube4ReductionTablesBrowser(baseUrl) {
         return cachedTables;
     }
     const resolved = resolveBaseUrl(baseUrl);
-    const [center1, center2, center3, edge3] = await Promise.all([
+    const [center1, center2, center3, edge3, hc] = await Promise.all([
         loadCenter1(resolved),
         loadCenter2(resolved),
         loadCenter3(resolved),
-        loadEdge3(resolved)
+        loadEdge3(resolved),
+        loadHc(resolved)
     ]);
     cachedTables = { center1, center2, center3, edge3 };
+    if (hc)
+        cachedTables.hc = hc;
     return cachedTables;
 }
 async function fetchJson(baseUrl, file) {
@@ -74,7 +78,18 @@ async function loadCenter2(baseUrl) {
         const byte = pruningPacked[i >> 1];
         pruning[i] = (i & 1) === 0 ? byte & 0x0f : byte >> 4;
     }
-    return { ctMove, rlMove, pruning };
+    const tables = { ctMove, rlMove, pruning };
+    if (manifest.pruningWideTable) {
+        const wideBuffer = await fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.pruningWideTable.file, { cacheName: CACHE_NAME, compressed: manifest.pruningWideTable.compressed !== false });
+        const widePacked = new Uint8Array(wideBuffer);
+        const pruningWide = new Uint8Array(450450);
+        for (let i = 0; i < 450450; i++) {
+            const byte = widePacked[i >> 1];
+            pruningWide[i] = (i & 1) === 0 ? byte & 0x0f : byte >> 4;
+        }
+        tables.pruningWide = pruningWide;
+    }
+    return tables;
 }
 async function loadCenter3(baseUrl) {
     const manifest = await fetchJson(baseUrl, "center3-manifest.json");
@@ -90,6 +105,22 @@ async function loadCenter3(baseUrl) {
 async function loadEdge3(baseUrl) {
     const manifest = await fetchJson(baseUrl, "edge3-manifest.json");
     const distancesBuffer = await fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.distances.file, { cacheName: CACHE_NAME, compressed: manifest.distances.compressed !== false });
+    // Keep nibble-packed (see node-loader.ts): all readers handle both formats.
     const distances = new Uint8Array(distancesBuffer);
     return { distances, distanceOfEdge: edge3DistanceLookup(distances) };
 }
+async function loadHc(baseUrl) {
+    try {
+        const manifest = await fetchJson(baseUrl, "hc-manifest.json");
+        const distancesBuffer = await fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.distances.file, { cacheName: CACHE_NAME, compressed: manifest.distances.compressed !== false });
+        const dense = buildHcDense(new Uint8Array(distancesBuffer));
+        if (manifest.moveTable) {
+            const moveBuffer = await fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.moveTable.file, { cacheName: CACHE_NAME, compressed: manifest.moveTable.compressed !== false });
+            dense.moves = new Int32Array(moveBuffer);
+        }
+        return dense;
+    }
+    catch {
+        return undefined;
+    }
+}

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,8 +68,13 @@ 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;
 export interface Center2Phase2Result {
@@ -77,6 +93,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 +104,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":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAOzD,6EAA6E;AAC7E,eAAO,MAAM,aAAa,EAAE,SAAS,SAAS,EAIpC,CAAC;AAEX,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,EAAE,SAAS,SAAS,EAA+B,CAAC;AAErF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,SAAS,EAAkB,CAAC;AAE7E,4EAA4E;AAC5E,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAA4B,CAAC;AAE1E,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,cAAc,QAAwC,CAAC;AA6BpE,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAYD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAe3D;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,cAAc,CAQ/D;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7D;AAgCD,eAAO,MAAM,mBAAmB,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAI7D,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,6BAA6B;IAC7B,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,qCAAqC;IACrC,KAAK,EAAE,UAAU,CAAC;IAClB,oDAAoD;IACpD,OAAO,EAAE,cAAc,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,mBAAmB,GAAG,IAAI,CAiB3E;AAsBD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,MAAM,EAAE,UAAU,CAAC;IACnB,2DAA2D;IAC3D,MAAM,EAAE,UAAU,CAAC;IACnB,+DAA+D;IAC/D,OAAO,EAAE,UAAU,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACtC;AAeD,wBAAgB,qBAAqB,IAAI,aAAa,CA6FrD;AAMD,MAAM,WAAW,mBAAmB;IAClC,mDAAmD;IACnD,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,EAAE,CAAC,EAAE,UAAU,CAAC;CACjB;AA+BD,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,EACrB,SAAS,SAAK,GACb,mBAAmB,GAAG,IAAI,CAG5B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,EACrB,SAAS,SAAK,EACd,GAAG,SAAM,GACR,mBAAmB,EAAE,CAkCvB;AAID,wBAAgB,eAAe,IAAI,UAAU,CAK5C;AAgBD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,EAC3C,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,MAAM,EAAoC,GAClD,mBAAmB,GAAG,IAAI,CA2C5B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,EAC3C,SAAS,SAAK,GACb,mBAAmB,GAAG,IAAI,CAgB5B;AAsBD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,UAA2B,EACpC,KAAK,GAAE,SAAS,SAAS,EAAyB,GACjD,MAAM,EAAE,CA2BV"}

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,6 +30,12 @@ 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;
@@ -112,6 +120,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 +137,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 +156,7 @@ export function center2Bridge(state) {
         if (ctDiff === 8 && rlDiff === 4) {
             return {
                 alignment: [...alignment],
+                rotation: [...ALIGNMENT_ROTATIONS[idx]],
                 state: aligned,
                 encoded: encodeCenter2(aligned)
             };
@@ -246,7 +266,31 @@ 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 };
 }
 // 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 +364,7 @@ export function solveCenter2All(startCt, startRl, tables, maxLength = 40, cap =
     }
 }
 let cachedWingMaps = null;
-function getWingMoveMaps() {
+export function getWingMoveMaps() {
     if (!cachedWingMaps) {
         cachedWingMaps = buildWingMoveMaps();
     }
@@ -421,24 +465,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) {