@cubingcenter/scrambler 0.7.0 → 0.8.0

package/dist/puzzles/cube4/moves.js

@@ -306,45 +306,137 @@ function parse4Move(m) {
         (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);
+const AXIS_FACES = [
+    ["U", "D"],
+    ["R", "L"],
+    ["F", "B"]
+];
+const AXIS_TURN_OPTIONS = [
+    ["2", 2],
+    ["", 1],
+    ["'", 3]
+];
+function axisVectorKey(vector) {
+    return vector[0] | (vector[1] << 2) | (vector[2] << 4) | (vector[3] << 6);
 }
-function movesCommute4(a, b) {
-    return a.axis === b.axis && a.base !== b.base;
+function applyMoveToAxisVector(vector, base, turns, out) {
+    out[0] = vector[0];
+    out[1] = vector[1];
+    out[2] = vector[2];
+    out[3] = vector[3];
+    const axis = base[0];
+    const [positive, negative] = AXIS_FACES.find(([p, n]) => p === axis || n === axis);
+    const isPositive = axis === positive;
+    const signedTurns = isPositive ? turns : 4 - turns;
+    const wide = base.endsWith("w");
+    if (wide) {
+        const firstLayer = isPositive ? 0 : 2;
+        out[firstLayer] = (out[firstLayer] + signedTurns) & 3;
+        out[firstLayer + 1] = (out[firstLayer + 1] + signedTurns) & 3;
+    }
+    else {
+        const layer = isPositive ? 0 : 3;
+        out[layer] = (out[layer] + signedTurns) & 3;
+    }
+}
+function buildAxisReductionTable(positiveFace, negativeFace) {
+    const bases = [positiveFace, negativeFace, `${positiveFace}w`, `${negativeFace}w`];
+    const paths = new Array(256);
+    const queue = new Uint8Array(256);
+    let head = 0;
+    let tail = 0;
+    paths[0] = [];
+    queue[tail++] = 0;
+    while (head < tail) {
+        const key = queue[head++];
+        const vector = [key & 3, (key >> 2) & 3, (key >> 4) & 3, (key >> 6) & 3];
+        const prefix = paths[key];
+        for (const base of bases) {
+            for (const [suffix, turns] of AXIS_TURN_OPTIONS) {
+                const nextVector = [0, 0, 0, 0];
+                applyMoveToAxisVector(vector, base, turns, nextVector);
+                const nextKey = axisVectorKey(nextVector);
+                if (paths[nextKey] !== undefined)
+                    continue;
+                paths[nextKey] = [...prefix, `${base}${suffix}`];
+                queue[tail++] = nextKey;
+            }
+        }
+    }
+    if (tail !== 256 || paths.some((path) => path === undefined)) {
+        throw new Error(`4x4 move simplifier: incomplete axis table for ${positiveFace}/${negativeFace}.`);
+    }
+    return paths;
+}
+const AXIS_REDUCTIONS = AXIS_FACES.map(([positive, negative]) => buildAxisReductionTable(positive, negative));
+function encodeAxisRun(moves, axis) {
+    const vector = [0, 0, 0, 0];
+    const next = [0, 0, 0, 0];
+    for (const move of moves) {
+        if (move.axis === axis) {
+            applyMoveToAxisVector(vector, move.base, move.amount, next);
+            vector[0] = next[0];
+            vector[1] = next[1];
+            vector[2] = next[2];
+            vector[3] = next[3];
+        }
+    }
+    return axisVectorKey(vector);
+}
+function addAxisKeys(a, b) {
+    let result = 0;
+    for (let layer = 0; layer < 4; layer++) {
+        const shift = layer * 2;
+        const amount = (((a >> shift) & 3) + ((b >> shift) & 3)) & 3;
+        result |= amount << shift;
+    }
+    return result;
 }
 /**
  * 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);
+    // Moves on parallel layers commute, and each maximal same-axis run is a
+    // four-coordinate vector of quarter turns (one coordinate per layer).
+    // A small exact shortest-path table maps that vector back to the fewest
+    // legal face/wide moves, including mixed identities such as Rw R' = the
+    // corresponding inner-slice turn. Different axes are never reordered.
+    const segments = [];
+    let run = [];
+    let runAxis = -1;
+    const flushRun = () => {
+        if (run.length === 0)
+            return;
+        const key = encodeAxisRun(run, runAxis);
+        if (key !== 0) {
+            const previous = segments[segments.length - 1];
+            if (previous?.axis === runAxis) {
+                const mergedKey = addAxisKeys(previous.key, key);
+                if (mergedKey === 0)
+                    segments.pop();
+                else {
+                    previous.key = mergedKey;
+                    previous.moves = AXIS_REDUCTIONS[runAxis][mergedKey];
+                }
+            }
+            else {
+                segments.push({ axis: runAxis, key, moves: AXIS_REDUCTIONS[runAxis][key] });
+            }
         }
+        run = [];
+        runAxis = -1;
+    };
+    for (const move of moves) {
+        const parsed = parse4Move(move);
+        if (runAxis !== -1 && parsed.axis !== runAxis)
+            flushRun();
+        if (runAxis === -1)
+            runAxis = parsed.axis;
+        run.push(parsed);
     }
-    return out
-        .map((p) => format4Move(p.base, p.amount))
-        .filter((m) => m !== null);
+    flushRun();
+    return segments.flatMap((segment) => segment.moves);
 }
 // ---------------------------------------------------------------------------
 // Export the raw effects for use by the reduction solver

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

@@ -1,6 +1,29 @@
 /**
  * Browser loader for the cube4 reduction tables (the committed .bin files).
- * The manifests are per-phase (`center1-manifest.json`, ...).
+ * The manifests are per-phase (`center1-manifest.json`, ...) plus the shared
+ * `hc-manifest.json`, which also seals the optional `c3_pair_dist.bin`.
+ *
+ * Integrity — identical to node-loader.ts: every downloaded .bin is verified
+ * against the manifest sha256 + expected byte length (on the DECOMPRESSED
+ * payload, so .br/.gz variants and the raw file are checked the same way).
+ *
+ * Optional tables (`hc` + `c3PairDist`), NEVER silent:
+ *  - `hc-manifest.json` present → its entries must download and verify, else
+ *    the whole load REJECTS (node throws too). There is no silent degradation
+ *    to an unpruned search: it would change the scramble produced for the
+ *    same seed, breaking node/browser determinism.
+ *  - `hc-manifest.json` absent (404) → the optional tables were not deployed;
+ *    `c3_pair_dist.bin` is then probed to tell "not deployed" (both absent →
+ *    skip, like node) apart from "stale/half-deployed assets" (bin present,
+ *    manifest missing → REJECT with an actionable message — node refuses the
+ *    same asset set).
+ * There is deliberately no "degraded" flag: the only valid outcomes are
+ * "fully loaded tables" or "loud failure", so both platforms always compute
+ * the same scrambles.
+ *
+ * Caching: concurrent loads share ONE in-flight promise (one fetch pass per
+ * table). The promise is kept after success; when it rejects it is purged so
+ * the next call can retry instead of being stuck on a poisoned cache.
  */
 import type { Center1Tables } from "./center1.js";
 import type { Center2Tables } from "./center2.js";
@@ -14,6 +37,8 @@ export interface Cube4ReductionTables {
     edge3: Edge3Tables;
     /** Half-class exact PDB distances (optional; absent = bound disabled). */
     hc?: HcDenseTables;
+    /** Joint Center3 x Single Pair PDB distances (optional; node parity). */
+    c3PairDist?: Uint8Array;
 }
 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;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"}
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/browser-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;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;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAqDD,wBAAgB,oBAAoB,IAAI,oBAAoB,GAAG,SAAS,CAEvE;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C;AAgBD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAiC/F"}

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

@@ -1,18 +1,69 @@
 /**
  * Browser loader for the cube4 reduction tables (the committed .bin files).
- * The manifests are per-phase (`center1-manifest.json`, ...).
+ * The manifests are per-phase (`center1-manifest.json`, ...) plus the shared
+ * `hc-manifest.json`, which also seals the optional `c3_pair_dist.bin`.
+ *
+ * Integrity — identical to node-loader.ts: every downloaded .bin is verified
+ * against the manifest sha256 + expected byte length (on the DECOMPRESSED
+ * payload, so .br/.gz variants and the raw file are checked the same way).
+ *
+ * Optional tables (`hc` + `c3PairDist`), NEVER silent:
+ *  - `hc-manifest.json` present → its entries must download and verify, else
+ *    the whole load REJECTS (node throws too). There is no silent degradation
+ *    to an unpruned search: it would change the scramble produced for the
+ *    same seed, breaking node/browser determinism.
+ *  - `hc-manifest.json` absent (404) → the optional tables were not deployed;
+ *    `c3_pair_dist.bin` is then probed to tell "not deployed" (both absent →
+ *    skip, like node) apart from "stale/half-deployed assets" (bin present,
+ *    manifest missing → REJECT with an actionable message — node refuses the
+ *    same asset set).
+ * There is deliberately no "degraded" flag: the only valid outcomes are
+ * "fully loaded tables" or "loud failure", so both platforms always compute
+ * the same scrambles.
+ *
+ * Caching: concurrent loads share ONE in-flight promise (one fetch pass per
+ * table). The promise is kept after success; when it rejects it is purged so
+ * the next call can retry instead of being stuck on a poisoned cache.
  */
+import { CENTER3_STATES } from "./center3.js";
 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";
+const TABLE_MEMORY_BUDGET_BYTES = 150 * 1024 * 1024;
+/**
+ * Byte length of `c3_pair_dist.bin`: CENTER3_STATES x 144 nibble entries
+ * (index = ct3 * 144 + f * 12 + h, see phase3-search.ts), nibble-packed.
+ * Kept in sync with node-loader.ts.
+ */
+const C3_PAIR_DIST_BYTES = (CENTER3_STATES * 144) / 2;
 let cachedTables;
+let cachedTablesPromise;
+function assertCube4ReductionTableBudget(tables) {
+    const bytes = tables.center1.distance.byteLength +
+        tables.center1.moveMaps.byteLength +
+        tables.center2.ctMove.byteLength +
+        tables.center2.rlMove.byteLength +
+        tables.center2.pruning.byteLength +
+        (tables.center2.pruningWide?.byteLength ?? 0) +
+        tables.center3.moveTable.byteLength +
+        tables.center3.pruning.byteLength +
+        tables.edge3.distances.byteLength +
+        (tables.hc?.moves.byteLength ?? 0) +
+        (tables.hc?.distances.byteLength ?? 0) +
+        (tables.hc?.coordinates.byteLength ?? 0) +
+        (tables.c3PairDist?.byteLength ?? 0);
+    if (bytes > TABLE_MEMORY_BUDGET_BYTES) {
+        throw new Error(`Cube4 reduction tables use ${(bytes / (1024 * 1024)).toFixed(1)} MiB, above the 150 MiB table budget.`);
+    }
+}
 export function getCachedCube4Tables() {
     return cachedTables;
 }
 export function clearCachedCube4Tables() {
     cachedTables = undefined;
+    cachedTablesPromise = undefined;
 }
 function resolveBaseUrl(provided) {
     if (provided) {
@@ -27,36 +78,95 @@ function resolveBaseUrl(provided) {
     }
     return ".";
 }
-export async function loadCube4ReductionTablesBrowser(baseUrl) {
-    if (cachedTables) {
-        return cachedTables;
+export function loadCube4ReductionTablesBrowser(baseUrl) {
+    if (cachedTablesPromise) {
+        // One shared in-flight promise: concurrent calls trigger exactly one
+        // fetch pass (dedup), and the resolved value stays cached afterwards.
+        return cachedTablesPromise;
     }
     const resolved = resolveBaseUrl(baseUrl);
-    const [center1, center2, center3, edge3, hc] = await Promise.all([
-        loadCenter1(resolved),
-        loadCenter2(resolved),
-        loadCenter3(resolved),
-        loadEdge3(resolved),
-        loadHc(resolved)
-    ]);
-    cachedTables = { center1, center2, center3, edge3 };
-    if (hc)
-        cachedTables.hc = hc;
-    return cachedTables;
+    const promise = (async () => {
+        const [center1, center2, center3, edge3, optional] = await Promise.all([
+            loadCenter1(resolved),
+            loadCenter2(resolved),
+            loadCenter3(resolved),
+            loadEdge3(resolved),
+            loadOptionalTables(resolved)
+        ]);
+        const tables = { center1, center2, center3, edge3 };
+        if (optional.hc)
+            tables.hc = optional.hc;
+        if (optional.c3PairDist)
+            tables.c3PairDist = optional.c3PairDist;
+        assertCube4ReductionTableBudget(tables);
+        return tables;
+    })();
+    cachedTablesPromise = promise;
+    promise.then((value) => {
+        cachedTables = value;
+    }, () => {
+        // A failed load must not poison the cache: purge the rejected promise
+        // so a later call retries from scratch.
+        if (cachedTablesPromise === promise)
+            cachedTablesPromise = undefined;
+    });
+    return promise;
+}
+function requireEntry(entry, manifestUrl, label) {
+    if (!entry || typeof entry.file !== "string" || typeof entry.checksum !== "string") {
+        throw new Error(`Invalid table manifest ${manifestUrl}: entry "${label}" must declare { file, checksum } — ` +
+            "the deployed assets are stale; sync them with pnpm tables:web:sync.");
+    }
+    return entry;
 }
-async function fetchJson(baseUrl, file) {
+/**
+ * Expected byte length of a table file from its manifest entry.
+ * `packing` matches how each table is serialized — keep in sync with
+ * node-loader.ts.
+ */
+function expectedBytes(entry, packing) {
+    if (typeof entry.bytes === "number")
+        return entry.bytes;
+    if (typeof entry.range !== "number")
+        return undefined;
+    if (packing === "byte")
+        return entry.range;
+    if (packing === "nibble")
+        return Math.ceil(entry.range / 2);
+    return entry.range * 4;
+}
+async function fetchVerified(baseUrl, entry, packing, expectedLength) {
+    const length = expectedLength ?? expectedBytes(entry, packing);
+    return fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, entry.file, {
+        cacheName: CACHE_NAME,
+        compressed: entry.compressed !== false,
+        expectedSha256: entry.checksum,
+        ...(length !== undefined ? { expectedBytes: length } : {})
+    });
+}
+async function fetchManifest(baseUrl, file) {
     const url = `${baseUrl}/${GENERATED_DIRECTORY}/${file}`;
     const response = await fetch(url);
     if (!response.ok) {
-        throw new Error(`Failed to load ${file}: ${response.status} ${response.statusText}`);
+        throw new Error(`Failed to load table manifest ${url}: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        // Always name the URL: a bare JSON.parse error is unactionable.
+        throw new Error(`Invalid table manifest JSON: ${url}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return response.json();
 }
 async function loadCenter1(baseUrl) {
-    const manifest = await fetchJson(baseUrl, "center1-manifest.json");
+    const manifestUrl = `${baseUrl}/${GENERATED_DIRECTORY}/center1-manifest.json`;
+    const manifest = await fetchManifest(baseUrl, "center1-manifest.json");
+    const distanceTable = requireEntry(manifest.distanceTable, manifestUrl, "distanceTable");
+    const moveMaps = requireEntry(manifest.moveMaps, manifestUrl, "moveMaps");
     const [distanceBuffer, moveMapsBuffer] = await Promise.all([
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.distanceTable.file, { cacheName: CACHE_NAME, compressed: manifest.distanceTable.compressed !== false }),
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.moveMaps.file, { cacheName: CACHE_NAME, compressed: manifest.moveMaps.compressed !== false })
+        fetchVerified(baseUrl, distanceTable, "nibble"),
+        fetchVerified(baseUrl, moveMaps, "int32")
     ]);
     return {
         distance: new Uint8Array(distanceBuffer),
@@ -64,23 +174,30 @@ async function loadCenter1(baseUrl) {
     };
 }
 async function loadCenter2(baseUrl) {
-    const manifest = await fetchJson(baseUrl, "center2-manifest.json");
+    const manifestUrl = `${baseUrl}/${GENERATED_DIRECTORY}/center2-manifest.json`;
+    const manifest = await fetchManifest(baseUrl, "center2-manifest.json");
+    const ctMove = requireEntry(manifest.ctMove, manifestUrl, "ctMove");
+    const rlMove = requireEntry(manifest.rlMove, manifestUrl, "rlMove");
+    const pruningTable = requireEntry(manifest.pruningTable, manifestUrl, "pruningTable");
+    const pruningWideEntry = manifest.pruningWideTable
+        ? requireEntry(manifest.pruningWideTable, manifestUrl, "pruningWideTable")
+        : undefined;
     const [ctMoveBuffer, rlMoveBuffer, pruningBuffer] = await Promise.all([
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.ctMove.file, { cacheName: CACHE_NAME, compressed: manifest.ctMove.compressed !== false }),
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.rlMove.file, { cacheName: CACHE_NAME, compressed: manifest.rlMove.compressed !== false }),
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.pruningTable.file, { cacheName: CACHE_NAME, compressed: manifest.pruningTable.compressed !== false })
+        fetchVerified(baseUrl, ctMove, "int32"),
+        fetchVerified(baseUrl, rlMove, "int32"),
+        fetchVerified(baseUrl, pruningTable, "nibble")
     ]);
-    const ctMove = new Int32Array(ctMoveBuffer);
-    const rlMove = new Int32Array(rlMoveBuffer);
+    const ctMoveValues = new Int32Array(ctMoveBuffer);
+    const rlMoveValues = new Int32Array(rlMoveBuffer);
     const pruningPacked = new Uint8Array(pruningBuffer);
     const pruning = new Uint8Array(450450);
     for (let i = 0; i < 450450; i++) {
         const byte = pruningPacked[i >> 1];
         pruning[i] = (i & 1) === 0 ? byte & 0x0f : byte >> 4;
     }
-    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 tables = { ctMove: ctMoveValues, rlMove: rlMoveValues, pruning };
+    if (pruningWideEntry) {
+        const wideBuffer = await fetchVerified(baseUrl, pruningWideEntry, "nibble");
         const widePacked = new Uint8Array(wideBuffer);
         const pruningWide = new Uint8Array(450450);
         for (let i = 0; i < 450450; i++) {
@@ -92,10 +209,13 @@ async function loadCenter2(baseUrl) {
     return tables;
 }
 async function loadCenter3(baseUrl) {
-    const manifest = await fetchJson(baseUrl, "center3-manifest.json");
+    const manifestUrl = `${baseUrl}/${GENERATED_DIRECTORY}/center3-manifest.json`;
+    const manifest = await fetchManifest(baseUrl, "center3-manifest.json");
+    const moveTable = requireEntry(manifest.moveTable, manifestUrl, "moveTable");
+    const pruningTable = requireEntry(manifest.pruningTable, manifestUrl, "pruningTable");
     const [moveTableBuffer, pruningBuffer] = await Promise.all([
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.moveTable.file, { cacheName: CACHE_NAME, compressed: manifest.moveTable.compressed !== false }),
-        fetchTableBuffer(baseUrl, GENERATED_DIRECTORY, manifest.pruningTable.file, { cacheName: CACHE_NAME, compressed: manifest.pruningTable.compressed !== false })
+        fetchVerified(baseUrl, moveTable, "int32"),
+        fetchVerified(baseUrl, pruningTable, "byte")
     ]);
     return {
         moveTable: new Int32Array(moveTableBuffer),
@@ -103,24 +223,68 @@ 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 });
+    const manifestUrl = `${baseUrl}/${GENERATED_DIRECTORY}/edge3-manifest.json`;
+    const manifest = await fetchManifest(baseUrl, "edge3-manifest.json");
+    const distances = requireEntry(manifest.distances, manifestUrl, "distances");
+    // `range` here already counts packed nibble BYTES (classCount / 2), unlike
+    // the other manifests — derive the length from classCount instead.
+    const length = typeof manifest.classCount === "number" ? Math.ceil(manifest.classCount / 2) : expectedBytes(distances, "byte");
+    const distancesBuffer = await fetchVerified(baseUrl, distances, "nibble", length);
     // Keep nibble-packed (see node-loader.ts): all readers handle both formats.
-    const distances = new Uint8Array(distancesBuffer);
-    return { distances, distanceOfEdge: edge3DistanceLookup(distances) };
+    const table = new Uint8Array(distancesBuffer);
+    return { distances: table, distanceOfEdge: edge3DistanceLookup(table) };
 }
-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);
+/**
+ * The two optional PDB tables sealed in `hc-manifest.json`. Semantics mirror
+ * node-loader.ts exactly (see the header comment): present → verified or
+ * reject; absent → probe the c3 bin so stale deployments fail loudly.
+ */
+async function loadOptionalTables(baseUrl) {
+    const manifestUrl = `${baseUrl}/${GENERATED_DIRECTORY}/hc-manifest.json`;
+    const response = await fetch(manifestUrl);
+    let manifest;
+    if (response.ok) {
+        const text = await response.text();
+        try {
+            manifest = JSON.parse(text);
+        }
+        catch (error) {
+            throw new Error(`Invalid table manifest JSON: ${manifestUrl}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return dense;
     }
-    catch {
-        return undefined;
+    else if (response.status !== 404) {
+        throw new Error(`Failed to load table manifest ${manifestUrl}: ${response.status} ${response.statusText}`);
+    }
+    const result = {};
+    if (manifest?.c3PairDist !== undefined) {
+        const entry = requireEntry(manifest.c3PairDist, manifestUrl, "c3PairDist");
+        if (typeof entry.bytes === "number" && entry.bytes !== C3_PAIR_DIST_BYTES) {
+            throw new Error(`Invalid table manifest ${manifestUrl}: c3PairDist.bytes is ${entry.bytes}, expected ` +
+                `${C3_PAIR_DIST_BYTES} — sync the assets with pnpm tables:web:sync.`);
+        }
+        const buffer = await fetchVerified(baseUrl, entry, "nibble", C3_PAIR_DIST_BYTES);
+        result.c3PairDist = new Uint8Array(buffer);
+    }
+    else {
+        // Mirror node's fs check: bin present but unsealed = broken deployment.
+        const probeUrl = `${baseUrl}/${GENERATED_DIRECTORY}/c3_pair_dist.bin`;
+        const probe = await fetch(probeUrl);
+        if (probe.ok) {
+            throw new Error(`c3_pair_dist.bin is deployed (${probeUrl}) but hc-manifest.json has no "c3PairDist" checksum ` +
+                `entry (${manifestUrl}) — refusing to load tables without integrity checks (node fails on the ` +
+                "same assets). Sync the assets: pnpm tables:web:sync.");
+        }
+    }
+    if (manifest) {
+        const distances = requireEntry(manifest.distances, manifestUrl, "distances");
+        const packed = new Uint8Array(await fetchVerified(baseUrl, distances, "nibble"));
+        const dense = buildHcDense(packed);
+        if (manifest.moveTable !== undefined) {
+            const moveTable = requireEntry(manifest.moveTable, manifestUrl, "moveTable");
+            const moveBuffer = await fetchVerified(baseUrl, moveTable, "int32");
+            dense.moves = new Int32Array(moveBuffer);
+        }
+        result.hc = dense;
     }
+    return result;
 }

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

@@ -77,6 +77,30 @@ export interface Center2Tables {
     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[];

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