@holoscript/core 8.0.14 → 8.0.15

package/dist/{dist-GRMOP2UL.cjs → dist-YGATNURH.cjs}

@@ -3,12 +3,352 @@
 var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 
 // ../snn-webgpu/dist/index.js
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require2 = /* @__PURE__ */ ((x) => typeof chunkZHPMP447_cjs.__require !== "undefined" ? chunkZHPMP447_cjs.__require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof chunkZHPMP447_cjs.__require !== "undefined" ? chunkZHPMP447_cjs.__require : a)[b]
 }) : x)(function(x) {
   if (typeof chunkZHPMP447_cjs.__require !== "undefined") return chunkZHPMP447_cjs.__require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var qec_codes_exports = {};
+__export(qec_codes_exports, {
+  DEFAULT_PRIOR: () => DEFAULT_PRIOR,
+  HX: () => HX,
+  HZ: () => HZ,
+  LOOKUP_X: () => LOOKUP_X,
+  LOOKUP_Z: () => LOOKUP_Z,
+  N: () => N,
+  XL: () => XL,
+  XSTAB: () => XSTAB,
+  ZL: () => ZL,
+  ZSTAB: () => ZSTAB,
+  bpMinSum: () => bpMinSum,
+  bpOsdDecode: () => bpOsdDecode,
+  codeDistance: () => codeDistance,
+  decodeReceipt: () => decodeReceipt,
+  decodeShot: () => decodeShot,
+  decodeX: () => decodeX,
+  decodeXBP: () => decodeXBP,
+  decodeZ: () => decodeZ,
+  decodeZBP: () => decodeZBP,
+  isLogicalX: () => isLogicalX,
+  isLogicalZ: () => isLogicalZ,
+  osd0: () => osd0,
+  overlapParity: () => overlapParity,
+  priorLLR: () => priorLLR,
+  stabsToMatrix: () => stabsToMatrix,
+  syndromeCosetAudit: () => syndromeCosetAudit,
+  syndromeX: () => syndromeX,
+  syndromeZ: () => syndromeZ,
+  tannerGraph: () => tannerGraph,
+  weight: () => weight,
+  xorVec: () => xorVec
+});
+function syndromeX(eX) {
+  return ZSTAB.map((s) => overlapParity(eX, s));
+}
+function syndromeZ(eZ) {
+  return XSTAB.map((s) => overlapParity(eZ, s));
+}
+function buildLookup(stabs) {
+  const table = /* @__PURE__ */ new Map();
+  for (let m = 0; m < 1 << N; m++) {
+    const err = vec();
+    for (let q = 0; q < N; q++) err[q] = m >> q & 1;
+    const s = stabs.map((st) => overlapParity(err, st)).join("");
+    const w = weight(err);
+    const prev = table.get(s);
+    if (!prev || w < prev.w) table.set(s, { correction: err.slice(), w });
+  }
+  return table;
+}
+function decodeX(eX) {
+  return LOOKUP_X.get(syndromeX(eX).join("")).correction;
+}
+function decodeZ(eZ) {
+  return LOOKUP_Z.get(syndromeZ(eZ).join("")).correction;
+}
+function isLogicalX(residualX) {
+  return (overlapParity(residualX, ZL) & 1) === 1;
+}
+function isLogicalZ(residualZ) {
+  return (overlapParity(residualZ, XL) & 1) === 1;
+}
+function decodeShot(eX, eZ) {
+  const resX = xorVec(eX, decodeX(eX));
+  const resZ = xorVec(eZ, decodeZ(eZ));
+  return isLogicalX(resX) || isLogicalZ(resZ);
+}
+function codeDistance() {
+  let d = Infinity;
+  for (let m = 1; m < 1 << N; m++) {
+    const e = vec();
+    for (let q = 0; q < N; q++) e[q] = m >> q & 1;
+    if (syndromeX(e).every((b) => b === 0) && isLogicalX(e)) d = Math.min(d, weight(e));
+    if (syndromeZ(e).every((b) => b === 0) && isLogicalZ(e)) d = Math.min(d, weight(e));
+  }
+  return d;
+}
+function stabsToMatrix(stabs, n = N) {
+  return stabs.map((s) => {
+    const row = new Array(n).fill(0);
+    for (const q of s) row[q] = 1;
+    return row;
+  });
+}
+function priorLLR(p) {
+  const pf = Math.min(Math.max(2 * p / 3, 1e-9), 0.5 - 1e-9);
+  return Math.log((1 - pf) / pf);
+}
+function bpMinSum(H, s, lambda, { maxIter = 30, alpha = 0.8125, gamma = 0.2 } = {}) {
+  const m = H.length;
+  const n = H[0].length;
+  const checkVars = H.map((row) => row.map((h, i) => h ? i : -1).filter((i) => i >= 0));
+  const varChecks = Array.from(
+    { length: n },
+    (_, i) => H.map((row, a) => row[i] ? a : -1).filter((a) => a >= 0)
+  );
+  const v2c = Array.from({ length: n }, () => ({}));
+  const c2v = Array.from({ length: m }, () => ({}));
+  for (let i = 0; i < n; i++) for (const a of varChecks[i]) v2c[i][a] = lambda;
+  const e = new Array(n).fill(0);
+  const posterior = new Array(n).fill(lambda);
+  let converged = false;
+  let iters = 0;
+  for (let it = 1; it <= maxIter; it++) {
+    iters = it;
+    for (let a = 0; a < m; a++) {
+      const vars = checkVars[a];
+      for (const i of vars) {
+        let signProd = 1;
+        let minMag = Infinity;
+        for (const j of vars) {
+          if (j === i) continue;
+          const msg = v2c[j][a];
+          signProd *= msg < 0 ? -1 : 1;
+          minMag = Math.min(minMag, Math.abs(msg));
+        }
+        if (!isFinite(minMag)) minMag = 0;
+        c2v[a][i] = alpha * (s[a] ? -1 : 1) * signProd * minMag;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      let total = lambda;
+      for (const a of varChecks[i]) total += c2v[a][i];
+      posterior[i] = total;
+      for (const a of varChecks[i]) {
+        const newMsg = total - c2v[a][i];
+        v2c[i][a] = (1 - gamma) * newMsg + gamma * v2c[i][a];
+      }
+      e[i] = total < 0 ? 1 : 0;
+    }
+    let ok = true;
+    for (let a = 0; a < m; a++) {
+      let par = 0;
+      for (const i of checkVars[a]) par ^= e[i];
+      if (par !== s[a]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) {
+      converged = true;
+      break;
+    }
+  }
+  return { e, converged, iters, posterior };
+}
+function osd0(H, s, reliability, hard) {
+  const m = H.length;
+  const n = H[0].length;
+  const asc = [...Array(n).keys()].sort((x2, y) => reliability[x2] - reliability[y]);
+  const reduced = [];
+  const parity = [];
+  for (const c of asc) {
+    let vv = H.map((row) => row[c]);
+    for (const b of reduced) if (vv[b.pivot]) vv = vv.map((x2, k) => x2 ^ b.vec[k]);
+    const piv = vv.findIndex((x2) => x2 === 1);
+    if (piv !== -1) {
+      reduced.push({ vec: vv, pivot: piv });
+      parity.push(c);
+      if (parity.length === m) break;
+    }
+  }
+  const paritySet = new Set(parity);
+  const e = new Array(n).fill(0);
+  for (let c = 0; c < n; c++) if (!paritySet.has(c)) e[c] = hard[c];
+  const sPrime = H.map((row, a) => {
+    let par = s[a];
+    for (let c = 0; c < n; c++) if (!paritySet.has(c)) par ^= row[c] & e[c];
+    return par;
+  });
+  const A = H.map((row, a) => parity.map((c) => row[c]).concat([sPrime[a]]));
+  let rp = 0;
+  for (let col = 0; col < m && rp < m; col++) {
+    let piv = -1;
+    for (let r = rp; r < m; r++)
+      if (A[r][col]) {
+        piv = r;
+        break;
+      }
+    if (piv === -1) continue;
+    [A[rp], A[piv]] = [A[piv], A[rp]];
+    for (let r = 0; r < m; r++)
+      if (r !== rp && A[r][col]) for (let k = col; k <= m; k++) A[r][k] ^= A[rp][k];
+    rp++;
+  }
+  const x = new Array(m).fill(0);
+  for (let r = 0; r < m; r++) {
+    let pc = -1;
+    for (let c = 0; c < m; c++)
+      if (A[r][c]) {
+        pc = c;
+        break;
+      }
+    if (pc !== -1) x[pc] = A[r][m];
+  }
+  for (let k = 0; k < m; k++) e[parity[k]] = x[k];
+  return e;
+}
+function bpOsdDecode(H, s, p, opts = {}) {
+  const lambda = priorLLR(p);
+  const { e, converged, iters, posterior } = bpMinSum(H, s, lambda, opts);
+  if (converged) return { correction: e, method: "bp", iters };
+  const reliability = posterior.map(Math.abs);
+  const hard = posterior.map((v) => v < 0 ? 1 : 0);
+  return { correction: osd0(H, s, reliability, hard), method: "osd0", iters };
+}
+function decodeXBP(eX, p = DEFAULT_PRIOR, opts) {
+  return bpOsdDecode(HX, syndromeX(eX), p, opts).correction;
+}
+function decodeZBP(eZ, p = DEFAULT_PRIOR, opts) {
+  return bpOsdDecode(HZ, syndromeZ(eZ), p, opts).correction;
+}
+function syndromeCosetAudit() {
+  const audit = (H, LOOKUP, isLogical, syndromeFn) => {
+    let exact = 0;
+    let cosetEq = 0;
+    let invalid = 0;
+    for (let m = 0; m < 16; m++) {
+      const s = [m >> 3 & 1, m >> 2 & 1, m >> 1 & 1, m & 1];
+      const cBp = bpOsdDecode(H, s, DEFAULT_PRIOR).correction;
+      const cOpt = LOOKUP.get(s.join("")).correction;
+      const valid = syndromeFn(cBp).every((b, i) => b === s[i]);
+      if (!valid) {
+        invalid++;
+        continue;
+      }
+      const diff = xorVec(cBp, cOpt);
+      const trivialSynd = syndromeFn(diff).every((b) => b === 0);
+      const notLogical = !isLogical(diff);
+      if (trivialSynd && notLogical) {
+        cosetEq++;
+        if (cBp.join("") === cOpt.join("")) exact++;
+      }
+    }
+    return { exact_match: exact, coset_equivalent: cosetEq, syndrome_invalid: invalid, total: 16 };
+  };
+  return {
+    x_errors: audit(HX, LOOKUP_X, isLogicalX, syndromeX),
+    z_errors: audit(HZ, LOOKUP_Z, isLogicalZ, syndromeZ)
+  };
+}
+function tannerGraph() {
+  const checks = [];
+  const edges = [];
+  ZSTAB.forEach((s, i) => {
+    checks.push({ id: `Z${i}`, type: "Z", detects: "X", support: s });
+    s.forEach((q) => edges.push([`Z${i}`, `q${q}`]));
+  });
+  XSTAB.forEach((s, i) => {
+    checks.push({ id: `X${i}`, type: "X", detects: "Z", support: s });
+    s.forEach((q) => edges.push([`X${i}`, `q${q}`]));
+  });
+  return {
+    data_qubits: Array.from({ length: N }, (_, q) => `q${q}`),
+    checks,
+    edges
+  };
+}
+function decodeReceipt(eX, eZ) {
+  const sX = syndromeX(eX);
+  const sZ = syndromeZ(eZ);
+  const cX = decodeX(eX);
+  const cZ = decodeZ(eZ);
+  return {
+    schema: "qec-decode-receipt/v0",
+    code: "[[9,1,3]] rotated surface",
+    layout: { z_stabilizers: ZSTAB, x_stabilizers: XSTAB, logical_x: XL, logical_z: ZL },
+    x_syndrome: sX.join(""),
+    z_syndrome: sZ.join(""),
+    x_correction: cX.join(""),
+    z_correction: cZ.join(""),
+    logical_error: isLogicalX(xorVec(eX, cX)) || isLogicalZ(xorVec(eZ, cZ))
+  };
+}
+var N;
+var ZSTAB;
+var XSTAB;
+var ZL;
+var XL;
+var vec;
+var weight;
+var xorVec;
+var overlapParity;
+var LOOKUP_X;
+var LOOKUP_Z;
+var HX;
+var HZ;
+var DEFAULT_PRIOR;
+var init_qec_codes = __esm({
+  "src/qec/qec-codes.ts"() {
+    N = 9;
+    ZSTAB = [
+      [0, 1, 3, 4],
+      // top-left plaquette
+      [4, 5, 7, 8],
+      // bottom-right plaquette
+      [1, 2],
+      // top boundary
+      [6, 7]
+      // bottom boundary
+    ];
+    XSTAB = [
+      [0, 3],
+      // left boundary
+      [1, 2, 4, 5],
+      // upper-right plaquette
+      [3, 4, 6, 7],
+      // lower-left plaquette
+      [5, 8]
+      // right boundary
+    ];
+    ZL = [0, 3, 6];
+    XL = [0, 1, 2];
+    vec = () => new Array(N).fill(0);
+    weight = (v) => v.reduce((a, b) => a + b, 0);
+    xorVec = (a, b) => a.map((x, i) => x ^ b[i]);
+    overlapParity = (v, support) => support.reduce((acc, q) => acc ^ v[q], 0);
+    LOOKUP_X = buildLookup(ZSTAB);
+    LOOKUP_Z = buildLookup(XSTAB);
+    HX = stabsToMatrix(ZSTAB);
+    HZ = stabsToMatrix(XSTAB);
+    DEFAULT_PRIOR = 0.05;
+  }
+});
 var _bootstrapAttempted = false;
 var _bootstrapResult = false;
 function ensureNodeWebGpuSync() {
@@ -1075,10 +1415,10 @@ function collectRegionPixels(fixtures, region) {
   for (const fixture of fixtures) {
     for (const sample of fixture.regions) {
       if (sample.region !== region) continue;
-      const weight = Math.max(1, Math.round(sample.weight ?? 1));
+      const weight2 = Math.max(1, Math.round(sample.weight ?? 1));
       for (const color of sample.pixels) {
         const parsed = parseColor(color);
-        for (let i = 0; i < weight; i += 1) pixels.push(parsed);
+        for (let i = 0; i < weight2; i += 1) pixels.push(parsed);
       }
     }
   }
@@ -2028,10 +2368,10 @@ function denseToCSR(adjacency, n) {
     rowPtr[row] = colIdx.length;
     for (let col = 0; col < n; col++) {
       if (row === col) continue;
-      const weight = adjacency[row * n + col];
-      if (Number.isFinite(weight) && weight < TROPICAL_INF) {
+      const weight2 = adjacency[row * n + col];
+      if (Number.isFinite(weight2) && weight2 < TROPICAL_INF) {
         colIdx.push(col);
-        values.push(weight);
+        values.push(weight2);
       }
     }
   }
@@ -2060,12 +2400,12 @@ function fromEdges(nodeCount, edges) {
     }
   }
   const grouped = /* @__PURE__ */ new Map();
-  for (const [key, weight] of minWeightByEdge) {
+  for (const [key, weight2] of minWeightByEdge) {
     const [fromRaw, toRaw] = key.split(":");
     const from = Number(fromRaw);
     const to = Number(toRaw);
     if (!grouped.has(from)) grouped.set(from, []);
-    grouped.get(from).push({ to, weight });
+    grouped.get(from).push({ to, weight: weight2 });
   }
   const rowPtr = new Uint32Array(nodeCount + 1);
   const colIdx = [];
@@ -3342,6 +3682,357 @@ function completenessStatus2(count, total) {
   }
   return count === total ? "complete" : "partial";
 }
+var qec_exports = {};
+__export(qec_exports, {
+  CONVERGED_BIT: () => CONVERGED_BIT,
+  DEFAULT_PRIOR: () => DEFAULT_PRIOR,
+  E_CHECK: () => E_CHECK,
+  E_VAR: () => E_VAR,
+  HX: () => HX,
+  HZ: () => HZ,
+  LOOKUP_X: () => LOOKUP_X,
+  LOOKUP_Z: () => LOOKUP_Z,
+  N: () => N,
+  NCHECK: () => NCHECK,
+  NVAR: () => NVAR,
+  QECDecoder: () => QECDecoder,
+  QEC_BP_WGSL: () => QEC_BP_WGSL,
+  XL: () => XL,
+  XSTAB: () => XSTAB,
+  ZL: () => ZL,
+  ZSTAB: () => ZSTAB,
+  bpMinSum: () => bpMinSum,
+  bpOsdDecode: () => bpOsdDecode,
+  codeDistance: () => codeDistance,
+  decodeReceipt: () => decodeReceipt,
+  decodeShot: () => decodeShot,
+  decodeX: () => decodeX,
+  decodeXBP: () => decodeXBP,
+  decodeZ: () => decodeZ,
+  decodeZBP: () => decodeZBP,
+  isLogicalX: () => isLogicalX,
+  isLogicalZ: () => isLogicalZ,
+  osd0: () => osd0,
+  overlapParity: () => overlapParity,
+  packSyndrome: () => packSyndrome,
+  priorLLR: () => priorLLR,
+  stabsToMatrix: () => stabsToMatrix,
+  syndromeCosetAudit: () => syndromeCosetAudit,
+  syndromeX: () => syndromeX,
+  syndromeZ: () => syndromeZ,
+  tannerEdgesMatchZstab: () => tannerEdgesMatchZstab,
+  tannerGraph: () => tannerGraph,
+  unpackCorrection: () => unpackCorrection,
+  weight: () => weight,
+  xorVec: () => xorVec
+});
+init_qec_codes();
+init_qec_codes();
+var NVAR = 9;
+var NCHECK = 4;
+var CONVERGED_BIT = 31;
+var E_CHECK = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3];
+var E_VAR = [0, 1, 3, 4, 4, 5, 7, 8, 1, 2, 6, 7];
+function tannerEdgesMatchZstab() {
+  const rebuilt = Array.from({ length: NCHECK }, () => []);
+  for (let e = 0; e < E_CHECK.length; e++) rebuilt[E_CHECK[e]].push(E_VAR[e]);
+  const norm = (rows) => JSON.stringify(rows.map((r) => [...r].sort((a, b) => a - b)));
+  return norm(rebuilt) === norm(ZSTAB);
+}
+var QEC_BP_WGSL = (
+  /* wgsl */
+  `
+struct Params { lambda: f32, count: u32, pad0: u32, pad1: u32 };
+@group(0) @binding(0) var<storage, read> syndromes: array<u32>;
+@group(0) @binding(1) var<storage, read_write> corrections: array<u32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+const ALPHA: f32 = 0.8125;
+const GAMMA: f32 = 0.2;
+const MAXITER: u32 = 30u;
+const NVAR: u32 = 9u;
+const NCHECK: u32 = 4u;
+const NEDGE: u32 = 12u;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.count) { return; }
+
+  var eCheck = array<u32,12>(0u,0u,0u,0u,1u,1u,1u,1u,2u,2u,3u,3u);
+  var eVar   = array<u32,12>(0u,1u,3u,4u,4u,5u,7u,8u,1u,2u,6u,7u);
+
+  let sPacked = syndromes[idx];
+  var s = array<u32,4>(0u,0u,0u,0u);
+  for (var a = 0u; a < NCHECK; a = a + 1u) { s[a] = (sPacked >> a) & 1u; }
+
+  let lambda = params.lambda;
+  var v2c = array<f32,12>(lambda,lambda,lambda,lambda,lambda,lambda,lambda,lambda,lambda,lambda,lambda,lambda);
+  var c2v = array<f32,12>(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
+  var ecorr = array<u32,9>(0u,0u,0u,0u,0u,0u,0u,0u,0u);
+  var converged = false;
+
+  for (var it = 0u; it < MAXITER; it = it + 1u) {
+    // check-node update (syndrome-signed normalized min-sum)
+    for (var e = 0u; e < NEDGE; e = e + 1u) {
+      let a = eCheck[e];
+      var signProd = 1.0;
+      var minMag = 1e30;
+      for (var f = 0u; f < NEDGE; f = f + 1u) {
+        if (eCheck[f] != a || f == e) { continue; }
+        let msg = v2c[f];
+        if (msg < 0.0) { signProd = -signProd; }
+        let mag = abs(msg);
+        if (mag < minMag) { minMag = mag; }
+      }
+      var sgn = 1.0;
+      if (s[a] == 1u) { sgn = -1.0; }
+      c2v[e] = ALPHA * sgn * signProd * minMag;
+    }
+    // variable-node update + posterior + hard decision (with damping)
+    for (var i = 0u; i < NVAR; i = i + 1u) {
+      var total = lambda;
+      for (var e = 0u; e < NEDGE; e = e + 1u) { if (eVar[e] == i) { total = total + c2v[e]; } }
+      for (var e = 0u; e < NEDGE; e = e + 1u) { if (eVar[e] == i) { let newMsg = total - c2v[e]; v2c[e] = (1.0 - GAMMA) * newMsg + GAMMA * v2c[e]; } }
+      if (total < 0.0) { ecorr[i] = 1u; } else { ecorr[i] = 0u; }
+    }
+    // convergence: parity of ecorr over each check == s
+    var ok = true;
+    for (var a = 0u; a < NCHECK; a = a + 1u) {
+      var par = 0u;
+      for (var e = 0u; e < NEDGE; e = e + 1u) { if (eCheck[e] == a) { par = par ^ ecorr[eVar[e]]; } }
+      if (par != s[a]) { ok = false; }
+    }
+    if (ok) { converged = true; break; }
+  }
+
+  var packed = 0u;
+  for (var i = 0u; i < NVAR; i = i + 1u) { packed = packed | (ecorr[i] << i); }
+  if (converged) { packed = packed | (1u << 31u); }
+  corrections[idx] = packed;
+}
+`
+);
+function unpackCorrection(word) {
+  const correction = new Array(NVAR).fill(0);
+  for (let i = 0; i < NVAR; i++) correction[i] = word >>> i & 1;
+  const converged = (word >>> CONVERGED_BIT & 1) === 1;
+  return { correction, converged };
+}
+function packSyndrome(s) {
+  let packed = 0;
+  for (let a = 0; a < NCHECK; a++) packed |= (s[a] & 1) << a;
+  return packed >>> 0;
+}
+var QECDecoder = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this._pipeline = null;
+  }
+  /** Build the compute pipeline. Idempotent. Throws if the WGSL Tanner graph drifted from ZSTAB. */
+  async initialize() {
+    if (this._pipeline) return;
+    if (!tannerEdgesMatchZstab()) {
+      throw new Error(
+        "QECDecoder: WGSL Tanner edges (E_CHECK/E_VAR) do not reconstruct ZSTAB \u2014 refusing to build a decoder that diverges from the CPU-validated code."
+      );
+    }
+    const module = this.ctx.createShaderModule(QEC_BP_WGSL, "qec-bp-decoder");
+    this._pipeline = await this.ctx.createComputePipelineAsync(module, "main", "auto", "qec-bp");
+  }
+  pipeline() {
+    if (!this._pipeline) {
+      throw new Error("QECDecoder not initialized. Call initialize() first.");
+    }
+    return this._pipeline;
+  }
+  /**
+   * Decode a batch of packed syndromes on the GPU with pure BP. Returns packed correction words
+   * (bits 0..8 = qubit corrections, bit 31 = converged) — one per input, in order.
+   */
+  async decodeBatch(packedSyndromes, p = DEFAULT_PRIOR) {
+    const pipeline = this.pipeline();
+    const device = this.ctx.device;
+    const B = packedSyndromes.length;
+    if (B === 0) return new Uint32Array(0);
+    const inBuf = device.createBuffer({
+      size: B * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(
+      inBuf,
+      0,
+      packedSyndromes.buffer,
+      packedSyndromes.byteOffset,
+      packedSyndromes.byteLength
+    );
+    const outBuf = device.createBuffer({
+      size: B * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    });
+    const readBuf = device.createBuffer({
+      size: B * 4,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+    });
+    const params = new ArrayBuffer(16);
+    new Float32Array(params, 0, 1)[0] = priorLLR(p);
+    new Uint32Array(params, 4, 1)[0] = B;
+    const paramBuf = device.createBuffer({
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(paramBuf, 0, params);
+    const bind = device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: inBuf } },
+        { binding: 1, resource: { buffer: outBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ]
+    });
+    const enc = device.createCommandEncoder();
+    const pass = enc.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bind);
+    pass.dispatchWorkgroups(Math.ceil(B / 64));
+    pass.end();
+    enc.copyBufferToBuffer(outBuf, 0, readBuf, 0, B * 4);
+    device.queue.submit([enc.finish()]);
+    await readBuf.mapAsync(GPUMapMode.READ);
+    const out = new Uint32Array(readBuf.getMappedRange().slice(0));
+    readBuf.unmap();
+    inBuf.destroy();
+    outBuf.destroy();
+    readBuf.destroy();
+    paramBuf.destroy();
+    return out;
+  }
+  /**
+   * Full-pipeline decode: run GPU BP over the batch, then fall to the host OSD-0 guard for any
+   * syndrome BP did not converge on — the standard BP-on-accelerator / OSD-on-host split. Each
+   * result carries whether the GPU fast path succeeded.
+   */
+  async decodeWithFallback(syndromes, p = DEFAULT_PRIOR) {
+    const packed = new Uint32Array(syndromes.map((s) => packSyndrome(s)));
+    const out = await this.decodeBatch(packed, p);
+    return syndromes.map((s, i) => {
+      const { correction, converged } = unpackCorrection(out[i]);
+      if (converged) return { correction, gpuConverged: true, method: "gpu-bp" };
+      return { correction: bpOsdDecode(HX, s, p).correction, gpuConverged: false, method: "host-osd0" };
+    });
+  }
+  /**
+   * Exhaustively validate the GPU decoder over all 16 X-syndromes against the exact ML lookup:
+   * every GPU-converged decode must be syndrome-valid + coset-equivalent, the full pipeline must
+   * solve all 16, and the GPU converged flag must match the CPU BP reference.
+   */
+  async validateExhaustive(p = DEFAULT_PRIOR) {
+    const { LOOKUP_X: LOOKUP_X2, syndromeX: syndromeX2, xorVec: xorVec2, isLogicalX: isLogicalX2, bpMinSum: bpMinSum2 } = await Promise.resolve().then(() => (init_qec_codes(), qec_codes_exports));
+    const syndromes = [];
+    for (let m = 0; m < 16; m++) syndromes.push([m & 1, m >> 1 & 1, m >> 2 & 1, m >> 3 & 1]);
+    const results = await this.decodeWithFallback(syndromes, p);
+    let gpuConverged = 0;
+    let gpuConvergedCorrect = 0;
+    let fullValidCoset = 0;
+    let convMatch = 0;
+    const lambda = priorLLR(p);
+    const okOf = (c, s) => {
+      const valid = syndromeX2(c).every((b, i) => b === s[i]);
+      const diff = xorVec2(c, LOOKUP_X2.get(s.join("")).correction);
+      return valid && syndromeX2(diff).every((b) => b === 0) && !isLogicalX2(diff);
+    };
+    for (let m = 0; m < 16; m++) {
+      const s = syndromes[m];
+      const r = results[m];
+      const cpuConv = bpMinSum2(HX, s, lambda).converged;
+      if (r.gpuConverged === cpuConv) convMatch++;
+      if (r.gpuConverged) {
+        gpuConverged++;
+        if (okOf(r.correction, s)) gpuConvergedCorrect++;
+      }
+      if (okOf(r.correction, s)) fullValidCoset++;
+    }
+    return {
+      syndromesTested: 16,
+      gpuBpConverged: gpuConverged,
+      gpuConvergedAllValidCoset: gpuConvergedCorrect === gpuConverged,
+      fullPipelineAll16ValidCoset: fullValidCoset === 16,
+      convergedFlagMatchesCpu: convMatch
+    };
+  }
+  /**
+   * Measure batched decode throughput on the real device: warm up, then time `reps` dispatches
+   * of a `batchSize` batch (submit → onSubmittedWorkDone) with no per-dispatch readback. The
+   * honest GPU metric is throughput, not single-shot latency.
+   */
+  async benchmarkThroughput(batchSize, reps, p = DEFAULT_PRIOR) {
+    const pipeline = this.pipeline();
+    const device = this.ctx.device;
+    const B = batchSize;
+    const batch = new Uint32Array(B);
+    let seed = 12345 >>> 0;
+    for (let i = 0; i < B; i++) {
+      seed = seed + 1831565813 | 0;
+      let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      batch[i] = (t ^ t >>> 14) >>> 0 & 15;
+    }
+    const inBuf = device.createBuffer({
+      size: B * 4,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(inBuf, 0, batch.buffer, batch.byteOffset, batch.byteLength);
+    const outBuf = device.createBuffer({ size: B * 4, usage: GPUBufferUsage.STORAGE });
+    const params = new ArrayBuffer(16);
+    new Float32Array(params, 0, 1)[0] = priorLLR(p);
+    new Uint32Array(params, 4, 1)[0] = B;
+    const paramBuf = device.createBuffer({
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(paramBuf, 0, params);
+    const bind = device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: inBuf } },
+        { binding: 1, resource: { buffer: outBuf } },
+        { binding: 2, resource: { buffer: paramBuf } }
+      ]
+    });
+    const dispatch = () => {
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bind);
+      pass.dispatchWorkgroups(Math.ceil(B / 64));
+      pass.end();
+      device.queue.submit([enc.finish()]);
+    };
+    const converged = await this.decodeBatch(batch, p);
+    let convergedCount = 0;
+    for (let i = 0; i < B; i++) if (converged[i] >>> CONVERGED_BIT & 1) convergedCount++;
+    for (let r = 0; r < 3; r++) dispatch();
+    await device.queue.onSubmittedWorkDone();
+    const t0 = performance.now();
+    for (let r = 0; r < reps; r++) dispatch();
+    await device.queue.onSubmittedWorkDone();
+    const t1 = performance.now();
+    inBuf.destroy();
+    outBuf.destroy();
+    paramBuf.destroy();
+    const totalDecodes = B * reps;
+    const wallSeconds = (t1 - t0) / 1e3;
+    return {
+      batchSize: B,
+      reps,
+      totalDecodes,
+      wallSeconds: Number(wallSeconds.toFixed(4)),
+      decodesPerSecond: Math.round(totalDecodes / wallSeconds),
+      nsPerDecodeAmortized: Number(((t1 - t0) * 1e6 / totalDecodes).toFixed(3)),
+      gpuFastPathFraction: Number((convergedCount / B).toFixed(4))
+    };
+  }
+};
 
 exports.BufferManager = BufferManager;
 exports.CPUReferenceSimulator = CPUReferenceSimulator;
@@ -3359,6 +4050,7 @@ exports.PROPHECY_SPIKE_FEATURE_COUNT = PROPHECY_SPIKE_FEATURE_COUNT;
 exports.PipelineFactory = PipelineFactory;
 exports.ProphecyNotImplementedError = ProphecyNotImplementedError;
 exports.ProphecyOrchestrator = ProphecyOrchestrator;
+exports.QECDecoder = QECDecoder;
 exports.SNNNetwork = SNNNetwork;
 exports.SpikeDecoder = SpikeDecoder;
 exports.SpikeEncoder = SpikeEncoder;
@@ -3382,8 +4074,12 @@ exports.generateSynapticInput = generateSynapticInput;
 exports.generateWeightMatrix = generateWeightMatrix;
 exports.normalizeAdjacency = normalizeAdjacency;
 exports.normalizeBotanicalMaterialExtraction = normalizeBotanicalMaterialExtraction;
+exports.packSyndrome = packSyndrome;
+exports.qec = qec_exports;
 exports.runLIFDeterminismProbe = runLIFDeterminismProbe;
+exports.tannerEdgesMatchZstab = tannerEdgesMatchZstab;
 exports.toBotanicalLotusTrait = toBotanicalLotusTrait;
 exports.trainProphecySpikeRateModel = trainProphecySpikeRateModel;
-//# sourceMappingURL=dist-GRMOP2UL.cjs.map
-//# sourceMappingURL=dist-GRMOP2UL.cjs.map
+exports.unpackCorrection = unpackCorrection;
+//# sourceMappingURL=dist-YGATNURH.cjs.map
+//# sourceMappingURL=dist-YGATNURH.cjs.map