@cubingcenter/scrambler 0.6.3 → 0.8.0

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,149 @@ 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 };
+}
+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 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) {
+    // 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);
+    }
+    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,16 +1,44 @@
 /**
  * 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";
 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;
+    /** 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;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;;;;;;;;;;;;;;;;;;;;;;;;;;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,17 +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) {
@@ -26,33 +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] = await Promise.all([
-        loadCenter1(resolved),
-        loadCenter2(resolved),
-        loadCenter3(resolved),
-        loadEdge3(resolved)
-    ]);
-    cachedTables = { center1, center2, center3, edge3 };
-    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),
@@ -60,27 +174,48 @@ 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;
     }
-    return { ctMove, rlMove, pruning };
+    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++) {
+            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");
+    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),
@@ -88,8 +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 distances = new Uint8Array(distancesBuffer);
-    return { distances, distanceOfEdge: edge3DistanceLookup(distances) };
+    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 table = new Uint8Array(distancesBuffer);
+    return { distances: table, distanceOfEdge: edge3DistanceLookup(table) };
+}
+/**
+ * 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)}`);
+        }
+    }
+    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;
 }