@svrnsec/pulse 0.1.0

package/dist/pulse.esm.js

@@ -0,0 +1,4898 @@
+/**
+ * @sovereign/pulse — Statistical Jitter Analysis
+ *
+ * Analyses the timing distribution from the entropy probe to classify
+ * the host as a real consumer device or a sanitised datacenter VM.
+ *
+ * Core insight:
+ *   Real hardware  → thermal throttling, OS context switches, DRAM refresh
+ *                    cycles create a characteristic "noisy" but physically
+ *                    plausible timing distribution.
+ *   Datacenter VM  → hypervisor scheduler presents a nearly-flat execution
+ *                    curve; thermal feedback is absent; timer may be
+ *                    quantised to the host's scheduler quantum.
+ */
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Full statistical analysis of a timing vector.
+ *
+ * @param {number[]} timings  - per-iteration millisecond deltas from WASM probe
+ * @param {object}   [opts]
+ * @param {object}   [opts.autocorrelations]  - pre-computed { lag1 … lag10 }
+ * @returns {JitterAnalysis}
+ */
+function classifyJitter(timings, opts = {}) {
+  if (!timings || timings.length < 10) {
+    return _insufficientData();
+  }
+
+  const stats       = computeStats(timings);
+  const autocorr    = opts.autocorrelations ?? _computeLocalAutocorr(timings);
+  const hurst       = computeHurst(timings);
+  const quantEnt    = detectQuantizationEntropy(timings);
+  const thermal     = detectThermalSignature(timings);
+  const outlierRate = _outlierRate(timings, stats);
+
+  // ── Scoring rubric ───────────────────────────────────────────────────────
+  // Each criterion contributes 0–1 to a weighted sum.
+  // Weights sum to 1.0; final score is in [0, 1].
+  //   1.0 = almost certainly a real consumer device + real silicon
+  //   0.0 = almost certainly a sanitised VM / AI instance
+
+  const components = {};
+  const flags      = [];
+
+  // 1. Coefficient of Variation  (weight 0.25)
+  //    Real hardware: CV ∈ [0.04, 0.35]
+  //    VM:            CV often < 0.02 ("too flat") or > 0.5 (scheduler bursts)
+  let cvScore = 0;
+  if (stats.cv >= 0.04 && stats.cv <= 0.35) {
+    cvScore = 1.0;
+  } else if (stats.cv >= 0.02 && stats.cv < 0.04) {
+    cvScore = (stats.cv - 0.02) / 0.02; // linear ramp up
+    flags.push('LOW_CV_BORDERLINE');
+  } else if (stats.cv > 0.35 && stats.cv < 0.5) {
+    cvScore = 1.0 - (stats.cv - 0.35) / 0.15; // ramp down
+    flags.push('HIGH_CV_POSSIBLE_SCHEDULER_BURST');
+  } else if (stats.cv < 0.02) {
+    cvScore = 0;
+    flags.push('CV_TOO_FLAT_VM_INDICATOR');
+  } else {
+    cvScore = 0.2;
+    flags.push('CV_TOO_HIGH_SCHEDULER_BURST');
+  }
+  components.cv = { score: cvScore, weight: 0.25, value: stats.cv };
+
+  // 2. Autocorrelation profile  (weight 0.20)
+  //    Real thermal noise → all lags near 0 (i.i.d. / Brownian)
+  //    VM hypervisor scheduler → positive autocorr (periodic steal-time bursts)
+  //    We use the maximum absolute autocorrelation across all measured lags
+  //    to catch both lag-1 and longer-period scheduler artifacts.
+  const acVals   = Object.values(autocorr).filter(v => v != null);
+  const maxAbsAC = acVals.length ? Math.max(...acVals.map(Math.abs)) : 0;
+  const meanAbsAC = acVals.length ? acVals.reduce((s, v) => s + Math.abs(v), 0) / acVals.length : 0;
+  const acStat   = (maxAbsAC + meanAbsAC) / 2; // blend: worst + average
+
+  let ac1Score = 0;
+  if (acStat < 0.12) {
+    ac1Score = 1.0;
+  } else if (acStat < 0.28) {
+    ac1Score = 1.0 - (acStat - 0.12) / 0.16;
+    flags.push('MODERATE_AUTOCORR_POSSIBLE_SCHEDULER');
+  } else {
+    ac1Score = 0;
+    flags.push('HIGH_AUTOCORR_VM_SCHEDULER_DETECTED');
+  }
+  components.autocorr = { score: ac1Score, weight: 0.20, value: acStat };
+
+  // 3. Quantization Entropy  (weight 0.20)
+  //    High entropy → timings are spread, not clustered on fixed boundaries
+  //    Low entropy  → values cluster on integer-ms ticks (legacy VM timer)
+  //
+  //    Scale:
+  //      QE ≥ 4.5  → 1.00  (strongly physical)
+  //      QE  3.0–4.5 → 0.00–1.00  (linear ramp, healthy range)
+  //      QE  2.0–3.0 → 0.00–0.20  (borderline; still gives partial credit so one
+  //                                 weak metric doesn't zero-out the whole score)
+  //      QE < 2.0  → 0.00  (clearly synthetic/quantised timer)
+  let qeScore = 0;
+  if (quantEnt >= 4.5) {
+    qeScore = 1.0;
+  } else if (quantEnt >= 3.0) {
+    qeScore = (quantEnt - 3.0) / 1.5;             // 0.00 → 1.00
+  } else if (quantEnt >= 2.0) {
+    // Partial credit — not obviously VM but not clearly physical.
+    // Lets other strong signals (CV, autocorr, Hurst) still carry the device
+    // over the physical threshold instead of being zeroed by a single weak metric.
+    qeScore = ((quantEnt - 2.0) / 1.0) * 0.20;   // 0.00 → 0.20
+    flags.push('LOW_QUANTIZATION_ENTROPY_BORDERLINE');
+  } else {
+    qeScore = 0;
+    flags.push('LOW_QUANTIZATION_ENTROPY_SYNTHETIC_TIMER');
+  }
+  components.quantization = { score: qeScore, weight: 0.20, value: quantEnt };
+
+  // 4. Hurst Exponent  (weight 0.15)
+  //    Genuine white thermal noise → H ≈ 0.5
+  //    VM scheduler periodicity   → H > 0.7 (persistent / self-similar)
+  //    Synthetic / replayed       → H near 0 or 1
+  let hurstScore = 0;
+  const hurstDev = Math.abs(hurst - 0.5);
+  if (hurstDev < 0.10) {
+    hurstScore = 1.0;
+  } else if (hurstDev < 0.25) {
+    hurstScore = 1.0 - (hurstDev - 0.10) / 0.15;
+    if (hurst > 0.7) flags.push('HIGH_HURST_VM_SCHEDULER_PERIODICITY');
+  } else {
+    hurstScore = 0;
+    if (hurst > 0.7)      flags.push('VERY_HIGH_HURST_VM');
+    else if (hurst < 0.3) flags.push('VERY_LOW_HURST_ANTIPERSISTENT');
+  }
+  components.hurst = { score: hurstScore, weight: 0.15, value: hurst };
+
+  // 5. Thermal signature  (weight 0.10)
+  //    Real CPU under sustained load → upward drift or sawtooth (fan cycling)
+  //    VM: flat timing regardless of simulated load (no thermal feedback loop)
+  let thermalScore = 0;
+  if (thermal.pattern === 'rising' || thermal.pattern === 'sawtooth') {
+    thermalScore = 1.0;
+  } else if (Math.abs(thermal.slope) > 5e-5) {
+    thermalScore = 0.5; // some drift present
+    flags.push('WEAK_THERMAL_SIGNATURE');
+  } else {
+    thermalScore = 0;
+    flags.push('FLAT_THERMAL_PROFILE_VM_INDICATOR');
+  }
+  components.thermal = { score: thermalScore, weight: 0.10, value: thermal.slope };
+
+  // 6. Outlier rate  (weight 0.10)
+  //    Context switches on real OS → occasional timing spikes (> 3σ)
+  //    VMs: far fewer OS-level interruptions visible to guest
+  let outlierScore = 0;
+  if (outlierRate >= 0.02 && outlierRate <= 0.15) {
+    outlierScore = 1.0;
+  } else if (outlierRate > 0 && outlierRate < 0.02) {
+    outlierScore = outlierRate / 0.02;
+    flags.push('FEW_OUTLIERS_POSSIBLY_VM');
+  } else if (outlierRate > 0.15) {
+    outlierScore = Math.max(0, 1.0 - (outlierRate - 0.15) / 0.15);
+    flags.push('EXCESSIVE_OUTLIERS_UNSTABLE');
+  }
+  components.outliers = { score: outlierScore, weight: 0.10, value: outlierRate };
+
+  // ── Weighted aggregate ────────────────────────────────────────────────────
+  const score = Object.values(components)
+    .reduce((sum, c) => sum + c.score * c.weight, 0);
+
+  return {
+    score: Math.max(0, Math.min(1, score)),
+    flags,
+    components,
+    stats,
+    autocorrelations: autocorr,
+    hurstExponent:    hurst,
+    quantizationEntropy: quantEnt,
+    thermalSignature: thermal,
+    outlierRate,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// computeStats
+// ---------------------------------------------------------------------------
+
+/**
+ * Descriptive statistics for a timing vector.
+ * @param {number[]} arr
+ * @returns {TimingStats}
+ */
+function computeStats(arr) {
+  const sorted = [...arr].sort((a, b) => a - b);
+  const n      = arr.length;
+  const mean   = arr.reduce((s, v) => s + v, 0) / n;
+  const varr   = arr.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1);
+  const std    = Math.sqrt(varr);
+
+  const pct = (p) => {
+    const idx = (p / 100) * (n - 1);
+    const lo  = Math.floor(idx);
+    const hi  = Math.ceil(idx);
+    return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+  };
+
+  // Skewness (Fisher-Pearson)
+  const skew = n < 3 ? 0 :
+    arr.reduce((s, v) => s + ((v - mean) / std) ** 3, 0) *
+    (n / ((n - 1) * (n - 2)));
+
+  // Excess kurtosis
+  const kurt = n < 4 ? 0 :
+    (arr.reduce((s, v) => s + ((v - mean) / std) ** 4, 0) *
+     (n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))) -
+    (3 * (n - 1) ** 2) / ((n - 2) * (n - 3));
+
+  return {
+    n, mean, std,
+    cv:       std / mean,
+    min:      sorted[0],
+    max:      sorted[n - 1],
+    p5:       pct(5),
+    p25:      pct(25),
+    p50:      pct(50),
+    p75:      pct(75),
+    p95:      pct(95),
+    p99:      pct(99),
+    skewness: skew,
+    kurtosis: kurt,
+  };
+}
+
+/**
+ * @typedef {object} TimingStats
+ * @property {number} n
+ * @property {number} mean
+ * @property {number} std
+ * @property {number} cv
+ * @property {number} min
+ * @property {number} max
+ * @property {number} p5
+ * @property {number} p25
+ * @property {number} p50
+ * @property {number} p75
+ * @property {number} p95
+ * @property {number} p99
+ * @property {number} skewness
+ * @property {number} kurtosis
+ */
+
+// ---------------------------------------------------------------------------
+// computeHurst
+// ---------------------------------------------------------------------------
+
+/**
+ * Estimates the Hurst exponent via Rescaled Range (R/S) analysis.
+ * Covers 4 sub-series sizes (n/4, n/3, n/2, n) to get a log-log slope.
+ *
+ * H ≈ 0.5 → random walk (Brownian, thermal noise)
+ * H > 0.5 → persistent (VM hypervisor periodicity)
+ * H < 0.5 → anti-persistent
+ *
+ * @param {number[]} arr
+ * @returns {number}
+ */
+function computeHurst(arr) {
+  const n = arr.length;
+  if (n < 16) return 0.5; // not enough data
+
+  const sizes = [
+    Math.floor(n / 4),
+    Math.floor(n / 3),
+    Math.floor(n / 2),
+    n,
+  ].filter(s => s >= 8);
+
+  const points = sizes.map(s => {
+    const rs = _rescaledRange(arr.slice(0, s));
+    return [Math.log(s), Math.log(rs)];
+  });
+
+  // Ordinary least squares on log-log
+  const xMean = points.reduce((s, p) => s + p[0], 0) / points.length;
+  const yMean = points.reduce((s, p) => s + p[1], 0) / points.length;
+  let num = 0, den = 0;
+  for (const [x, y] of points) {
+    num += (x - xMean) * (y - yMean);
+    den += (x - xMean) ** 2;
+  }
+  const H = den === 0 ? 0.5 : num / den;
+  return Math.max(0, Math.min(1, H));
+}
+
+function _rescaledRange(arr) {
+  const n    = arr.length;
+  const mean = arr.reduce((s, v) => s + v, 0) / n;
+  const dev  = arr.map(v => v - mean);
+
+  // Cumulative deviation
+  const cum = [];
+  let acc = 0;
+  for (const d of dev) { acc += d; cum.push(acc); }
+
+  const R = Math.max(...cum) - Math.min(...cum);
+  const S = Math.sqrt(arr.reduce((s, v) => s + (v - mean) ** 2, 0) / n);
+  return S === 0 ? 1 : R / S;
+}
+
+// ---------------------------------------------------------------------------
+// detectQuantizationEntropy
+// ---------------------------------------------------------------------------
+
+/**
+ * Computes Shannon entropy of a histogram of timing values.
+ * Low entropy (< 3 bits) indicates clustered / quantised timings (VM timer).
+ *
+ * @param {number[]} arr
+ * @param {number}   [binWidthMs=0.2]
+ * @returns {number}  entropy in bits
+ */
+function detectQuantizationEntropy(arr, binWidthMs = 0.2) {
+  if (!arr.length) return 0;
+  const bins = new Map();
+  for (const v of arr) {
+    const bin = Math.round(v / binWidthMs);
+    bins.set(bin, (bins.get(bin) ?? 0) + 1);
+  }
+  const n = arr.length;
+  let H = 0;
+  for (const count of bins.values()) {
+    const p = count / n;
+    H -= p * Math.log2(p);
+  }
+  return H;
+}
+
+// ---------------------------------------------------------------------------
+// detectThermalSignature
+// ---------------------------------------------------------------------------
+
+/**
+ * Analyses whether the timing series shows a thermal throttle pattern:
+ * a rising trend (CPU heating up) or sawtooth (fan intervention).
+ *
+ * @param {number[]} arr
+ * @returns {{ slope: number, pattern: 'rising'|'falling'|'sawtooth'|'flat', r2: number }}
+ */
+function detectThermalSignature(arr) {
+  const n    = arr.length;
+  if (n < 10) return { slope: 0, pattern: 'flat', r2: 0 };
+
+  // Linear regression (timing vs sample index)
+  const xMean = (n - 1) / 2;
+  const yMean = arr.reduce((s, v) => s + v, 0) / n;
+  let num = 0, den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (i - xMean) * (arr[i] - yMean);
+    den += (i - xMean) ** 2;
+  }
+  const slope = den === 0 ? 0 : num / den;
+
+  // R² of linear fit
+  const ss_res = arr.reduce((s, v, i) => {
+    const pred = yMean + slope * (i - xMean);
+    return s + (v - pred) ** 2;
+  }, 0);
+  const ss_tot = arr.reduce((s, v) => s + (v - yMean) ** 2, 0);
+  const r2 = ss_tot === 0 ? 0 : 1 - ss_res / ss_tot;
+
+  // Sawtooth detection: look for a drop > 2σ after a rising segment
+  const std  = Math.sqrt(arr.reduce((s, v) => s + (v - yMean) ** 2, 0) / n);
+  let sawtoothCount = 0;
+  for (let i = 1; i < n; i++) {
+    if (arr[i - 1] - arr[i] > 2 * std) sawtoothCount++;
+  }
+
+  let pattern;
+  if (sawtoothCount >= 2)   pattern = 'sawtooth';
+  else if (slope > 5e-5)    pattern = 'rising';
+  else if (slope < -5e-5)   pattern = 'falling';
+  else                      pattern = 'flat';
+
+  return { slope, pattern, r2, sawtoothCount };
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _outlierRate(arr, stats) {
+  const threshold = stats.mean + 3 * stats.std;
+  return arr.filter(v => v > threshold).length / arr.length;
+}
+
+function _computeLocalAutocorr(arr) {
+  const autocorr = {};
+  for (const lag of [1, 2, 3, 5, 10]) {
+    autocorr[`lag${lag}`] = _pearsonAC(arr, lag);
+  }
+  return autocorr;
+}
+
+function _pearsonAC(arr, lag) {
+  const n = arr.length;
+  if (lag >= n) return 0;
+  const valid = n - lag;
+  const mean  = arr.reduce((s, v) => s + v, 0) / n;
+  let num = 0, da = 0, db = 0;
+  for (let i = 0; i < valid; i++) {
+    const a = arr[i]       - mean;
+    const b = arr[i + lag] - mean;
+    num += a * b;
+    da  += a * a;
+    db  += b * b;
+  }
+  const denom = Math.sqrt(da * db);
+  return denom < 1e-14 ? 0 : num / denom;
+}
+
+function _insufficientData() {
+  return {
+    score: 0,
+    flags: ['INSUFFICIENT_DATA'],
+    components:          {},
+    stats:               null,
+    autocorrelations:    {},
+    hurstExponent:       0.5,
+    quantizationEntropy: 0,
+    thermalSignature:    { slope: 0, pattern: 'flat', r2: 0 },
+    outlierRate:         0,
+  };
+}
+
+/**
+ * @typedef {object} JitterAnalysis
+ * @property {number}   score              - [0,1], 1 = real hardware
+ * @property {string[]} flags              - diagnostic flags
+ * @property {object}   components         - per-criterion scores and weights
+ * @property {TimingStats} stats
+ * @property {object}   autocorrelations
+ * @property {number}   hurstExponent
+ * @property {number}   quantizationEntropy
+ * @property {object}   thermalSignature
+ * @property {number}   outlierRate
+ */
+
+var jitter = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  classifyJitter: classifyJitter,
+  computeHurst: computeHurst,
+  computeStats: computeStats,
+  detectQuantizationEntropy: detectQuantizationEntropy,
+  detectThermalSignature: detectThermalSignature
+});
+
+/**
+ * @sovereign/pulse — Adaptive Entropy Probe
+ *
+ * Runs the WASM probe in batches and stops early once the signal is decisive.
+ *
+ * Why this works:
+ *   A KVM VM with QE=1.27 and lag-1 autocorr=0.67 is unambiguously a VM after
+ *   just 50 iterations.  Running 200 iterations confirms what was already obvious
+ *   at 50 — it adds no new information but wastes 3 seconds of user time.
+ *
+ *   Conversely, a physical device with healthy entropy needs more data to
+ *   rule out edge cases, so it runs longer.
+ *
+ * Speed profile:
+ *   Obvious VM  (QE < 1.5,  lag1 > 0.60)  →  stops at  50 iters  →  ~0.9s  (75% faster)
+ *   Clear HW    (QE > 3.5,  lag1 < 0.10)  →  stops at ~100 iters  →  ~1.8s  (50% faster)
+ *   Ambiguous   (borderline metrics)       →  runs full 200 iters  →  ~3.5s  (same)
+ */
+
+
+// ---------------------------------------------------------------------------
+// Quick classifier (cheap, runs after every batch)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fast signal-quality check.  No Hurst, no thermal analysis — just the three
+ * metrics that converge quickest: QE, CV, and lag-1 autocorrelation.
+ *
+ * @param {number[]} timings
+ * @returns {{ vmConf: number, hwConf: number, qe: number, cv: number, lag1: number }}
+ */
+function quickSignal(timings) {
+  const n    = timings.length;
+  const mean = timings.reduce((s, v) => s + v, 0) / n;
+  const variance = timings.reduce((s, v) => s + (v - mean) ** 2, 0) / n;
+  const cv   = mean > 0 ? Math.sqrt(variance) / mean : 0;
+  const qe   = detectQuantizationEntropy(timings);
+
+  // Pearson autocorrelation at lag-1 (O(n), fits in a single pass)
+  let num = 0, da = 0, db = 0;
+  for (let i = 0; i < n - 1; i++) {
+    const a = timings[i]     - mean;
+    const b = timings[i + 1] - mean;
+    num += a * b;
+    da  += a * a;
+    db  += b * b;
+  }
+  const lag1 = Math.sqrt(da * db) < 1e-14 ? 0 : num / Math.sqrt(da * db);
+
+  // VM confidence: each factor independently identifies the hypervisor footprint
+  const vmConf = Math.min(1,
+    (qe   < 1.50 ? 0.40 : qe   < 2.00 ? 0.20 : 0.0) +
+    (lag1 > 0.60 ? 0.35 : lag1 > 0.40 ? 0.18 : 0.0) +
+    (cv   < 0.04 ? 0.25 : cv   < 0.07 ? 0.10 : 0.0)
+  );
+
+  // HW confidence: must see all three positive signals together
+  const hwConf = Math.min(1,
+    (qe   > 3.50 ? 0.38 : qe   > 3.00 ? 0.22 : 0.0) +
+    (Math.abs(lag1) < 0.10 ? 0.32 : Math.abs(lag1) < 0.20 ? 0.15 : 0.0) +
+    (cv   > 0.10 ? 0.30 : cv   > 0.07 ? 0.14 : 0.0)
+  );
+
+  return { vmConf, hwConf, qe, cv, lag1 };
+}
+
+// ---------------------------------------------------------------------------
+// collectEntropyAdaptive
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {object}   opts
+ * @param {number}   [opts.minIterations=50]        - never stop before this
+ * @param {number}   [opts.maxIterations=200]        - hard cap
+ * @param {number}   [opts.batchSize=25]             - WASM call granularity
+ * @param {number}   [opts.vmThreshold=0.85]         - stop early if VM confidence ≥ this
+ * @param {number}   [opts.hwThreshold=0.80]         - stop early if HW confidence ≥ this
+ * @param {number}   [opts.hwMinIterations=75]        - physical needs more data to confirm
+ * @param {number}   [opts.matrixSize=64]
+ * @param {Function} [opts.onBatch]                  - called after each batch with interim signal
+ * @param {string}   [opts.wasmPath]
+ * @param {Function}  wasmModule                     - pre-initialised WASM module
+ * @returns {Promise<AdaptiveEntropyResult>}
+ */
+async function collectEntropyAdaptive(wasmModule, opts = {}) {
+  const {
+    minIterations  = 50,
+    maxIterations  = 200,
+    batchSize      = 25,
+    vmThreshold    = 0.85,
+    hwThreshold    = 0.80,
+    hwMinIterations = 75,
+    matrixSize     = 64,
+    onBatch,
+  } = opts;
+
+  const wasm       = wasmModule;
+  const allTimings = [];
+  const batches    = [];       // per-batch timing snapshots
+  let   stoppedAt  = null;    // { reason, iterations, vmConf, hwConf }
+  let   checksum   = 0;
+
+  const t_start = Date.now();
+
+  while (allTimings.length < maxIterations) {
+    const n      = Math.min(batchSize, maxIterations - allTimings.length);
+    const result = wasm.run_entropy_probe(n, matrixSize);
+    const chunk  = Array.from(result.timings);
+
+    allTimings.push(...chunk);
+    checksum += result.checksum;
+
+    const sig = quickSignal(allTimings);
+    batches.push({ iterations: allTimings.length, ...sig });
+
+    // Fire progress callback with live signal so callers can stream to UI
+    if (typeof onBatch === 'function') {
+      try {
+        onBatch({
+          iterations:   allTimings.length,
+          maxIterations,
+          pct:          Math.round(allTimings.length / maxIterations * 100),
+          vmConf:       sig.vmConf,
+          hwConf:       sig.hwConf,
+          qe:           sig.qe,
+          cv:           sig.cv,
+          lag1:         sig.lag1,
+          // Thresholds: 0.70 — high enough that a legitimate device won't be
+        // shown a false early verdict from a noisy first batch.
+        // 'borderline' surfaces when one axis is moderate but not decisive.
+        earlyVerdict: sig.vmConf > 0.70 ? 'vm'
+          : sig.hwConf > 0.70 ? 'physical'
+          : (sig.vmConf > 0.45 || sig.hwConf > 0.45) ? 'borderline'
+          : 'uncertain',
+        });
+      } catch {}
+    }
+
+    // ── Early-exit checks ──────────────────────────────────────────────────
+    if (allTimings.length < minIterations) continue;
+
+    if (sig.vmConf >= vmThreshold) {
+      stoppedAt = { reason: 'VM_SIGNAL_DECISIVE', vmConf: sig.vmConf, hwConf: sig.hwConf };
+      break;
+    }
+
+    if (allTimings.length >= hwMinIterations && sig.hwConf >= hwThreshold) {
+      stoppedAt = { reason: 'PHYSICAL_SIGNAL_DECISIVE', vmConf: sig.vmConf, hwConf: sig.hwConf };
+      break;
+    }
+  }
+
+  const elapsed          = Date.now() - t_start;
+  const iterationsRan    = allTimings.length;
+  const iterationsSaved  = maxIterations - iterationsRan;
+  const speedupFactor    = maxIterations / iterationsRan;
+
+  // ── Resolution probe using cached WASM call ────────────────────────────
+  const resResult     = wasm.run_entropy_probe(1, 4); // tiny probe for resolution
+  const resProbe      = Array.from(resResult.resolution_probe ?? []);
+
+  const resDeltas = [];
+  for (let i = 1; i < resProbe.length; i++) {
+    const d = resProbe[i] - resProbe[i - 1];
+    if (d > 0) resDeltas.push(d);
+  }
+
+  return {
+    timings:          allTimings,
+    iterations:       iterationsRan,
+    maxIterations,
+    checksum:         checksum.toString(),
+    resolutionProbe:  resProbe,
+    timerGranularityMs: resDeltas.length
+      ? resDeltas.reduce((a, b) => Math.min(a, b), Infinity)
+      : null,
+    earlyExit: stoppedAt ? {
+      ...stoppedAt,
+      iterationsSaved,
+      timeSavedMs:    Math.round(iterationsSaved * (elapsed / iterationsRan)),
+      speedupFactor:  +speedupFactor.toFixed(2),
+    } : null,
+    batches,
+    elapsedMs: elapsed,
+    collectedAt: t_start,
+    matrixSize,
+    phased: false, // adaptive replaces phased for speed
+  };
+}
+
+/**
+ * @typedef {object} AdaptiveEntropyResult
+ * @property {number[]}  timings
+ * @property {number}    iterations         - how many actually ran
+ * @property {number}    maxIterations      - cap that was set
+ * @property {object|null} earlyExit        - null if ran to completion
+ * @property {object[]}  batches            - per-batch signal snapshots
+ * @property {number}    elapsedMs
+ */
+
+/**
+ * @sovereign/pulse — Entropy Collector
+ *
+ * Bridges the Rust/WASM matrix-multiply probe into JavaScript.
+ * The WASM module is lazily initialised once and cached for subsequent calls.
+ */
+
+
+// ---------------------------------------------------------------------------
+// WASM loader (lazy singleton)
+// ---------------------------------------------------------------------------
+let _wasmModule   = null;
+let _initPromise  = null;
+
+/**
+ * Initialise (or return the cached) WASM module.
+ * Works in browsers (via fetch), in Electron (Node.js context), and in
+ * Jest/Vitest via a manual WASM path override.
+ *
+ * @param {string} [wasmPath] – override path/URL to the .wasm binary
+ */
+async function initWasm(wasmPath) {
+  if (_wasmModule) return _wasmModule;
+  if (_initPromise) return _initPromise;
+
+  _initPromise = (async () => {
+    // Dynamic import so bundlers can tree-shake this for server-only builds.
+    const { default: init, run_entropy_probe, run_memory_probe, compute_autocorrelation } =
+      await Promise.resolve().then(function () { return pulse_core; });
+
+    const url = wasmPath ?? new URL('../../pkg/pulse_core_bg.wasm', import.meta.url).href;
+    await init(url);
+
+    _wasmModule = { run_entropy_probe, run_memory_probe, compute_autocorrelation };
+    return _wasmModule;
+  })();
+
+  return _initPromise;
+}
+
+// ---------------------------------------------------------------------------
+// collectEntropy
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the WASM entropy probe and return raw timing data.
+ *
+ * @param {object}  opts
+ * @param {number}  [opts.iterations=200]  - number of matrix-multiply rounds
+ * @param {number}  [opts.matrixSize=64]   - N for the N×N matrices
+ * @param {number}  [opts.memSizeKb=512]   - size of the memory bandwidth probe
+ * @param {number}  [opts.memIterations=50]
+ * @param {boolean} [opts.phased=true]     - run cold/load/hot phases for entropy-jitter ratio
+ * @param {string}  [opts.wasmPath]        - optional custom WASM binary path
+ *
+ * @returns {Promise<EntropyResult>}
+ */
+async function collectEntropy(opts = {}) {
+  const {
+    iterations        = 200,
+    matrixSize        = 64,
+    memSizeKb         = 512,
+    memIterations     = 50,
+    phased            = true,
+    adaptive          = false,
+    adaptiveThreshold = 0.85,
+    onBatch,
+    wasmPath,
+  } = opts;
+
+  const wasm    = await initWasm(wasmPath);
+  const t_start = Date.now();
+
+  let phases = null;
+  let timings, resolutionProbe, checksum, timerGranularityMs;
+  let _adaptiveInfo = null;
+
+  // ── Adaptive mode: smart early exit, fastest for obvious VMs ──────────
+  if (adaptive) {
+    const r = await collectEntropyAdaptive(wasm, {
+      minIterations:   50,
+      maxIterations:   iterations,
+      batchSize:       25,
+      vmThreshold:     adaptiveThreshold,
+      hwThreshold:     0.80,
+      hwMinIterations: 75,
+      matrixSize,
+      onBatch,
+    });
+    timings            = r.timings;
+    resolutionProbe    = r.resolutionProbe ?? [];
+    checksum           = r.checksum;
+    timerGranularityMs = r.timerGranularityMs;
+    _adaptiveInfo      = { earlyExit: r.earlyExit, batches: r.batches, elapsedMs: r.elapsedMs };
+
+  // ── Phased collection: cold → load → hot ──────────────────────────────
+  // Each phase runs a separate WASM probe.  On real hardware, sustained load
+  // increases thermal noise so Phase 3 (hot) entropy is measurably higher
+  // than Phase 1 (cold).  A VM's hypervisor clock is insensitive to guest
+  // thermal state, so all three phases return nearly identical entropy.
+  } else if (phased && iterations >= 60) {
+    const coldN = Math.floor(iterations * 0.25);  // ~25% cold
+    const loadN = Math.floor(iterations * 0.50);  // ~50% sustained load
+    const hotN  = iterations - coldN - loadN;     // ~25% hot
+
+    const cold = wasm.run_entropy_probe(coldN, matrixSize);
+    const load = wasm.run_entropy_probe(loadN, matrixSize);
+    const hot  = wasm.run_entropy_probe(hotN,  matrixSize);
+
+    const coldTimings = Array.from(cold.timings);
+    const loadTimings = Array.from(load.timings);
+    const hotTimings  = Array.from(hot.timings);
+
+    timings         = [...coldTimings, ...loadTimings, ...hotTimings];
+    resolutionProbe = Array.from(cold.resolution_probe);
+    checksum        = (cold.checksum + load.checksum + hot.checksum).toString();
+
+    const { detectQuantizationEntropy } = await Promise.resolve().then(function () { return jitter; });
+    const coldQE = detectQuantizationEntropy(coldTimings);
+    const hotQE  = detectQuantizationEntropy(hotTimings);
+
+    phases = {
+      cold: { n: coldN, timings: coldTimings, qe: coldQE, mean: _mean$1(coldTimings) },
+      load: { n: loadN, timings: loadTimings, qe: detectQuantizationEntropy(loadTimings), mean: _mean$1(loadTimings) },
+      hot:  { n: hotN,  timings: hotTimings,  qe: hotQE,  mean: _mean$1(hotTimings)  },
+      // The key signal: entropy growth under load.
+      // Real silicon: hotQE / coldQE typically 1.05 – 1.40
+      // VM:           hotQE / coldQE typically 0.95 – 1.05 (flat)
+      entropyJitterRatio: coldQE > 0 ? hotQE / coldQE : 1.0,
+    };
+  } else {
+    // Single-phase fallback (fewer iterations or phased disabled)
+    const result    = wasm.run_entropy_probe(iterations, matrixSize);
+    timings         = Array.from(result.timings);
+    resolutionProbe = Array.from(result.resolution_probe);
+    checksum        = result.checksum.toString();
+  }
+
+  // ── Timer resolution (non-adaptive path only — adaptive computes its own) ─
+  if (!adaptive) {
+    const resDeltas = [];
+    for (let i = 1; i < resolutionProbe.length; i++) {
+      const d = resolutionProbe[i] - resolutionProbe[i - 1];
+      if (d > 0) resDeltas.push(d);
+    }
+    timerGranularityMs = resDeltas.length
+      ? resDeltas.reduce((a, b) => Math.min(a, b), Infinity)
+      : null;
+  }
+
+  // ── Autocorrelation at diagnostic lags ────────────────────────────────
+  // Extended lags catch long-period steal-time rhythms (Xen: ~150 iters)
+  const lags = [1, 2, 3, 5, 10, 25, 50];
+  const autocorrelations = {};
+  for (const lag of lags) {
+    if (lag < timings.length) {
+      autocorrelations[`lag${lag}`] = wasm.compute_autocorrelation(timings, lag);
+    }
+  }
+
+  // ── Secondary probe: memory bandwidth jitter ───────────────────────────
+  const memTimings = Array.from(wasm.run_memory_probe(memSizeKb, memIterations));
+
+  return {
+    timings,
+    resolutionProbe,
+    timerGranularityMs,
+    autocorrelations,
+    memTimings,
+    phases,
+    checksum,
+    collectedAt: t_start,
+    iterations: timings.length,   // actual count (adaptive may differ from requested)
+    matrixSize,
+    adaptive: _adaptiveInfo,      // null in non-adaptive mode
+  };
+}
+
+function _mean$1(arr) {
+  return arr.length ? arr.reduce((s, v) => s + v, 0) / arr.length : 0;
+}
+
+/**
+ * @typedef {object} EntropyResult
+ * @property {number[]}  timings            - per-iteration wall-clock deltas (ms)
+ * @property {number[]}  resolutionProbe    - raw successive perf.now() readings
+ * @property {number|null} timerGranularityMs - effective timer resolution
+ * @property {object}    autocorrelations   - { lag1, lag2, lag3, lag5, lag10 }
+ * @property {number[]}  memTimings         - memory-probe timings (ms)
+ * @property {string}    checksum           - proof the computation ran
+ * @property {number}    collectedAt        - Date.now() at probe start
+ * @property {number}    iterations
+ * @property {number}    matrixSize
+ */
+
+/**
+ * @sovereign/pulse — Bio-Binding Layer
+ *
+ * Captures mouse-movement micro-stutters and keystroke-cadence dynamics
+ * WHILE the hardware entropy probe is running.  Computes the
+ * "Interference Coefficient": how much human input jitters hardware timing.
+ *
+ * PRIVACY NOTE: Only timing deltas are retained.  No key labels, no raw
+ * (x, y) coordinates, no content of any kind is stored or transmitted.
+ */
+
+// ---------------------------------------------------------------------------
+// Internal state
+// ---------------------------------------------------------------------------
+const MAX_EVENTS = 500; // rolling buffer cap
+
+// ---------------------------------------------------------------------------
+// BioCollector class
+// ---------------------------------------------------------------------------
+class BioCollector {
+  constructor() {
+    this._mouseEvents  = []; // { t: DOMHighResTimeStamp, dx, dy }
+    this._keyEvents    = []; // { t, type: 'down'|'up', dwell: ms|null }
+    this._lastKey      = {}; // keyCode → { downAt: t }
+    this._lastMouse    = null; // { t, x, y }
+    this._startTime    = null;
+    this._active       = false;
+
+    // Bound handlers (needed for removeEventListener)
+    this._onMouseMove  = this._onMouseMove.bind(this);
+    this._onKeyDown    = this._onKeyDown.bind(this);
+    this._onKeyUp      = this._onKeyUp.bind(this);
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+
+  start() {
+    if (this._active) return;
+    this._active    = true;
+    this._startTime = performance.now();
+
+    if (typeof window !== 'undefined') {
+      window.addEventListener('pointermove', this._onMouseMove, { passive: true });
+      window.addEventListener('keydown',     this._onKeyDown,   { passive: true });
+      window.addEventListener('keyup',       this._onKeyUp,     { passive: true });
+    }
+  }
+
+  stop() {
+    if (!this._active) return;
+    this._active = false;
+
+    if (typeof window !== 'undefined') {
+      window.removeEventListener('pointermove', this._onMouseMove);
+      window.removeEventListener('keydown',     this._onKeyDown);
+      window.removeEventListener('keyup',       this._onKeyUp);
+    }
+  }
+
+  // ── Event handlers ────────────────────────────────────────────────────────
+
+  _onMouseMove(e) {
+    if (!this._active) return;
+    const t   = e.timeStamp ?? performance.now();
+    const cur = { t, x: e.clientX, y: e.clientY };
+
+    if (this._lastMouse) {
+      const dt = t - this._lastMouse.t;
+      const dx = cur.x - this._lastMouse.x;
+      const dy = cur.y - this._lastMouse.y;
+      // Only store the delta, not absolute position (privacy)
+      if (this._mouseEvents.length < MAX_EVENTS) {
+        this._mouseEvents.push({ t, dt, dx, dy,
+          pressure: e.pressure ?? 0,
+          pointerType: e.pointerType ?? 'mouse' });
+      }
+    }
+    this._lastMouse = cur;
+  }
+
+  _onKeyDown(e) {
+    if (!this._active) return;
+    const t = e.timeStamp ?? performance.now();
+    // Store timestamp keyed by code (NOT key label)
+    this._lastKey[e.code] = { downAt: t };
+  }
+
+  _onKeyUp(e) {
+    if (!this._active) return;
+    const t   = e.timeStamp ?? performance.now();
+    const rec = this._lastKey[e.code];
+    const dwell = rec ? (t - rec.downAt) : null;
+    delete this._lastKey[e.code];
+
+    if (this._keyEvents.length < MAX_EVENTS) {
+      // Only dwell time; key identity NOT stored.
+      this._keyEvents.push({ t, dwell });
+    }
+  }
+
+  // ── snapshot ─────────────────────────────────────────────────────────────
+
+  /**
+   * Returns a privacy-preserving statistical snapshot of collected bio signals.
+   * Raw events are summarised; nothing identifiable is included in the output.
+   *
+   * @param {number[]} computationTimings  - entropy probe timing array
+   * @returns {BioSnapshot}
+   */
+  snapshot(computationTimings = []) {
+    const now = performance.now();
+    const durationMs = this._startTime != null ? (now - this._startTime) : 0;
+
+    // ── Mouse statistics ────────────────────────────────────────────────
+    const iei         = this._mouseEvents.map(e => e.dt);
+    const velocities  = this._mouseEvents.map(e =>
+      e.dt > 0 ? Math.hypot(e.dx, e.dy) / e.dt : 0
+    );
+    const pressure    = this._mouseEvents.map(e => e.pressure);
+    const angJerk     = _computeAngularJerk(this._mouseEvents);
+
+    const mouseStats = {
+      sampleCount:      iei.length,
+      ieiMean:          _mean(iei),
+      ieiCV:            _cv(iei),
+      velocityP50:      _percentile$1(velocities, 50),
+      velocityP95:      _percentile$1(velocities, 95),
+      angularJerkMean:  _mean(angJerk),
+      pressureVariance: _variance(pressure),
+    };
+
+    // ── Keyboard statistics ───────────────────────────────────────────────
+    const dwellTimes = this._keyEvents.filter(e => e.dwell != null).map(e => e.dwell);
+    const iki = [];
+    for (let i = 1; i < this._keyEvents.length; i++) {
+      iki.push(this._keyEvents[i].t - this._keyEvents[i - 1].t);
+    }
+
+    const keyStats = {
+      sampleCount:   dwellTimes.length,
+      dwellMean:     _mean(dwellTimes),
+      dwellCV:       _cv(dwellTimes),
+      ikiMean:       _mean(iki),
+      ikiCV:         _cv(iki),
+    };
+
+    // ── Interference Coefficient ──────────────────────────────────────────
+    // Cross-correlate input event density with computation timing deviations.
+    // A real human on real hardware creates measurable CPU-scheduling pressure
+    // that perturbs the entropy probe's timing.
+    const interferenceCoefficient = _computeInterference(
+      this._mouseEvents,
+      this._keyEvents,
+      computationTimings,
+    );
+
+    return {
+      mouse:                   mouseStats,
+      keyboard:                keyStats,
+      interferenceCoefficient,
+      durationMs,
+      hasActivity:             iei.length > 5 || dwellTimes.length > 2,
+    };
+  }
+}
+
+/**
+ * @typedef {object} BioSnapshot
+ * @property {object}  mouse
+ * @property {object}  keyboard
+ * @property {number}  interferenceCoefficient  – [−1, 1]; higher = more human
+ * @property {number}  durationMs
+ * @property {boolean} hasActivity
+ */
+
+// ---------------------------------------------------------------------------
+// Statistical helpers (private)
+// ---------------------------------------------------------------------------
+
+function _mean(arr) {
+  if (!arr.length) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+function _variance(arr) {
+  if (arr.length < 2) return 0;
+  const m = _mean(arr);
+  return arr.reduce((s, v) => s + (v - m) ** 2, 0) / (arr.length - 1);
+}
+
+function _cv(arr) {
+  if (!arr.length) return 0;
+  const m = _mean(arr);
+  if (m === 0) return 0;
+  return Math.sqrt(_variance(arr)) / Math.abs(m);
+}
+
+function _percentile$1(sorted, p) {
+  const arr = [...sorted].sort((a, b) => a - b);
+  if (!arr.length) return 0;
+  const idx = (p / 100) * (arr.length - 1);
+  const lo  = Math.floor(idx);
+  const hi  = Math.ceil(idx);
+  return arr[lo] + (arr[hi] - arr[lo]) * (idx - lo);
+}
+
+/** Angular jerk: second derivative of movement direction (radians / s²) */
+function _computeAngularJerk(events) {
+  if (events.length < 3) return [];
+  const angles = [];
+  for (let i = 0; i < events.length; i++) {
+    const { dx, dy } = events[i];
+    angles.push(Math.atan2(dy, dx));
+  }
+  const d1 = [];
+  for (let i = 1; i < angles.length; i++) {
+    const dt = events[i].dt || 1;
+    d1.push((angles[i] - angles[i - 1]) / dt);
+  }
+  const d2 = [];
+  for (let i = 1; i < d1.length; i++) {
+    const dt = events[i].dt || 1;
+    d2.push(Math.abs((d1[i] - d1[i - 1]) / dt));
+  }
+  return d2;
+}
+
+/**
+ * Interference Coefficient
+ *
+ * For each computation sample, check whether an input event occurred within
+ * ±16 ms (one animation frame).  Build two parallel series:
+ *   X[i] = 1 if input near sample i, else 0
+ *   Y[i] = deviation of timing[i] from mean timing
+ * Return the Pearson correlation between X and Y.
+ * A real human on real hardware produces positive correlation (input events
+ * cause measurable CPU scheduling perturbations).
+ */
+function _computeInterference(mouseEvents, keyEvents, timings) {
+  if (!timings.length) return 0;
+
+  const allInputTimes = [
+    ...mouseEvents.map(e => e.t),
+    ...keyEvents.map(e => e.t),
+  ].sort((a, b) => a - b);
+
+  if (!allInputTimes.length) return 0;
+
+  const WINDOW_MS = 16;
+  const meanTiming = _mean(timings);
+
+  // We need absolute timestamps for the probe samples.
+  // We don't have them directly – use relative index spacing as a proxy.
+  // The entropy probe runs for ~(mean * n) ms starting at collectedAt.
+  // This is a statistical approximation; the exact alignment improves
+  // when callers pass `collectedAt` from the entropy result.
+  // For now we distribute samples evenly across the collection window.
+  const first = allInputTimes[0];
+  const last  = allInputTimes[allInputTimes.length - 1];
+  const span  = Math.max(last - first, 1);
+
+  const X = timings.map((_, i) => {
+    const tSample = first + (i / timings.length) * span;
+    return allInputTimes.some(t => Math.abs(t - tSample) < WINDOW_MS) ? 1 : 0;
+  });
+
+  const Y = timings.map(t => t - meanTiming);
+
+  return _pearson(X, Y);
+}
+
+function _pearson(X, Y) {
+  const n   = X.length;
+  if (n < 2) return 0;
+  const mx  = _mean(X);
+  const my  = _mean(Y);
+  let num = 0, da = 0, db = 0;
+  for (let i = 0; i < n; i++) {
+    const a = X[i] - mx;
+    const b = Y[i] - my;
+    num += a * b;
+    da  += a * a;
+    db  += b * b;
+  }
+  const denom = Math.sqrt(da * db);
+  return denom < 1e-14 ? 0 : num / denom;
+}
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+/** Cast u8 / u16 / u32 to u8. */
+function u8(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** Conditionally byte swap if on a big-endian platform */
+const swap8IfBE = isLE
+    ? (n) => n
+    : (n) => byteSwap(n);
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+    return arr;
+}
+const swap32IfBE = isLE
+    ? (u) => u
+    : byteSwap32;
+// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
+const hasHexBuiltin = /* @__PURE__ */ (() => 
+// @ts-ignore
+typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
+// Array where index 0xf0 (240) is mapped to string 'f0'
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Convert byte array to hex string. Uses built-in function, when available.
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    abytes(bytes);
+    // @ts-ignore
+    if (hasHexBuiltin)
+        return bytes.toHex();
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/** For runtime check if class implements interface */
+class Hash {
+}
+function createXOFer(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+/**
+ * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+ * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+ */
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+    if (le)
+        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+
+/**
+ * Internal helpers for blake hash.
+ * @module
+ */
+// Mixing function G splitted in two halfs
+function G1s(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = rotr(d ^ a, 16);
+    c = (c + d) | 0;
+    b = rotr(b ^ c, 12);
+    return { a, b, c, d };
+}
+function G2s(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = rotr(d ^ a, 8);
+    c = (c + d) | 0;
+    b = rotr(b ^ c, 7);
+    return { a, b, c, d };
+}
+
+/**
+ * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+ * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+ * @module
+ */
+/** Class, from which others are subclassed. */
+class BLAKE2 extends Hash {
+    constructor(blockLen, outputLen) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        this.length = 0;
+        this.pos = 0;
+        anumber(blockLen);
+        anumber(outputLen);
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.buffer = new Uint8Array(blockLen);
+        this.buffer32 = u32(this.buffer);
+    }
+    update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        // Main difference with other hashes: there is flag for last block,
+        // so we cannot process current block before we know that there
+        // is the next one. This significantly complicates logic and reduces ability
+        // to do zero-copy processing
+        const { blockLen, buffer, buffer32 } = this;
+        const len = data.length;
+        const offset = data.byteOffset;
+        const buf = data.buffer;
+        for (let pos = 0; pos < len;) {
+            // If buffer is full and we still have input (don't process last block, same as blake2s)
+            if (this.pos === blockLen) {
+                swap32IfBE(buffer32);
+                this.compress(buffer32, 0, false);
+                swap32IfBE(buffer32);
+                this.pos = 0;
+            }
+            const take = Math.min(blockLen - this.pos, len - pos);
+            const dataOffset = offset + pos;
+            // full block && aligned to 4 bytes && not last in input
+            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                swap32IfBE(data32);
+                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                    this.length += blockLen;
+                    this.compress(data32, pos32, false);
+                }
+                swap32IfBE(data32);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            this.length += take;
+            pos += take;
+        }
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        const { pos, buffer32 } = this;
+        this.finished = true;
+        // Padding
+        clean(this.buffer.subarray(pos));
+        swap32IfBE(buffer32);
+        this.compress(buffer32, 0, true);
+        swap32IfBE(buffer32);
+        const out32 = u32(out);
+        this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        const { buffer, length, finished, destroyed, outputLen, pos } = this;
+        to || (to = new this.constructor({ dkLen: outputLen }));
+        to.set(...this.get());
+        to.buffer.set(buffer);
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        // @ts-ignore
+        to.outputLen = outputLen;
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+// prettier-ignore
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+    let j = 0;
+    for (let i = 0; i < rounds; i++) {
+        ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    }
+    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+
+/**
+ * Blake3 fast hash is Blake2 with reduced security (round count). Can also be used as MAC & KDF.
+ *
+ * It is advertised as "the fastest cryptographic hash". However, it isn't true in JS.
+ * Why is this so slow? While it should be 6x faster than blake2b, perf diff is only 20%:
+ *
+ * * There is only 30% reduction in number of rounds from blake2s
+ * * Speed-up comes from tree structure, which is parallelized using SIMD & threading.
+ *   These features are not present in JS, so we only get overhead from trees.
+ * * Parallelization only happens on 1024-byte chunks: there is no benefit for small inputs.
+ * * It is still possible to make it faster using: a) loop unrolling b) web workers c) wasm
+ * @module
+ */
+// Flag bitset
+const B3_Flags = {
+    CHUNK_START: 0b1,
+    CHUNK_END: 0b10,
+    PARENT: 0b100,
+    ROOT: 0b1000,
+    KEYED_HASH: 0b10000,
+    DERIVE_KEY_CONTEXT: 0b100000,
+    DERIVE_KEY_MATERIAL: 0b1000000,
+};
+const B3_IV = SHA256_IV.slice();
+const B3_SIGMA = /* @__PURE__ */ (() => {
+    const Id = Array.from({ length: 16 }, (_, i) => i);
+    const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+    const res = [];
+    for (let i = 0, v = Id; i < 7; i++, v = permute(v))
+        res.push(...v);
+    return Uint8Array.from(res);
+})();
+/** Blake3 hash. Can be used as MAC and KDF. */
+class BLAKE3 extends BLAKE2 {
+    constructor(opts = {}, flags = 0) {
+        super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+        this.chunkPos = 0; // Position of current block in chunk
+        this.chunksDone = 0; // How many chunks we already have
+        this.flags = 0 | 0;
+        this.stack = [];
+        // Output
+        this.posOut = 0;
+        this.bufferOut32 = new Uint32Array(16);
+        this.chunkOut = 0; // index of output chunk
+        this.enableXOF = true;
+        const { key, context } = opts;
+        const hasContext = context !== undefined;
+        if (key !== undefined) {
+            if (hasContext)
+                throw new Error('Only "key" or "context" can be specified at same time');
+            const k = toBytes(key).slice();
+            abytes(k, 32);
+            this.IV = u32(k);
+            swap32IfBE(this.IV);
+            this.flags = flags | B3_Flags.KEYED_HASH;
+        }
+        else if (hasContext) {
+            const ctx = toBytes(context);
+            const contextKey = new BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT)
+                .update(ctx)
+                .digest();
+            this.IV = u32(contextKey);
+            swap32IfBE(this.IV);
+            this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+        }
+        else {
+            this.IV = B3_IV.slice();
+            this.flags = flags;
+        }
+        this.state = this.IV.slice();
+        this.bufferOut = u8(this.bufferOut32);
+    }
+    // Unused
+    get() {
+        return [];
+    }
+    set() { }
+    b2Compress(counter, flags, buf, bufPos = 0) {
+        const { state: s, pos } = this;
+        const { h, l } = fromBig(BigInt(counter), true);
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
+        s[0] = v0 ^ v8;
+        s[1] = v1 ^ v9;
+        s[2] = v2 ^ v10;
+        s[3] = v3 ^ v11;
+        s[4] = v4 ^ v12;
+        s[5] = v5 ^ v13;
+        s[6] = v6 ^ v14;
+        s[7] = v7 ^ v15;
+    }
+    compress(buf, bufPos = 0, isLast = false) {
+        // Compress last block
+        let flags = this.flags;
+        if (!this.chunkPos)
+            flags |= B3_Flags.CHUNK_START;
+        if (this.chunkPos === 15 || isLast)
+            flags |= B3_Flags.CHUNK_END;
+        if (!isLast)
+            this.pos = this.blockLen;
+        this.b2Compress(this.chunksDone, flags, buf, bufPos);
+        this.chunkPos += 1;
+        // If current block is last in chunk (16 blocks), then compress chunks
+        if (this.chunkPos === 16 || isLast) {
+            let chunk = this.state;
+            this.state = this.IV.slice();
+            // If not the last one, compress only when there are trailing zeros in chunk counter
+            // chunks used as binary tree where current stack is path. Zero means current leaf is finished and can be compressed.
+            // 1 (001) - leaf not finished (just push current chunk to stack)
+            // 2 (010) - leaf finished at depth=1 (merge with last elm on stack and push back)
+            // 3 (011) - last leaf not finished
+            // 4 (100) - leafs finished at depth=1 and depth=2
+            for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+                if (!(last = this.stack.pop()))
+                    break;
+                this.buffer32.set(last, 0);
+                this.buffer32.set(chunk, 8);
+                this.pos = this.blockLen;
+                this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+                chunk = this.state;
+                this.state = this.IV.slice();
+            }
+            this.chunksDone++;
+            this.chunkPos = 0;
+            this.stack.push(chunk);
+        }
+        this.pos = 0;
+    }
+    _cloneInto(to) {
+        to = super._cloneInto(to);
+        const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+        to.state.set(state.slice());
+        to.stack = stack.map((i) => Uint32Array.from(i));
+        to.IV.set(IV);
+        to.flags = flags;
+        to.chunkPos = chunkPos;
+        to.chunksDone = chunksDone;
+        to.posOut = posOut;
+        to.chunkOut = chunkOut;
+        to.enableXOF = this.enableXOF;
+        to.bufferOut32.set(this.bufferOut32);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+        clean(...this.stack);
+    }
+    // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+    b2CompressOut() {
+        const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+        const { h, l } = fromBig(BigInt(this.chunkOut++));
+        swap32IfBE(buffer32);
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
+        out32[0] = v0 ^ v8;
+        out32[1] = v1 ^ v9;
+        out32[2] = v2 ^ v10;
+        out32[3] = v3 ^ v11;
+        out32[4] = v4 ^ v12;
+        out32[5] = v5 ^ v13;
+        out32[6] = v6 ^ v14;
+        out32[7] = v7 ^ v15;
+        out32[8] = s[0] ^ v8;
+        out32[9] = s[1] ^ v9;
+        out32[10] = s[2] ^ v10;
+        out32[11] = s[3] ^ v11;
+        out32[12] = s[4] ^ v12;
+        out32[13] = s[5] ^ v13;
+        out32[14] = s[6] ^ v14;
+        out32[15] = s[7] ^ v15;
+        swap32IfBE(buffer32);
+        swap32IfBE(out32);
+        this.posOut = 0;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        // Padding
+        clean(this.buffer.subarray(this.pos));
+        // Process last chunk
+        let flags = this.flags | B3_Flags.ROOT;
+        if (this.stack.length) {
+            flags |= B3_Flags.PARENT;
+            swap32IfBE(this.buffer32);
+            this.compress(this.buffer32, 0, true);
+            swap32IfBE(this.buffer32);
+            this.chunksDone = 0;
+            this.pos = this.blockLen;
+        }
+        else {
+            flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+        }
+        this.flags = flags;
+        this.b2CompressOut();
+    }
+    writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const { blockLen, bufferOut } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.b2CompressOut();
+            const take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    }
+    xofInto(out) {
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible after digest call');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.enableXOF = false;
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+}
+/**
+ * BLAKE3 hash function. Can be used as MAC and KDF.
+ * @param msg - message that would be hashed
+ * @param opts - `dkLen` for output length, `key` for MAC mode, `context` for KDF mode
+ * @example
+ * const data = new Uint8Array(32);
+ * const hash = blake3(data);
+ * const mac = blake3(data, { key: new Uint8Array(32) });
+ * const kdf = blake3(data, { context: 'application name' });
+ */
+const blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
+
+/**
+ * @sovereign/pulse — Hardware Fingerprint & Proof Builder
+ *
+ * Assembles all collected signals into a canonical ProofPayload, then
+ * produces a BLAKE3 commitment: BLAKE3(canonicalJSON(payload)).
+ *
+ * The commitment is what gets sent to the server.  The server recomputes
+ * the hash from the payload to detect tampering.  Raw timing arrays and
+ * pixel buffers are NOT included — only statistical summaries.
+ *
+ * Zero-Knowledge property: the server learns only that the device passes
+ * statistical thresholds.  It never sees raw hardware telemetry.
+ */
+
+
+// ---------------------------------------------------------------------------
+// BLAKE3 helpers (re-exported for use by canvas.js etc.)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute BLAKE3 of a Uint8Array and return hex string.
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function blake3Hex(data) {
+  return bytesToHex(blake3(data));
+}
+
+/**
+ * Compute BLAKE3 of a UTF-8 string and return hex string.
+ * @param {string} str
+ * @returns {string}
+ */
+function blake3HexStr(str) {
+  return blake3Hex(new TextEncoder().encode(str));
+}
+
+// ---------------------------------------------------------------------------
+// buildProof
+// ---------------------------------------------------------------------------
+
+/**
+ * Assembles a ProofPayload from all collected signals.
+ * This is the canonical structure that gets hashed into the commitment.
+ *
+ * @param {object} p
+ * @param {import('../collector/entropy.js').EntropyResult}  p.entropy
+ * @param {import('../analysis/jitter.js').JitterAnalysis}   p.jitter
+ * @param {import('../collector/bio.js').BioSnapshot}         p.bio
+ * @param {import('../collector/canvas.js').CanvasFingerprint} p.canvas
+ * @param {import('../analysis/audio.js').AudioJitter}         p.audio
+ * @param {string}  p.nonce    – server-issued challenge nonce (hex)
+ * @returns {ProofPayload}
+ */
+function buildProof({ entropy, jitter, bio, canvas, audio, nonce }) {
+  if (!nonce || typeof nonce !== 'string') {
+    throw new Error('@sovereign/pulse: nonce is required for anti-replay protection');
+  }
+
+  // Hash the raw timing arrays IN-BROWSER so we can prove their integrity
+  // without transmitting the raw data.
+  const timingsHash = blake3HexStr(JSON.stringify(entropy.timings));
+  const memHash     = blake3HexStr(JSON.stringify(entropy.memTimings));
+
+  const payload = {
+    version:   1,
+    timestamp: entropy.collectedAt,
+    nonce,
+
+    signals: {
+      // ── Entropy probe ───────────────────────────────────────────────────
+      entropy: {
+        timingsMean:          _round$1(jitter.stats?.mean,        4),
+        timingsCV:            _round$1(jitter.stats?.cv,          4),
+        timingsP50:           _round$1(jitter.stats?.p50,         4),
+        timingsP95:           _round$1(jitter.stats?.p95,         4),
+        timingsSkewness:      _round$1(jitter.stats?.skewness,    4),
+        timingsKurtosis:      _round$1(jitter.stats?.kurtosis,    4),
+        autocorr_lag1:        _round$1(jitter.autocorrelations?.lag1, 4),
+        autocorr_lag2:        _round$1(jitter.autocorrelations?.lag2, 4),
+        autocorr_lag5:        _round$1(jitter.autocorrelations?.lag5, 4),
+        autocorr_lag10:       _round$1(jitter.autocorrelations?.lag10, 4),
+        hurstExponent:        _round$1(jitter.hurstExponent,      4),
+        quantizationEntropy:  _round$1(jitter.quantizationEntropy, 4),
+        thermalDrift:         _round$1(jitter.thermalSignature?.slope, 8),
+        thermalPattern:       jitter.thermalSignature?.pattern ?? 'unknown',
+        outlierRate:          _round$1(jitter.outlierRate,        4),
+        timerGranularityMs:   _round$1(entropy.timerGranularityMs, 6),
+        checksum:             entropy.checksum, // proves computation ran
+        timingsHash,          // proves timing array integrity
+        memTimingsHash:       memHash,
+        iterations:           entropy.iterations,
+        matrixSize:           entropy.matrixSize,
+      },
+
+      // ── Bio signals ─────────────────────────────────────────────────────
+      bio: {
+        mouseSampleCount:     bio.mouse.sampleCount,
+        mouseIEIMean:         _round$1(bio.mouse.ieiMean,         3),
+        mouseIEICV:           _round$1(bio.mouse.ieiCV,           4),
+        mouseVelocityP50:     _round$1(bio.mouse.velocityP50,     3),
+        mouseVelocityP95:     _round$1(bio.mouse.velocityP95,     3),
+        mouseAngularJerkMean: _round$1(bio.mouse.angularJerkMean, 4),
+        pressureVariance:     _round$1(bio.mouse.pressureVariance, 6),
+        keyboardSampleCount:  bio.keyboard.sampleCount,
+        keyboardDwellMean:    _round$1(bio.keyboard.dwellMean,    3),
+        keyboardDwellCV:      _round$1(bio.keyboard.dwellCV,      4),
+        keyboardIKIMean:      _round$1(bio.keyboard.ikiMean,      3),
+        keyboardIKICV:        _round$1(bio.keyboard.ikiCV,        4),
+        interferenceCoefficient: _round$1(bio.interferenceCoefficient, 4),
+        hasActivity:          bio.hasActivity,
+        durationMs:           _round$1(bio.durationMs,            1),
+      },
+
+      // ── Canvas fingerprint ───────────────────────────────────────────────
+      canvas: {
+        webglRenderer:        canvas.webglRenderer,
+        webglVendor:          canvas.webglVendor,
+        webglVersion:         canvas.webglVersion,
+        webglPixelHash:       canvas.webglPixelHash,
+        canvas2dHash:         canvas.canvas2dHash,
+        extensionCount:       canvas.extensionCount,
+        isSoftwareRenderer:   canvas.isSoftwareRenderer,
+        available:            canvas.available,
+      },
+
+      // ── Audio jitter ─────────────────────────────────────────────────────
+      audio: {
+        available:            audio.available,
+        workletAvailable:     audio.workletAvailable,
+        callbackJitterCV:     _round$1(audio.callbackJitterCV,    4),
+        noiseFloorMean:       _round$1(audio.noiseFloorMean,      6),
+        noiseFloorStd:        _round$1(audio.noiseFloorStd,       6),
+        sampleRate:           audio.sampleRate,
+        callbackCount:        audio.callbackCount,
+        jitterMeanMs:         _round$1(audio.jitterMeanMs,        4),
+        jitterP95Ms:          _round$1(audio.jitterP95Ms,         4),
+      },
+    },
+
+    // Top-level classification summary
+    classification: {
+      jitterScore:  _round$1(jitter.score, 4),
+      flags:        jitter.flags ?? [],
+    },
+  };
+
+  return payload;
+}
+
+/**
+ * @typedef {object} ProofPayload
+ * @property {number}  version
+ * @property {number}  timestamp
+ * @property {string}  nonce
+ * @property {object}  signals
+ * @property {object}  classification
+ */
+
+// ---------------------------------------------------------------------------
+// buildCommitment
+// ---------------------------------------------------------------------------
+
+/**
+ * Hashes a ProofPayload into a BLAKE3 commitment.
+ * Uses a deterministic canonical JSON serialiser (sorted keys) to ensure
+ * byte-identical output across JS engines.
+ *
+ * @param {ProofPayload} payload
+ * @returns {{ payload: ProofPayload, hash: string }}
+ */
+function buildCommitment(payload) {
+  const canonical = canonicalJson(payload);
+  const hash      = blake3HexStr(canonical);
+  return { payload, hash };
+}
+
+// ---------------------------------------------------------------------------
+// canonicalJson
+//
+// JSON.stringify with sorted keys — ensures the hash is engine-independent.
+// Numbers are serialised with fixed precision to avoid cross-platform float
+// formatting differences.
+// ---------------------------------------------------------------------------
+
+function canonicalJson(obj) {
+  return JSON.stringify(obj, _replacer, 0);
+}
+
+function _replacer(key, value) {
+  // Sort object keys deterministically
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    const sorted = {};
+    for (const k of Object.keys(value).sort()) {
+      sorted[k] = value[k];
+    }
+    return sorted;
+  }
+  return value;
+}
+
+// ---------------------------------------------------------------------------
+// Internal utilities
+// ---------------------------------------------------------------------------
+
+function _round$1(v, decimals) {
+  if (v == null || !isFinite(v)) return null;
+  const factor = 10 ** decimals;
+  return Math.round(v * factor) / factor;
+}
+
+/**
+ * @sovereign/pulse — GPU Canvas Fingerprint
+ *
+ * Collects device-class signals from WebGL and 2D Canvas rendering.
+ * The exact pixel values of GPU-rendered scenes are vendor/driver-specific
+ * due to floating-point rounding in shader execution.  Virtual machines
+ * expose software renderers (LLVMpipe, SwiftShader, Microsoft Basic Render
+ * Driver) whose strings and output pixels are well-known and enumerable.
+ *
+ * NO persistent identifier is generated – only a content hash is retained.
+ */
+
+
+// ---------------------------------------------------------------------------
+// Known software-renderer substrings (VM / headless environment indicators)
+// ---------------------------------------------------------------------------
+const SOFTWARE_RENDERER_PATTERNS = [
+  'llvmpipe', 'swiftshader', 'softpipe', 'mesa offscreen',
+  'microsoft basic render', 'vmware svga', 'virtualbox',
+  'parallels', 'angle (', 'google swiftshader',
+];
+
+// ---------------------------------------------------------------------------
+// collectCanvasFingerprint
+// ---------------------------------------------------------------------------
+
+/**
+ * @returns {Promise<CanvasFingerprint>}
+ */
+async function collectCanvasFingerprint() {
+  const result = {
+    webglRenderer:      null,
+    webglVendor:        null,
+    webglVersion:       null,
+    webglPixelHash:     null,
+    canvas2dHash:       null,
+    extensionCount:     0,
+    extensions:         [],
+    isSoftwareRenderer: false,
+    available:          false,
+  };
+
+  if (typeof document === 'undefined' && typeof OffscreenCanvas === 'undefined') {
+    // Node.js / server-side with no DOM – skip gracefully.
+    return result;
+  }
+
+  // ── WebGL fingerprint ────────────────────────────────────────────────────
+  try {
+    const canvas = _createCanvas(512, 512);
+    let   gl     = canvas.getContext('webgl2') || canvas.getContext('webgl');
+
+    if (gl) {
+      result.webglVersion = gl instanceof WebGL2RenderingContext ? 2 : 1;
+      result.available    = true;
+
+      // Renderer info
+      const dbgInfo = gl.getExtension('WEBGL_debug_renderer_info');
+      if (dbgInfo) {
+        result.webglRenderer = gl.getParameter(dbgInfo.UNMASKED_RENDERER_WEBGL);
+        result.webglVendor   = gl.getParameter(dbgInfo.UNMASKED_VENDOR_WEBGL);
+      }
+
+      // Extension list (fingerprints driver capabilities)
+      const exts = gl.getSupportedExtensions() ?? [];
+      result.extensions    = exts;
+      result.extensionCount = exts.length;
+
+      // Software-renderer detection
+      const rendererLc = (result.webglRenderer ?? '').toLowerCase();
+      result.isSoftwareRenderer = SOFTWARE_RENDERER_PATTERNS.some(p =>
+        rendererLc.includes(p)
+      );
+
+      // ── Render a Mandelbrot fragment scene ───────────────────────────────
+      // Floating-point precision differences in the GPU's shader ALU cause
+      // per-pixel rounding variations that are stable per device but differ
+      // across GPU vendors, driver versions, and software renderers.
+      const pixels = _renderMandelbrot(gl, canvas);
+      result.webglPixelHash = pixels ? blake3Hex(pixels) : null;
+
+      gl.getExtension('WEBGL_lose_context')?.loseContext();
+    }
+  } catch (_) {
+    // WebGL blocked (privacy settings, etc.) – continue with 2D canvas.
+  }
+
+  // ── 2D Canvas fingerprint ────────────────────────────────────────────────
+  try {
+    const c2   = _createCanvas(200, 50);
+    const ctx2 = c2.getContext('2d');
+
+    if (ctx2) {
+      // Text rendering differences: font hinting, subpixel AA, emoji rasterisation
+      ctx2.textBaseline = 'top';
+      ctx2.font         = '14px Arial, sans-serif';
+      ctx2.fillStyle    = 'rgba(102,204,0,0.7)';
+      ctx2.fillText('Cwm fjordbank glyphs vext quiz 🎯', 2, 5);
+
+      // Shadow compositing (driver-specific blur kernel)
+      ctx2.shadowBlur   = 10;
+      ctx2.shadowColor  = 'blue';
+      ctx2.fillStyle    = 'rgba(255,0,255,0.5)';
+      ctx2.fillRect(100, 25, 80, 20);
+
+      // Bezier curve (Bézier precision varies per 2D canvas implementation)
+      ctx2.beginPath();
+      ctx2.moveTo(10, 40);
+      ctx2.bezierCurveTo(30, 0, 70, 80, 160, 30);
+      ctx2.strokeStyle = 'rgba(0,0,255,0.8)';
+      ctx2.lineWidth   = 1.5;
+      ctx2.stroke();
+
+      const dataUrl = c2.toDataURL('image/png');
+      // Hash the data URL (not storing raw image data)
+      const enc = new TextEncoder().encode(dataUrl);
+      result.canvas2dHash = blake3Hex(enc);
+
+      result.available = true;
+    }
+  } catch (_) {
+    // 2D canvas blocked.
+  }
+
+  return result;
+}
+
+/**
+ * @typedef {object} CanvasFingerprint
+ * @property {string|null}  webglRenderer
+ * @property {string|null}  webglVendor
+ * @property {1|2|null}     webglVersion
+ * @property {string|null}  webglPixelHash
+ * @property {string|null}  canvas2dHash
+ * @property {number}       extensionCount
+ * @property {string[]}     extensions
+ * @property {boolean}      isSoftwareRenderer
+ * @property {boolean}      available
+ */
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _createCanvas(w, h) {
+  if (typeof OffscreenCanvas !== 'undefined') {
+    return new OffscreenCanvas(w, h);
+  }
+  const c = document.createElement('canvas');
+  c.width  = w;
+  c.height = h;
+  return c;
+}
+
+/**
+ * Render a Mandelbrot set fragment using WebGL and read back pixels.
+ * The number of iterations is fixed (100) so that rounding differences in
+ * the smooth-colouring formula are the primary source of per-GPU variation.
+ *
+ * @param {WebGLRenderingContext} gl
+ * @param {HTMLCanvasElement|OffscreenCanvas} canvas
+ * @returns {Uint8Array|null}
+ */
+function _renderMandelbrot(gl, canvas) {
+  const W = canvas.width;
+  const H = canvas.height;
+
+  // Vertex shader – full-screen quad
+  const vsSource = `
+    attribute vec4 a_pos;
+    void main() { gl_Position = a_pos; }
+  `;
+
+  // Fragment shader – Mandelbrot with smooth colouring
+  // Floating-point precision in the escape-radius and log() calls differs
+  // between GPU vendors / drivers, producing per-device pixel signatures.
+  const fsSource = `
+    precision highp float;
+    uniform vec2 u_res;
+    void main() {
+      vec2 uv  = (gl_FragCoord.xy / u_res - 0.5) * 3.5;
+      uv.x    -= 0.5;
+      vec2 c   = uv;
+      vec2 z   = vec2(0.0);
+      float n  = 0.0;
+      for (int i = 0; i < 100; i++) {
+        if (dot(z, z) > 4.0) break;
+        z = vec2(z.x*z.x - z.y*z.y, 2.0*z.x*z.y) + c;
+        n += 1.0;
+      }
+      float smooth_n = n - log2(log2(dot(z,z))) + 4.0;
+      float t = smooth_n / 100.0;
+      gl_FragColor = vec4(0.5 + 0.5*cos(6.28318*t + vec3(0.0, 0.4, 0.7)), 1.0);
+    }
+  `;
+
+  const vs = _compileShader(gl, gl.VERTEX_SHADER,   vsSource);
+  const fs = _compileShader(gl, gl.FRAGMENT_SHADER, fsSource);
+  if (!vs || !fs) return null;
+
+  const prog = gl.createProgram();
+  gl.attachShader(prog, vs);
+  gl.attachShader(prog, fs);
+  gl.linkProgram(prog);
+  if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) return null;
+
+  gl.useProgram(prog);
+
+  // Full-screen quad
+  const buf = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+  gl.bufferData(gl.ARRAY_BUFFER,
+    new Float32Array([-1,-1, 1,-1, -1,1, 1,1]), gl.STATIC_DRAW);
+  const loc = gl.getAttribLocation(prog, 'a_pos');
+  gl.enableVertexAttribArray(loc);
+  gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);
+
+  const resLoc = gl.getUniformLocation(prog, 'u_res');
+  gl.uniform2f(resLoc, W, H);
+
+  gl.viewport(0, 0, W, H);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  // Read back a 64×64 centre crop (reduces data without losing discriminating power)
+  const x0 = Math.floor((W - 64) / 2);
+  const y0 = Math.floor((H - 64) / 2);
+  const pixels = new Uint8Array(64 * 64 * 4);
+  gl.readPixels(x0, y0, 64, 64, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+
+  return pixels;
+}
+
+function _compileShader(gl, type, source) {
+  const s = gl.createShader(type);
+  gl.shaderSource(s, source);
+  gl.compileShader(s);
+  return gl.getShaderParameter(s, gl.COMPILE_STATUS) ? s : null;
+}
+
+/**
+ * @sovereign/pulse — AudioContext Oscillator Jitter
+ *
+ * Measures the scheduling jitter of the browser's audio pipeline.
+ * Real audio hardware callbacks are driven by a hardware interrupt (IRQ)
+ * from the sound card; the timing reflects the actual interrupt latency
+ * of the physical device.  VM audio drivers (if present at all) are
+ * emulated and show either unrealistically low jitter or burst-mode
+ * scheduling artefacts that are statistically distinguishable.
+ */
+
+/**
+ * @param {object} [opts]
+ * @param {number} [opts.durationMs=2000]  - how long to collect audio callbacks
+ * @param {number} [opts.bufferSize=256]   - ScriptProcessorNode buffer size
+ * @returns {Promise<AudioJitter>}
+ */
+async function collectAudioJitter(opts = {}) {
+  const { durationMs = 2000, bufferSize = 256 } = opts;
+
+  const base = {
+    available:         false,
+    workletAvailable:  false,
+    callbackJitterCV:  0,
+    noiseFloorMean:    0,
+    sampleRate:        0,
+    callbackCount:     0,
+    jitterTimings:     [],
+  };
+
+  if (typeof AudioContext === 'undefined' && typeof webkitAudioContext === 'undefined') {
+    return base; // Node.js / server environment
+  }
+
+  let ctx;
+  try {
+    ctx = new (window.AudioContext || window.webkitAudioContext)();
+  } catch (_) {
+    return base;
+  }
+
+  // Some browsers require a user gesture before AudioContext can run.
+  if (ctx.state === 'suspended') {
+    try {
+      await ctx.resume();
+    } catch (_) {
+      await ctx.close().catch(() => {});
+      return base;
+    }
+  }
+
+  const sampleRate       = ctx.sampleRate;
+  const expectedInterval = (bufferSize / sampleRate) * 1000; // ms per callback
+
+  const jitterTimings = []; // absolute AudioContext.currentTime at each callback
+  const callbackDeltas = [];
+
+  await new Promise((resolve) => {
+    // ── AudioWorklet (preferred — runs on dedicated real-time thread) ──────
+    const useWorklet = typeof AudioWorkletNode !== 'undefined';
+    base.workletAvailable = useWorklet;
+
+    if (useWorklet) {
+      // Inline worklet: send currentTime back via MessagePort every buffer
+      const workletCode = `
+        class PulseProbe extends AudioWorkletProcessor {
+          process(inputs, outputs) {
+            this.port.postMessage({ t: currentTime });
+            // Pass-through silence
+            for (const out of outputs)
+              for (const ch of out) ch.fill(0);
+            return true;
+          }
+        }
+        registerProcessor('pulse-probe', PulseProbe);
+      `;
+      const blob    = new Blob([workletCode], { type: 'application/javascript' });
+      const blobUrl = URL.createObjectURL(blob);
+
+      ctx.audioWorklet.addModule(blobUrl).then(() => {
+        const node = new AudioWorkletNode(ctx, 'pulse-probe');
+        node.port.onmessage = (e) => {
+          jitterTimings.push(e.data.t * 1000); // convert to ms
+        };
+        node.connect(ctx.destination);
+
+        setTimeout(async () => {
+          node.disconnect();
+          URL.revokeObjectURL(blobUrl);
+          resolve(node);
+        }, durationMs);
+      }).catch(() => {
+        URL.revokeObjectURL(blobUrl);
+        _fallbackScriptProcessor(ctx, bufferSize, durationMs, jitterTimings, resolve);
+      });
+
+    } else {
+      _fallbackScriptProcessor(ctx, bufferSize, durationMs, jitterTimings, resolve);
+    }
+  });
+
+  // ── Compute deltas between successive callback times ────────────────────
+  for (let i = 1; i < jitterTimings.length; i++) {
+    callbackDeltas.push(jitterTimings[i] - jitterTimings[i - 1]);
+  }
+
+  // ── Noise floor via AnalyserNode ─────────────────────────────────────────
+  // Feed a silent oscillator through an analyser; the FFT magnitude at silence
+  // reveals the hardware's thermal noise floor (varies per ADC/DAC chipset).
+  const noiseFloor = await _measureNoiseFloor(ctx);
+
+  await ctx.close().catch(() => {});
+
+  // ── Statistics ────────────────────────────────────────────────────────────
+  const mean = callbackDeltas.length
+    ? callbackDeltas.reduce((s, v) => s + v, 0) / callbackDeltas.length
+    : 0;
+  const variance = callbackDeltas.length > 1
+    ? callbackDeltas.reduce((s, v) => s + (v - mean) ** 2, 0) / (callbackDeltas.length - 1)
+    : 0;
+  const jitterCV = mean > 0 ? Math.sqrt(variance) / mean : 0;
+
+  return {
+    available:         true,
+    workletAvailable:  base.workletAvailable,
+    callbackJitterCV:  jitterCV,
+    noiseFloorMean:    noiseFloor.mean,
+    noiseFloorStd:     noiseFloor.std,
+    sampleRate,
+    callbackCount:     jitterTimings.length,
+    expectedIntervalMs: expectedInterval,
+    // Only include summary stats, not raw timings (privacy / size)
+    jitterMeanMs:      mean,
+    jitterP95Ms:       _percentile(callbackDeltas, 95),
+  };
+}
+
+/**
+ * @typedef {object} AudioJitter
+ * @property {boolean} available
+ * @property {boolean} workletAvailable
+ * @property {number}  callbackJitterCV
+ * @property {number}  noiseFloorMean
+ * @property {number}  sampleRate
+ * @property {number}  callbackCount
+ */
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _fallbackScriptProcessor(ctx, bufferSize, durationMs, jitterTimings, resolve) {
+  // ScriptProcessorNode is deprecated but universally supported.
+  const proc = ctx.createScriptProcessor(bufferSize, 1, 1);
+  proc.onaudioprocess = () => {
+    jitterTimings.push(ctx.currentTime * 1000);
+  };
+  // Connect to keep the graph alive
+  const osc = ctx.createOscillator();
+  osc.frequency.value = 1; // sub-audible
+  osc.connect(proc);
+  proc.connect(ctx.destination);
+  osc.start();
+
+  setTimeout(() => {
+    osc.stop();
+    osc.disconnect();
+    proc.disconnect();
+    resolve(proc);
+  }, durationMs);
+}
+
+async function _measureNoiseFloor(ctx) {
+  try {
+    const analyser = ctx.createAnalyser();
+    analyser.fftSize = 256;
+    analyser.connect(ctx.destination);
+
+    // Silent source
+    const buf  = ctx.createBuffer(1, ctx.sampleRate * 0.1, ctx.sampleRate);
+    const src  = ctx.createBufferSource();
+    src.buffer = buf;
+    src.connect(analyser);
+    src.start();
+
+    await new Promise(r => setTimeout(r, 150));
+
+    const data = new Float32Array(analyser.frequencyBinCount);
+    analyser.getFloatFrequencyData(data);
+    analyser.disconnect();
+
+    // Limit to 32 bins to keep the payload small
+    const trimmed = Array.from(data.slice(0, 32)).map(v =>
+      isFinite(v) ? Math.pow(10, v / 20) : 0 // dB → linear
+    );
+    const mean = trimmed.reduce((s, v) => s + v, 0) / trimmed.length;
+    const std  = Math.sqrt(
+      trimmed.reduce((s, v) => s + (v - mean) ** 2, 0) / trimmed.length
+    );
+    return { mean, std };
+  } catch (_) {
+    return { mean: 0, std: 0 };
+  }
+}
+
+function _percentile(arr, p) {
+  if (!arr.length) return 0;
+  const sorted = [...arr].sort((a, b) => a - b);
+  const idx    = (p / 100) * (sorted.length - 1);
+  const lo     = Math.floor(idx);
+  const hi     = Math.ceil(idx);
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (idx - lo);
+}
+
+/**
+ * @sovereign/pulse — Cross-Metric Heuristic Engine
+ *
+ * Instead of checking individual thresholds in isolation, this module looks
+ * at the *relationships* between metrics. A sophisticated adversary can spoof
+ * any single number.  Spoofing six metrics so they remain mutually consistent
+ * with physical laws is exponentially harder.
+ *
+ * Three core insights drive this engine:
+ *
+ *   1. Entropy-Jitter Coherence
+ *      Real silicon gets noisier as it heats up. Under sustained load, the
+ *      Quantization Entropy of the timing distribution grows because thermal
+ *      fluctuations add variance. A VM's hypervisor clock doesn't care about
+ *      guest temperature — its entropy is flat across all load phases.
+ *
+ *   2. Hurst-Autocorrelation Coherence
+ *      Genuine Brownian noise has Hurst ≈ 0.5 and near-zero autocorrelation
+ *      at all lags. These two values are physically linked. If they diverge —
+ *      high autocorrelation but Hurst near 0.5, or vice versa — the timings
+ *      were generated, not measured.
+ *
+ *   3. CV-Entropy Coherence
+ *      High variance (CV) must come from somewhere. On real hardware, high CV
+ *      means the timing distribution is spread out, which also means high
+ *      entropy. A VM that inflates CV without inflating entropy (e.g. by
+ *      adding synthetic outliers at fixed offsets) produces a coherence gap.
+ */
+
+
+// ---------------------------------------------------------------------------
+// runHeuristicEngine
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {object} p
+ * @param {import('./jitter.js').JitterAnalysis}  p.jitter
+ * @param {object|null}                           p.phases  - from entropy collector
+ * @param {object}                                p.autocorrelations
+ * @returns {HeuristicReport}
+ */
+function runHeuristicEngine({ jitter, phases, autocorrelations }) {
+  const findings = [];
+  const bonuses  = [];
+  let   penalty  = 0;  // accumulated penalty [0, 1]
+  let   bonus    = 0;  // accumulated bonus   [0, 1]
+  let   hardOverride = null;  // 'vm' | null — bypasses score entirely when set
+
+  const stats = jitter.stats;
+  if (!stats) return _empty$1();
+
+  // ── 1. Entropy-Jitter Ratio (phases required) ────────────────────────────
+  let entropyJitterRatio  = null;
+  let entropyJitterScore  = 0.5; // neutral if no phased data
+
+  if (phases) {
+    entropyJitterRatio = phases.entropyJitterRatio;
+
+    const coldQE = phases.cold?.qe ?? null;
+    const hotQE  = phases.hot?.qe  ?? null;
+
+    // ── HARD KILL: Phase trajectory mathematical contradiction ──────────────
+    //
+    // EJR is defined as:  entropyJitterRatio = hot_QE / cold_QE
+    //
+    // Before trusting any EJR value, verify it is internally consistent with
+    // the QE measurements it purports to summarise. Two forgery vectors exist:
+    //
+    //   Attack A — EJR field overwritten independently:
+    //     Attacker sets entropyJitterRatio = 1.15 to claim thermal growth,
+    //     but leaves cold_QE = 3.50, hot_QE = 3.00 unchanged.
+    //     Computed EJR = 3.00 / 3.50 = 0.857.
+    //     Discrepancy 1.15 − 0.857 = 0.293 >> 0.005 tolerance → HARD KILL.
+    //
+    //   Attack B — QE values also faked but left inconsistent:
+    //     Attacker overwrites both QE fields carelessly: cold_QE = 3.5,
+    //     hot_QE = 3.0, but EJR = 1.15 is still written.
+    //     cold_QE ≥ hot_QE with EJR ≥ 1.08 is a mathematical impossibility —
+    //     if hot ≤ cold then hot/cold ≤ 1.0, which can never be ≥ 1.08.
+    //
+    // Tolerance of 0.005 accounts for floating-point rounding in the entropy
+    // collector (detectQuantizationEntropy uses discrete histogram bins).
+    //
+    // When HARD KILL fires:
+    //   • hardOverride = 'vm' — fingerprint.js short-circuits isSynthetic
+    //   • entropyJitterScore = 0.0 — no EJR contribution to stage-2 bonus
+    //   • penalty += 1.0 — overwhelms the physical floor cap
+    //   • No further EJR evaluation runs (the data cannot be trusted)
+    //   • The physical floor protection is explicitly bypassed (see aggregate)
+
+    if (coldQE !== null && hotQE !== null) {
+      const computedEJR    = coldQE > 0 ? hotQE / coldQE : null;
+      const fieldTampered  = computedEJR !== null &&
+                             Math.abs(entropyJitterRatio - computedEJR) > 0.005;
+      const qeContradicts  = entropyJitterRatio >= 1.08 && coldQE >= hotQE;
+
+      if (fieldTampered || qeContradicts) {
+        hardOverride       = 'vm';
+        entropyJitterScore = 0.0;
+        findings.push({
+          id:       'EJR_PHASE_HARD_KILL',
+          label:    fieldTampered
+            ? 'HARD KILL: stored EJR is inconsistent with cold/hot QE values — phase data tampered'
+            : 'HARD KILL: EJR ≥ 1.08 claims entropy growth but cold_QE ≥ hot_QE — physically impossible',
+          detail:   `ejr_stored=${entropyJitterRatio.toFixed(4)}  ` +
+                    `ejr_computed=${computedEJR?.toFixed(4) ?? 'n/a'}  ` +
+                    `cold_QE=${coldQE.toFixed(4)}  hot_QE=${hotQE.toFixed(4)}  ` +
+                    `delta=${computedEJR != null ? Math.abs(entropyJitterRatio - computedEJR).toFixed(4) : 'n/a'}`,
+          severity: 'critical',
+          penalty:  1.0,
+        });
+        penalty += 1.0;
+
+      } else {
+        // QE values confirmed consistent — proceed with normal EJR evaluation.
+        _evaluateEJR(entropyJitterRatio, coldQE, hotQE, findings, bonuses,
+                     (p) => { penalty += p; }, (b) => { bonus += b; },
+                     (s) => { entropyJitterScore = s; });
+      }
+
+    } else {
+      // QE values unavailable — evaluate EJR ratio in isolation.
+      _evaluateEJR(entropyJitterRatio, null, null, findings, bonuses,
+                   (p) => { penalty += p; }, (b) => { bonus += b; },
+                   (s) => { entropyJitterScore = s; });
+    }
+
+    // Phase mean drift: real CPU heats up → iterations get slower.
+    // Only apply if hard kill wasn't already triggered.
+    if (!hardOverride) {
+      const coldToHotDrift = (phases.hot?.mean ?? 0) - (phases.cold?.mean ?? 0);
+      if (coldToHotDrift > 0.05) {
+        bonuses.push({
+          id:    'THERMAL_DRIFT_CONFIRMED',
+          label: 'CPU mean timing increased from cold to hot phase (thermal drift)',
+          detail: `cold=${phases.cold.mean.toFixed(3)}ms  hot=${phases.hot.mean.toFixed(3)}ms  Δ=${coldToHotDrift.toFixed(3)}ms`,
+          value:  0.08,
+        });
+        bonus += 0.08;
+      }
+    }
+  }
+
+  // ── 2. Hurst-Autocorrelation Coherence ───────────────────────────────────
+  const h    = jitter.hurstExponent ?? 0.5;
+  const ac1  = Math.abs(autocorrelations?.lag1  ?? 0);
+  const ac5  = Math.abs(autocorrelations?.lag5  ?? 0);
+  Math.abs(autocorrelations?.lag50 ?? 0);
+
+  // Physical law: Brownian noise (H≈0.5) must have low autocorrelation.
+  // Divergence between these two means the data wasn't generated by physics.
+  const hurstExpectedAC = Math.abs(2 * h - 1); // theoretical max |autocorr| for given H
+  const actualAC        = (ac1 + ac5) / 2;
+  const acHurstDivergence = Math.abs(actualAC - hurstExpectedAC);
+
+  if (acHurstDivergence > 0.35) {
+    findings.push({
+      id:      'HURST_AUTOCORR_INCOHERENT',
+      label:   'Hurst exponent and autocorrelation are physically inconsistent',
+      detail:  `H=${h.toFixed(3)}  expected_AC≈${hurstExpectedAC.toFixed(3)}  actual_AC=${actualAC.toFixed(3)}  divergence=${acHurstDivergence.toFixed(3)}`,
+      severity: 'high',
+      penalty:  0.12,
+    });
+    penalty += 0.12;
+  } else if (h > 0.45 && h < 0.55 && ac1 < 0.15) {
+    // Ideal Brownian + low autocorr — physically coherent
+    bonuses.push({
+      id:    'BROWNIAN_COHERENCE_CONFIRMED',
+      label: 'Hurst ≈ 0.5 and autocorrelation near zero — genuine Brownian noise',
+      detail: `H=${h.toFixed(3)}  lag1_AC=${ac1.toFixed(3)}`,
+      value:  0.10,
+    });
+    bonus += 0.10;
+  }
+
+  // ── 3. CV-Entropy Coherence ───────────────────────────────────────────────
+  // High CV should correlate with high QE. If CV is high but QE is low,
+  // the variance was added artificially (fixed-offset outliers, synthetic spikes).
+  const cv = stats.cv;
+  const qe = jitter.quantizationEntropy;
+
+  // Expected QE given CV, assuming roughly normal distribution
+  // Normal dist with σ/μ = CV: entropy ≈ log2(σ * sqrt(2πe)) + log2(n/binWidth)
+  // We use a simplified linear proxy calibrated against real benchmarks.
+  const expectedQE = Math.max(0, 1.5 + cv * 16);  // empirical: CV=0.15 → QE≈3.9
+  const qeDivergence = expectedQE - qe;            // positive = QE lower than expected
+
+  if (qeDivergence > 1.8 && cv > 0.05) {
+    // High variance but low entropy: synthetic outliers at fixed offsets
+    findings.push({
+      id:      'CV_ENTROPY_INCOHERENT',
+      label:   'High CV but low entropy — variance appears synthetic (fixed-offset outliers)',
+      detail:  `CV=${cv.toFixed(4)}  QE=${qe.toFixed(3)} bits  expected_QE≈${expectedQE.toFixed(3)}  gap=${qeDivergence.toFixed(3)}`,
+      severity: 'high',
+      penalty:  0.10,
+    });
+    penalty += 0.10;
+  } else if (qeDivergence < 0.5 && cv > 0.08) {
+    // CV and QE are coherent — timings come from a real distribution
+    bonuses.push({
+      id:    'CV_ENTROPY_COHERENT',
+      label: 'Variance and entropy are physically coherent',
+      detail: `CV=${cv.toFixed(4)}  QE=${qe.toFixed(3)}  expected≈${expectedQE.toFixed(3)}`,
+      value:  0.06,
+    });
+    bonus += 0.06;
+  }
+
+  // ── 4. Steal-time periodicity (the "Picket Fence" detector) ─────────────
+  // VM steal-time bursts create a periodic signal in the autocorrelation.
+  // If lag-50 autocorrelation is significantly higher than lag-5,
+  // the scheduler quantum is approximately 50× the mean iteration time.
+  const picketFence = _detectPicketFence(autocorrelations);
+  if (picketFence.detected) {
+    findings.push({
+      id:      'PICKET_FENCE_DETECTED',
+      label:   `"Picket Fence" steal-time rhythm detected at lag ${picketFence.dominantLag}`,
+      detail:  picketFence.detail,
+      severity: 'high',
+      penalty:  0.08,
+    });
+    penalty += 0.08;
+  }
+
+  // ── 5. Skewness-Kurtosis coherence ───────────────────────────────────────
+  // Real hardware timing is right-skewed (occasional slow outliers from OS preemption).
+  // VMs that add synthetic outliers at fixed offsets produce wrong skew/kurtosis.
+  const skew = stats.skewness ?? 0;
+  const kurt = stats.kurtosis ?? 0;
+
+  if (skew > 0.3 && kurt > 0) {
+    // Right-skewed, leptokurtic — consistent with OS preemption on real hardware
+    bonuses.push({
+      id:    'NATURAL_SKEW_CONFIRMED',
+      label: 'Right-skewed distribution with positive kurtosis — OS preemption pattern',
+      detail: `skew=${skew.toFixed(3)}  kurtosis=${kurt.toFixed(3)}`,
+      value:  0.06,
+    });
+    bonus += 0.06;
+  } else if (skew < 0 && Math.abs(kurt) > 1) {
+    // Negative skew with high kurtosis: inconsistent with physical timing noise
+    findings.push({
+      id:      'SKEW_KURTOSIS_ANOMALY',
+      label:   'Left-skewed distribution — inconsistent with natural hardware timing',
+      detail:  `skew=${skew.toFixed(3)}  kurtosis=${kurt.toFixed(3)}`,
+      severity: 'medium',
+      penalty:  0.06,
+    });
+    penalty += 0.06;
+  }
+
+  // ── Physical floor protection (anti-compounding) ──────────────────────────
+  // When the three PRIMARY timing metrics are clearly consistent with real
+  // silicon, cap the penalty so that marginal secondary signals (weak Picket
+  // Fence, mild EJR, slight skew anomaly) cannot compound into a rejection.
+  //
+  // Why: a modern i7 laptop running heavy browser extensions may show:
+  //   EJR = 1.01  → -0.10 penalty (just under the 1.02 threshold)
+  //   lag50 = 0.31 → picket fence → -0.08 penalty (background process rhythm)
+  //   slight negative skew → -0.06 penalty
+  //   total: -0.24, drops score from 0.73 → 0.49 → wrongly flagged as synthetic
+  //
+  // Solution: if ≥ 2 of the 3 primary metrics are unambiguously physical,
+  // treat the device as "probably physical with some noise" and limit the
+  // penalty to 0.22 (enough to lower confidence but not enough to reject).
+  const clearQE   = jitter.quantizationEntropy    > 3.2;
+  const clearCV   = stats.cv >= 0.05 && stats.cv <= 0.30;
+  const clearLag1 = Math.abs(autocorrelations?.lag1 ?? 1) < 0.22;
+  const clearPhysicalCount = [clearQE, clearCV, clearLag1].filter(Boolean).length;
+
+  // Also check: if at least one metric is a HARD VM indicator (QE < 2.0 or
+  // lag1 > 0.65), override the floor — the floor is for borderline noise, not
+  // for devices that are clearly VMs on at least one axis.
+  const hardVmSignal =
+    jitter.quantizationEntropy < 2.0 ||
+    Math.abs(autocorrelations?.lag1 ?? 0) > 0.65;
+
+  const penaltyCap = (!hardVmSignal && clearPhysicalCount >= 2)
+    ? 0.22   // physical floor: cap compounding for clearly physical devices
+    : 0.60;  // default: full penalty range for ambiguous or VM-like signals
+
+  // HARD KILL overrides the physical floor protection entirely.
+  // The floor was designed to protect legitimate hardware with multiple
+  // marginal-but-honest signals — it must never shelter a forged proof.
+  const totalPenalty = hardOverride === 'vm'
+    ? Math.min(1.0, penalty)        // hard kill: uncapped, overwhelms all bonuses
+    : Math.min(penaltyCap, penalty); // normal: apply floor protection
+
+  // When a hard kill is active, strip all bonuses — they were earned on
+  // data that has been proved untrustworthy.
+  const totalBonus = hardOverride === 'vm' ? 0 : Math.min(0.35, bonus);
+
+  return {
+    penalty:             totalPenalty,
+    bonus:               totalBonus,
+    netAdjustment:       totalBonus - totalPenalty,
+    findings,
+    bonuses:             hardOverride === 'vm' ? [] : bonuses,
+    entropyJitterRatio,
+    entropyJitterScore,
+    picketFence,
+    hardOverride,
+    coherenceFlags: findings.map(f => f.id),
+  };
+}
+
+/**
+ * @typedef {object} HeuristicReport
+ * @property {number}      penalty             - total score penalty [0, 1.0]
+ * @property {number}      bonus               - total score bonus   [0, 0.35]
+ * @property {number}      netAdjustment       - bonus - penalty
+ * @property {object[]}    findings            - detected anomalies
+ * @property {object[]}    bonuses             - confirmed physical properties
+ * @property {number|null} entropyJitterRatio
+ * @property {'vm'|null}   hardOverride        - set when a mathematical impossibility is detected
+ * @property {object}      picketFence
+ * @property {string[]}    coherenceFlags
+ */
+
+// ---------------------------------------------------------------------------
+// EJR evaluation helper (extracted so it can run with or without QE values)
+// ---------------------------------------------------------------------------
+
+/**
+ * Applies the normal EJR classification logic (called only after the hard-kill
+ * check passes, meaning the EJR value has been verified as consistent).
+ */
+function _evaluateEJR(ejr, coldQE, hotQE, findings, bonuses, addPenalty, addBonus, setScore) {
+  const qeDetail = coldQE != null
+    ? `cold_QE=${coldQE.toFixed(3)}  hot_QE=${hotQE.toFixed(3)}`
+    : '';
+
+  if (ejr >= 1.08) {
+    setScore(1.0);
+    bonuses.push({
+      id:     'ENTROPY_GROWS_WITH_LOAD',
+      label:  'Entropy grew under load — thermal feedback confirmed',
+      detail: `ratio=${ejr.toFixed(3)}  ${qeDetail}`,
+      value:  0.12,
+    });
+    addBonus(0.12);
+
+  } else if (ejr >= 1.02) {
+    setScore(0.7);
+    findings.push({
+      id:       'ENTROPY_MILD_GROWTH',
+      label:    'Weak entropy growth under load',
+      detail:   `ratio=${ejr.toFixed(3)}  ${qeDetail}`,
+      severity: 'info',
+      penalty:  0,
+    });
+
+  } else if (ejr > 0.95) {
+    // Flat entropy — hypervisor clock unresponsive to guest load
+    setScore(0.2);
+    findings.push({
+      id:       'ENTROPY_FLAT_UNDER_LOAD',
+      label:    'Entropy did not grow under load — hypervisor clock suspected',
+      detail:   `ratio=${ejr.toFixed(3)}  (expected ≥ 1.08 for real hardware)  ${qeDetail}`,
+      severity: 'high',
+      penalty:  0.10,
+    });
+    addPenalty(0.10);
+
+  } else {
+    // Entropy DECREASED — hypervisor clock rounding became more aggressive
+    setScore(0.0);
+    findings.push({
+      id:       'ENTROPY_DECREASES_UNDER_LOAD',
+      label:    'Entropy shrank under load — hypervisor clock-rounding confirmed',
+      detail:   `ratio=${ejr.toFixed(3)}  (clock rounding more aggressive at high load)  ${qeDetail}`,
+      severity: 'critical',
+      penalty:  0.18,
+    });
+    addPenalty(0.18);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Picket Fence detector
+// ---------------------------------------------------------------------------
+
+/**
+ * Detects periodic steal-time bursts by finding the lag with the highest
+ * autocorrelation beyond lag-5.  A strong periodic peak indicates the
+ * hypervisor is scheduling the guest on a fixed quantum.
+ *
+ * Named "Picket Fence" because of how the timing histogram looks: dense
+ * clusters at fixed intervals with empty space between them — like fence posts.
+ */
+function _detectPicketFence(autocorrelations) {
+  const longLags = [10, 25, 50].map(l => ({
+    lag:  l,
+    ac:   Math.abs(autocorrelations?.[`lag${l}`] ?? 0),
+  }));
+
+  const shortBaseline = (Math.abs(autocorrelations?.lag5 ?? 0) +
+                         Math.abs(autocorrelations?.lag3 ?? 0)) / 2;
+
+  const peak = longLags.reduce((best, cur) =>
+    cur.ac > best.ac ? cur : best, { lag: 0, ac: 0 });
+
+  // "Picket fence" condition: a long-lag autocorr significantly exceeds baseline
+  if (peak.ac > 0.30 && peak.ac > shortBaseline + 0.20) {
+    return {
+      detected:     true,
+      dominantLag:  peak.lag,
+      peakAC:       peak.ac,
+      baseline:     shortBaseline,
+      detail: `lag${peak.lag}_AC=${peak.ac.toFixed(3)}  baseline_AC=${shortBaseline.toFixed(3)}  ` +
+              `estimated_quantum≈${(peak.lag * 5).toFixed(0)}ms (at 5ms/iter)`,
+    };
+  }
+
+  return { detected: false, dominantLag: null, peakAC: peak.ac, baseline: shortBaseline, detail: '' };
+}
+
+function _empty$1() {
+  return {
+    penalty: 0, bonus: 0, netAdjustment: 0,
+    findings: [], bonuses: [],
+    entropyJitterRatio: null, entropyJitterScore: 0.5,
+    hardOverride: null,
+    picketFence: { detected: false },
+    coherenceFlags: [],
+  };
+}
+
+/**
+ * @sovereign/pulse — Zero-Latency Second-Stage Coherence Analysis
+ *
+ * Runs entirely on data already collected by the entropy probe, bio
+ * collector, canvas fingerprinter, and audio analyser.
+ * Adds approximately 1–3 ms of CPU time. Zero WASM, zero network.
+ *
+ * Architecture:
+ *   Stage 1 — classifyJitter()       → rawScore  [0, 1]
+ *   Stage 2 — runHeuristicEngine()   → netAdjustment  (physics coherence)
+ *   Stage 3 — runCoherenceAnalysis() → THIS MODULE
+ *              ↳ small score refinement  [-0.15, +0.18]
+ *              ↳ dynamic threshold       [0.55, 0.67]
+ *              ↳ hard override           'vm' | null
+ *
+ * Why a third stage?
+ *   Stage 1 checks individual metrics in isolation.
+ *   Stage 2 checks pairwise relationships between metrics.
+ *   Stage 3 checks STRUCTURAL properties of the entire time-series and
+ *   signal evolution that require the full dataset to evaluate — and that
+ *   a sophisticated attacker cannot spoof without also spoofing every
+ *   other correlated signal simultaneously.
+ *
+ * The six checks cover orthogonal signal dimensions so they are hard to
+ * spoof together even if one is individually defeated:
+ *
+ *   1. Timing distinctness   — frequency domain (quantization density)
+ *   2. AC decay shape        — temporal domain (Brownian vs harmonic)
+ *   3. Chunk CV stability    — stationarity axis (thermal non-stationarity)
+ *   4. Level-dependent noise — noise model axis (multiplicative vs additive)
+ *   5. Batch convergence     — measurement stability (adaptive mode)
+ *   6. Phase trajectory      — EJR monotonicity (thermal sequence integrity)
+ *
+ * Dynamic threshold:
+ *   The evidence weight reflects how much data was actually collected.
+ *   An early-exit proof with 50 iterations and no bio activity has far less
+ *   support than a 200-iteration proof with bio, audio, and phased data.
+ *   The threshold rises automatically as evidence decreases:
+ *     Full evidence  → threshold 0.55  (standard)
+ *     Minimal proof  → threshold 0.67  (conservative gate)
+ *   This prevents low-evidence proofs from passing the same bar as full ones.
+ */
+
+// ---------------------------------------------------------------------------
+// runCoherenceAnalysis
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {object}        p
+ * @param {number[]}      p.timings   — raw timing array (already collected)
+ * @param {object}        p.jitter    — JitterAnalysis from classifyJitter()
+ * @param {object|null}   p.phases    — phased entropy result (optional)
+ * @param {object[]|null} p.batches   — adaptive batch snapshots (optional)
+ * @param {object}        p.bio       — bio snapshot
+ * @param {object}        p.canvas    — canvas fingerprint
+ * @param {object}        p.audio     — audio jitter result
+ * @returns {CoherenceReport}
+ */
+function runCoherenceAnalysis({ timings, jitter, phases, batches, bio, canvas, audio }) {
+  if (!timings || timings.length < 10) {
+    // Insufficient data — return a conservative threshold and no adjustments.
+    return _empty(0.64);
+  }
+
+  const checks  = [];   // anomalies found (each may carry a penalty)
+  const bonuses = [];   // physical properties confirmed (each carries a bonus)
+  let   penalty = 0;
+  let   bonus   = 0;
+  let   hardOverride = null;  // 'vm' | null
+
+  const n  = timings.length;
+  const ac = jitter.autocorrelations ?? {};
+
+  // ── Check 1: Timing Distinctness Ratio ──────────────────────────────────────
+  // VM quantized timers repeat the same integer-millisecond values.
+  // Real silicon at sub-ms resolution produces mostly unique values.
+  //
+  // Bin width: 0.2 ms (matches detectQuantizationEntropy for consistency).
+  // Normalized by sample count → iteration-count-independent.
+  //
+  //   distinctRatio > 0.65 → sub-ms resolution confirmed → physical bonus
+  //   distinctRatio < 0.30 → heavy quantization         → VM penalty
+  //   distinctRatio < 0.45 at n ≥ 100                   → mild VM penalty
+  {
+    const bins = new Set(timings.map(t => Math.round(t / 0.2)));
+    const distinctRatio = bins.size / n;
+
+    if (n >= 50) {
+      if (distinctRatio > 0.65) {
+        bonuses.push({
+          id:     'HIGH_TIMING_DISTINCTNESS',
+          label:  'Timer produces mostly unique values — sub-ms resolution confirmed',
+          detail: `ratio=${distinctRatio.toFixed(3)} (${bins.size}/${n} distinct 0.2ms bins)`,
+          value:  0.06,
+        });
+        bonus += 0.06;
+
+      } else if (distinctRatio < 0.30) {
+        // Severely quantized — VM with integer-ms timer emulation
+        checks.push({
+          id:       'LOW_TIMING_DISTINCTNESS',
+          label:    'Heavy timer quantization — integer-ms VM timer suspected',
+          detail:   `ratio=${distinctRatio.toFixed(3)} (only ${bins.size}/${n} distinct 0.2ms bins)`,
+          severity: 'high',
+          penalty:  0.12,
+        });
+        penalty += 0.12;
+
+      } else if (distinctRatio < 0.45 && n >= 100) {
+        // At 100+ iterations we expect more spread; below 0.45 is suspicious
+        checks.push({
+          id:       'BORDERLINE_TIMING_DISTINCTNESS',
+          label:    'Below-expected timer resolution — coarse-grained timer suspected',
+          detail:   `ratio=${distinctRatio.toFixed(3)} at n=${n}`,
+          severity: 'medium',
+          penalty:  0.05,
+        });
+        penalty += 0.05;
+      }
+    }
+  }
+
+  // ── Check 2: Autocorrelation Decay Shape ────────────────────────────────────
+  // Genuine Brownian noise decays monotonically: lag1 > lag2 > lag5 > lag10 > …
+  // VM scheduler rhythms create harmonic revivals: lag25 or lag50 elevated
+  // above lag10 because steal-time bursts recur at the scheduler quantum period.
+  //
+  // This is structurally orthogonal to the Picket Fence detector (stage 2),
+  // which checks absolute magnitude — this checks the SHAPE of the decay curve.
+  {
+    const l1  = Math.abs(ac.lag1  ?? 0);
+    const l2  = Math.abs(ac.lag2  ?? 0);
+    const l3  = Math.abs(ac.lag3  ?? 0);
+    const l5  = Math.abs(ac.lag5  ?? 0);
+    const l10 = Math.abs(ac.lag10 ?? 0);
+    const l25 = Math.abs(ac.lag25 ?? 0);
+    const l50 = Math.abs(ac.lag50 ?? 0);
+
+    // Strict Brownian decay: each successive lag is no higher than the previous
+    // (+0.03 tolerance for estimation noise)
+    const isBrownianDecay =
+      l1  < 0.20 &&
+      l2  <= l1  + 0.03 &&
+      l5  <= l2  + 0.03 &&
+      l10 <= l5  + 0.03 &&
+      l25 <= l10 + 0.05 &&
+      l50 <= l10 + 0.05;
+
+    // Harmonic revival: a long lag significantly exceeds medium lags
+    // (scheduler quantum footprint)
+    const revival25 = l25 > l5 + 0.12 && l25 > 0.18;
+    const revival50 = l50 > l5 + 0.12 && l50 > 0.18;
+
+    if (isBrownianDecay && l1 < 0.15) {
+      bonuses.push({
+        id:     'BROWNIAN_DECAY_SHAPE',
+        label:  'AC decays monotonically at all measured lags — genuine Brownian noise structure',
+        detail: `lag1=${l1.toFixed(3)} lag3=${l3.toFixed(3)} lag5=${l5.toFixed(3)} lag10=${l10.toFixed(3)} lag50=${l50.toFixed(3)}`,
+        value:  0.09,
+      });
+      bonus += 0.09;
+    }
+
+    if (revival25 || revival50) {
+      const peakLag = revival25 ? 25 : 50;
+      const peakVal = revival25 ? l25 : l50;
+      checks.push({
+        id:       'HARMONIC_AUTOCORR_REVIVAL',
+        label:    `Long-lag AC revival at lag ${peakLag} — VM scheduler harmonic footprint`,
+        detail:   `lag5=${l5.toFixed(3)}  lag${peakLag}=${peakVal.toFixed(3)}  Δ=${(peakVal - l5).toFixed(3)}`,
+        severity: 'high',
+        penalty:  0.10,
+      });
+      penalty += 0.10;
+    }
+  }
+
+  // ── Check 3: Chunk CV Stability (temporal stationarity test) ─────────────────
+  // Split the timing series into 4 equal windows and compute CV per window.
+  // Real hardware: CV varies across chunks — CPU temperature changes, workload
+  // varies, OS scheduling fluctuates — making the process non-stationary.
+  // VM hypervisor: CV is nearly identical in every chunk because the hypervisor's
+  // scheduling behaviour is constant — a stationary process.
+  //
+  // Metric: CV of the 4 chunk CVs (CV-of-CVs).
+  //   > 0.15 → non-stationary noise → physical bonus
+  //   < 0.06 → suspiciously constant → VM penalty
+  if (n >= 40) {
+    const chunkSize = Math.floor(n / 4);
+    const chunkCVs  = [];
+
+    for (let c = 0; c < 4; c++) {
+      const chunk = timings.slice(c * chunkSize, (c + 1) * chunkSize);
+      const m     = chunk.reduce((a, b) => a + b, 0) / chunk.length;
+      const s     = Math.sqrt(chunk.reduce((acc, v) => acc + (v - m) ** 2, 0) / chunk.length);
+      if (m > 0) chunkCVs.push(s / m);
+    }
+
+    if (chunkCVs.length === 4) {
+      const cvMean  = chunkCVs.reduce((a, b) => a + b, 0) / 4;
+      const cvStd   = Math.sqrt(chunkCVs.reduce((s, v) => s + (v - cvMean) ** 2, 0) / 4);
+      const cvOfCVs = cvMean > 1e-9 ? cvStd / cvMean : 0;
+
+      if (cvOfCVs > 0.15) {
+        bonuses.push({
+          id:     'TEMPORAL_NON_STATIONARITY',
+          label:  'Noise level varies across time windows — thermal non-stationarity confirmed',
+          detail: `CV-of-CVs=${cvOfCVs.toFixed(3)}  windows=[${chunkCVs.map(v => v.toFixed(3)).join(', ')}]`,
+          value:  0.07,
+        });
+        bonus += 0.07;
+
+      } else if (cvOfCVs < 0.06 && cvMean > 0.01) {
+        checks.push({
+          id:       'STATIONARY_NOISE_PROCESS',
+          label:    'Noise level constant across all time windows — hypervisor stationarity suspected',
+          detail:   `CV-of-CVs=${cvOfCVs.toFixed(3)}  windows=[${chunkCVs.map(v => v.toFixed(3)).join(', ')}]`,
+          severity: 'high',
+          penalty:  0.09,
+        });
+        penalty += 0.09;
+      }
+    }
+  }
+
+  // ── Check 4: Level-Dependent Volatility (noise model test) ──────────────────
+  // Thermal noise is multiplicative: the physical process that adds jitter
+  // (electron thermal motion, gate capacitance variation) scales with the
+  // operating conditions that also drive longer execution times.
+  // Consequence: larger timing values tend to have more incremental variance.
+  // This produces a positive Pearson correlation between:
+  //   — timing[i]              (level — how long that iteration took)
+  //   — |timing[i+1]-timing[i]| (volatility — how much it changed)
+  //
+  // VM hypervisor noise is additive: a constant scheduling jitter is applied
+  // regardless of the iteration's timing level → near-zero correlation.
+  //
+  //   r > 0.15 → multiplicative noise → physical bonus
+  //   r < 0.04 at n ≥ 80 → additive noise → VM penalty
+  if (n >= 30) {
+    const levels = timings.slice(0, n - 1);
+    const deltas = timings.slice(1).map((v, i) => Math.abs(v - timings[i]));
+    const lMean  = levels.reduce((a, b) => a + b, 0) / levels.length;
+    const dMean  = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+
+    let cov = 0, lVar = 0, dVar = 0;
+    for (let i = 0; i < levels.length; i++) {
+      const ld = levels[i] - lMean;
+      const dd = deltas[i] - dMean;
+      cov  += ld * dd;
+      lVar += ld * ld;
+      dVar += dd * dd;
+    }
+    const denom         = Math.sqrt(lVar * dVar);
+    const levelVolCorr  = denom < 1e-14 ? 0 : cov / denom;
+
+    if (levelVolCorr > 0.15) {
+      bonuses.push({
+        id:     'MULTIPLICATIVE_NOISE_MODEL',
+        label:  'Timing variance scales with level — multiplicative thermal noise confirmed',
+        detail: `level-volatility r=${levelVolCorr.toFixed(3)} (expected >0.15 for real silicon)`,
+        value:  0.07,
+      });
+      bonus += 0.07;
+
+    } else if (levelVolCorr < 0.04 && n >= 80) {
+      // Enough samples to trust the estimate; near-zero = additive hypervisor noise
+      checks.push({
+        id:       'ADDITIVE_NOISE_MODEL',
+        label:    'Timing variance independent of level — additive hypervisor noise suspected',
+        detail:   `level-volatility r=${levelVolCorr.toFixed(3)} (expected >0.15 for real silicon)`,
+        severity: 'medium',
+        penalty:  0.07,
+      });
+      penalty += 0.07;
+    }
+  }
+
+  // ── Check 5: Batch Convergence Variance (adaptive mode only) ─────────────────
+  // In adaptive mode each batch of 25 iterations produces a vmConf estimate.
+  // Real hardware: these estimates wander batch-to-batch because the underlying
+  // physical source is genuinely stochastic.
+  // VM hypervisor: estimates lock in immediately — deterministic scheduling means
+  // each batch produces essentially the same picture.
+  //
+  // Most diagnostic in the ambiguous zone (vmConf 0.25–0.70) where stability
+  // is suspicious.  A clearly obvious VM (vmConf 0.90 every batch) is expected
+  // to be stable.  A borderline device (vmConf 0.45 across 6 identical batches)
+  // is exhibiting VM-like stability despite claiming ambiguity.
+  //
+  // Uses only batches collected after iteration 75 to avoid early-sample noise.
+  if (batches && batches.length >= 4) {
+    const stableBatches = batches.filter(b => b.iterations >= 75);
+
+    if (stableBatches.length >= 3) {
+      const vmConfs = stableBatches.map(b => b.vmConf);
+      const hwConfs = stableBatches.map(b => b.hwConf);
+      const vmMean  = vmConfs.reduce((a, b) => a + b, 0) / vmConfs.length;
+      const hwMean  = hwConfs.reduce((a, b) => a + b, 0) / hwConfs.length;
+      const vmStd   = Math.sqrt(
+        vmConfs.reduce((s, v) => s + (v - vmMean) ** 2, 0) / vmConfs.length
+      );
+
+      // Only meaningful in the ambiguous zone
+      const isAmbiguous = vmMean > 0.25 && vmMean < 0.70 && hwMean < 0.55;
+
+      if (isAmbiguous) {
+        if (vmStd > 0.06) {
+          bonuses.push({
+            id:     'SIGNAL_FLUCTUATES_STOCHASTICALLY',
+            label:  'Batch-by-batch signal variance confirms genuine stochastic noise source',
+            detail: `vmConf σ=${vmStd.toFixed(3)} across ${stableBatches.length} stable batches (μ=${vmMean.toFixed(3)})`,
+            value:  0.05,
+          });
+          bonus += 0.05;
+
+        } else if (vmStd < 0.025 && stableBatches.length >= 4) {
+          checks.push({
+            id:       'SIGNAL_DETERMINISTICALLY_STABLE',
+            label:    'Signal locked-in immediately — deterministic hypervisor suspected',
+            detail:   `vmConf σ=${vmStd.toFixed(3)} across ${stableBatches.length} stable batches (μ=${vmMean.toFixed(3)})`,
+            severity: 'medium',
+            penalty:  0.06,
+          });
+          penalty += 0.06;
+        }
+      }
+    }
+  }
+
+  // ── Check 6: Phase Entropy Trajectory ────────────────────────────────────────
+  // The EJR (hot_QE / cold_QE) captures the endpoint ratio, but misses the
+  // intermediate trajectory.  We additionally verify monotonic growth:
+  //   cold_QE < load_QE < hot_QE
+  //
+  // If all three phases are available, monotonic growth is a strong bonus.
+  // Non-monotonic trajectory (entropy dropped then recovered) is suspicious.
+  //
+  // HARD OVERRIDE: if EJR ≥ 1.08 (claims entropy grew from cold to hot)
+  // but cold_QE ≥ hot_QE (entropy provably didn't grow), the proof is
+  // mathematically self-contradictory → forgery attempt.
+  if (phases) {
+    const coldQE = phases.cold?.qe ?? null;
+    const loadQE = phases.load?.qe ?? null;
+    const hotQE  = phases.hot?.qe  ?? null;
+    const ejr    = phases.entropyJitterRatio ?? null;
+
+    // Mathematical contradiction: EJR = hot_QE / cold_QE, so EJR ≥ 1.08
+    // implies hot_QE ≥ 1.08 × cold_QE > cold_QE.  Violation = tampered proof.
+    if (ejr !== null && ejr >= 1.08 && coldQE !== null && hotQE !== null) {
+      if (coldQE >= hotQE) {
+        hardOverride = 'vm';
+        checks.push({
+          id:       'EJR_QE_CONTRADICTION',
+          label:    'HARD OVERRIDE: EJR claims entropy growth but cold_QE ≥ hot_QE — mathematically impossible',
+          detail:   `ejr=${ejr.toFixed(4)}  cold_QE=${coldQE.toFixed(3)}  hot_QE=${hotQE.toFixed(3)}  (ejr=hot/cold requires hot>cold)`,
+          severity: 'critical',
+          penalty:  0.60,  // overwhelms any bonus
+        });
+        penalty += 0.60;
+      }
+    }
+
+    // Monotonic trajectory check (requires all three phases)
+    if (!hardOverride && coldQE !== null && loadQE !== null && hotQE !== null) {
+      if (coldQE < loadQE && loadQE < hotQE) {
+        bonuses.push({
+          id:     'MONOTONIC_ENTROPY_TRAJECTORY',
+          label:  'QE increased continuously cold→load→hot — unbroken thermal feedback confirmed',
+          detail: `${coldQE.toFixed(3)} → ${loadQE.toFixed(3)} → ${hotQE.toFixed(3)}`,
+          value:  0.09,
+        });
+        bonus += 0.09;
+
+      } else if (coldQE >= loadQE || loadQE >= hotQE) {
+        // Entropy stalled or reversed mid-run — unusual for real silicon
+        checks.push({
+          id:       'NON_MONOTONIC_ENTROPY_TRAJECTORY',
+          label:    'Entropy did not increase monotonically across load phases',
+          detail:   `cold=${coldQE.toFixed(3)}  load=${loadQE.toFixed(3)}  hot=${hotQE.toFixed(3)}`,
+          severity: 'medium',
+          penalty:  0.06,
+        });
+        penalty += 0.06;
+      }
+    }
+  }
+
+  // ── Dynamic threshold ─────────────────────────────────────────────────────────
+  // A proof built from more evidence earns a more permissive (lower) passing bar.
+  // Weights:
+  //   iterations (0→200): up to 0.65 of the evidence score
+  //   phased collection:  +0.15 (gold standard of thermal measurement)
+  //   bio activity:       +0.10 (human presence confirmed)
+  //   audio available:    +0.05 (additional timing channel)
+  //   canvas available:   +0.05 (hardware renderer identified)
+  //
+  // dynamicThreshold = 0.55 + (1 − evidenceWeight) × 0.12
+  //   Full evidence  → 0.55  (standard gate)
+  //   Minimal proof  → 0.67  (tightened gate for low-evidence submissions)
+  const iterFraction   = Math.min(1.0, n / 200);
+  const phasedBonus    = phases                  ? 0.15 : 0.0;
+  const bioBonus       = bio?.hasActivity        ? 0.10 : 0.0;
+  const audioBonus     = audio?.available        ? 0.05 : 0.0;
+  const canvasBonus    = canvas?.available       ? 0.05 : 0.0;
+
+  const evidenceWeight = Math.min(1.0,
+    iterFraction * 0.65 + phasedBonus + bioBonus + audioBonus + canvasBonus
+  );
+
+  const dynamicThreshold = +(0.55 + (1 - evidenceWeight) * 0.12).toFixed(4);
+
+  // ── Stage-3 caps ─────────────────────────────────────────────────────────────
+  // Stage 3 is a REFINEMENT, not the primary classifier.  The caps are smaller
+  // than stage 2 to prevent triple-compounding across all three stages on
+  // legitimate hardware with multiple marginal-but-not-damning signals.
+  const totalPenalty = Math.min(0.15, penalty);   // hard floor: stage 3 can't reject alone
+  const totalBonus   = Math.min(0.18, bonus);
+
+  return {
+    penalty:          totalPenalty,
+    bonus:            totalBonus,
+    netAdjustment:    +(totalBonus - totalPenalty).toFixed(4),
+    checks,
+    bonuses,
+    hardOverride,                               // 'vm' | null
+    dynamicThreshold,                           // [0.55, 0.67]
+    evidenceWeight:   +evidenceWeight.toFixed(4),
+    coherenceFlags:   checks.map(c => c.id),
+    physicalFlags:    bonuses.map(b => b.id),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// computeServerDynamicThreshold
+// ---------------------------------------------------------------------------
+
+/**
+ * Server-side recomputation of the dynamic threshold.
+ * The server NEVER trusts the client's dynamicThreshold value; it recomputes
+ * from known payload fields.
+ *
+ * @param {object} payload - validated ProofPayload
+ * @returns {number} - minimum passing score for this proof [0.50, 0.62]
+ */
+function computeServerDynamicThreshold(payload) {
+  const entropy = payload?.signals?.entropy;
+  const bio     = payload?.signals?.bio;
+  const audio   = payload?.signals?.audio;
+  const canvas  = payload?.signals?.canvas;
+
+  const n            = entropy?.iterations ?? 0;
+  const hasPhases    = payload?.heuristic?.entropyJitterRatio != null;
+  const hasBio       = bio?.hasActivity === true;
+  const hasAudio     = audio?.available === true;
+  const hasCanvas    = canvas?.available === true;
+
+  const iterFraction = Math.min(1.0, n / 200);
+  const evidenceWeight = Math.min(1.0,
+    iterFraction * 0.65 +
+    (hasPhases ? 0.15 : 0) +
+    (hasBio    ? 0.10 : 0) +
+    (hasAudio  ? 0.05 : 0) +
+    (hasCanvas ? 0.05 : 0)
+  );
+
+  // Server threshold: [0.50, 0.62]
+  // Slightly more lenient than client [0.55, 0.67] because the server already
+  // applies minJitterScore as an independent check.  The dynamic component
+  // adds an ADDITIONAL evidence-proportional tightening on top.
+  return +(0.50 + (1 - evidenceWeight) * 0.12).toFixed(4);
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _empty(threshold) {
+  return {
+    penalty: 0, bonus: 0, netAdjustment: 0,
+    checks: [], bonuses: [],
+    hardOverride: null,
+    dynamicThreshold: threshold,
+    evidenceWeight: 0,
+    coherenceFlags: [],
+    physicalFlags:  [],
+  };
+}
+
+/**
+ * @typedef {object} CoherenceReport
+ * @property {number}    penalty            - total score penalty [0, 0.15]
+ * @property {number}    bonus              - total score bonus   [0, 0.18]
+ * @property {number}    netAdjustment      - bonus − penalty  [-0.15, +0.18]
+ * @property {object[]}  checks             - anomalies found (with penalty values)
+ * @property {object[]}  bonuses            - physical properties confirmed
+ * @property {'vm'|null} hardOverride       - overrides score when set
+ * @property {number}    dynamicThreshold   - computed passing threshold [0.55, 0.67]
+ * @property {number}    evidenceWeight     - how much evidence was collected [0, 1]
+ * @property {string[]}  coherenceFlags     - check IDs for logging
+ * @property {string[]}  physicalFlags      - bonus IDs for logging
+ */
+
+/**
+ * @sovereign/pulse — Hypervisor & Cloud Provider Fingerprinter
+ *
+ * Each hypervisor has a distinct "steal-time rhythm" — a characteristic
+ * pattern in how it schedules guest vCPUs on host physical cores.
+ * This creates detectable signatures in the timing autocorrelation profile.
+ *
+ * Think of it like a heartbeat EKG:
+ *   KVM      → regular 50-iteration bursts  (~250ms quantum at 5ms/iter)
+ *   Xen      → longer 150-iteration bursts  (~750ms credit scheduler quantum)
+ *   VMware   → irregular bursts, memory balloon noise
+ *   Hyper-V  → 78-iteration bursts          (~390ms at 5ms/iter, 15.6ms quantum)
+ *   Nitro    → almost none — SR-IOV passthrough is nearly invisible
+ *   Physical → no rhythm at all
+ *
+ * Canvas renderer strings give a second, independent signal that we cross-
+ * reference to increase confidence in the provider classification.
+ */
+
+// ---------------------------------------------------------------------------
+// Provider profile database
+// ---------------------------------------------------------------------------
+// Each profile is calibrated from real benchmark data.
+// Fields: lag1_range, lag50_range, qe_range, cv_range, renderer_hints
+
+const PROVIDER_PROFILES = [
+  {
+    id:         'physical',
+    label:      'Physical Hardware',
+    profile:    'analog-fog',
+    confidence: 0,  // set dynamically
+    match: ({ lag1, lag50, qe, cv, entropyJitterRatio, isSoftwareRenderer }) =>
+      !isSoftwareRenderer &&
+      Math.abs(lag1) < 0.20 &&
+      Math.abs(lag50) < 0.15 &&
+      qe > 3.0 &&
+      cv > 0.06 &&
+      (entropyJitterRatio === null || entropyJitterRatio >= 1.02),
+  },
+  {
+    id:         'kvm-generic',
+    label:      'KVM Hypervisor (generic)',
+    profile:    'picket-fence',
+    match: ({ lag1, lag50, qe, cv }) =>
+      lag1 > 0.40 && qe < 2.5 && cv < 0.15 && Math.abs(lag50) > 0.25,
+    providerHints: ['digitalocean', 'linode', 'vultr', 'hetzner', 'ovh'],
+  },
+  {
+    id:         'kvm-digitalocean',
+    label:      'DigitalOcean Droplet (KVM)',
+    profile:    'picket-fence',
+    match: ({ lag1, lag50, qe, cv, rendererHints }) =>
+      lag1 > 0.55 && qe < 2.0 && cv < 0.12 &&
+      (rendererHints.some(r => ['llvmpipe', 'virtio', 'qxl'].includes(r)) ||
+       lag50 > 0.30),
+  },
+  {
+    id:         'kvm-aws-ec2-xen',
+    label:      'AWS EC2 (Xen/older generation)',
+    profile:    'picket-fence',
+    // Xen credit scheduler has longer period (~150 iters)
+    match: ({ lag1, lag25, lag50, qe, cv }) =>
+      qe < 2.2 && cv < 0.13 &&
+      lag25 > 0.20 && lag50 > 0.20 &&
+      lag1 < 0.50,   // lag-1 less pronounced than KVM
+  },
+  {
+    id:         'nitro-aws',
+    label:      'AWS EC2 Nitro (near-baremetal)',
+    profile:    'near-physical',
+    // Nitro uses SR-IOV and dedicated hardware — steal-time is very low.
+    // Looks almost physical but canvas renderer gives it away.
+    match: ({ lag1, lag50, qe, cv, isSoftwareRenderer, rendererHints }) =>
+      qe > 2.5 && cv > 0.05 &&
+      lag1 < 0.25 && lag50 < 0.20 &&
+      (isSoftwareRenderer ||
+       rendererHints.some(r => r.includes('nvidia t4') || r.includes('nvidia a10'))),
+  },
+  {
+    id:         'vmware-esxi',
+    label:      'VMware ESXi',
+    profile:    'burst-scheduler',
+    // VMware balloon driver creates irregular memory pressure bursts
+    match: ({ lag1, lag50, qe, cv, rendererHints }) =>
+      qe < 2.5 &&
+      (rendererHints.some(r => r.includes('vmware')) ||
+       (lag1 > 0.30 && lag50 < lag1 * 0.7 && cv < 0.14)),
+  },
+  {
+    id:         'hyperv',
+    label:      'Microsoft Hyper-V',
+    profile:    'picket-fence',
+    // 15.6ms scheduler quantum → burst every ~78 iters
+    match: ({ lag1, lag25, qe, cv, rendererHints }) =>
+      qe < 2.3 &&
+      (rendererHints.some(r => r.includes('microsoft basic render') || r.includes('warp')) ||
+       (lag25 > 0.25 && lag1 > 0.35 && cv < 0.12)),
+  },
+  {
+    id:         'gcp-kvm',
+    label:      'Google Cloud (KVM)',
+    profile:    'picket-fence',
+    match: ({ lag1, lag50, qe, cv, rendererHints }) =>
+      qe < 2.3 && lag1 > 0.45 &&
+      (rendererHints.some(r => r.includes('swiftshader') || r.includes('google')) ||
+       (lag50 > 0.28 && cv < 0.11)),
+  },
+  {
+    id:         'gh200-datacenter',
+    label:      'NVIDIA GH200 / HPC Datacenter',
+    profile:    'hypervisor-flat',
+    // Even with massive compute, still trapped by hypervisor clock.
+    // GH200 shows near-zero Hurst (extreme quantization) + very high lag-1.
+    match: ({ lag1, qe, hurst, cv, rendererHints }) =>
+      (rendererHints.some(r => r.includes('gh200') || r.includes('grace hopper') ||
+                                r.includes('nvidia a100') || r.includes('nvidia h100')) ||
+       (hurst < 0.10 && lag1 > 0.60 && qe < 1.8 && cv < 0.10)),
+  },
+  {
+    id:         'generic-vm',
+    label:      'Virtual Machine (unclassified)',
+    profile:    'picket-fence',
+    match: ({ lag1, qe, cv, isSoftwareRenderer }) =>
+      isSoftwareRenderer ||
+      (qe < 2.0 && lag1 > 0.35) ||
+      (cv < 0.02),
+  },
+];
+
+// ---------------------------------------------------------------------------
+// detectProvider
+// ---------------------------------------------------------------------------
+
+/**
+ * Classifies the host environment based on timing + canvas signals.
+ *
+ * @param {object} p
+ * @param {import('./jitter.js').JitterAnalysis} p.jitter
+ * @param {object} p.autocorrelations           - extended lags including lag25, lag50
+ * @param {import('../collector/canvas.js').CanvasFingerprint} p.canvas
+ * @param {object|null} p.phases
+ * @returns {ProviderResult}
+ */
+function detectProvider({ jitter, autocorrelations, canvas, phases }) {
+  const rendererHints = _rendererHints(canvas?.webglRenderer, canvas?.webglVendor);
+
+  const signals = {
+    lag1:               Math.abs(autocorrelations?.lag1  ?? 0),
+    lag25:              Math.abs(autocorrelations?.lag25 ?? 0),
+    lag50:              Math.abs(autocorrelations?.lag50 ?? 0),
+    qe:                 jitter.quantizationEntropy,
+    cv:                 jitter.stats?.cv ?? 0,
+    hurst:              jitter.hurstExponent ?? 0.5,
+    isSoftwareRenderer: canvas?.isSoftwareRenderer ?? false,
+    rendererHints,
+    entropyJitterRatio: phases?.entropyJitterRatio ?? null,
+  };
+
+  // Score each profile and pick the best match
+  const scored = PROVIDER_PROFILES
+    .filter(p => {
+      try { return p.match(signals); }
+      catch { return false; }
+    })
+    .map(p => ({
+      ...p,
+      // Physical hardware is the last resort; give it lower priority when
+      // other profiles match so we don't misclassify VMs.
+      priority: p.id === 'physical' ? 0 : 1,
+    }))
+    .sort((a, b) => b.priority - a.priority);
+
+  const best = scored[0] ?? { id: 'unknown', label: 'Unknown', profile: 'unknown' };
+
+  // Confidence: how many "VM indicator" thresholds the signals cross
+  const vmIndicatorCount = [
+    signals.qe < 2.5,
+    signals.lag1 > 0.35,
+    signals.lag50 > 0.20,
+    signals.cv < 0.04,
+    signals.isSoftwareRenderer,
+    signals.hurst < 0.15,
+    phases?.entropyJitterRatio != null && phases.entropyJitterRatio < 1.02,
+  ].filter(Boolean).length;
+
+  const isPhysical   = best.id === 'physical';
+  const confidence   = isPhysical
+    ? Math.max(20, 95 - vmIndicatorCount * 15)
+    : Math.min(95, 40 + vmIndicatorCount * 12);
+
+  return {
+    providerId:         best.id,
+    providerLabel:      best.label,
+    profile:            best.profile,
+    confidence,
+    isVirtualized:      best.id !== 'physical',
+    signals,
+    alternatives:       scored.slice(1, 3).map(p => ({ id: p.id, label: p.label })),
+    rendererHints,
+    schedulerQuantumMs: _estimateQuantum(signals),
+  };
+}
+
+/**
+ * @typedef {object} ProviderResult
+ * @property {string}  providerId
+ * @property {string}  providerLabel
+ * @property {string}  profile           'analog-fog' | 'picket-fence' | 'burst-scheduler' | 'near-physical' | 'hypervisor-flat' | 'unknown'
+ * @property {number}  confidence        0–100
+ * @property {boolean} isVirtualized
+ * @property {object}  signals
+ * @property {object[]} alternatives
+ * @property {string[]} rendererHints
+ * @property {number|null} schedulerQuantumMs
+ */
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract lowercase hint tokens from WebGL renderer string for pattern matching.
+ */
+function _rendererHints(renderer = '', vendor = '') {
+  return `${renderer} ${vendor}`.toLowerCase()
+    .split(/[\s\/(),]+/)
+    .filter(t => t.length > 2);
+}
+
+/**
+ * Estimate the hypervisor's scheduler quantum from the dominant autocorrelation lag.
+ * Returns null if the device appears to be physical.
+ */
+function _estimateQuantum({ lag1, lag25, lag50, qe }) {
+  if (qe > 3.2) return null;  // likely physical
+
+  // Find the dominant lag (highest absolute autocorrelation beyond lag-5)
+  const lags = [
+    { lag: 50, ac: lag50 },
+    { lag: 25, ac: lag25 },
+  ];
+  const peak = lags.reduce((b, c) => c.ac > b.ac ? c : b, { lag: 0, ac: 0 });
+
+  if (peak.ac < 0.20) return null;
+
+  // Quantum (ms) ≈ dominant_lag × estimated_iteration_time (≈5ms)
+  return peak.lag * 5;
+}
+
+/**
+ * @sovereign/pulse — High-Level Fingerprint Class
+ *
+ * The developer-facing API.  Instead of forcing devs to understand Hurst
+ * Exponents and Quantization Entropy, they get a Fingerprint object with
+ * plain-language properties and one critical boolean: isSynthetic.
+ *
+ * Usage:
+ *
+ *   import { Fingerprint } from '@sovereign/pulse';
+ *
+ *   const fp = await Fingerprint.collect({ nonce });
+ *
+ *   if (fp.isSynthetic) {
+ *     console.log(`Blocked: ${fp.providerLabel} detected (${fp.confidence}% confidence)`);
+ *     console.log(`Profile: ${fp.profile}`);        // 'picket-fence'
+ *     console.log(`Reason: ${fp.topFlag}`);          // 'LOW_QE + HIGH_LAG1_AUTOCORR'
+ *   } else {
+ *     console.log(`Verified: ${fp.hardwareId()}`);
+ *     console.log(`Score: ${fp.score}`);             // 0.0 – 1.0
+ *   }
+ *
+ *   // Always send to server for final validation:
+ *   const { payload, hash } = fp.toCommitment();
+ */
+
+
+// ---------------------------------------------------------------------------
+// Fingerprint class
+// ---------------------------------------------------------------------------
+
+class Fingerprint {
+  /** @private */
+  constructor(raw) {
+    this._raw        = raw;         // full internal data
+    this._commitment = null;        // lazy-built on first toCommitment() call
+  }
+
+  // ── Static factory ────────────────────────────────────────────────────────
+
+  /**
+   * Collect all hardware signals and return a Fingerprint instance.
+   *
+   * @param {object}   opts
+   * @param {string}   opts.nonce          - server-issued challenge nonce (required)
+   * @param {number}   [opts.iterations=200]
+   * @param {number}   [opts.bioWindowMs=3000]
+   * @param {boolean}  [opts.phased=true]  - run cold/load/hot phases
+   * @param {Function} [opts.onProgress]   - (stage: string) => void
+   * @param {string}   [opts.wasmPath]
+   * @returns {Promise<Fingerprint>}
+   */
+  static async collect(opts = {}) {
+    const {
+      nonce,
+      iterations        = 200,
+      bioWindowMs       = 3000,
+      phased            = true,
+      adaptive          = true,
+      adaptiveThreshold = 0.85,
+      onProgress,
+      wasmPath,
+    } = opts;
+
+    if (!nonce) throw new Error('Fingerprint.collect() requires opts.nonce');
+
+    const emit = (stage, meta) => { try { onProgress?.(stage, meta); } catch {} };
+
+    emit('start');
+
+    // ── Parallel collection ────────────────────────────────────────────────
+    const bio = new BioCollector();
+    bio.start();
+
+    const [entropy, canvas, audio] = await Promise.all([
+      collectEntropy({
+        iterations, phased, adaptive, adaptiveThreshold, wasmPath,
+        onBatch: (meta) => emit('entropy_batch', meta),
+      }).then(r => { emit('entropy_done'); return r; }),
+      collectCanvasFingerprint()
+        .then(r => { emit('canvas_done'); return r; }),
+      collectAudioJitter({ durationMs: Math.min(bioWindowMs, 2000) })
+        .then(r => { emit('audio_done'); return r; }),
+    ]);
+
+    // Wait out the bio window
+    const elapsed = Date.now() - entropy.collectedAt;
+    const remain  = Math.max(0, bioWindowMs - elapsed);
+    if (remain > 0) await new Promise(r => setTimeout(r, remain));
+
+    bio.stop();
+    const bioSnapshot = bio.snapshot(entropy.timings);
+    emit('bio_done');
+
+    // ── Analysis pipeline ─────────────────────────────────────────────────
+    const jitter    = classifyJitter(entropy.timings, { autocorrelations: entropy.autocorrelations });
+    const heuristic = runHeuristicEngine({ jitter, phases: entropy.phases, autocorrelations: entropy.autocorrelations });
+    const provider  = detectProvider({ jitter, autocorrelations: entropy.autocorrelations, canvas, phases: entropy.phases });
+
+    // ── Three-stage scoring pipeline ──────────────────────────────────────
+    // Stage 1: base jitter score from timing distribution analysis
+    const rawScore  = jitter.score;
+    // Stage 2: heuristic cross-metric coherence adjustment
+    const adjScore  = Math.max(0, Math.min(1, rawScore + heuristic.netAdjustment));
+    // Stage 3: zero-latency structural coherence analysis on already-collected data
+    const coherence = runCoherenceAnalysis({
+      timings:  entropy.timings,
+      jitter,
+      phases:   entropy.phases  ?? null,
+      batches:  entropy.batches ?? null,
+      bio:      bioSnapshot,
+      canvas,
+      audio,
+    });
+    // Final score: stage-2 adjusted score refined by stage-3 coherence
+    const finalScore = Math.max(0, Math.min(1, adjScore + coherence.netAdjustment));
+
+    emit('analysis_done');
+
+    // ── Build commitment ──────────────────────────────────────────────────
+    const payload    = buildProof({ entropy, jitter, bio: bioSnapshot, canvas, audio, nonce });
+    // Inject heuristic + provider into proof payload for server-side reference
+    payload.heuristic = {
+      penalty:            heuristic.penalty,
+      bonus:              heuristic.bonus,
+      entropyJitterRatio: heuristic.entropyJitterRatio,
+      picketFence:        heuristic.picketFence.detected,
+      coherenceFlags:     heuristic.coherenceFlags,
+      hardOverride:       heuristic.hardOverride,  // 'vm' | null
+    };
+    payload.provider = {
+      id:               provider.providerId,
+      label:            provider.providerLabel,
+      profile:          provider.profile,
+      confidence:       provider.confidence,
+      schedulerQuantum: provider.schedulerQuantumMs,
+    };
+    // Stage-3 coherence summary (server uses these for logging + dynamic threshold)
+    payload.coherence = {
+      netAdjustment:    coherence.netAdjustment,
+      dynamicThreshold: coherence.dynamicThreshold,
+      evidenceWeight:   coherence.evidenceWeight,
+      coherenceFlags:   coherence.coherenceFlags,
+      physicalFlags:    coherence.physicalFlags,
+      hardOverride:     coherence.hardOverride,
+    };
+    payload.classification.adjustedScore  = _round(adjScore,    4);
+    payload.classification.finalScore     = _round(finalScore,  4);
+    payload.classification.dynamicThreshold = coherence.dynamicThreshold;
+
+    const commitment = buildCommitment(payload);
+    emit('complete');
+
+    return new Fingerprint({
+      entropy, canvas, audio,
+      bioSnapshot, jitter, heuristic, coherence, provider,
+      rawScore, adjScore, finalScore,
+      nonce, commitment,
+    });
+  }
+
+  // ── Primary API ────────────────────────────────────────────────────────────
+
+  /**
+   * True if the device is likely a VM, AI inference endpoint, or sanitised
+   * cloud environment.  Uses the adjusted score (base + heuristic bonuses/penalties).
+   * @type {boolean}
+   */
+  get isSynthetic() {
+    // Stage-2 hard kill: EJR/QE mathematical contradiction detected in the
+    // heuristic engine before any bonuses could accumulate.
+    if (this._raw.heuristic.hardOverride === 'vm') return true;
+    // Stage-3 hard kill: EJR/QE contradiction or phase forgery detected in
+    // the coherence analyser (second line of defence).
+    if (this._raw.coherence.hardOverride === 'vm') return true;
+    // Normal path: final score vs dynamic threshold.
+    return this._raw.finalScore < this._raw.coherence.dynamicThreshold;
+  }
+
+  /**
+   * Confidence in the isSynthetic verdict, 0–100.
+   * @type {number}
+   */
+  get confidence() {
+    const s = this._raw.finalScore;
+    const t = this._raw.coherence.dynamicThreshold;
+    // Map distance from threshold to confidence percentage.
+    // At the threshold: 0% confident. Far above/below: approaching 100%.
+    const distance = Math.abs(s - t);
+    return Math.min(100, Math.round(distance * 500));
+  }
+
+  /**
+   * Normalised score [0.0, 1.0].  Higher = more physical.
+   * This is the FINAL score after all three analysis stages.
+   * @type {number}
+   */
+  get score() {
+    return _round(this._raw.finalScore, 4);
+  }
+
+  /**
+   * The dynamic passing threshold for this proof [0.55, 0.67].
+   * Reflects how much evidence was collected — a full-evidence proof has a
+   * lower (more permissive) threshold; a minimal-evidence proof has a higher
+   * (more conservative) threshold.
+   * @type {number}
+   */
+  get threshold() {
+    return this._raw.coherence.dynamicThreshold;
+  }
+
+  /**
+   * How much evidence was collected [0, 1].
+   * 1.0 = 200 iterations + phased + bio + audio + canvas
+   * 0.0 = minimal proof
+   * @type {number}
+   */
+  get evidenceWeight() {
+    return this._raw.coherence.evidenceWeight;
+  }
+
+  /**
+   * Human-readable confidence tier.
+   * @type {'high'|'medium'|'low'|'uncertain'}
+   */
+  get tier() {
+    const c = this.confidence;
+    if (c >= 70) return 'high';
+    if (c >= 40) return 'medium';
+    if (c >= 20) return 'low';
+    return 'uncertain';
+  }
+
+  /**
+   * Detected timing profile name.
+   *   'analog-fog'      → real hardware, natural Brownian noise
+   *   'picket-fence'    → VM steal-time bursts at regular intervals
+   *   'burst-scheduler' → irregular VM scheduling (VMware-style)
+   *   'hypervisor-flat' → flat timing, hypervisor completely irons out noise
+   *   'near-physical'   → hard to classify (Nitro, GPU passthrough)
+   *   'unknown'
+   * @type {string}
+   */
+  get profile() {
+    return this._raw.provider.profile;
+  }
+
+  /**
+   * Detected cloud provider / hypervisor.
+   * @type {string}  e.g. 'kvm-digitalocean', 'nitro-aws', 'physical', 'generic-vm'
+   */
+  get providerId() {
+    return this._raw.provider.providerId;
+  }
+
+  /**
+   * Human-readable provider label.
+   * @type {string}  e.g. 'DigitalOcean Droplet (KVM)', 'Physical Hardware'
+   */
+  get providerLabel() {
+    return this._raw.provider.providerLabel;
+  }
+
+  /**
+   * Estimated hypervisor scheduler quantum in milliseconds.
+   * Null if the device appears to be physical.
+   * @type {number|null}
+   */
+  get schedulerQuantumMs() {
+    return this._raw.provider.schedulerQuantumMs;
+  }
+
+  /**
+   * Entropy-Jitter Ratio — the key signal distinguishing real silicon from VMs.
+   * Values ≥ 1.08 confirm thermal feedback (real hardware).
+   * Values near 1.0 indicate a hypervisor clock (VM).
+   * Null if phased collection was not run.
+   * @type {number|null}
+   */
+  get entropyJitterRatio() {
+    return this._raw.heuristic.entropyJitterRatio;
+  }
+
+  /**
+   * The most diagnostic flag from the heuristic engine.
+   * @type {string}
+   */
+  get topFlag() {
+    const flags = [
+      ...this._raw.heuristic.findings.map(f => f.id),
+      ...this._raw.jitter.flags,
+    ];
+    return flags[0] ?? 'NONE';
+  }
+
+  /**
+   * All flags from both the base classifier and heuristic engine.
+   * @type {string[]}
+   */
+  get flags() {
+    return [
+      ...this._raw.heuristic.coherenceFlags,
+      ...this._raw.jitter.flags,
+    ];
+  }
+
+  /**
+   * Summary of heuristic findings with human-readable labels.
+   * @type {Array<{id, label, severity, detail}>}
+   */
+  get findings() {
+    return this._raw.heuristic.findings;
+  }
+
+  /**
+   * Confirmed physical properties (positive evidence for real hardware).
+   * @type {Array<{id, label, detail}>}
+   */
+  get physicalEvidence() {
+    return this._raw.heuristic.bonuses;
+  }
+
+  // ── Hardware ID ────────────────────────────────────────────────────────────
+
+  /**
+   * A stable, privacy-preserving hardware identifier derived from the GPU
+   * canvas fingerprint, audio sample rate, and WebGL extension set.
+   *
+   * Properties:
+   *   - Stable: same device → same ID across sessions
+   *   - Not uniquely identifying: changes if GPU or driver changes
+   *   - Not reversible: BLAKE3 hash, cannot recover original signals
+   *   - Not a tracking cookie: no PII, no cross-origin data
+   *
+   * @returns {string}  16-character hex ID
+   */
+  hardwareId() {
+    const { canvas, audio } = this._raw;
+    const components = [
+      canvas?.webglRenderer ?? '',
+      canvas?.webglVendor   ?? '',
+      canvas?.extensionCount?.toString() ?? '',
+      audio?.sampleRate?.toString() ?? '',
+      canvas?.webglVersion?.toString() ?? '',
+    ].join('|');
+    return blake3HexStr(components).slice(0, 16);
+  }
+
+  // ── Diagnostic data ────────────────────────────────────────────────────────
+
+  /**
+   * Key metrics summary — useful for logging and debugging.
+   * @returns {object}
+   */
+  metrics() {
+    const { jitter, heuristic, coherence, provider } = this._raw;
+    return {
+      // ── Final verdict ──────────────────────────────────────────────────
+      score:                this.score,           // final (stage 3)
+      threshold:            this.threshold,       // dynamic passing bar
+      evidenceWeight:       this.evidenceWeight,
+      isSynthetic:          this.isSynthetic,
+      // ── Score pipeline breakdown ───────────────────────────────────────
+      rawScore:             _round(this._raw.rawScore, 4),       // stage 1
+      adjustedScore:        _round(this._raw.adjScore, 4),       // stage 2
+      finalScore:           _round(this._raw.finalScore, 4),     // stage 3
+      heuristicAdjustment:  _round(heuristic.netAdjustment, 4),
+      coherenceAdjustment:  _round(coherence.netAdjustment, 4),
+      // ── Timing signals ─────────────────────────────────────────────────
+      cv:                   _round(jitter.stats?.cv, 4),
+      hurstExponent:        _round(jitter.hurstExponent, 4),
+      quantizationEntropy:  _round(jitter.quantizationEntropy, 4),
+      autocorrLag1:         _round(jitter.autocorrelations?.lag1, 4),
+      autocorrLag50:        _round(this._raw.entropy.autocorrelations?.lag50, 4),
+      outlierRate:          _round(jitter.outlierRate, 4),
+      thermalPattern:       jitter.thermalSignature?.pattern,
+      entropyJitterRatio:   _round(heuristic.entropyJitterRatio, 4),
+      picketFence:          heuristic.picketFence.detected,
+      // ── Coherence signals ──────────────────────────────────────────────
+      coherenceFlags:       coherence.coherenceFlags,
+      physicalFlags:        coherence.physicalFlags,
+      hardOverride:         coherence.hardOverride,
+      // ── Provider ───────────────────────────────────────────────────────
+      provider:             provider.providerLabel,
+      providerConfidence:   provider.confidence,
+      schedulerQuantumMs:   provider.schedulerQuantumMs,
+      // ── Hardware ───────────────────────────────────────────────────────
+      webglRenderer:        this._raw.canvas?.webglRenderer,
+      isSoftwareRenderer:   this._raw.canvas?.isSoftwareRenderer,
+      hardwareId:           this.hardwareId(),
+    };
+  }
+
+  /**
+   * Full diagnostic report for debugging / integration testing.
+   * @returns {object}
+   */
+  report() {
+    const { coherence } = this._raw;
+    return {
+      verdict: {
+        isSynthetic:      this.isSynthetic,
+        score:            this.score,
+        threshold:        this.threshold,
+        confidence:       this.confidence,
+        tier:             this.tier,
+        profile:          this.profile,
+        provider:         this.providerLabel,
+        topFlag:          this.topFlag,
+        hardOverride:     coherence.hardOverride,
+        evidenceWeight:   this.evidenceWeight,
+      },
+      pipeline: {
+        rawScore:             _round(this._raw.rawScore,    4),
+        adjustedScore:        _round(this._raw.adjScore,    4),
+        finalScore:           _round(this._raw.finalScore,  4),
+        heuristicAdjustment:  _round(this._raw.heuristic.netAdjustment, 4),
+        coherenceAdjustment:  _round(coherence.netAdjustment, 4),
+        dynamicThreshold:     coherence.dynamicThreshold,
+      },
+      metrics:          this.metrics(),
+      findings:         this.findings,
+      physicalEvidence: this.physicalEvidence,
+      coherenceChecks:  coherence.checks,
+      coherenceBonuses: coherence.bonuses,
+      phases:           this._raw.entropy.phases ? {
+        cold: { qe: _round(this._raw.entropy.phases.cold.qe, 4), mean: _round(this._raw.entropy.phases.cold.mean, 4) },
+        hot:  { qe: _round(this._raw.entropy.phases.hot.qe,  4), mean: _round(this._raw.entropy.phases.hot.mean,  4) },
+        entropyJitterRatio: _round(this._raw.entropy.phases.entropyJitterRatio, 4),
+      } : null,
+    };
+  }
+
+  // ── Proof commitment ───────────────────────────────────────────────────────
+
+  /**
+   * Returns the BLAKE3 commitment to send to the server for validation.
+   * @returns {{ payload: object, hash: string }}
+   */
+  toCommitment() {
+    return this._raw.commitment;
+  }
+
+  // ── String representations ─────────────────────────────────────────────────
+
+  toString() {
+    const icon = this.isSynthetic ? '🚩' : '✅';
+    const verb = this.isSynthetic ? 'Synthetic' : 'Physical';
+    return `${icon} ${verb} | ${this.providerLabel} | score=${this.score} | conf=${this.confidence}% | profile=${this.profile}`;
+  }
+
+  toJSON() {
+    return this.report();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _round(v, d) {
+  if (v == null || !isFinite(v)) return null;
+  const f = 10 ** d;
+  return Math.round(v * f) / f;
+}
+
+/**
+ * @sovereign/pulse — Server-Side Validator
+ *
+ * Verifies a ProofPayload + BLAKE3 commitment received from the client.
+ * This module is for NODE.JS / SERVER use only.  It should NOT be bundled
+ * into the browser build (see package.json "exports" field).
+ *
+ * Trust model:
+ *   • The server issues a challenge `nonce` before the client runs pulse().
+ *   • The client returns { payload, hash }.
+ *   • The server calls validateProof(payload, hash, options) to:
+ *       1. Verify hash integrity (no tampering).
+ *       2. Verify nonce freshness (no replay).
+ *       3. Verify timestamp recency.
+ *       4. Check jitter score against thresholds.
+ *       5. Check canvas fingerprint against software-renderer blocklist.
+ *       6. Cross-validate signal consistency.
+ *
+ * NOTE: The server NEVER sees raw timing arrays or mouse coordinates.
+ * Only statistical summaries are transmitted.  This is the ZK property.
+ */
+
+
+// ---------------------------------------------------------------------------
+// Known software / virtual renderer substring patterns (lowercase)
+// ---------------------------------------------------------------------------
+const VM_RENDERER_BLOCKLIST = [
+  // Software / virtual renderers
+  'llvmpipe', 'swiftshader', 'softpipe', 'mesa offscreen',
+  'microsoft basic render', 'vmware svga', 'vmware', 'virtualbox',
+  'parallels', 'chromium swiftshader', 'google swiftshader',
+  'angle (', 'cirrussm', 'qxl', 'virtio', 'bochs',
+  // NVIDIA datacenter / inference — no consumer unit has these
+  'nvidia t4',     // AWS/GCP inference VM
+  'nvidia a10g',   // AWS g5 inference
+  'nvidia a100',   // Datacenter A100
+  'nvidia h100',   // Hopper — datacenter only
+  'nvidia h200',   // Hopper successor — datacenter only
+  'nvidia b100',   // Blackwell — datacenter only
+  'nvidia b200',   // Blackwell Ultra — datacenter only
+  'nvidia gh200',  // Grace-Hopper superchip
+  // AMD datacenter / HPC — no consumer has these
+  'amd instinct',  // covers mi100, mi200, mi250, mi300 family
+  'amd mi300',
+  'amd mi250',
+  'amd mi200',
+  // Cloud-specific AI accelerators
+  'aws inferentia',
+  'aws trainium',
+  'google tpu',
+];
+
+// ---------------------------------------------------------------------------
+// validateProof
+// ---------------------------------------------------------------------------
+
+/**
+ * Validates a client-submitted proof.
+ *
+ * @param {import('./fingerprint.js').ProofPayload} payload
+ * @param {string}  receivedHash  - hex BLAKE3 from the client
+ * @param {object}  [opts]
+ * @param {number}  [opts.minJitterScore=0.55]     - minimum acceptable jitter score
+ * @param {number}  [opts.maxAgeMs=300_000]         - max payload age (5 min)
+ * @param {number}  [opts.clockSkewMs=30_000]        - tolerated future timestamp drift
+ * @param {boolean} [opts.requireBio=false]          - reject if no bio activity
+ * @param {boolean} [opts.blockSoftwareRenderer=true] - reject software WebGL
+ * @param {Function} [opts.checkNonce]               - async fn(nonce) → boolean
+ *   Called to verify the nonce was issued by this server and not yet consumed.
+ *   Should mark the nonce as consumed atomically (e.g. Redis SET NX with TTL).
+ *   If omitted, nonce freshness is NOT checked (not recommended for production).
+ *
+ * @returns {Promise<ValidationResult>}
+ */
+async function validateProof(payload, receivedHash, opts = {}) {
+  const {
+    minJitterScore        = 0.55,
+    maxAgeMs              = 300_000,
+    clockSkewMs           = 30_000,
+    requireBio            = false,
+    blockSoftwareRenderer = true,
+    checkNonce            = null,
+  } = opts;
+
+  const reasons   = [];
+  const riskFlags = [];
+  let   valid     = true;
+
+  // ── 0. Strict payload structure validation ────────────────────────────────
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return _reject(['INVALID_PAYLOAD_STRUCTURE']);
+  }
+
+  // Prototype pollution guard — reject any payload with __proto__ / constructor tricks
+  if (
+    Object.prototype.hasOwnProperty.call(payload, '__proto__') ||
+    Object.prototype.hasOwnProperty.call(payload, 'constructor') ||
+    Object.prototype.hasOwnProperty.call(payload, 'prototype')
+  ) {
+    return _reject(['PROTOTYPE_POLLUTION_ATTEMPT']);
+  }
+
+  // Required top-level fields
+  const REQUIRED_TOP = ['version', 'timestamp', 'nonce', 'signals', 'classification'];
+  for (const field of REQUIRED_TOP) {
+    if (!(field in payload)) {
+      return _reject([`MISSING_REQUIRED_FIELD:${field}`]);
+    }
+  }
+
+  // Type assertions on top-level scalars
+  if (typeof payload.version !== 'number')   return _reject(['INVALID_TYPE:version']);
+  if (typeof payload.timestamp !== 'number') return _reject(['INVALID_TYPE:timestamp']);
+  if (typeof payload.nonce !== 'string')     return _reject(['INVALID_TYPE:nonce']);
+  if (typeof payload.signals !== 'object' || Array.isArray(payload.signals)) {
+    return _reject(['INVALID_TYPE:signals']);
+  }
+  if (typeof payload.classification !== 'object' || Array.isArray(payload.classification)) {
+    return _reject(['INVALID_TYPE:classification']);
+  }
+
+  // Nonce must be a 64-character lowercase hex string (32 bytes)
+  if (!/^[0-9a-f]{64}$/.test(payload.nonce)) {
+    return _reject(['INVALID_NONCE_FORMAT']);
+  }
+
+  // Timestamp must be a plausible Unix ms value (> year 2020, < year 2100)
+  const TS_MIN = 1_577_836_800_000; // 2020-01-01
+  const TS_MAX = 4_102_444_800_000; // 2100-01-01
+  if (payload.timestamp < TS_MIN || payload.timestamp > TS_MAX) {
+    return _reject(['TIMESTAMP_OUT_OF_RANGE']);
+  }
+
+  if (payload.version !== 1) {
+    return _reject(['UNSUPPORTED_PROOF_VERSION']);
+  }
+
+  // ── 1. Hash integrity ─────────────────────────────────────────────────────
+  // receivedHash must be exactly 64 lowercase hex characters
+  if (typeof receivedHash !== 'string' || !/^[0-9a-f]{64}$/.test(receivedHash)) {
+    return _reject(['INVALID_HASH_FORMAT']);
+  }
+  const canonical = canonicalJson(payload);
+  const enc       = new TextEncoder().encode(canonical);
+  const computed  = bytesToHex(blake3(enc));
+
+  if (computed !== receivedHash) {
+    return _reject(['HASH_MISMATCH_PAYLOAD_TAMPERED']);
+  }
+
+  // ── 2. Timestamp recency ──────────────────────────────────────────────────
+  const now     = Date.now();
+  const age     = now - payload.timestamp;
+  if (age > maxAgeMs) {
+    valid = false;
+    reasons.push(`PROOF_EXPIRED: age=${Math.round(age / 1000)}s, max=${maxAgeMs / 1000}s`);
+  }
+  if (payload.timestamp > now + clockSkewMs) {
+    valid = false;
+    reasons.push('PROOF_FROM_FUTURE');
+  }
+
+  // ── 3. Nonce freshness ────────────────────────────────────────────────────
+  if (checkNonce) {
+    const nonceOk = await checkNonce(payload.nonce);
+    if (!nonceOk) {
+      valid = false;
+      reasons.push('NONCE_INVALID_OR_REPLAYED');
+    }
+  } else {
+    riskFlags.push('NONCE_FRESHNESS_NOT_CHECKED');
+  }
+
+  // ── 4. Jitter score ───────────────────────────────────────────────────────
+  const jitterScore = payload.classification?.jitterScore ?? 0;
+  if (jitterScore < minJitterScore) {
+    valid = false;
+    reasons.push(`JITTER_SCORE_TOO_LOW: ${jitterScore} < ${minJitterScore}`);
+  }
+
+  // ── 4b. Dynamic threshold (evidence-proportional gate) ──────────────────
+  // The server independently computes the minimum passing score based on how
+  // much evidence the proof contains.  The client's dynamicThreshold field is
+  // NEVER trusted — it is only used for logging/auditing.
+  //
+  // Logic: a proof with only 50 iterations and no bio/audio faces a higher bar
+  // (0.62) than a full 200-iteration proof with phased data (0.50).
+  // This makes replay attacks with minimal proofs automatically fail the gate.
+  const serverDynamicMin = computeServerDynamicThreshold(payload);
+
+  // We check the FINAL client score (which includes stage-3 coherence adjustment)
+  // if it was included, otherwise fall back to the base jitterScore.
+  const finalClientScore = payload.classification?.finalScore ?? jitterScore;
+  if (finalClientScore < serverDynamicMin) {
+    valid = false;
+    reasons.push(
+      `DYNAMIC_THRESHOLD_NOT_MET: score=${finalClientScore} < ` +
+      `serverMin=${serverDynamicMin} (evidenceWeight=${
+        _computeEvidenceWeight(payload).toFixed(3)
+      })`
+    );
+  }
+
+  // Surface diagnostic flags from the client's classifier
+  for (const flag of (payload.classification?.flags ?? [])) {
+    if (flag.includes('VM') || flag.includes('FLAT') || flag.includes('SYNTHETIC')) {
+      riskFlags.push(`CLIENT_FLAG:${flag}`);
+    }
+  }
+
+  // Hard override from the client heuristic engine (stage 2).
+  // EJR_PHASE_HARD_KILL fires when the stored entropyJitterRatio is mathematically
+  // inconsistent with the stored cold_QE / hot_QE values — proof of tampering.
+  // A legitimate SDK running on real hardware never triggers this.
+  if (payload.heuristic?.hardOverride === 'vm') {
+    valid = false;
+    reasons.push(
+      `HEURISTIC_HARD_OVERRIDE: stage-2 EJR/QE mathematical contradiction — ` +
+      `${(payload.heuristic.coherenceFlags ?? []).join(', ')}`
+    );
+  }
+
+  // Hard override from the client coherence stage (stage 3).
+  // Second line of defence — catches the same contradiction via a different
+  // code path and also catches the phase-trajectory forgery variant.
+  if (payload.coherence?.hardOverride === 'vm') {
+    valid = false;
+    reasons.push(
+      `COHERENCE_HARD_OVERRIDE: stage-3 analysis detected a mathematical ` +
+      `impossibility — ${(payload.coherence.coherenceFlags ?? []).join(', ')}`
+    );
+  }
+
+  // Surface all coherence flags for risk tracking / audit logs
+  for (const flag of (payload.heuristic?.coherenceFlags ?? [])) {
+    riskFlags.push(`HEURISTIC:${flag}`);
+  }
+  for (const flag of (payload.coherence?.coherenceFlags ?? [])) {
+    riskFlags.push(`COHERENCE:${flag}`);
+  }
+
+  // ── 5. Canvas / WebGL renderer check ──────────────────────────────────────
+  const canvas = payload.signals?.canvas;
+  if (canvas) {
+    if (canvas.isSoftwareRenderer && blockSoftwareRenderer) {
+      valid = false;
+      reasons.push(`SOFTWARE_RENDERER_DETECTED: ${canvas.webglRenderer}`);
+    }
+    const rendererLc = (canvas.webglRenderer ?? '').toLowerCase();
+    for (const pattern of VM_RENDERER_BLOCKLIST) {
+      if (rendererLc.includes(pattern)) {
+        valid = false;
+        reasons.push(`BLOCKLISTED_RENDERER: ${canvas.webglRenderer}`);
+        riskFlags.push(`RENDERER_MATCH:${pattern}`);
+        break;
+      }
+    }
+    if (!canvas.available) {
+      riskFlags.push('CANVAS_UNAVAILABLE');
+    }
+  }
+
+  // ── 6. Bio activity ───────────────────────────────────────────────────────
+  const bio = payload.signals?.bio;
+  if (bio) {
+    if (requireBio && !bio.hasActivity) {
+      valid = false;
+      reasons.push('NO_BIO_ACTIVITY_DETECTED');
+    }
+    if (bio.mouseSampleCount === 0 && bio.keyboardSampleCount === 0) {
+      riskFlags.push('ZERO_BIO_SAMPLES');
+    }
+    // Interference coefficient check: real human+hardware shows measurable correlation
+    if (bio.interferenceCoefficient < -0.3) {
+      riskFlags.push('NEGATIVE_INTERFERENCE_COEFFICIENT');
+    }
+  }
+
+  // ── 7. Internal consistency checks ────────────────────────────────────────
+  const entropy = payload.signals?.entropy;
+  if (entropy) {
+    // CV and jitter score should be directionally consistent
+    if (entropy.timingsCV < 0.01 && jitterScore > 0.7) {
+      riskFlags.push('INCONSISTENCY:LOW_CV_BUT_HIGH_SCORE');
+    }
+    // Timer granularity should not be exactly 0 (no real device has infinite resolution)
+    if (entropy.timerGranularityMs === 0) {
+      riskFlags.push('SUSPICIOUS_ZERO_TIMER_GRANULARITY');
+    }
+    // Extreme thermal patterns inconsistent with score
+    if (entropy.thermalPattern === 'flat' && jitterScore > 0.8) {
+      riskFlags.push('INCONSISTENCY:FLAT_THERMAL_BUT_HIGH_SCORE');
+    }
+    // Hurst exponent way out of range
+    if (entropy.hurstExponent != null) {
+      if (entropy.hurstExponent < 0.2 || entropy.hurstExponent > 0.85) {
+        riskFlags.push(`EXTREME_HURST:${entropy.hurstExponent}`);
+      }
+    }
+  }
+
+  // ── 7b. Cross-signal physics forgery detection ────────────────────────────
+  // BLAKE3 prevents tampering with a payload that was legitimately generated by
+  // the SDK. However, a determined attacker can:
+  //   1. Obtain a valid server nonce
+  //   2. Craft a fake payload with forged statistics
+  //   3. Compute BLAKE3(forgedPayload) themselves (BLAKE3 is public)
+  //   4. Submit { payload: forgedPayload, hash: selfComputedHash }
+  //
+  // These checks detect statistically impossible metric combinations that no
+  // real device would ever produce, catching crafted payloads even though the
+  // hash integrity check passes.
+  //
+  // All three thresholds are set conservatively: they only fire when the
+  // combination is physically IMPOSSIBLE, not just unlikely, to avoid false
+  // positives on unusual-but-legitimate hardware.
+  if (entropy) {
+    const cv   = entropy.timingsCV        ?? null;
+    const qe   = entropy.quantizationEntropy ?? null;
+    const lag1 = entropy.autocorr_lag1    ?? null;
+
+    // Impossibly flat CV + high physical score
+    // Real explanation: CV < 0.015 means timing jitter < 1.5% — hypervisor-flat.
+    // No real-silicon CPU running a WASM matrix multiply achieves this.
+    // A high jitterScore (> 0.65) is physically incompatible with CV < 0.015.
+    if (cv !== null && cv < 0.015 && jitterScore > 0.65) {
+      valid = false;
+      reasons.push(
+        `FORGED_SIGNAL:CV_SCORE_IMPOSSIBLE cv=${cv.toFixed(5)} is hypervisor-flat ` +
+        `but jitterScore=${jitterScore.toFixed(3)} claims physical hardware`
+      );
+    }
+
+    // VM-grade autocorrelation + high physical score
+    // lag1 > 0.70 is a hypervisor scheduler rhythm — unambiguous VM signature.
+    // A device with that level of autocorrelation cannot score > 0.70 on the
+    // physical scale; the jitter classifier would have penalised it heavily.
+    if (lag1 !== null && lag1 > 0.70 && jitterScore > 0.70) {
+      valid = false;
+      reasons.push(
+        `FORGED_SIGNAL:AUTOCORR_SCORE_IMPOSSIBLE lag1=${lag1.toFixed(3)} is VM-level ` +
+        `but jitterScore=${jitterScore.toFixed(3)} claims physical hardware`
+      );
+    }
+
+    // VM-grade quantization entropy + high physical score
+    // QE < 2.0 means timings cluster on a small number of distinct values —
+    // the classic integer-millisecond quantisation of an emulated/virtual timer.
+    // A device producing QE < 2.0 cannot legitimately score > 0.65 as physical.
+    if (qe !== null && qe < 2.0 && jitterScore > 0.65) {
+      valid = false;
+      reasons.push(
+        `FORGED_SIGNAL:QE_SCORE_IMPOSSIBLE qe=${qe.toFixed(3)} bits is VM-level ` +
+        `but jitterScore=${jitterScore.toFixed(3)} claims physical hardware`
+      );
+    }
+  }
+
+  // ── 8. Audio signal check ─────────────────────────────────────────────────
+  const audio = payload.signals?.audio;
+  if (audio?.available) {
+    // Impossibly low jitter CV may indicate a synthetic audio driver
+    if (audio.callbackJitterCV < 0.001) {
+      riskFlags.push('AUDIO_JITTER_TOO_FLAT');
+    }
+  }
+
+  // ── Confidence rating ─────────────────────────────────────────────────────
+  let confidence;
+  if (!valid) {
+    confidence = 'rejected';
+  } else if (riskFlags.length === 0 && jitterScore >= 0.75) {
+    confidence = 'high';
+  } else if (riskFlags.length <= 2 && jitterScore >= 0.60) {
+    confidence = 'medium';
+  } else {
+    confidence = 'low';
+  }
+
+  return {
+    valid,
+    score:      jitterScore,
+    confidence,
+    reasons,
+    riskFlags,
+    meta: {
+      receivedAt:   now,
+      proofAge:     age,
+      jitterScore,
+      canvasRenderer: canvas?.webglRenderer ?? null,
+      bioActivity:    bio?.hasActivity ?? false,
+    },
+  };
+}
+
+/**
+ * @typedef {object} ValidationResult
+ * @property {boolean}  valid
+ * @property {number}   score
+ * @property {'high'|'medium'|'low'|'rejected'} confidence
+ * @property {string[]} reasons    - human-readable rejection reasons
+ * @property {string[]} riskFlags  - non-blocking risk indicators
+ * @property {object}   meta
+ */
+
+// ---------------------------------------------------------------------------
+// generateNonce  (convenience helper for the server challenge flow)
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a cryptographically random 32-byte nonce for the server challenge.
+ * The server should store this nonce with a TTL before issuing it to the client.
+ *
+ * @returns {string}  hex nonce
+ */
+async function generateNonce() {
+  const buf = new Uint8Array(32);
+  if (typeof globalThis.crypto?.getRandomValues === 'function') {
+    // Browser + Node.js ≥ 19
+    globalThis.crypto.getRandomValues(buf);
+  } else {
+    // Node.js 18 — webcrypto is at `crypto.webcrypto`
+    const { webcrypto } = await import('node:crypto');
+    webcrypto.getRandomValues(buf);
+  }
+  return bytesToHex(buf);
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _reject(reasons) {
+  return {
+    valid:      false,
+    score:      0,
+    confidence: 'rejected',
+    reasons,
+    riskFlags:  [],
+    meta:       {},
+  };
+}
+
+function _computeEvidenceWeight(payload) {
+  const n         = payload?.signals?.entropy?.iterations ?? 0;
+  const hasPhases = payload?.heuristic?.entropyJitterRatio != null;
+  const hasBio    = payload?.signals?.bio?.hasActivity === true;
+  const hasAudio  = payload?.signals?.audio?.available === true;
+  const hasCanvas = payload?.signals?.canvas?.available === true;
+  return Math.min(1.0,
+    Math.min(1.0, n / 200) * 0.65 +
+    (hasPhases ? 0.15 : 0) +
+    (hasBio    ? 0.10 : 0) +
+    (hasAudio  ? 0.05 : 0) +
+    (hasCanvas ? 0.05 : 0)
+  );
+}
+
+/**
+ * @sovereign/pulse
+ *
+ * Physical Turing Test — distinguishes a real consumer device with a human
+ * operator from a sanitised Datacenter VM / AI Instance.
+ *
+ * Usage (client-side):
+ *
+ *   import { pulse } from '@sovereign/pulse';
+ *
+ *   // 1. Get a server-issued nonce (prevents replay attacks)
+ *   const { nonce } = await fetch('/api/pulse-challenge').then(r => r.json());
+ *
+ *   // 2. Run the probe (takes ~3-5 seconds)
+ *   const { payload, hash } = await pulse({ nonce });
+ *
+ *   // 3. Send to your server
+ *   const verdict = await fetch('/api/pulse-verify', {
+ *     method: 'POST',
+ *     body: JSON.stringify({ payload, hash }),
+ *   }).then(r => r.json());
+ *
+ * Usage (server-side):
+ *
+ *   import { validateProof, generateNonce } from '@sovereign/pulse/validator';
+ *
+ *   // Challenge endpoint
+ *   app.get('/api/pulse-challenge', (req, res) => {
+ *     const nonce = generateNonce();
+ *     await redis.set(`pulse:nonce:${nonce}`, '1', 'EX', 300); // 5-min TTL
+ *     res.json({ nonce });
+ *   });
+ *
+ *   // Verify endpoint
+ *   app.post('/api/pulse-verify', async (req, res) => {
+ *     const { payload, hash } = req.body;
+ *     const result = await validateProof(payload, hash, {
+ *       checkNonce: async (n) => {
+ *         const ok = await redis.del(`pulse:nonce:${n}`);
+ *         return ok === 1; // true only if nonce existed and was consumed
+ *       },
+ *     });
+ *     res.json(result);
+ *   });
+ */
+
+
+// ---------------------------------------------------------------------------
+// Hosted API mode — pulse({ apiKey }) with zero server setup
+// ---------------------------------------------------------------------------
+
+/**
+ * Run pulse() against the sovereign hosted API.
+ * Fetches nonce, runs probe locally (WASM still on device), submits proof.
+ *
+ * @param {object} opts  — same as pulse(), plus apiKey + apiUrl
+ * @returns {Promise<{ payload, hash, result }>}
+ */
+async function _pulseHosted(opts) {
+  const {
+    apiKey,
+    apiUrl            = 'https://api.sovereign.dev',
+    iterations        = 200,
+    matrixSize        = 64,
+    bioWindowMs       = 3_000,
+    phased            = true,
+    adaptive          = true,
+    adaptiveThreshold = 0.85,
+    requireBio        = false,
+    wasmPath,
+    onProgress,
+    verifyOptions     = {},
+  } = opts;
+
+  // 1. Fetch nonce from hosted challenge endpoint
+  const challengeRes = await fetch(`${apiUrl}/v1/challenge`, {
+    headers: { 'Authorization': `Bearer ${apiKey}` },
+  });
+  if (!challengeRes.ok) {
+    const body = await challengeRes.json().catch(() => ({}));
+    throw new Error(`[pulse] Challenge failed (${challengeRes.status}): ${body.message ?? 'unknown error'}`);
+  }
+  const { nonce } = await challengeRes.json();
+
+  // 2. Run the local probe (WASM, bio, canvas, audio — all on device)
+  const commitment = await _runProbe({
+    nonce, iterations, matrixSize, bioWindowMs,
+    phased, adaptive, adaptiveThreshold, requireBio,
+    wasmPath, onProgress,
+  });
+
+  // 3. Submit proof to hosted verify endpoint
+  const verifyRes = await fetch(`${apiUrl}/v1/verify`, {
+    method:  'POST',
+    headers: {
+      'Content-Type':  'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      payload: commitment.payload,
+      hash:    commitment.hash,
+      options: verifyOptions,
+    }),
+  });
+
+  const result = await verifyRes.json();
+
+  // Return commitment + server result for convenience
+  return { ...commitment, result };
+}
+
+// ---------------------------------------------------------------------------
+// pulse()  — main entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the full @sovereign/pulse probe and return a signed commitment.
+ *
+ * Two modes:
+ *   - pulse({ nonce })     — self-hosted (you manage the nonce server)
+ *   - pulse({ apiKey })    — hosted API (zero server setup required)
+ *
+ * @param {PulseOptions} opts
+ * @returns {Promise<PulseCommitment>}
+ */
+async function pulse(opts = {}) {
+  // ── Hosted API mode ────────────────────────────────────────────────────────
+  if (opts.apiKey) {
+    return _pulseHosted(opts);
+  }
+
+  // ── Self-hosted mode ───────────────────────────────────────────────────────
+  const { nonce } = opts;
+  if (!nonce || typeof nonce !== 'string') {
+    throw new Error(
+      '@sovereign/pulse: opts.nonce is required (self-hosted), or pass opts.apiKey for zero-config hosted mode.'
+    );
+  }
+
+  return _runProbe(opts);
+}
+
+/**
+ * Internal probe runner — shared between self-hosted and hosted API modes.
+ * @private
+ */
+async function _runProbe(opts) {
+  const {
+    nonce,
+    timeout           = 8_000,
+    iterations        = 200,
+    matrixSize        = 64,
+    bioWindowMs       = 3_000,
+    phased            = true,
+    adaptive          = true,
+    adaptiveThreshold = 0.85,
+    requireBio        = false,
+    wasmPath,
+    onProgress,
+  } = opts;
+
+  _emit(onProgress, 'start');
+
+  // ── Phase 1: Start bio collector immediately (collects events over time) ──
+  const bio = new BioCollector();
+  bio.start();
+
+  // ── Phase 2: Parallel collection ──────────────────────────────────────────
+  const raceTimeout = new Promise((_, reject) =>
+    setTimeout(() => reject(new Error('pulse() timed out')), timeout)
+  );
+
+  let entropyResult, canvasResult, audioResult;
+
+  try {
+    [entropyResult, canvasResult, audioResult] = await Promise.race([
+      Promise.all([
+        collectEntropy({
+          iterations, matrixSize, phased, adaptive, adaptiveThreshold, wasmPath,
+          onBatch: (meta) => _emit(onProgress, 'entropy_batch', meta),
+        }).then(r => { _emit(onProgress, 'entropy_done'); return r; }),
+        collectCanvasFingerprint()
+          .then(r => { _emit(onProgress, 'canvas_done'); return r; }),
+        collectAudioJitter({ durationMs: Math.min(bioWindowMs, 2_000) })
+          .then(r => { _emit(onProgress, 'audio_done'); return r; }),
+      ]),
+      raceTimeout,
+    ]);
+  } catch (err) {
+    bio.stop();
+    throw err;
+  }
+
+  // ── Phase 3: Bio snapshot ─────────────────────────────────────────────────
+  const bioElapsed = Date.now() - entropyResult.collectedAt;
+  const bioRemain  = Math.max(0, bioWindowMs - bioElapsed);
+  if (bioRemain > 0) await _sleep(bioRemain);
+
+  bio.stop();
+  const bioSnapshot = bio.snapshot(entropyResult.timings);
+
+  if (requireBio && !bioSnapshot.hasActivity) {
+    throw new Error('@sovereign/pulse: no bio activity detected (requireBio=true)');
+  }
+
+  _emit(onProgress, 'bio_done');
+
+  // ── Phase 4: Jitter analysis ───────────────────────────────────────────────
+  const jitterAnalysis = classifyJitter(entropyResult.timings, {
+    autocorrelations: entropyResult.autocorrelations,
+  });
+
+  _emit(onProgress, 'analysis_done');
+
+  // ── Phase 5: Build proof & commitment ─────────────────────────────────────
+  const payload    = buildProof({
+    entropy: entropyResult,
+    jitter:  jitterAnalysis,
+    bio:     bioSnapshot,
+    canvas:  canvasResult,
+    audio:   audioResult,
+    nonce,
+  });
+
+  const commitment = buildCommitment(payload);
+
+  _emit(onProgress, 'complete', {
+    score:      jitterAnalysis.score,
+    confidence: _scoreToLabel(jitterAnalysis.score),
+    flags:      jitterAnalysis.flags,
+  });
+
+  return commitment;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function _sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+function _emit(fn, stage, meta = {}) {
+  if (typeof fn === 'function') {
+    try { fn(stage, meta); } catch (_) {}
+  }
+}
+
+function _scoreToLabel(score) {
+  if (score >= 0.75) return 'high';
+  if (score >= 0.55) return 'medium';
+  if (score >= 0.35) return 'low';
+  return 'rejected';
+}
+
+/**
+ * pulse_core — pure-JavaScript probe engine
+ *
+ * This module ships the entropy probe as portable JS so the package works
+ * out-of-the-box without a Rust toolchain.  When a compiled .wasm binary is
+ * present (dropped in via `build.sh`) this file is replaced by the wasm-pack
+ * output and the native engine runs instead.
+ *
+ * Physics model
+ * ─────────────
+ * Real silicon: DRAM refresh cycles, branch-predictor misses, and L3-cache
+ * evictions inject sub-microsecond noise into any tight compute loop.
+ * Hypervisors virtualise the TSC and smooth those interrupts out, leaving
+ * a near-flat timing distribution that our QE/EJR checks catch.
+ *
+ * The JS loop below is a faithful port of the Rust matrix-multiply probe:
+ * same work unit (N×N DGEMM-style loop), same checksum accumulation to
+ * prevent dead-code elimination, same resolution micro-probe.
+ */
+
+/* ─── clock ─────────────────────────────────────────────────────────────── */
+
+const _now = (typeof performance !== 'undefined' && typeof performance.now === 'function')
+  ? () => performance.now()
+  : (() => {
+      // Node.js fallback: process.hrtime.bigint() → milliseconds
+      const _hr = process.hrtime.bigint;
+      return () => Number(_hr()) / 1_000_000;
+    })();
+
+/* ─── init (no-op for the JS engine) ───────────────────────────────────── */
+
+/**
+ * Initialise the engine.  When a real .wasm binary is supplied the wasm-pack
+ * glue calls WebAssembly.instantiateStreaming here.  The JS engine is already
+ * "compiled", so we return immediately.
+ *
+ * @param {string|URL|Request|BufferSource|WebAssembly.Module} [_source]
+ * @returns {Promise<void>}
+ */
+async function init(_source) {
+  // JS engine is ready synchronously — nothing to stream or compile.
+}
+
+/* ─── run_entropy_probe ─────────────────────────────────────────────────── */
+
+/**
+ * Run N iterations of a matrix-multiply work unit and record wall-clock time
+ * per iteration.  The distribution of those times is what the heuristic
+ * engine analyses.
+ *
+ * @param {number} iterations  – number of timing samples to collect
+ * @param {number} matrixSize  – N for the N×N multiply (default 64)
+ * @returns {{ timings: Float64Array, checksum: number, resolution_probe: Float64Array }}
+ */
+function run_entropy_probe(iterations, matrixSize = 64) {
+  const N = matrixSize | 0;
+
+  // Persistent working matrices — allocated once per probe to avoid GC noise.
+  const A = new Float64Array(N * N);
+  const B = new Float64Array(N * N);
+  const C = new Float64Array(N * N);
+
+  // Seed matrices with pseudo-random data (deterministic per call for
+  // reproducibility, but different each run due to xorshift seeding from time).
+  let seed = (_now() * 1e6) | 0 || 0xdeadbeef;
+  const xr  = () => { seed ^= seed << 13; seed ^= seed >> 17; seed ^= seed << 5; return (seed >>> 0) / 4294967296; };
+  for (let i = 0; i < N * N; i++) { A[i] = xr(); B[i] = xr(); }
+
+  const timings         = new Float64Array(iterations);
+  const resolution_probe = new Float64Array(32);
+  let   checksum        = 0;
+
+  for (let iter = 0; iter < iterations; iter++) {
+    // Zero accumulator each round (realistic cache pressure).
+    C.fill(0);
+
+    const t0 = _now();
+
+    // N×N matrix multiply: C = A · B  (ikj loop order for cache friendliness)
+    for (let i = 0; i < N; i++) {
+      const rowA = i * N;
+      const rowC = i * N;
+      for (let k = 0; k < N; k++) {
+        const aik   = A[rowA + k];
+        const rowBk = k * N;
+        for (let j = 0; j < N; j++) {
+          C[rowC + j] += aik * B[rowBk + j];
+        }
+      }
+    }
+
+    const t1 = _now();
+    timings[iter] = t1 - t0;
+
+    // Accumulate one element so the compiler cannot eliminate the work.
+    checksum += C[0];
+  }
+
+  // Resolution micro-probe: fire 32 back-to-back timestamps.
+  // The minimum non-zero delta reveals timer granularity.
+  for (let i = 0; i < resolution_probe.length; i++) {
+    resolution_probe[i] = _now();
+  }
+
+  return { timings, checksum, resolution_probe };
+}
+
+/* ─── run_memory_probe ──────────────────────────────────────────────────── */
+
+/**
+ * Sequential read/write bandwidth probe over a large buffer.
+ * Memory latency variance is a secondary signal (NUMA, DRAM refresh).
+ *
+ * @param {number} memSizeKb    – buffer size in kibibytes
+ * @param {number} memIterations
+ * @returns {{ timings: Float64Array, checksum: number }}
+ */
+function run_memory_probe(memSizeKb = 512, memIterations = 50) {
+  const len     = (memSizeKb * 1024 / 8) | 0;   // 64-bit elements
+  const buf     = new Float64Array(len);
+  const timings = new Float64Array(memIterations);
+  let   checksum = 0;
+
+  // Warm-up pass (fills TLB, avoids first-access bias)
+  for (let i = 0; i < len; i++) buf[i] = i;
+
+  for (let iter = 0; iter < memIterations; iter++) {
+    const t0 = _now();
+    // Sequential read-modify-write
+    for (let i = 0; i < len; i++) buf[i] = buf[i] * 1.0000001;
+    const t1 = _now();
+
+    timings[iter] = t1 - t0;
+    checksum += buf[0];
+  }
+
+  return { timings, checksum };
+}
+
+/* ─── compute_autocorrelation ───────────────────────────────────────────── */
+
+/**
+ * Pearson autocorrelation for lags 1..maxLag.
+ * O(n·maxLag) — kept cheap by the adaptive early-exit cap.
+ *
+ * @param {ArrayLike<number>} data
+ * @param {number}            maxLag
+ * @returns {Float64Array}  length = maxLag, index 0 = lag-1
+ */
+function compute_autocorrelation(data, maxLag) {
+  const n    = data.length;
+  let   mean = 0;
+  for (let i = 0; i < n; i++) mean += data[i];
+  mean /= n;
+
+  let variance = 0;
+  for (let i = 0; i < n; i++) variance += (data[i] - mean) ** 2;
+  variance /= n;
+
+  const result = new Float64Array(maxLag);
+  if (variance < 1e-14) return result;          // degenerate — all identical
+
+  for (let lag = 1; lag <= maxLag; lag++) {
+    let cov = 0;
+    for (let i = 0; i < n - lag; i++) {
+      cov += (data[i] - mean) * (data[i + lag] - mean);
+    }
+    result[lag - 1] = cov / ((n - lag) * variance);
+  }
+
+  return result;
+}
+
+var pulse_core = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  compute_autocorrelation: compute_autocorrelation,
+  default: init,
+  run_entropy_probe: run_entropy_probe,
+  run_memory_probe: run_memory_probe
+});
+
+export { Fingerprint, detectProvider, generateNonce, pulse, runHeuristicEngine, validateProof };
+//# sourceMappingURL=pulse.esm.js.map