@cubingcenter/scrambler 0.6.3 → 0.7.0

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

@@ -9,6 +9,7 @@ exports.clearCachedCube4Tables = clearCachedCube4Tables;
 exports.loadCube4ReductionTablesBrowser = loadCube4ReductionTablesBrowser;
 const edge3_js_1 = require("./edge3.js");
 const compressed_fetch_js_1 = require("../../shared/compressed-fetch.js");
+const hc_pdb_js_1 = require("./hc-pdb.js");
 const GENERATED_DIRECTORY = "puzzles/cube4/reduction/generated";
 const CACHE_NAME = "cubingcenter-scrambler-tables-v1";
 let cachedTables;
@@ -36,13 +37,16 @@ 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) {
@@ -79,7 +83,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 (0, compressed_fetch_js_1.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");
@@ -95,6 +110,22 @@ async function loadCenter3(baseUrl) {
 async function loadEdge3(baseUrl) {
     const manifest = await fetchJson(baseUrl, "edge3-manifest.json");
     const distancesBuffer = await (0, compressed_fetch_js_1.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: (0, edge3_js_1.edge3DistanceLookup)(distances) };
 }
+async function loadHc(baseUrl) {
+    try {
+        const manifest = await fetchJson(baseUrl, "hc-manifest.json");
+        const distancesBuffer = await (0, compressed_fetch_js_1.fetchTableBuffer)(baseUrl, GENERATED_DIRECTORY, manifest.distances.file, { cacheName: CACHE_NAME, compressed: manifest.distances.compressed !== false });
+        const dense = (0, hc_pdb_js_1.buildHcDense)(new Uint8Array(distancesBuffer));
+        if (manifest.moveTable) {
+            const moveBuffer = await (0, compressed_fetch_js_1.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-cjs/puzzles/cube4/reduction/center2.js

@@ -13,12 +13,14 @@
  *  - 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`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CENTER2_STATES = exports.CENTER2_RL_STATES = exports.CENTER2_CT_STATES = exports.CENTER2_GOAL_RL = exports.CENTER2_SEARCH_MOVES = exports.CENTER2_MOVES = void 0;
+exports.ALIGNMENT_ROTATIONS = exports.CENTER2_STATES = exports.CENTER2_RL_STATES = exports.CENTER2_CT_STATES = exports.CENTER2_GOAL_RL = exports.CENTER2_SEARCH_MOVES_WIDE = exports.CENTER2_SEARCH_MOVES = exports.CENTER2_MOVES = void 0;
 exports.wingPermutationParity = wingPermutationParity;
 exports.encodeCenter2 = encodeCenter2;
 exports.isCenter2Goal = isCenter2Goal;
@@ -26,6 +28,7 @@ exports.center2Bridge = center2Bridge;
 exports.generateCenter2Tables = generateCenter2Tables;
 exports.solveCenter2 = solveCenter2;
 exports.solveCenter2All = solveCenter2All;
+exports.getWingMoveMaps = getWingMoveMaps;
 exports.solveCenter2GatedLength = solveCenter2GatedLength;
 exports.solveCenter2Gated = solveCenter2Gated;
 exports.verifyCenter2 = verifyCenter2;
@@ -41,6 +44,12 @@ exports.CENTER2_MOVES = [
 ];
 /** The search's exploration set (the first 23 of CENTER2_MOVES). */
 exports.CENTER2_SEARCH_MOVES = exports.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).
+ */
+exports.CENTER2_SEARCH_MOVES_WIDE = exports.CENTER2_MOVES;
 /** The 6 reference goal rl patterns (full 70-space values, even parity). */
 exports.CENTER2_GOAL_RL = [0, 18, 28, 46, 54, 56];
 exports.CENTER2_CT_STATES = 6435;
@@ -125,6 +134,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++) {
@@ -137,12 +151,18 @@ function center2InvariantDiffs(centers) {
     }
     return { ctDiff, rlDiff };
 }
+exports.ALIGNMENT_ROTATIONS = [
+    [],
+    ["z"],
+    ["y"]
+];
 /**
  * Phase-1 → phase-2 bridge: apply the shortest alignment candidate that
  * makes the state coordinate-invariant, then encode.
  */
 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
             : (0, moves_js_1.applyCube4Algorithm)(state, alignment);
@@ -150,6 +170,7 @@ function center2Bridge(state) {
         if (ctDiff === 8 && rlDiff === 4) {
             return {
                 alignment: [...alignment],
+                rotation: [...exports.ALIGNMENT_ROTATIONS[idx]],
                 state: aligned,
                 encoded: encodeCenter2(aligned)
             };
@@ -259,7 +280,31 @@ 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(exports.CENTER2_STATES).fill(0xff);
+    const wideQueue = [];
+    for (const rl of exports.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 / exports.CENTER2_RL_STATES);
+        const rl = idx % exports.CENTER2_RL_STATES;
+        const d = pruningWide[idx];
+        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES_WIDE.length; m++) {
+            const nextCt = ctMove[ct * exports.CENTER2_MOVES.length + m];
+            const nextRl = rlMove[rl * exports.CENTER2_MOVES.length + m];
+            const next = nextCt * exports.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
@@ -434,24 +479,24 @@ function buildWingMoveMaps() {
 // ---------------------------------------------------------------------------
 // Verification gates
 // ---------------------------------------------------------------------------
-function verifyCenter2(tables) {
+function verifyCenter2(tables, pruning = tables.pruning, moves = exports.CENTER2_SEARCH_MOVES) {
     const errors = [];
     for (const rl of exports.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 < exports.CENTER2_STATES; idx++) {
-        const d = tables.pruning[idx];
+        const d = pruning[idx];
         if (d > maxDepth)
             maxDepth = d;
         const ct = Math.floor(idx / exports.CENTER2_RL_STATES);
         const rl = idx % exports.CENTER2_RL_STATES;
-        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES.length; m++) {
+        for (let m = 0; m < moves.length; m++) {
             const nc = tables.ctMove[ct * exports.CENTER2_MOVES.length + m];
             const nr = tables.rlMove[rl * exports.CENTER2_MOVES.length + m];
-            const nd = tables.pruning[nc * exports.CENTER2_RL_STATES + nr];
+            const nd = pruning[nc * exports.CENTER2_RL_STATES + nr];
             if (nd < d - 1 || nd > d + 1) {
                 errors.push(`Pruning inconsistency at ${idx} move ${exports.CENTER2_MOVES[m]}: ${d} -> ${nd}.`);
                 break;

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

@@ -28,6 +28,7 @@ exports.getSymTables = getSymTables;
 exports.buildSymTables = buildSymTables;
 exports.getMvSymFrom = getMvSymFrom;
 exports.generateEdge3Tables = generateEdge3Tables;
+exports.unpackEdge3Distances = unpackEdge3Distances;
 exports.edge3DistanceLookup = edge3DistanceLookup;
 exports.__edge3TestHooks = __edge3TestHooks;
 exports.verifyEdge3 = verifyEdge3;
@@ -479,8 +480,23 @@ 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).
+ */
+function unpackEdge3Distances(packed) {
+    if (packed.length >= exports.EDGE3_TOTAL)
+        return packed;
+    const unpacked = new Uint8Array(exports.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
@@ -491,9 +507,12 @@ 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 >= exports.EDGE3_TOTAL;
     return (e) => {
         const std = (0, pairing_coordinate_js_1.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;
     };
 }
@@ -511,8 +530,10 @@ function verifyEdge3(tables) {
         errors.push("Solved state must have distance 0.");
     }
     let seen = 0;
+    const isUnpacked = tables.distances.length >= exports.EDGE3_TOTAL;
     for (let i = 0; i < exports.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 !== exports.EDGE3_TOTAL) {