@entros/pulse-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,3130 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_CAPTURE_MS: () => DEFAULT_CAPTURE_MS,
+  DEFAULT_MIN_DISTANCE: () => DEFAULT_MIN_DISTANCE,
+  DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD,
+  FINGERPRINT_BITS: () => FINGERPRINT_BITS,
+  MAX_CAPTURE_MS: () => MAX_CAPTURE_MS,
+  MIN_CAPTURE_MS: () => MIN_CAPTURE_MS,
+  PROGRAM_IDS: () => PROGRAM_IDS,
+  PulseSDK: () => PulseSDK,
+  PulseSession: () => PulseSession,
+  SPEAKER_FEATURE_COUNT: () => SPEAKER_FEATURE_COUNT,
+  attestAgentOperator: () => attestAgentOperator,
+  autocorrelation: () => autocorrelation,
+  bigintToBytes32: () => bigintToBytes32,
+  computeCommitment: () => computeCommitment,
+  condense: () => condense,
+  encodeAudioAsBase64: () => encodeAudioAsBase64,
+  entropy: () => entropy,
+  extractAccelerationMagnitude: () => extractAccelerationMagnitude,
+  extractMotionFeatures: () => extractMotionFeatures,
+  extractMouseDynamics: () => extractMouseDynamics,
+  extractSpeakerFeatures: () => extractSpeakerFeatures,
+  extractSpeakerFeaturesDetailed: () => extractSpeakerFeaturesDetailed,
+  extractTouchFeatures: () => extractTouchFeatures,
+  fetchChallenge: () => fetchChallenge,
+  fetchIdentityState: () => fetchIdentityState,
+  fuseFeatures: () => fuseFeatures,
+  fuseRawFeatures: () => fuseRawFeatures,
+  generateLissajousPoints: () => generateLissajousPoints,
+  generateLissajousSequence: () => generateLissajousSequence,
+  generatePhrase: () => generatePhrase,
+  generatePhraseSequence: () => generatePhraseSequence,
+  generateProof: () => generateProof,
+  generateSalt: () => generateSalt,
+  generateSolanaProof: () => generateSolanaProof,
+  generateTBH: () => generateTBH,
+  getAgentHumanOperator: () => getAgentHumanOperator,
+  hammingDistance: () => hammingDistance,
+  kurtosis: () => kurtosis,
+  loadVerificationData: () => loadVerificationData,
+  mean: () => mean,
+  packBits: () => packBits,
+  prepareCircuitInput: () => prepareCircuitInput,
+  randomLissajousParams: () => randomLissajousParams,
+  serializeProof: () => serializeProof,
+  simhash: () => simhash,
+  skewness: () => skewness,
+  storeVerificationData: () => storeVerificationData,
+  submitResetViaWallet: () => submitResetViaWallet,
+  submitViaRelayer: () => submitViaRelayer,
+  submitViaWallet: () => submitViaWallet,
+  toBigEndian32: () => toBigEndian32,
+  variance: () => variance,
+  verifyEntrosAttestation: () => verifyEntrosAttestation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var BN254_BASE_FIELD = BigInt(
+  "21888242871839275222246405745257275088696311157297823662689037894645226208583"
+);
+var BN254_SCALAR_FIELD = BigInt(
+  "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+);
+var FINGERPRINT_BITS = 256;
+var DEFAULT_THRESHOLD = 96;
+var DEFAULT_MIN_DISTANCE = 3;
+var NUM_PUBLIC_INPUTS = 4;
+var PROOF_A_SIZE = 64;
+var PROOF_B_SIZE = 128;
+var PROOF_C_SIZE = 64;
+var TOTAL_PROOF_SIZE = 256;
+var SIMHASH_SEED = "IAM-PROTOCOL-SIMHASH-V1";
+var MIN_CAPTURE_MS = 2e3;
+var MAX_CAPTURE_MS = 6e4;
+var DEFAULT_CAPTURE_MS = 7e3;
+var PROGRAM_IDS = {
+  entrosAnchor: "GZYwTp2ozeuRA5Gof9vs4ya961aANcJBdUzB7LN6q4b2",
+  entrosVerifier: "4F97jNoxQzT2qRbkWpW3ztC3Nz2TtKj3rnKG8ExgnrfV",
+  entrosRegistry: "6VBs3zr9KrfFPGd6j7aGBPQWwZa5tajVfA7HN6MMV9VW"
+};
+var AGENT_REGISTRY_CONFIG = {
+  programIdDevnet: "8oo4J9tBB3Hna1jRQ3rWvJjojqM5DYTDJo5cejUuJy3C",
+  programIdMainnet: "8oo4dC4JvBLwy5tGgiH3WwK4B9PWxL9Z4XjA2jzkQMbQ",
+  metadataKey: "iam:human-operator"
+};
+var SAS_CONFIG = {
+  programId: "22zoJMtdu4tQc2PzL74ZUT7FrwgB1Udec8DdW4yw4BdG",
+  entrosCredentialPda: "GaPTkZC6JEGds1G5h645qyUrogx7NWghR2JgjvKQwTDo",
+  entrosSchemaPda: "EPkajiGQjycPwcc3pupqExVdAmSfxWd31tRYZezd8c5g"
+};
+
+// src/log.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function sdkLog(...args) {
+  if (debugEnabled) console.log(...args);
+}
+function sdkWarn(...args) {
+  if (debugEnabled) console.warn(...args);
+}
+
+// src/sensor/audio.ts
+var TARGET_SAMPLE_RATE = 16e3;
+async function captureAudio(options = {}) {
+  const {
+    signal,
+    minDurationMs = MIN_CAPTURE_MS,
+    maxDurationMs = MAX_CAPTURE_MS,
+    onAudioLevel,
+    stream: preAcquiredStream
+  } = options;
+  const stream = preAcquiredStream ?? await navigator.mediaDevices.getUserMedia({
+    audio: {
+      sampleRate: TARGET_SAMPLE_RATE,
+      channelCount: 1,
+      echoCancellation: false,
+      noiseSuppression: false,
+      autoGainControl: false
+    }
+  });
+  const ctx = new AudioContext({ sampleRate: TARGET_SAMPLE_RATE });
+  await ctx.resume();
+  const capturedSampleRate = ctx.sampleRate;
+  const source = ctx.createMediaStreamSource(stream);
+  const chunks = [];
+  const startTime = performance.now();
+  return new Promise((resolve) => {
+    let stopped = false;
+    const bufferSize = 4096;
+    const processor = ctx.createScriptProcessor(bufferSize, 1, 1);
+    processor.onaudioprocess = (e) => {
+      const data = e.inputBuffer.getChannelData(0);
+      chunks.push(new Float32Array(data));
+      if (onAudioLevel) {
+        let sum = 0;
+        for (let i = 0; i < data.length; i++) sum += data[i] * data[i];
+        onAudioLevel(Math.sqrt(sum / data.length));
+      }
+    };
+    source.connect(processor);
+    processor.connect(ctx.destination);
+    function stopCapture() {
+      if (stopped) return;
+      stopped = true;
+      clearTimeout(maxTimer);
+      processor.disconnect();
+      source.disconnect();
+      stream.getTracks().forEach((t) => t.stop());
+      ctx.close().catch(() => {
+      });
+      const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+      const samples = new Float32Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        samples.set(chunk, offset);
+        offset += chunk.length;
+      }
+      resolve({
+        samples,
+        sampleRate: capturedSampleRate,
+        duration: totalLength / capturedSampleRate
+      });
+    }
+    const maxTimer = setTimeout(stopCapture, maxDurationMs);
+    if (signal) {
+      if (signal.aborted) {
+        setTimeout(stopCapture, minDurationMs);
+      } else {
+        signal.addEventListener(
+          "abort",
+          () => {
+            const elapsed = performance.now() - startTime;
+            const remaining = Math.max(0, minDurationMs - elapsed);
+            setTimeout(stopCapture, remaining);
+          },
+          { once: true }
+        );
+      }
+    }
+  });
+}
+
+// src/sensor/encode.ts
+function encodeAudioAsBase64(samples) {
+  const buf = new ArrayBuffer(samples.length * 2);
+  const view = new DataView(buf);
+  for (let i = 0; i < samples.length; i++) {
+    const s = Math.max(-1, Math.min(1, samples[i]));
+    const int16 = s < 0 ? Math.round(s * 32768) : Math.round(s * 32767);
+    view.setInt16(i * 2, int16, true);
+  }
+  return bytesToBase64(new Uint8Array(buf));
+}
+function bytesToBase64(bytes) {
+  const chunkSize = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+}
+
+// src/sensor/motion.ts
+async function requestMotionPermission() {
+  const DME = globalThis.DeviceMotionEvent;
+  if (!DME) return false;
+  if (typeof DME.requestPermission === "function") {
+    const permission = await DME.requestPermission();
+    return permission === "granted";
+  }
+  return true;
+}
+async function captureMotion(options = {}) {
+  const {
+    signal,
+    minDurationMs = MIN_CAPTURE_MS,
+    maxDurationMs = MAX_CAPTURE_MS
+  } = options;
+  const hasPermission = options.permissionGranted ?? await requestMotionPermission();
+  if (!hasPermission) return [];
+  const samples = [];
+  const startTime = performance.now();
+  return new Promise((resolve) => {
+    let stopped = false;
+    const handler = (e) => {
+      samples.push({
+        timestamp: performance.now(),
+        ax: e.acceleration?.x ?? 0,
+        ay: e.acceleration?.y ?? 0,
+        az: e.acceleration?.z ?? 0,
+        gx: e.rotationRate?.alpha ?? 0,
+        gy: e.rotationRate?.beta ?? 0,
+        gz: e.rotationRate?.gamma ?? 0
+      });
+    };
+    function stopCapture() {
+      if (stopped) return;
+      stopped = true;
+      clearTimeout(maxTimer);
+      window.removeEventListener("devicemotion", handler);
+      resolve(samples);
+    }
+    window.addEventListener("devicemotion", handler);
+    const maxTimer = setTimeout(stopCapture, maxDurationMs);
+    if (signal) {
+      if (signal.aborted) {
+        setTimeout(stopCapture, minDurationMs);
+      } else {
+        signal.addEventListener(
+          "abort",
+          () => {
+            const elapsed = performance.now() - startTime;
+            const remaining = Math.max(0, minDurationMs - elapsed);
+            setTimeout(stopCapture, remaining);
+          },
+          { once: true }
+        );
+      }
+    }
+  });
+}
+
+// src/sensor/touch.ts
+function captureTouch(element, options = {}) {
+  const {
+    signal,
+    minDurationMs = MIN_CAPTURE_MS,
+    maxDurationMs = MAX_CAPTURE_MS
+  } = options;
+  const samples = [];
+  const startTime = performance.now();
+  return new Promise((resolve) => {
+    let stopped = false;
+    const handler = (e) => {
+      samples.push({
+        timestamp: performance.now(),
+        x: e.clientX,
+        y: e.clientY,
+        pressure: e.pressure,
+        width: e.width,
+        height: e.height
+      });
+    };
+    function stopCapture() {
+      if (stopped) return;
+      stopped = true;
+      clearTimeout(maxTimer);
+      element.removeEventListener("pointermove", handler);
+      element.removeEventListener("pointerdown", handler);
+      sdkLog(`[Entros SDK] Touch capture stopped: ${samples.length} samples collected`);
+      resolve(samples);
+    }
+    element.addEventListener("pointermove", handler);
+    element.addEventListener("pointerdown", handler);
+    sdkLog(`[Entros SDK] Touch capture started on <${element.tagName}>, listening for pointer events`);
+    const maxTimer = setTimeout(stopCapture, maxDurationMs);
+    if (signal) {
+      if (signal.aborted) {
+        setTimeout(stopCapture, minDurationMs);
+      } else {
+        signal.addEventListener(
+          "abort",
+          () => {
+            const elapsed = performance.now() - startTime;
+            const remaining = Math.max(0, minDurationMs - elapsed);
+            setTimeout(stopCapture, remaining);
+          },
+          { once: true }
+        );
+      }
+    }
+  });
+}
+
+// src/extraction/statistics.ts
+function mean(values) {
+  if (values.length === 0) return 0;
+  let sum = 0;
+  for (const v of values) sum += v;
+  return sum / values.length;
+}
+function variance(values, mu) {
+  if (values.length < 2) return 0;
+  const m = mu ?? mean(values);
+  let sum = 0;
+  for (const v of values) sum += (v - m) ** 2;
+  return sum / (values.length - 1);
+}
+function skewness(values) {
+  if (values.length < 3) return 0;
+  const n = values.length;
+  const m = mean(values);
+  const s = Math.sqrt(variance(values, m));
+  if (s === 0) return 0;
+  let sum = 0;
+  for (const v of values) sum += ((v - m) / s) ** 3;
+  return n / ((n - 1) * (n - 2)) * sum;
+}
+function kurtosis(values) {
+  if (values.length < 4) return 0;
+  const n = values.length;
+  const m = mean(values);
+  const s2 = variance(values, m);
+  if (s2 === 0) return 0;
+  let sum = 0;
+  for (const v of values) sum += (v - m) ** 4 / s2 ** 2;
+  const k = n * (n + 1) / ((n - 1) * (n - 2) * (n - 3)) * sum - 3 * (n - 1) ** 2 / ((n - 2) * (n - 3));
+  return k;
+}
+function condense(values) {
+  const m = mean(values);
+  return {
+    mean: m,
+    variance: variance(values, m),
+    skewness: skewness(values),
+    kurtosis: kurtosis(values)
+  };
+}
+function entropy(values, bins = 16) {
+  if (values.length < 2) return 0;
+  let min = values[0];
+  let max = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (values[i] < min) min = values[i];
+    if (values[i] > max) max = values[i];
+  }
+  if (min === max) return 0;
+  const counts = new Array(bins).fill(0);
+  const range = max - min;
+  for (const v of values) {
+    const idx = Math.min(Math.floor((v - min) / range * bins), bins - 1);
+    counts[idx]++;
+  }
+  let h = 0;
+  for (const c of counts) {
+    if (c > 0) {
+      const p = c / values.length;
+      h -= p * Math.log2(p);
+    }
+  }
+  return h;
+}
+function autocorrelation(values, lag = 1) {
+  if (values.length <= lag) return 0;
+  const m = mean(values);
+  const v = variance(values, m);
+  if (v === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < values.length - lag; i++) {
+    sum += (values[i] - m) * (values[i + lag] - m);
+  }
+  return sum / ((values.length - lag) * v);
+}
+function normalizeGroup(features) {
+  if (features.length === 0) return features;
+  const clean = features.map((v) => Number.isFinite(v) ? v : 0);
+  let sum = 0;
+  for (const v of clean) sum += v;
+  const mean2 = sum / clean.length;
+  let sqSum = 0;
+  for (const v of clean) sqSum += (v - mean2) * (v - mean2);
+  const std = Math.sqrt(sqSum / clean.length);
+  if (std < 1e-8) return clean.map(() => 0);
+  return clean.map((v) => (v - mean2) / std);
+}
+function fuseRawFeatures(audio, motion, touch) {
+  const sanitize = (v) => Number.isFinite(v) ? v : 0;
+  return [...audio.map(sanitize), ...motion.map(sanitize), ...touch.map(sanitize)];
+}
+function fuseFeatures(audio, motion, touch) {
+  return [...normalizeGroup(audio), ...normalizeGroup(motion), ...normalizeGroup(touch)];
+}
+
+// src/extraction/lpc.ts
+function autocorrelate(signal, order) {
+  const r = [];
+  for (let lag = 0; lag <= order; lag++) {
+    let sum = 0;
+    for (let i = 0; i < signal.length - lag; i++) {
+      sum += signal[i] * signal[i + lag];
+    }
+    r.push(sum);
+  }
+  return r;
+}
+function levinsonDurbin(r, order) {
+  const a = new Array(order + 1).fill(0);
+  const aTemp = new Array(order + 1).fill(0);
+  a[0] = 1;
+  let error = r[0];
+  if (error === 0) return new Array(order).fill(0);
+  for (let i = 1; i <= order; i++) {
+    let lambda = 0;
+    for (let j = 1; j < i; j++) {
+      lambda += a[j] * r[i - j];
+    }
+    lambda = -(r[i] + lambda) / error;
+    for (let j = 1; j < i; j++) {
+      aTemp[j] = a[j] + lambda * a[i - j];
+    }
+    aTemp[i] = lambda;
+    for (let j = 1; j <= i; j++) {
+      a[j] = aTemp[j];
+    }
+    error *= 1 - lambda * lambda;
+    if (error <= 0) break;
+  }
+  return a.slice(1);
+}
+function findRoots(coefficients, maxIterations = 50) {
+  const n = coefficients.length;
+  if (n === 0) return [];
+  const roots = [];
+  for (let i = 0; i < n; i++) {
+    const angle = 2 * Math.PI * i / n + 0.1;
+    roots.push([0.9 * Math.cos(angle), 0.9 * Math.sin(angle)]);
+  }
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let maxShift = 0;
+    for (let i = 0; i < n; i++) {
+      let pReal = 1;
+      let pImag = 0;
+      let zPowReal = 1;
+      let zPowImag = 0;
+      const [rr, ri] = roots[i];
+      let curReal = 1;
+      let curImag = 0;
+      let znReal = 1;
+      let znImag = 0;
+      for (let k = 0; k < n; k++) {
+        const newReal = znReal * rr - znImag * ri;
+        const newImag = znReal * ri + znImag * rr;
+        znReal = newReal;
+        znImag = newImag;
+      }
+      pReal = znReal;
+      pImag = znImag;
+      zPowReal = 1;
+      zPowImag = 0;
+      for (let k = n - 1; k >= 0; k--) {
+        pReal += coefficients[k] * zPowReal;
+        pImag += coefficients[k] * zPowImag;
+        const newReal = zPowReal * rr - zPowImag * ri;
+        const newImag = zPowReal * ri + zPowImag * rr;
+        zPowReal = newReal;
+        zPowImag = newImag;
+      }
+      let denomReal = 1;
+      let denomImag = 0;
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        const diffReal = rr - roots[j][0];
+        const diffImag = ri - roots[j][1];
+        const newReal = denomReal * diffReal - denomImag * diffImag;
+        const newImag = denomReal * diffImag + denomImag * diffReal;
+        denomReal = newReal;
+        denomImag = newImag;
+      }
+      const denomMag2 = denomReal * denomReal + denomImag * denomImag;
+      if (denomMag2 < 1e-30) continue;
+      const shiftReal = (pReal * denomReal + pImag * denomImag) / denomMag2;
+      const shiftImag = (pImag * denomReal - pReal * denomImag) / denomMag2;
+      roots[i] = [rr - shiftReal, ri - shiftImag];
+      maxShift = Math.max(maxShift, Math.sqrt(shiftReal * shiftReal + shiftImag * shiftImag));
+    }
+    if (maxShift < 1e-10) break;
+  }
+  return roots;
+}
+function extractFormants(frame, sampleRate, lpcOrder = 12) {
+  const r = autocorrelate(frame, lpcOrder);
+  const coeffs = levinsonDurbin(r, lpcOrder);
+  const roots = findRoots(coeffs);
+  const formantCandidates = [];
+  for (const [real, imag] of roots) {
+    if (imag <= 0) continue;
+    const freq = Math.atan2(imag, real) / (2 * Math.PI) * sampleRate;
+    const bandwidth = -sampleRate / (2 * Math.PI) * Math.log(Math.sqrt(real * real + imag * imag));
+    if (freq > 200 && freq < 5e3 && bandwidth < 500) {
+      formantCandidates.push(freq);
+    }
+  }
+  formantCandidates.sort((a, b) => a - b);
+  if (formantCandidates.length < 3) return null;
+  return [formantCandidates[0], formantCandidates[1], formantCandidates[2]];
+}
+function extractFormantRatios(samples, sampleRate, frameSize, hopSize) {
+  const f1f2 = [];
+  const f2f3 = [];
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    const frame = samples.slice(start, start + frameSize);
+    const windowed = new Float32Array(frameSize);
+    for (let j = 0; j < frameSize; j++) {
+      windowed[j] = (frame[j] ?? 0) * (0.54 - 0.46 * Math.cos(2 * Math.PI * j / (frameSize - 1)));
+    }
+    const formants = extractFormants(windowed, sampleRate);
+    if (formants) {
+      const [f1, f2, f3] = formants;
+      if (f2 > 0) f1f2.push(f1 / f2);
+      if (f3 > 0) f2f3.push(f2 / f3);
+    }
+  }
+  return { f1f2, f2f3 };
+}
+
+// src/extraction/speaker.ts
+function getFrameSize(sampleRate) {
+  const MIN_F0 = 50;
+  const minSize = Math.ceil(4 * sampleRate / MIN_F0);
+  let size = 512;
+  while (size < minSize) size *= 2;
+  return size;
+}
+function getHopSize(sampleRate) {
+  return Math.max(1, Math.round(sampleRate * 0.01));
+}
+var SPEAKER_FEATURE_COUNT = 44;
+var pitchDetector = null;
+var pitchDetectorRate = 0;
+var meydaModule = null;
+async function getPitchDetector(sampleRate) {
+  if (!pitchDetector || pitchDetectorRate !== sampleRate) {
+    const PitchFinder = await import("pitchfinder");
+    pitchDetector = PitchFinder.YIN({ sampleRate, threshold: 0.15 });
+    pitchDetectorRate = sampleRate;
+  }
+  return pitchDetector;
+}
+async function getMeyda() {
+  if (!meydaModule) {
+    try {
+      meydaModule = await import("meyda");
+    } catch {
+      return null;
+    }
+  }
+  return meydaModule.default ?? meydaModule;
+}
+async function detectF0Contour(samples, sampleRate) {
+  const detect = await getPitchDetector(sampleRate);
+  const frameSize = getFrameSize(sampleRate);
+  const hopSize = getHopSize(sampleRate);
+  const f0 = [];
+  const amplitudes = [];
+  const periods = [];
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  if (sampleRate !== 16e3) {
+    sdkWarn(`[Entros SDK] Audio captured at ${sampleRate}Hz (requested 16kHz). Frame size adjusted to ${frameSize}.`);
+  }
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    const frame = samples.slice(start, start + frameSize);
+    const pitch = detect(frame);
+    if (pitch && pitch > 50 && pitch < 600) {
+      f0.push(pitch);
+      periods.push(1 / pitch);
+    } else {
+      f0.push(0);
+    }
+    let sum = 0;
+    for (let j = 0; j < frame.length; j++) {
+      sum += (frame[j] ?? 0) * (frame[j] ?? 0);
+    }
+    amplitudes.push(Math.sqrt(sum / frame.length));
+  }
+  return { f0, amplitudes, periods };
+}
+function computeJitter(periods) {
+  const voiced = periods.filter((p) => p > 0);
+  if (voiced.length < 3) return [0, 0, 0, 0];
+  const meanPeriod = voiced.reduce((a, b) => a + b, 0) / voiced.length;
+  if (meanPeriod === 0) return [0, 0, 0, 0];
+  let localSum = 0;
+  for (let i = 1; i < voiced.length; i++) {
+    localSum += Math.abs(voiced[i] - voiced[i - 1]);
+  }
+  const jitterLocal = localSum / (voiced.length - 1) / meanPeriod;
+  let rapSum = 0;
+  for (let i = 1; i < voiced.length - 1; i++) {
+    const avg3 = (voiced[i - 1] + voiced[i] + voiced[i + 1]) / 3;
+    rapSum += Math.abs(voiced[i] - avg3);
+  }
+  const jitterRAP = voiced.length > 2 ? rapSum / (voiced.length - 2) / meanPeriod : 0;
+  let ppq5Sum = 0;
+  let ppq5Count = 0;
+  for (let i = 2; i < voiced.length - 2; i++) {
+    const avg5 = (voiced[i - 2] + voiced[i - 1] + voiced[i] + voiced[i + 1] + voiced[i + 2]) / 5;
+    ppq5Sum += Math.abs(voiced[i] - avg5);
+    ppq5Count++;
+  }
+  const jitterPPQ5 = ppq5Count > 0 ? ppq5Sum / ppq5Count / meanPeriod : 0;
+  let ddpSum = 0;
+  for (let i = 1; i < voiced.length - 1; i++) {
+    const d1 = voiced[i] - voiced[i - 1];
+    const d2 = voiced[i + 1] - voiced[i];
+    ddpSum += Math.abs(d2 - d1);
+  }
+  const jitterDDP = voiced.length > 2 ? ddpSum / (voiced.length - 2) / meanPeriod : 0;
+  return [jitterLocal, jitterRAP, jitterPPQ5, jitterDDP];
+}
+function computeShimmer(amplitudes, f0) {
+  const voicedAmps = amplitudes.filter((_, i) => f0[i] > 0);
+  if (voicedAmps.length < 3) return [0, 0, 0, 0];
+  const meanAmp = voicedAmps.reduce((a, b) => a + b, 0) / voicedAmps.length;
+  if (meanAmp === 0) return [0, 0, 0, 0];
+  let localSum = 0;
+  for (let i = 1; i < voicedAmps.length; i++) {
+    localSum += Math.abs(voicedAmps[i] - voicedAmps[i - 1]);
+  }
+  const shimmerLocal = localSum / (voicedAmps.length - 1) / meanAmp;
+  let apq3Sum = 0;
+  for (let i = 1; i < voicedAmps.length - 1; i++) {
+    const avg3 = (voicedAmps[i - 1] + voicedAmps[i] + voicedAmps[i + 1]) / 3;
+    apq3Sum += Math.abs(voicedAmps[i] - avg3);
+  }
+  const shimmerAPQ3 = voicedAmps.length > 2 ? apq3Sum / (voicedAmps.length - 2) / meanAmp : 0;
+  let apq5Sum = 0;
+  let apq5Count = 0;
+  for (let i = 2; i < voicedAmps.length - 2; i++) {
+    const avg5 = (voicedAmps[i - 2] + voicedAmps[i - 1] + voicedAmps[i] + voicedAmps[i + 1] + voicedAmps[i + 2]) / 5;
+    apq5Sum += Math.abs(voicedAmps[i] - avg5);
+    apq5Count++;
+  }
+  const shimmerAPQ5 = apq5Count > 0 ? apq5Sum / apq5Count / meanAmp : 0;
+  let ddaSum = 0;
+  for (let i = 1; i < voicedAmps.length - 1; i++) {
+    const d1 = voicedAmps[i] - voicedAmps[i - 1];
+    const d2 = voicedAmps[i + 1] - voicedAmps[i];
+    ddaSum += Math.abs(d2 - d1);
+  }
+  const shimmerDDA = voicedAmps.length > 2 ? ddaSum / (voicedAmps.length - 2) / meanAmp : 0;
+  return [shimmerLocal, shimmerAPQ3, shimmerAPQ5, shimmerDDA];
+}
+function computeHNR(samples, sampleRate, f0Contour) {
+  const frameSize = getFrameSize(sampleRate);
+  const hopSize = getHopSize(sampleRate);
+  const hnr = [];
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  for (let i = 0; i < numFrames && i < f0Contour.length; i++) {
+    const f0 = f0Contour[i];
+    if (f0 <= 0) continue;
+    const start = i * hopSize;
+    const frame = samples.slice(start, start + frameSize);
+    const period = Math.round(sampleRate / f0);
+    if (period <= 0 || period >= frame.length) continue;
+    let num = 0;
+    let den = 0;
+    for (let j = 0; j < frame.length - period; j++) {
+      num += (frame[j] ?? 0) * (frame[j + period] ?? 0);
+      den += (frame[j] ?? 0) * (frame[j] ?? 0);
+    }
+    if (den > 0) {
+      const r = num / den;
+      const clampedR = Math.max(1e-3, Math.min(0.999, r));
+      hnr.push(10 * Math.log10(clampedR / (1 - clampedR)));
+    }
+  }
+  return hnr;
+}
+async function computeLTAS(samples, sampleRate) {
+  const frameSize = getFrameSize(sampleRate);
+  const hopSize = getHopSize(sampleRate);
+  const Meyda = await getMeyda();
+  if (!Meyda) return new Array(8).fill(0);
+  const centroids = [];
+  const rolloffs = [];
+  const flatnesses = [];
+  const spreads = [];
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    const frame = samples.slice(start, start + frameSize);
+    const paddedFrame = new Float32Array(frameSize);
+    paddedFrame.set(frame);
+    const features = Meyda.extract(
+      ["spectralCentroid", "spectralRolloff", "spectralFlatness", "spectralSpread"],
+      paddedFrame,
+      { sampleRate, bufferSize: frameSize }
+    );
+    if (features) {
+      if (Number.isFinite(features.spectralCentroid)) centroids.push(features.spectralCentroid);
+      if (Number.isFinite(features.spectralRolloff)) rolloffs.push(features.spectralRolloff);
+      if (Number.isFinite(features.spectralFlatness)) flatnesses.push(features.spectralFlatness);
+      if (Number.isFinite(features.spectralSpread)) spreads.push(features.spectralSpread);
+    }
+  }
+  const m = (arr) => arr.length > 0 ? arr.reduce((a, b) => a + b, 0) / arr.length : 0;
+  const v = (arr) => {
+    if (arr.length < 2) return 0;
+    const mu = m(arr);
+    return arr.reduce((sum, x) => sum + (x - mu) * (x - mu), 0) / (arr.length - 1);
+  };
+  return [
+    m(centroids),
+    v(centroids),
+    m(rolloffs),
+    v(rolloffs),
+    m(flatnesses),
+    v(flatnesses),
+    m(spreads),
+    v(spreads)
+  ];
+}
+function derivative(values) {
+  const d = [];
+  for (let i = 1; i < values.length; i++) {
+    d.push(values[i] - values[i - 1]);
+  }
+  return d;
+}
+async function extractSpeakerFeaturesDetailed(audio) {
+  const { samples, sampleRate } = audio;
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0 || samples.length === 0) {
+    sdkWarn("[Entros SDK] Invalid audio data. Speaker features will be zeros.");
+    return { features: new Array(SPEAKER_FEATURE_COUNT).fill(0), f0Contour: [] };
+  }
+  const frameSize = getFrameSize(sampleRate);
+  const hopSize = getHopSize(sampleRate);
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  if (numFrames < 5) {
+    sdkWarn(`[Entros SDK] Too few audio frames (${numFrames}). Speaker features will be zeros.`);
+    return { features: new Array(SPEAKER_FEATURE_COUNT).fill(0), f0Contour: [] };
+  }
+  let peakAmp = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const abs = Math.abs(samples[i] ?? 0);
+    if (abs > peakAmp) peakAmp = abs;
+  }
+  const normalizedSamples = peakAmp > 1e-6 ? new Float32Array(samples.map((s) => s / peakAmp * 0.9)) : samples;
+  const { f0, amplitudes: normalizedAmplitudes, periods } = await detectF0Contour(normalizedSamples, sampleRate);
+  const amplitudes = [];
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    let sum = 0;
+    const end = Math.min(start + frameSize, samples.length);
+    for (let j = start; j < end; j++) {
+      sum += (samples[j] ?? 0) * (samples[j] ?? 0);
+    }
+    amplitudes.push(Math.sqrt(sum / (end - start)));
+  }
+  const voicedF0 = f0.filter((v) => v > 0);
+  const voicedRatio = voicedF0.length / f0.length;
+  const f0Stats = condense(voicedF0);
+  const f0Entropy = entropy(voicedF0);
+  const f0Features = [f0Stats.mean, f0Stats.variance, f0Stats.skewness, f0Stats.kurtosis, f0Entropy];
+  const f0Delta = derivative(voicedF0);
+  const f0DeltaStats = condense(f0Delta);
+  const f0DeltaFeatures = [f0DeltaStats.mean, f0DeltaStats.variance, f0DeltaStats.skewness, f0DeltaStats.kurtosis];
+  const jitterFeatures = computeJitter(periods);
+  const shimmerFeatures = computeShimmer(amplitudes, f0);
+  const hnrValues = computeHNR(normalizedSamples, sampleRate, f0);
+  const hnrStats = condense(hnrValues);
+  const hnrEntropy = entropy(hnrValues);
+  const hnrFeatures = [hnrStats.mean, hnrStats.variance, hnrStats.skewness, hnrStats.kurtosis, hnrEntropy];
+  const { f1f2, f2f3 } = extractFormantRatios(normalizedSamples, sampleRate, frameSize, hopSize);
+  const f1f2Stats = condense(f1f2);
+  const f2f3Stats = condense(f2f3);
+  const formantFeatures = [
+    f1f2Stats.mean,
+    f1f2Stats.variance,
+    f1f2Stats.skewness,
+    f1f2Stats.kurtosis,
+    f2f3Stats.mean,
+    f2f3Stats.variance,
+    f2f3Stats.skewness,
+    f2f3Stats.kurtosis
+  ];
+  const ltasFeatures = await computeLTAS(samples, sampleRate);
+  const voicingFeatures = [voicedRatio];
+  const ampStats = condense(amplitudes);
+  const ampEntropy = entropy(amplitudes);
+  const ampFeatures = [ampStats.mean, ampStats.variance, ampStats.skewness, ampStats.kurtosis, ampEntropy];
+  const features = [
+    ...f0Features,
+    // 5
+    ...f0DeltaFeatures,
+    // 4
+    ...jitterFeatures,
+    // 4
+    ...shimmerFeatures,
+    // 4
+    ...hnrFeatures,
+    // 5
+    ...formantFeatures,
+    // 8
+    ...ltasFeatures,
+    // 8
+    ...voicingFeatures,
+    // 1
+    ...ampFeatures
+    // 5
+  ];
+  return { features, f0Contour: f0 };
+}
+async function extractSpeakerFeatures(audio) {
+  const { features } = await extractSpeakerFeaturesDetailed(audio);
+  return features;
+}
+
+// src/extraction/kinematic.ts
+function extractAccelerationMagnitude(samples, targetFrameCount) {
+  if (samples.length < 2 || targetFrameCount < 2) return [];
+  const magnitudes = samples.map((s) => Math.sqrt(s.ax * s.ax + s.ay * s.ay + s.az * s.az));
+  if (magnitudes.length === targetFrameCount) return magnitudes;
+  const out = new Array(targetFrameCount);
+  const srcLen = magnitudes.length;
+  const scale = (srcLen - 1) / (targetFrameCount - 1);
+  for (let i = 0; i < targetFrameCount; i++) {
+    const pos = i * scale;
+    const lo = Math.floor(pos);
+    const hi = Math.min(lo + 1, srcLen - 1);
+    const t = pos - lo;
+    out[i] = magnitudes[lo] * (1 - t) + magnitudes[hi] * t;
+  }
+  return out;
+}
+function extractMotionFeatures(samples) {
+  if (samples.length < 5) return new Array(54).fill(0);
+  const axes = {
+    ax: samples.map((s) => s.ax),
+    ay: samples.map((s) => s.ay),
+    az: samples.map((s) => s.az),
+    gx: samples.map((s) => s.gx),
+    gy: samples.map((s) => s.gy),
+    gz: samples.map((s) => s.gz)
+  };
+  const features = [];
+  for (const values of Object.values(axes)) {
+    const jerk = derivative2(values);
+    const jounce = derivative2(jerk);
+    const jerkStats = condense(jerk);
+    const jounceStats = condense(jounce);
+    features.push(
+      jerkStats.mean,
+      jerkStats.variance,
+      jerkStats.skewness,
+      jerkStats.kurtosis,
+      jounceStats.mean,
+      jounceStats.variance,
+      jounceStats.skewness,
+      jounceStats.kurtosis
+    );
+  }
+  for (const values of Object.values(axes)) {
+    const jerk = derivative2(values);
+    const windowSize = Math.max(5, Math.floor(jerk.length / 4));
+    const windowVariances = [];
+    for (let i = 0; i <= jerk.length - windowSize; i += windowSize) {
+      windowVariances.push(variance(jerk.slice(i, i + windowSize)));
+    }
+    features.push(windowVariances.length >= 2 ? variance(windowVariances) : 0);
+  }
+  return features;
+}
+function extractTouchFeatures(samples) {
+  if (samples.length < 5) return new Array(36).fill(0);
+  const x = samples.map((s) => s.x);
+  const y = samples.map((s) => s.y);
+  const pressure = samples.map((s) => s.pressure);
+  const area = samples.map((s) => s.width * s.height);
+  const features = [];
+  const vx = derivative2(x);
+  const accX = derivative2(vx);
+  features.push(...Object.values(condense(vx)));
+  features.push(...Object.values(condense(accX)));
+  const vy = derivative2(y);
+  const accY = derivative2(vy);
+  features.push(...Object.values(condense(vy)));
+  features.push(...Object.values(condense(accY)));
+  features.push(...Object.values(condense(pressure)));
+  features.push(...Object.values(condense(area)));
+  const jerkX = derivative2(accX);
+  const jerkY = derivative2(accY);
+  features.push(...Object.values(condense(jerkX)));
+  features.push(...Object.values(condense(jerkY)));
+  for (const values of [vx, vy, pressure, area]) {
+    const windowSize = Math.max(5, Math.floor(values.length / 4));
+    const windowVariances = [];
+    for (let i = 0; i <= values.length - windowSize; i += windowSize) {
+      windowVariances.push(variance(values.slice(i, i + windowSize)));
+    }
+    features.push(windowVariances.length >= 2 ? variance(windowVariances) : 0);
+  }
+  return features;
+}
+function derivative2(values) {
+  const d = [];
+  for (let i = 1; i < values.length; i++) {
+    d.push((values[i] ?? 0) - (values[i - 1] ?? 0));
+  }
+  return d;
+}
+function extractMouseDynamics(samples) {
+  if (samples.length < 10) return new Array(54).fill(0);
+  const x = samples.map((s) => s.x);
+  const y = samples.map((s) => s.y);
+  const pressure = samples.map((s) => s.pressure);
+  const area = samples.map((s) => s.width * s.height);
+  const vx = derivative2(x);
+  const vy = derivative2(y);
+  const speed = vx.map((dx, i) => Math.sqrt(dx * dx + (vy[i] ?? 0) * (vy[i] ?? 0)));
+  const accX = derivative2(vx);
+  const accY = derivative2(vy);
+  const acc = accX.map((ax, i) => Math.sqrt(ax * ax + (accY[i] ?? 0) * (accY[i] ?? 0)));
+  const jerkX = derivative2(accX);
+  const jerkY = derivative2(accY);
+  const jerk = jerkX.map((jx, i) => Math.sqrt(jx * jx + (jerkY[i] ?? 0) * (jerkY[i] ?? 0)));
+  const curvatures = [];
+  for (let i = 1; i < vx.length; i++) {
+    const angle1 = Math.atan2(vy[i - 1] ?? 0, vx[i - 1] ?? 0);
+    const angle2 = Math.atan2(vy[i] ?? 0, vx[i] ?? 0);
+    let diff = angle2 - angle1;
+    while (diff > Math.PI) diff -= 2 * Math.PI;
+    while (diff < -Math.PI) diff += 2 * Math.PI;
+    curvatures.push(Math.abs(diff));
+  }
+  const directions = vx.map((dx, i) => Math.atan2(vy[i] ?? 0, dx));
+  let reversals = 0;
+  for (let i = 2; i < directions.length; i++) {
+    const d1 = directions[i - 1] - directions[i - 2];
+    const d2 = directions[i] - directions[i - 1];
+    if (d1 * d2 < 0) reversals++;
+  }
+  const reversalRate = directions.length > 2 ? reversals / (directions.length - 2) : 0;
+  const reversalMagnitude = curvatures.length > 0 ? curvatures.reduce((a, b) => a + b, 0) / curvatures.length : 0;
+  const speedThreshold = 0.5;
+  const pauseFrames = speed.filter((s) => s < speedThreshold).length;
+  const pauseRatio = speed.length > 0 ? pauseFrames / speed.length : 0;
+  const totalPathLength = speed.reduce((a, b) => a + b, 0);
+  const straightLine = Math.sqrt(
+    (x[x.length - 1] - x[0]) ** 2 + (y[y.length - 1] - y[0]) ** 2
+  );
+  const pathEfficiency = totalPathLength > 0 ? straightLine / totalPathLength : 0;
+  const movementDurations = [];
+  let currentDuration = 0;
+  for (const s of speed) {
+    if (s >= speedThreshold) {
+      currentDuration++;
+    } else if (currentDuration > 0) {
+      movementDurations.push(currentDuration);
+      currentDuration = 0;
+    }
+  }
+  if (currentDuration > 0) movementDurations.push(currentDuration);
+  const segmentLengths = [];
+  let segLen = 0;
+  for (let i = 1; i < directions.length; i++) {
+    segLen += speed[i] ?? 0;
+    const angleDiff = Math.abs(directions[i] - directions[i - 1]);
+    if (angleDiff > Math.PI / 4) {
+      segmentLengths.push(segLen);
+      segLen = 0;
+    }
+  }
+  if (segLen > 0) segmentLengths.push(segLen);
+  const windowSize = Math.max(5, Math.floor(speed.length / 4));
+  const windowVariances = [];
+  for (let i = 0; i + windowSize <= speed.length; i += windowSize) {
+    const window2 = speed.slice(i, i + windowSize);
+    windowVariances.push(variance(window2));
+  }
+  const speedJitter = windowVariances.length > 1 ? variance(windowVariances) : 0;
+  const duration = samples.length > 1 ? (samples[samples.length - 1].timestamp - samples[0].timestamp) / 1e3 : 1;
+  const normalizedPathLength = totalPathLength / Math.max(duration, 1e-3);
+  const angleAutoCorr = [];
+  for (let lag = 1; lag <= 3; lag++) {
+    if (directions.length <= lag) {
+      angleAutoCorr.push(0);
+      continue;
+    }
+    const n = directions.length - lag;
+    const meanDir = directions.reduce((a, b) => a + b, 0) / directions.length;
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+      num += (directions[i] - meanDir) * (directions[i + lag] - meanDir);
+      den += (directions[i] - meanDir) ** 2;
+    }
+    angleAutoCorr.push(den > 0 ? num / den : 0);
+  }
+  const curvatureStats = condense(curvatures);
+  const dirEntropy = entropy(directions, 16);
+  const speedStats = condense(speed);
+  const accStats = condense(acc);
+  const jerkStats = condense(jerk);
+  const vxStats = condense(vx);
+  const vyStats = condense(vy);
+  const accXStats = condense(accX);
+  const accYStats = condense(accY);
+  const pressureStats = condense(pressure);
+  const moveDurStats = condense(movementDurations);
+  const segLenStats = condense(segmentLengths);
+  return [
+    curvatureStats.mean,
+    curvatureStats.variance,
+    curvatureStats.skewness,
+    curvatureStats.kurtosis,
+    dirEntropy,
+    speedStats.mean,
+    speedStats.variance,
+    speedStats.skewness,
+    speedStats.kurtosis,
+    accStats.mean,
+    accStats.variance,
+    accStats.skewness,
+    accStats.kurtosis,
+    reversalRate,
+    reversalMagnitude,
+    pauseRatio,
+    pathEfficiency,
+    speedJitter,
+    jerkStats.mean,
+    jerkStats.variance,
+    jerkStats.skewness,
+    jerkStats.kurtosis,
+    vxStats.mean,
+    vxStats.variance,
+    vxStats.skewness,
+    vxStats.kurtosis,
+    vyStats.mean,
+    vyStats.variance,
+    vyStats.skewness,
+    vyStats.kurtosis,
+    accXStats.mean,
+    accXStats.variance,
+    accXStats.skewness,
+    accXStats.kurtosis,
+    accYStats.mean,
+    accYStats.variance,
+    accYStats.skewness,
+    accYStats.kurtosis,
+    pressureStats.mean,
+    pressureStats.variance,
+    pressureStats.skewness,
+    pressureStats.kurtosis,
+    moveDurStats.mean,
+    moveDurStats.variance,
+    moveDurStats.skewness,
+    moveDurStats.kurtosis,
+    segLenStats.mean,
+    segLenStats.variance,
+    segLenStats.skewness,
+    segLenStats.kurtosis,
+    angleAutoCorr[0] ?? 0,
+    angleAutoCorr[1] ?? 0,
+    angleAutoCorr[2] ?? 0,
+    normalizedPathLength
+  ];
+}
+
+// src/hashing/simhash.ts
+function mulberry32(seed) {
+  let state = seed | 0;
+  return () => {
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function deriveSeed(seedStr) {
+  let hash = 0;
+  for (let i = 0; i < seedStr.length; i++) {
+    const ch = seedStr.charCodeAt(i);
+    hash = (hash << 5) - hash + ch | 0;
+  }
+  return hash;
+}
+var cachedHyperplanes = null;
+var cachedDimension = 0;
+function getHyperplanes(dimension) {
+  if (cachedHyperplanes && cachedDimension === dimension) {
+    return cachedHyperplanes;
+  }
+  const rng = mulberry32(deriveSeed(SIMHASH_SEED));
+  const planes = [];
+  for (let i = 0; i < FINGERPRINT_BITS; i++) {
+    const plane = [];
+    for (let j = 0; j < dimension; j++) {
+      plane.push(rng() * 2 - 1);
+    }
+    planes.push(plane);
+  }
+  cachedHyperplanes = planes;
+  cachedDimension = dimension;
+  return planes;
+}
+var EXPECTED_FEATURE_DIMENSION = 134;
+function simhash(features) {
+  if (features.length === 0) {
+    return new Array(FINGERPRINT_BITS).fill(0);
+  }
+  if (features.length !== EXPECTED_FEATURE_DIMENSION) {
+    sdkWarn(
+      `[Entros SDK] Feature vector has ${features.length} dimensions, expected ${EXPECTED_FEATURE_DIMENSION}. Fingerprint quality may be degraded.`
+    );
+  }
+  const planes = getHyperplanes(features.length);
+  const fingerprint = [];
+  for (let i = 0; i < FINGERPRINT_BITS; i++) {
+    const plane = planes[i];
+    let dot = 0;
+    for (let j = 0; j < features.length; j++) {
+      dot += (features[j] ?? 0) * (plane?.[j] ?? 0);
+    }
+    fingerprint.push(dot >= 0 ? 1 : 0);
+  }
+  return fingerprint;
+}
+function hammingDistance(a, b) {
+  let distance = 0;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) distance++;
+  }
+  return distance;
+}
+
+// src/hashing/poseidon.ts
+var poseidonInstance = null;
+async function getPoseidon() {
+  if (!poseidonInstance) {
+    const circomlibjs = await import("circomlibjs");
+    poseidonInstance = await circomlibjs.buildPoseidon();
+  }
+  return poseidonInstance;
+}
+function packBits(fingerprint) {
+  let lo = BigInt(0);
+  for (let i = 0; i < 128; i++) {
+    if (fingerprint[i] === 1) {
+      lo += BigInt(1) << BigInt(i);
+    }
+  }
+  let hi = BigInt(0);
+  for (let i = 0; i < 128; i++) {
+    if (fingerprint[128 + i] === 1) {
+      hi += BigInt(1) << BigInt(i);
+    }
+  }
+  return { lo, hi };
+}
+async function computeCommitment(fingerprint, salt) {
+  const poseidon = await getPoseidon();
+  const { lo, hi } = packBits(fingerprint);
+  const hash = poseidon([lo, hi, salt]);
+  return poseidon.F.toObject(hash);
+}
+function generateSalt() {
+  const bytes = new Uint8Array(31);
+  crypto.getRandomValues(bytes);
+  let val = BigInt(0);
+  for (let i = 0; i < bytes.length; i++) {
+    val = (val << BigInt(8)) + BigInt(bytes[i] ?? 0);
+  }
+  return val % BN254_SCALAR_FIELD;
+}
+function bigintToBytes32(n) {
+  const bytes = new Uint8Array(32);
+  let val = n;
+  for (let i = 31; i >= 0; i--) {
+    bytes[i] = Number(val & BigInt(255));
+    val >>= BigInt(8);
+  }
+  return bytes;
+}
+async function generateTBH(fingerprint, salt) {
+  const s = salt ?? generateSalt();
+  const commitment = await computeCommitment(fingerprint, s);
+  return {
+    fingerprint,
+    salt: s,
+    commitment,
+    commitmentBytes: bigintToBytes32(commitment)
+  };
+}
+
+// src/proof/serializer.ts
+function toBigEndian32(decStr) {
+  let n = BigInt(decStr);
+  const bytes = new Uint8Array(32);
+  for (let i = 31; i >= 0; i--) {
+    bytes[i] = Number(n & BigInt(255));
+    n >>= BigInt(8);
+  }
+  return bytes;
+}
+function negateG1Y(yDecStr) {
+  const y = BigInt(yDecStr);
+  const yNeg = (BN254_BASE_FIELD - y) % BN254_BASE_FIELD;
+  return toBigEndian32(yNeg.toString());
+}
+function serializeProof(proof, publicSignals) {
+  if (publicSignals.length !== NUM_PUBLIC_INPUTS) {
+    throw new Error(
+      `Expected ${NUM_PUBLIC_INPUTS} public signals, got ${publicSignals.length}`
+    );
+  }
+  const a0 = toBigEndian32(proof.pi_a[0]);
+  const a1 = negateG1Y(proof.pi_a[1]);
+  const proofA = new Uint8Array(PROOF_A_SIZE);
+  proofA.set(a0, 0);
+  proofA.set(a1, 32);
+  const b00 = toBigEndian32(proof.pi_b[0][1]);
+  const b01 = toBigEndian32(proof.pi_b[0][0]);
+  const b10 = toBigEndian32(proof.pi_b[1][1]);
+  const b11 = toBigEndian32(proof.pi_b[1][0]);
+  const proofB = new Uint8Array(PROOF_B_SIZE);
+  proofB.set(b00, 0);
+  proofB.set(b01, 32);
+  proofB.set(b10, 64);
+  proofB.set(b11, 96);
+  const c0 = toBigEndian32(proof.pi_c[0]);
+  const c1 = toBigEndian32(proof.pi_c[1]);
+  const proofC = new Uint8Array(PROOF_C_SIZE);
+  proofC.set(c0, 0);
+  proofC.set(c1, 32);
+  const proofBytes = new Uint8Array(TOTAL_PROOF_SIZE);
+  proofBytes.set(proofA, 0);
+  proofBytes.set(proofB, PROOF_A_SIZE);
+  proofBytes.set(proofC, PROOF_A_SIZE + PROOF_B_SIZE);
+  const publicInputs = publicSignals.map((s) => toBigEndian32(s));
+  return { proofBytes, publicInputs };
+}
+
+// src/proof/prover.ts
+var snarkjsModule = null;
+async function getSnarkjs() {
+  if (!snarkjsModule) {
+    snarkjsModule = await import("snarkjs");
+  }
+  return snarkjsModule;
+}
+function prepareCircuitInput(current, previous, threshold = DEFAULT_THRESHOLD, minDistance = DEFAULT_MIN_DISTANCE) {
+  return {
+    ft_new: current.fingerprint,
+    ft_prev: previous.fingerprint,
+    salt_new: current.salt.toString(),
+    salt_prev: previous.salt.toString(),
+    commitment_new: current.commitment.toString(),
+    commitment_prev: previous.commitment.toString(),
+    threshold: threshold.toString(),
+    min_distance: minDistance.toString()
+  };
+}
+async function generateProof(input, wasmPath, zkeyPath) {
+  const snarkjs = await getSnarkjs();
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+    input,
+    wasmPath,
+    zkeyPath
+  );
+  return { proof, publicSignals };
+}
+async function generateSolanaProof(current, previous, wasmPath, zkeyPath, threshold) {
+  const input = prepareCircuitInput(current, previous, threshold);
+  const { proof, publicSignals } = await generateProof(
+    input,
+    wasmPath,
+    zkeyPath
+  );
+  return serializeProof(proof, publicSignals);
+}
+
+// src/submit/wallet.ts
+async function requestSasAttestation(wallet, walletAddress, relayerUrl, relayerApiKey, serverNonce) {
+  try {
+    const attestHeaders = {
+      "Content-Type": "application/json"
+    };
+    if (relayerApiKey) {
+      attestHeaders["X-API-Key"] = relayerApiKey;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15e3);
+    const baseUrl = new URL(relayerUrl);
+    const attestUrl = `${baseUrl.origin}/attest`;
+    const attestBody = { wallet_address: walletAddress };
+    if (serverNonce) attestBody.nonce = serverNonce;
+    if (wallet?.signMessage) {
+      try {
+        const timestamp = Math.floor(Date.now() / 1e3);
+        const attestMessage = `Entros-ATTEST:${walletAddress}:${timestamp}`;
+        const messageBytes = new TextEncoder().encode(attestMessage);
+        const sigBytes = await wallet.signMessage(messageBytes);
+        const sigHex = Array.from(sigBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        attestBody.signature = sigHex;
+        attestBody.message = attestMessage;
+      } catch {
+        sdkWarn("Wallet signMessage failed, skipping ownership proof");
+      }
+    }
+    const attestRes = await fetch(attestUrl, {
+      method: "POST",
+      headers: attestHeaders,
+      body: JSON.stringify(attestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (attestRes.ok) {
+      const attestData = await attestRes.json();
+      if (attestData.success && attestData.attestation_tx) {
+        return attestData.attestation_tx;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function submitViaWallet(proof, commitment, options) {
+  try {
+    const anchor = await import("@coral-xyz/anchor");
+    const { PublicKey, SystemProgram, Transaction, ComputeBudgetProgram } = await import("@solana/web3.js");
+    const provider = new anchor.AnchorProvider(
+      options.connection,
+      options.wallet,
+      { commitment: "confirmed" }
+    );
+    const anchorProgramId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+    let txSig;
+    let serverNonce = false;
+    let nonce = [];
+    if (!options.isFirstVerification) {
+      const verifierProgramId = new PublicKey(PROGRAM_IDS.entrosVerifier);
+      if (options.relayerUrl) {
+        try {
+          const baseUrl = new URL(options.relayerUrl);
+          const challengeHeaders = {};
+          if (options.relayerApiKey) {
+            challengeHeaders["X-API-Key"] = options.relayerApiKey;
+          }
+          const challengeController = new AbortController();
+          const challengeTimer = setTimeout(() => challengeController.abort(), 5e3);
+          const challengeRes = await fetch(
+            `${baseUrl.origin}/challenge?wallet=${provider.wallet.publicKey.toBase58()}`,
+            { headers: challengeHeaders, signal: challengeController.signal }
+          );
+          clearTimeout(challengeTimer);
+          if (challengeRes.ok) {
+            const challengeData = await challengeRes.json();
+            if (challengeData.nonce && challengeData.nonce.length === 32) {
+              nonce = challengeData.nonce;
+              serverNonce = true;
+              sdkLog("Using server-generated challenge nonce");
+            } else {
+              nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)));
+              sdkWarn("Server returned invalid nonce, using client-generated");
+            }
+          } else {
+            nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)));
+            sdkWarn("Challenge endpoint returned error, using client-generated nonce");
+          }
+        } catch {
+          nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)));
+          sdkWarn("Challenge fetch failed, using client-generated nonce");
+        }
+      } else {
+        nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)));
+      }
+      const [challengePda] = PublicKey.findProgramAddressSync(
+        [
+          new TextEncoder().encode("challenge"),
+          provider.wallet.publicKey.toBuffer(),
+          new Uint8Array(nonce)
+        ],
+        verifierProgramId
+      );
+      const [verificationPda] = PublicKey.findProgramAddressSync(
+        [
+          new TextEncoder().encode("verification"),
+          provider.wallet.publicKey.toBuffer(),
+          new Uint8Array(nonce)
+        ],
+        verifierProgramId
+      );
+      const [identityPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("identity"), provider.wallet.publicKey.toBuffer()],
+        anchorProgramId
+      );
+      const registryProgramId = new PublicKey(PROGRAM_IDS.entrosRegistry);
+      const [protocolConfigPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("protocol_config")],
+        registryProgramId
+      );
+      const [treasuryPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("protocol_treasury")],
+        registryProgramId
+      );
+      const [verifierIdl, anchorIdl] = await Promise.all([
+        anchor.Program.fetchIdl(verifierProgramId, provider),
+        anchor.Program.fetchIdl(anchorProgramId, provider)
+      ]);
+      if (!verifierIdl) {
+        return {
+          success: false,
+          error: `Failed to fetch entros-verifier IDL from Solana (program ${PROGRAM_IDS.entrosVerifier}). Check your RPC endpoint is reachable and on the correct cluster.`
+        };
+      }
+      if (!anchorIdl) {
+        return {
+          success: false,
+          error: `Failed to fetch entros-anchor IDL from Solana (program ${PROGRAM_IDS.entrosAnchor}). Check your RPC endpoint is reachable and on the correct cluster.`
+        };
+      }
+      const verifierProgram = new anchor.Program(verifierIdl, provider);
+      const anchorProgram = new anchor.Program(anchorIdl, provider);
+      const { Buffer: SolBuffer } = await import("buffer");
+      const createChallengeIx = await verifierProgram.methods.createChallenge(nonce).accounts({
+        challenger: provider.wallet.publicKey,
+        challenge: challengePda,
+        systemProgram: SystemProgram.programId
+      }).instruction();
+      const verifyProofIx = await verifierProgram.methods.verifyProof(
+        SolBuffer.from(proof.proofBytes),
+        proof.publicInputs.map((pi) => SolBuffer.from(pi)),
+        nonce
+      ).accounts({
+        verifier: provider.wallet.publicKey,
+        challenge: challengePda,
+        verificationResult: verificationPda,
+        systemProgram: SystemProgram.programId
+      }).instruction();
+      const updateAnchorIx = await anchorProgram.methods.updateAnchor(Array.from(commitment), nonce).accounts({
+        authority: provider.wallet.publicKey,
+        identityState: identityPda,
+        verificationResult: verificationPda,
+        protocolConfig: protocolConfigPda,
+        treasury: treasuryPda,
+        systemProgram: SystemProgram.programId
+      }).instruction();
+      const tx = new Transaction();
+      tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 25e4 }));
+      tx.add(createChallengeIx);
+      tx.add(verifyProofIx);
+      tx.add(updateAnchorIx);
+      tx.feePayer = provider.wallet.publicKey;
+      tx.recentBlockhash = (await options.connection.getLatestBlockhash("confirmed")).blockhash;
+      txSig = await options.wallet.sendTransaction(tx, options.connection, {
+        skipPreflight: true
+      });
+      await options.connection.confirmTransaction(txSig, "confirmed");
+    } else {
+      const anchorIdl = await anchor.Program.fetchIdl(anchorProgramId, provider);
+      if (!anchorIdl) {
+        return {
+          success: false,
+          error: `Failed to fetch entros-anchor IDL from Solana (program ${PROGRAM_IDS.entrosAnchor}). Check your RPC endpoint is reachable and on the correct cluster.`
+        };
+      }
+      const anchorProgram = new anchor.Program(anchorIdl, provider);
+      const [identityPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("identity"), provider.wallet.publicKey.toBuffer()],
+        anchorProgramId
+      );
+      const [mintPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("mint"), provider.wallet.publicKey.toBuffer()],
+        anchorProgramId
+      );
+      const [mintAuthority] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("mint_authority")],
+        anchorProgramId
+      );
+      const registryProgramId = new PublicKey(PROGRAM_IDS.entrosRegistry);
+      const [protocolConfigPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("protocol_config")],
+        registryProgramId
+      );
+      const [treasuryPda] = PublicKey.findProgramAddressSync(
+        [new TextEncoder().encode("protocol_treasury")],
+        registryProgramId
+      );
+      const TOKEN_2022_PROGRAM_ID = new PublicKey(
+        "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+      );
+      const { getAssociatedTokenAddressSync } = await import("@solana/spl-token");
+      const ata = getAssociatedTokenAddressSync(
+        mintPda,
+        provider.wallet.publicKey,
+        false,
+        TOKEN_2022_PROGRAM_ID
+      );
+      await anchorProgram.methods.mintAnchor(Array.from(commitment)).accounts({
+        user: provider.wallet.publicKey,
+        identityState: identityPda,
+        mint: mintPda,
+        mintAuthority,
+        tokenAccount: ata,
+        associatedTokenProgram: new PublicKey(
+          "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        ),
+        tokenProgram: TOKEN_2022_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+        protocolConfig: protocolConfigPda,
+        treasury: treasuryPda
+      }).rpc();
+    }
+    const attestationTx = options.relayerUrl ? await requestSasAttestation(
+      options.wallet,
+      provider.wallet.publicKey.toBase58(),
+      options.relayerUrl,
+      options.relayerApiKey,
+      serverNonce ? nonce : void 0
+    ) : void 0;
+    return { success: true, txSignature: txSig, attestationTx };
+  } catch (err) {
+    return { success: false, error: err.message ?? String(err) };
+  }
+}
+async function submitResetViaWallet(commitment, options) {
+  try {
+    const anchor = await import("@coral-xyz/anchor");
+    const { PublicKey, SystemProgram, Transaction, ComputeBudgetProgram } = await import("@solana/web3.js");
+    const provider = new anchor.AnchorProvider(
+      options.connection,
+      options.wallet,
+      { commitment: "confirmed" }
+    );
+    const anchorProgramId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+    const registryProgramId = new PublicKey(PROGRAM_IDS.entrosRegistry);
+    const [identityPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("identity"), provider.wallet.publicKey.toBuffer()],
+      anchorProgramId
+    );
+    const [protocolConfigPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("protocol_config")],
+      registryProgramId
+    );
+    const [treasuryPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("protocol_treasury")],
+      registryProgramId
+    );
+    const anchorIdl = await anchor.Program.fetchIdl(anchorProgramId, provider);
+    if (!anchorIdl) {
+      return {
+        success: false,
+        error: `Failed to fetch entros-anchor IDL from Solana (program ${PROGRAM_IDS.entrosAnchor}). Check your RPC endpoint is reachable and on the correct cluster.`
+      };
+    }
+    const anchorProgram = new anchor.Program(anchorIdl, provider);
+    const resetIx = await anchorProgram.methods.resetIdentityState(Array.from(commitment)).accounts({
+      authority: provider.wallet.publicKey,
+      identityState: identityPda,
+      protocolConfig: protocolConfigPda,
+      treasury: treasuryPda,
+      systemProgram: SystemProgram.programId
+    }).instruction();
+    const tx = new Transaction();
+    tx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 15e4 }));
+    tx.add(resetIx);
+    tx.feePayer = provider.wallet.publicKey;
+    tx.recentBlockhash = (await options.connection.getLatestBlockhash("confirmed")).blockhash;
+    const txSig = await options.wallet.sendTransaction(
+      tx,
+      options.connection,
+      { skipPreflight: true }
+    );
+    await options.connection.confirmTransaction(txSig, "confirmed");
+    const attestationTx = options.relayerUrl ? await requestSasAttestation(
+      options.wallet,
+      provider.wallet.publicKey.toBase58(),
+      options.relayerUrl,
+      options.relayerApiKey,
+      void 0
+    ) : void 0;
+    return { success: true, txSignature: txSig, attestationTx };
+  } catch (err) {
+    return { success: false, error: err.message ?? String(err) };
+  }
+}
+
+// src/submit/relayer.ts
+var RELAYER_TIMEOUT_MS = 3e4;
+async function submitViaRelayer(proof, commitment, options) {
+  try {
+    const body = {
+      proof_bytes: Array.from(proof.proofBytes),
+      public_inputs: proof.publicInputs.map((pi) => Array.from(pi)),
+      commitment: Array.from(commitment),
+      is_first_verification: options.isFirstVerification
+    };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.apiKey) {
+      headers["X-API-Key"] = options.apiKey;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), RELAYER_TIMEOUT_MS);
+    const response = await fetch(options.relayerUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        success: false,
+        error: `Relayer returned HTTP ${response.status} from ${options.relayerUrl}: ${errorText}. Check relayerUrl and apiKey in PulseConfig.`
+      };
+    }
+    const result = await response.json();
+    if (result.success !== true) {
+      return {
+        success: false,
+        error: "Relayer accepted the request but reported failure. Typically means proof verification failed on-chain \u2014 check the relayer logs."
+      };
+    }
+    return {
+      success: true,
+      txSignature: result.tx_signature
+    };
+  } catch (err) {
+    if (err.name === "AbortError") {
+      return {
+        success: false,
+        error: `Relayer request timed out after ${RELAYER_TIMEOUT_MS / 1e3}s. Check network connectivity and relayerUrl reachability.`
+      };
+    }
+    return { success: false, error: err.message ?? String(err) };
+  }
+}
+
+// src/identity/crypto.ts
+var DB_NAME = "entros-protocol-keystore";
+var DB_VERSION = 2;
+var STORE_NAME = "keys";
+var KEY_ID = "encryption-key";
+function hasCryptoSupport() {
+  return typeof globalThis.crypto?.subtle !== "undefined" && typeof globalThis.indexedDB !== "undefined";
+}
+function openAtVersion(version) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, version);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function openKeyStore() {
+  const db = await openAtVersion(DB_VERSION);
+  if (!db.objectStoreNames.contains(STORE_NAME)) {
+    const nextVersion = db.version + 1;
+    db.close();
+    return openAtVersion(nextVersion);
+  }
+  return db;
+}
+function getKey(db) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.get(KEY_ID);
+    request.onsuccess = () => resolve(request.result ?? null);
+    request.onerror = () => reject(request.error);
+  });
+}
+function putKey(db, key) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.put(key, KEY_ID);
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error);
+  });
+}
+async function getOrCreateEncryptionKey() {
+  try {
+    const db = await openKeyStore();
+    try {
+      const existing = await getKey(db);
+      if (existing) return existing;
+      const key = await crypto.subtle.generateKey(
+        { name: "AES-GCM", length: 256 },
+        false,
+        // non-extractable
+        ["encrypt", "decrypt"]
+      );
+      await putKey(db, key);
+      return key;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+async function encrypt(plaintext, key) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoded = new TextEncoder().encode(plaintext);
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    encoded
+  );
+  return {
+    iv: toBase64(iv),
+    ct: toBase64(new Uint8Array(ciphertext))
+  };
+}
+async function decrypt(iv, ct, key) {
+  const ivBytes = fromBase64(iv);
+  const ctBytes = fromBase64(ct);
+  const plaintext = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: ivBytes.buffer },
+    key,
+    ctBytes.buffer
+  );
+  return new TextDecoder().decode(plaintext);
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/identity/anchor.ts
+var STORAGE_KEY = "entros-protocol-verification-data";
+var ENCRYPTED_VERSION = 2;
+var inMemoryStore = null;
+function isEncryptedEnvelope(obj) {
+  return typeof obj === "object" && obj !== null && obj.v === ENCRYPTED_VERSION && typeof obj.iv === "string" && typeof obj.ct === "string";
+}
+function isPlaintextData(obj) {
+  return typeof obj === "object" && obj !== null && Array.isArray(obj.fingerprint);
+}
+async function fetchIdentityState(walletPubkey, connection) {
+  try {
+    const { PublicKey } = await import("@solana/web3.js");
+    const anchor = await import("@coral-xyz/anchor");
+    const programId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+    const [identityPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("identity"), new PublicKey(walletPubkey).toBuffer()],
+      programId
+    );
+    const accountInfo = await connection.getAccountInfo(identityPda);
+    if (!accountInfo) return null;
+    const idl = await anchor.Program.fetchIdl(programId, {
+      connection
+    });
+    if (!idl) return null;
+    const coder = new anchor.BorshAccountsCoder(idl);
+    const decoded = coder.decode("identityState", accountInfo.data);
+    return {
+      owner: decoded.owner.toBase58(),
+      creationTimestamp: decoded.creationTimestamp.toNumber(),
+      lastVerificationTimestamp: decoded.lastVerificationTimestamp.toNumber(),
+      verificationCount: decoded.verificationCount,
+      trustScore: decoded.trustScore,
+      currentCommitment: new Uint8Array(decoded.currentCommitment),
+      mint: decoded.mint.toBase58(),
+      // Anchor's Borsh coder returns the raw BN for i64 fields; .toNumber()
+      // is safe here because Unix timestamps fit in Number.MAX_SAFE_INTEGER
+      // until year 275760.
+      lastResetTimestamp: decoded.lastResetTimestamp?.toNumber?.() ?? 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function storeVerificationData(data) {
+  try {
+    if (!hasCryptoSupport()) {
+      sdkWarn("[Entros SDK] Crypto unavailable \u2014 verification data stored unencrypted");
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+      return;
+    }
+    const key = await getOrCreateEncryptionKey();
+    if (!key) {
+      sdkWarn("[Entros SDK] Encryption key unavailable \u2014 storing unencrypted");
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+      return;
+    }
+    const { iv, ct } = await encrypt(JSON.stringify(data), key);
+    const envelope = { v: ENCRYPTED_VERSION, iv, ct };
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(envelope));
+  } catch {
+    inMemoryStore = data;
+  }
+}
+async function loadVerificationData() {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return inMemoryStore;
+    const parsed = JSON.parse(raw);
+    if (isEncryptedEnvelope(parsed)) {
+      if (!hasCryptoSupport()) {
+        sdkWarn("[Entros SDK] Encrypted data found but crypto unavailable");
+        return inMemoryStore;
+      }
+      const key = await getOrCreateEncryptionKey();
+      if (!key) {
+        sdkWarn(
+          "[Entros SDK] Encryption key unavailable \u2014 keeping envelope for recovery. If this persists across reloads, check IndexedDB state via DevTools."
+        );
+        return inMemoryStore;
+      }
+      try {
+        const plaintext = await decrypt(parsed.iv, parsed.ct, key);
+        return JSON.parse(plaintext);
+      } catch {
+        sdkWarn(
+          "[Entros SDK] Decryption failed \u2014 keeping envelope for recovery. Trigger a baseline reset or Clear site data if this is persistent."
+        );
+        return inMemoryStore;
+      }
+    }
+    if (isPlaintextData(parsed)) {
+      await storeVerificationData(parsed);
+      return parsed;
+    }
+    sdkWarn("[Entros SDK] Unrecognized verification data format \u2014 clearing");
+    localStorage.removeItem(STORAGE_KEY);
+    return inMemoryStore;
+  } catch {
+    return inMemoryStore;
+  }
+}
+
+// src/pulse.ts
+async function extractFeatures(data) {
+  if (!data.audio) {
+    throw new Error(
+      "Audio data missing. Capture audio via session.startAudio() before extracting features."
+    );
+  }
+  const { features: audioFeatures, f0Contour } = await extractSpeakerFeaturesDetailed(
+    data.audio
+  );
+  const hasMotion = data.motion.length >= MIN_MOTION_SAMPLES;
+  const hasTouch = data.touch.length >= MIN_TOUCH_SAMPLES;
+  const motionFeatures = hasMotion && hasTouch ? extractMouseDynamics(data.touch) : hasMotion ? extractMotionFeatures(data.motion) : extractMouseDynamics(data.touch);
+  const touchFeatures = extractTouchFeatures(data.touch);
+  const accelMagnitude = hasMotion && f0Contour.length > 0 ? extractAccelerationMagnitude(data.motion, f0Contour.length) : [];
+  return {
+    raw: fuseRawFeatures(audioFeatures, motionFeatures, touchFeatures),
+    normalized: fuseFeatures(audioFeatures, motionFeatures, touchFeatures),
+    f0Contour,
+    accelMagnitude
+  };
+}
+var MIN_AUDIO_SAMPLES = 16e3;
+var MIN_MOTION_SAMPLES = 10;
+var MIN_TOUCH_SAMPLES = 10;
+async function extractFingerprintAndValidate(sensorData, config, walletAddress, onProgress) {
+  onProgress?.("Extracting features...");
+  const {
+    raw: features,
+    normalized: normalizedFeatures,
+    f0Contour,
+    accelMagnitude
+  } = await extractFeatures(sensorData);
+  const nonZero = features.filter((v) => v !== 0).length;
+  sdkLog(
+    `[Entros SDK] Feature vector: ${features.length} dimensions, ${nonZero} non-zero. Audio[0..43]: ${features.slice(0, 44).filter((v) => v !== 0).length} non-zero. Motion/Mouse[44..97]: ${features.slice(44, 98).filter((v) => v !== 0).length} non-zero. Touch[98..133]: ${features.slice(98, 134).filter((v) => v !== 0).length} non-zero.`
+  );
+  onProgress?.("Validating...");
+  if (config.relayerUrl && walletAddress) {
+    try {
+      const baseUrl = new URL(config.relayerUrl);
+      const validateUrl = `${baseUrl.origin}/validate-features`;
+      const validateHeaders = { "Content-Type": "application/json" };
+      if (config.relayerApiKey) {
+        validateHeaders["X-API-Key"] = config.relayerApiKey;
+      }
+      const audioSamplesB64 = sensorData.audio?.samples ? encodeAudioAsBase64(sensorData.audio.samples) : void 0;
+      const audioSampleRateHz = sensorData.audio?.sampleRate;
+      const validateController = new AbortController();
+      const validateTimer = setTimeout(() => validateController.abort(), 15e3);
+      const validateResponse = await fetch(validateUrl, {
+        method: "POST",
+        headers: validateHeaders,
+        body: JSON.stringify({
+          features,
+          f0_contour: f0Contour,
+          accel_magnitude: accelMagnitude,
+          wallet_id: walletAddress,
+          audio_samples_b64: audioSamplesB64,
+          audio_sample_rate_hz: audioSampleRateHz
+        }),
+        signal: validateController.signal
+      });
+      clearTimeout(validateTimer);
+      if (!validateResponse.ok) {
+        const errorBody = await validateResponse.json().catch(() => ({}));
+        sdkWarn("[Entros SDK] Feature validation rejected by server");
+        return {
+          ok: false,
+          error: errorBody.error || "Feature validation failed"
+        };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sdkWarn(`[Entros SDK] Feature validation unavailable: ${msg}, proceeding without server validation`);
+    }
+  }
+  const fingerprint = simhash(normalizedFeatures);
+  const tbh = await generateTBH(fingerprint);
+  return { ok: true, features, f0Contour, accelMagnitude, fingerprint, tbh };
+}
+async function processSensorData(sensorData, config, wallet, connection, onProgress) {
+  const audioSamples = sensorData.audio?.samples.length ?? 0;
+  const motionSamples = sensorData.motion.length;
+  const touchSamples = sensorData.touch.length;
+  const hasAudio = audioSamples >= MIN_AUDIO_SAMPLES;
+  const hasMotion = motionSamples >= MIN_MOTION_SAMPLES;
+  const hasTouch = touchSamples >= MIN_TOUCH_SAMPLES;
+  if (!hasAudio && !hasMotion && !hasTouch) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: "Insufficient behavioral data. Please speak the phrase and trace the curve during capture."
+    };
+  }
+  if (!hasAudio) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: "No voice data detected. Please speak the phrase clearly during capture."
+    };
+  }
+  let hasPreviousData;
+  if (wallet && connection) {
+    const walletPubkey = wallet.adapter?.publicKey ?? wallet.publicKey;
+    if (walletPubkey) {
+      try {
+        const { PublicKey } = await import("@solana/web3.js");
+        const programId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+        const [identityPda] = PublicKey.findProgramAddressSync(
+          [new TextEncoder().encode("identity"), walletPubkey.toBuffer()],
+          programId
+        );
+        const accountInfo = await connection.getAccountInfo(identityPda);
+        hasPreviousData = !!accountInfo;
+      } catch {
+        hasPreviousData = await loadVerificationData() !== null;
+      }
+    } else {
+      hasPreviousData = await loadVerificationData() !== null;
+    }
+  } else {
+    hasPreviousData = await loadVerificationData() !== null;
+  }
+  if (hasPreviousData && !hasMotion && !hasTouch) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: false,
+      error: "Insufficient sensor data for re-verification. Please trace the curve and allow motion access."
+    };
+  }
+  const walletAddress = wallet?.adapter?.publicKey?.toBase58?.() ?? wallet?.publicKey?.toBase58?.();
+  const extraction = await extractFingerprintAndValidate(
+    sensorData,
+    config,
+    walletAddress,
+    onProgress
+  );
+  if (!extraction.ok) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: false,
+      error: extraction.error
+    };
+  }
+  const { fingerprint, tbh, features } = extraction;
+  let isFirstVerification;
+  const previousData = await loadVerificationData();
+  if (wallet && connection) {
+    const walletPubkey = wallet.adapter?.publicKey ?? wallet.publicKey;
+    if (walletPubkey) {
+      try {
+        const { PublicKey } = await import("@solana/web3.js");
+        const programId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+        const [identityPda] = PublicKey.findProgramAddressSync(
+          [new TextEncoder().encode("identity"), walletPubkey.toBuffer()],
+          programId
+        );
+        const accountInfo = await connection.getAccountInfo(identityPda);
+        isFirstVerification = !accountInfo;
+      } catch {
+        isFirstVerification = !previousData;
+      }
+    } else {
+      isFirstVerification = !previousData;
+    }
+  } else {
+    isFirstVerification = !previousData;
+  }
+  if (!isFirstVerification && !previousData) {
+    return {
+      success: false,
+      commitment: tbh.commitmentBytes,
+      isFirstVerification: false,
+      error: "Previous behavioral fingerprint not found on this device. Your Entros Anchor exists on-chain but the local baseline is missing. Reset your baseline to re-enroll from this device, or verify from the device that has the original baseline."
+    };
+  }
+  let solanaProof = null;
+  if (!isFirstVerification && previousData) {
+    onProgress?.("Computing proof...");
+    const previousTBH = {
+      fingerprint: previousData.fingerprint,
+      salt: BigInt(previousData.salt),
+      commitment: BigInt(previousData.commitment),
+      commitmentBytes: bigintToBytes32(BigInt(previousData.commitment))
+    };
+    const distance = hammingDistance(fingerprint, previousData.fingerprint);
+    sdkLog(
+      `[Entros SDK] Re-verification: Hamming distance = ${distance} / 256 bits (threshold = ${config.threshold})`
+    );
+    const circuitInput = prepareCircuitInput(
+      tbh,
+      previousTBH,
+      config.threshold
+    );
+    const wasmPath = config.wasmUrl;
+    const zkeyPath = config.zkeyUrl;
+    if (!wasmPath || !zkeyPath) {
+      return {
+        success: false,
+        commitment: tbh.commitmentBytes,
+        isFirstVerification: false,
+        error: "Re-verification requires wasmUrl and zkeyUrl in PulseConfig. Host the iam_hamming.wasm and iam_hamming_final.zkey circuit artifacts at public URLs."
+      };
+    }
+    try {
+      const { proof, publicSignals } = await generateProof(
+        circuitInput,
+        wasmPath,
+        zkeyPath
+      );
+      solanaProof = serializeProof(proof, publicSignals);
+    } catch (proofErr) {
+      const audioNZ = features.slice(0, 44).filter((v) => v !== 0).length;
+      const motionNZ = features.slice(44, 98).filter((v) => v !== 0).length;
+      const touchNZ = features.slice(98, 134).filter((v) => v !== 0).length;
+      const rawAudio = sensorData.audio?.samples.length ?? 0;
+      const rawMotion = sensorData.motion.length;
+      const rawTouch = sensorData.touch.length;
+      const sig = features.slice(0, 3).map((v) => v.toFixed(4)).join(",");
+      return {
+        success: false,
+        commitment: tbh.commitmentBytes,
+        isFirstVerification: false,
+        error: `Proof generation failed: ${proofErr?.message ?? proofErr}. Check wasmUrl/zkeyUrl reachability. Diagnostics: dist=${distance}, nz=${audioNZ}/${motionNZ}/${touchNZ}, raw=${rawAudio}/${rawMotion}/${rawTouch}, sig=${sig}`
+      };
+    }
+  }
+  onProgress?.("Submitting to Solana...");
+  let submission;
+  if (wallet && connection) {
+    if (isFirstVerification) {
+      submission = await submitViaWallet(
+        solanaProof ?? { proofBytes: new Uint8Array(0), publicInputs: [] },
+        tbh.commitmentBytes,
+        { wallet, connection, isFirstVerification: true, relayerUrl: config.relayerUrl, relayerApiKey: config.relayerApiKey }
+      );
+    } else {
+      submission = await submitViaWallet(solanaProof, tbh.commitmentBytes, {
+        wallet,
+        connection,
+        isFirstVerification: false,
+        relayerUrl: config.relayerUrl,
+        relayerApiKey: config.relayerApiKey
+      });
+    }
+  } else if (config.relayerUrl) {
+    submission = await submitViaRelayer(
+      solanaProof ?? { proofBytes: new Uint8Array(0), publicInputs: [] },
+      tbh.commitmentBytes,
+      { relayerUrl: config.relayerUrl, apiKey: config.relayerApiKey, isFirstVerification }
+    );
+  } else {
+    return {
+      success: false,
+      commitment: tbh.commitmentBytes,
+      isFirstVerification,
+      error: "No submission path available. Pass wallet+connection to verify() for wallet-connected mode, or set relayerUrl in PulseConfig for walletless mode."
+    };
+  }
+  if (submission.success) {
+    await storeVerificationData({
+      fingerprint: tbh.fingerprint,
+      salt: tbh.salt.toString(),
+      commitment: tbh.commitment.toString(),
+      timestamp: Date.now()
+    });
+  }
+  return {
+    success: submission.success,
+    commitment: tbh.commitmentBytes,
+    txSignature: submission.txSignature,
+    attestationTx: submission.attestationTx,
+    isFirstVerification,
+    error: submission.error
+  };
+}
+async function processResetSensorData(sensorData, config, wallet, connection, onProgress) {
+  const audioSamples = sensorData.audio?.samples.length ?? 0;
+  const motionSamples = sensorData.motion.length;
+  const touchSamples = sensorData.touch.length;
+  const hasAudio = audioSamples >= MIN_AUDIO_SAMPLES;
+  const hasMotion = motionSamples >= MIN_MOTION_SAMPLES;
+  const hasTouch = touchSamples >= MIN_TOUCH_SAMPLES;
+  if (!hasAudio && !hasMotion && !hasTouch) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: "Insufficient behavioral data. Please speak the phrase and trace the curve during capture."
+    };
+  }
+  if (!hasAudio) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: "No voice data detected. Please speak the phrase clearly during capture."
+    };
+  }
+  if (!hasMotion && !hasTouch) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: "Insufficient sensor data for baseline reset. Please trace the curve and allow motion access."
+    };
+  }
+  const walletAddress = wallet.adapter?.publicKey?.toBase58?.() ?? wallet.publicKey?.toBase58?.();
+  const extraction = await extractFingerprintAndValidate(
+    sensorData,
+    config,
+    walletAddress,
+    onProgress
+  );
+  if (!extraction.ok) {
+    return {
+      success: false,
+      commitment: new Uint8Array(32),
+      isFirstVerification: true,
+      error: extraction.error
+    };
+  }
+  const { tbh } = extraction;
+  onProgress?.("Submitting reset to Solana...");
+  const submission = await submitResetViaWallet(tbh.commitmentBytes, {
+    wallet,
+    connection,
+    relayerUrl: config.relayerUrl,
+    relayerApiKey: config.relayerApiKey
+  });
+  if (submission.success) {
+    try {
+      await storeVerificationData({
+        fingerprint: tbh.fingerprint,
+        salt: tbh.salt.toString(),
+        commitment: tbh.commitment.toString(),
+        timestamp: Date.now()
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sdkWarn(`[Entros SDK] Reset succeeded on chain but local baseline persistence failed: ${msg}`);
+      return {
+        success: false,
+        commitment: tbh.commitmentBytes,
+        txSignature: submission.txSignature,
+        attestationTx: submission.attestationTx,
+        isFirstVerification: true,
+        error: "Reset confirmed on chain, but saving the new baseline to this device failed. Re-verification from this device will not work. Try clearing site data and resetting again after the 7-day cooldown, or transfer a baseline from another device."
+      };
+    }
+  }
+  return {
+    success: submission.success,
+    commitment: tbh.commitmentBytes,
+    txSignature: submission.txSignature,
+    attestationTx: submission.attestationTx,
+    // Semantically this is a fresh baseline enrollment from the UX
+    // perspective. `isFirstVerification: true` lets the caller render
+    // success copy that matches first-time flows.
+    isFirstVerification: true,
+    error: submission.error
+  };
+}
+var PulseSession = class {
+  constructor(config, touchElement) {
+    this.audioStageState = "idle";
+    this.motionStageState = "idle";
+    this.touchStageState = "idle";
+    this.audioController = null;
+    this.motionController = null;
+    this.touchController = null;
+    this.audioPromise = null;
+    this.motionPromise = null;
+    this.touchPromise = null;
+    this.audioData = null;
+    this.motionData = [];
+    this.touchData = [];
+    this.config = config;
+    this.touchElement = touchElement;
+  }
+  // --- Audio ---
+  async startAudio(onAudioLevel) {
+    if (this.audioStageState !== "idle")
+      throw new Error(
+        "Audio capture already in progress. Call stopAudio() before starting a new capture."
+      );
+    const stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        sampleRate: 16e3,
+        channelCount: 1,
+        echoCancellation: false,
+        noiseSuppression: false,
+        autoGainControl: false
+      }
+    });
+    this.audioStageState = "capturing";
+    this.audioController = new AbortController();
+    this.audioPromise = captureAudio({
+      signal: this.audioController.signal,
+      onAudioLevel,
+      stream
+    }).catch(() => {
+      stream.getTracks().forEach((t) => t.stop());
+      return null;
+    });
+  }
+  async stopAudio() {
+    if (this.audioStageState !== "capturing")
+      throw new Error(
+        "No active audio capture to stop. Call startAudio() first."
+      );
+    this.audioController.abort();
+    this.audioData = await this.audioPromise;
+    this.audioStageState = "captured";
+    return this.audioData;
+  }
+  // Audio is mandatory — no skipAudio() method.
+  // If startAudio() fails, the verification cannot proceed.
+  // --- Motion ---
+  async startMotion() {
+    if (this.motionStageState !== "idle")
+      throw new Error(
+        "Motion capture already in progress. Call stopMotion() before starting a new capture."
+      );
+    const hasPermission = await requestMotionPermission();
+    if (!hasPermission) {
+      this.motionStageState = "skipped";
+      return;
+    }
+    this.motionStageState = "capturing";
+    this.motionController = new AbortController();
+    this.motionPromise = captureMotion({
+      signal: this.motionController.signal,
+      permissionGranted: true
+    }).catch(() => []);
+  }
+  async stopMotion() {
+    if (this.motionStageState !== "capturing")
+      throw new Error(
+        "No active motion capture to stop. Call startMotion() first."
+      );
+    this.motionController.abort();
+    this.motionData = await this.motionPromise;
+    this.motionStageState = "captured";
+    return this.motionData;
+  }
+  skipMotion() {
+    if (this.motionStageState !== "idle")
+      throw new Error(
+        "Cannot skip motion: capture already started. skipMotion() must be called before startMotion()."
+      );
+    this.motionStageState = "skipped";
+  }
+  isMotionCapturing() {
+    return this.motionStageState === "capturing";
+  }
+  // --- Touch ---
+  async startTouch() {
+    if (this.touchStageState !== "idle")
+      throw new Error(
+        "Touch capture already in progress. Call stopTouch() before starting a new capture."
+      );
+    if (!this.touchElement)
+      throw new Error(
+        "No touch element provided to session. Pass an HTMLElement to createSession() to enable touch capture."
+      );
+    this.touchStageState = "capturing";
+    this.touchController = new AbortController();
+    this.touchPromise = captureTouch(this.touchElement, {
+      signal: this.touchController.signal
+    }).catch(() => []);
+  }
+  async stopTouch() {
+    if (this.touchStageState !== "capturing")
+      throw new Error(
+        "No active touch capture to stop. Call startTouch() first."
+      );
+    this.touchController.abort();
+    this.touchData = await this.touchPromise;
+    this.touchStageState = "captured";
+    return this.touchData;
+  }
+  skipTouch() {
+    if (this.touchStageState !== "idle")
+      throw new Error(
+        "Cannot skip touch: capture already started. skipTouch() must be called before startTouch()."
+      );
+    this.touchStageState = "skipped";
+  }
+  // --- Complete ---
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Solana types are optional peer deps
+  async complete(wallet, connection, onProgress) {
+    const active = [];
+    if (this.audioStageState === "capturing") active.push("audio");
+    if (this.motionStageState === "capturing") active.push("motion");
+    if (this.touchStageState === "capturing") active.push("touch");
+    if (active.length > 0) {
+      throw new Error(
+        `Cannot complete: stages still capturing: ${active.join(", ")}`
+      );
+    }
+    const sensorData = {
+      audio: this.audioData,
+      motion: this.motionData,
+      touch: this.touchData,
+      modalities: {
+        audio: this.audioData !== null,
+        motion: this.motionData.length > 0,
+        touch: this.touchData.length > 0
+      }
+    };
+    return processSensorData(sensorData, this.config, wallet, connection, onProgress);
+  }
+  /**
+   * Complete the session as a baseline RESET instead of a normal verify.
+   *
+   * Use when the wallet has an on-chain IdentityState but the device has
+   * no recoverable local baseline (cleared site data, new device, etc).
+   * Skips the Hamming ZK proof; submits `reset_identity_state` on chain,
+   * which rotates the commitment and zeros verification history.
+   *
+   * Requires a connected wallet + Solana connection. Rejects if either
+   * is missing — reset is a wallet-mode-only operation since it writes
+   * to the user's on-chain account.
+   */
+  async completeReset(wallet, connection, onProgress) {
+    const active = [];
+    if (this.audioStageState === "capturing") active.push("audio");
+    if (this.motionStageState === "capturing") active.push("motion");
+    if (this.touchStageState === "capturing") active.push("touch");
+    if (active.length > 0) {
+      throw new Error(
+        `Cannot complete reset: stages still capturing: ${active.join(", ")}`
+      );
+    }
+    if (!wallet || !connection) {
+      return {
+        success: false,
+        commitment: new Uint8Array(32),
+        isFirstVerification: true,
+        error: "Baseline reset requires a connected wallet and Solana connection. Reset cannot be performed in walletless mode."
+      };
+    }
+    const sensorData = {
+      audio: this.audioData,
+      motion: this.motionData,
+      touch: this.touchData,
+      modalities: {
+        audio: this.audioData !== null,
+        motion: this.motionData.length > 0,
+        touch: this.touchData.length > 0
+      }
+    };
+    return processResetSensorData(sensorData, this.config, wallet, connection, onProgress);
+  }
+};
+var PulseSDK = class {
+  constructor(config) {
+    this.config = {
+      threshold: DEFAULT_THRESHOLD,
+      ...config
+    };
+    setDebug(config.debug ?? false);
+  }
+  /**
+   * Create a staged capture session for event-driven control.
+   */
+  createSession(touchElement) {
+    return new PulseSession(this.config, touchElement);
+  }
+  /**
+   * Run a full verification with automatic timed capture (backward-compatible).
+   * Captures all sensors in parallel for DEFAULT_CAPTURE_MS, then processes.
+   */
+  async verify(touchElement, wallet, connection) {
+    try {
+      const session = this.createSession(touchElement);
+      const stopPromises = [];
+      try {
+        await session.startMotion();
+      } catch {
+      }
+      if (session.isMotionCapturing()) {
+        stopPromises.push(
+          new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopMotion()).then(() => {
+          })
+        );
+      }
+      try {
+        await session.startAudio();
+        stopPromises.push(
+          new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopAudio()).then(() => {
+          })
+        );
+      } catch (err) {
+        throw new Error(
+          `Audio capture failed: ${err?.message ?? "microphone unavailable"}. Ensure microphone permission is granted and no other app is using it.`
+        );
+      }
+      if (touchElement) {
+        try {
+          await session.startTouch();
+          stopPromises.push(
+            new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopTouch()).then(() => {
+            })
+          );
+        } catch {
+          session.skipTouch();
+        }
+      } else {
+        session.skipTouch();
+      }
+      await Promise.all(stopPromises);
+      return session.complete(wallet, connection);
+    } catch (err) {
+      return {
+        success: false,
+        commitment: new Uint8Array(32),
+        isFirstVerification: true,
+        error: err.message ?? String(err)
+      };
+    }
+  }
+  /**
+   * Reset the wallet's on-chain baseline using a fresh capture.
+   *
+   * Convenience wrapper that mirrors `verify()` but routes the captured
+   * sensor data through `reset_identity_state` instead of `update_anchor`.
+   * Use when the wallet has an on-chain IdentityState but the local
+   * encrypted baseline is unrecoverable.
+   *
+   * For fine-grained control, call `createSession()` and `completeReset()`
+   * directly — the session API exposes per-stage start/stop hooks that
+   * this convenience wrapper trades away for simplicity.
+   */
+  async resetBaseline(touchElement, wallet, connection, onProgress) {
+    try {
+      const session = this.createSession(touchElement);
+      const stopPromises = [];
+      try {
+        await session.startMotion();
+      } catch {
+      }
+      if (session.isMotionCapturing()) {
+        stopPromises.push(
+          new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopMotion()).then(() => {
+          })
+        );
+      }
+      try {
+        await session.startAudio();
+        stopPromises.push(
+          new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopAudio()).then(() => {
+          })
+        );
+      } catch (err) {
+        throw new Error(
+          `Audio capture failed: ${err?.message ?? "microphone unavailable"}. Ensure microphone permission is granted and no other app is using it.`
+        );
+      }
+      if (touchElement) {
+        try {
+          await session.startTouch();
+          stopPromises.push(
+            new Promise((r) => setTimeout(r, DEFAULT_CAPTURE_MS)).then(() => session.stopTouch()).then(() => {
+            })
+          );
+        } catch {
+          session.skipTouch();
+        }
+      } else {
+        session.skipTouch();
+      }
+      await Promise.all(stopPromises);
+      return session.completeReset(wallet, connection, onProgress);
+    } catch (err) {
+      return {
+        success: false,
+        commitment: new Uint8Array(32),
+        isFirstVerification: true,
+        error: err.message ?? String(err)
+      };
+    }
+  }
+};
+
+// src/attestation/sas.ts
+async function verifyEntrosAttestation(walletAddress, connection) {
+  try {
+    const { PublicKey } = await import("@solana/web3.js");
+    const sasProgramId = new PublicKey(SAS_CONFIG.programId);
+    const credentialPda = new PublicKey(SAS_CONFIG.entrosCredentialPda);
+    const schemaPda = new PublicKey(SAS_CONFIG.entrosSchemaPda);
+    const userWallet = new PublicKey(walletAddress);
+    const [attestationPda] = PublicKey.findProgramAddressSync(
+      [
+        new TextEncoder().encode("attestation"),
+        credentialPda.toBuffer(),
+        schemaPda.toBuffer(),
+        userWallet.toBuffer()
+      ],
+      sasProgramId
+    );
+    const accountInfo = await connection.getAccountInfo(attestationPda);
+    if (!accountInfo) return null;
+    return deserializeSasAttestation(new Uint8Array(accountInfo.data));
+  } catch {
+    return null;
+  }
+}
+function readU16LE(data, offset) {
+  return data[offset] | data[offset + 1] << 8;
+}
+function readU32LE(data, offset) {
+  return data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16 | data[offset + 3] << 24 >>> 0;
+}
+function readI64LE(data, offset) {
+  const low = readU32LE(data, offset);
+  const high = readU32LE(data, offset + 4);
+  const signedHigh = high > 2147483647 ? high - 4294967296 : high;
+  return signedHigh * 4294967296 + low;
+}
+function deserializeSasAttestation(raw) {
+  if (raw.length < 173) return null;
+  let offset = 0;
+  offset += 1;
+  offset += 96;
+  const dataLen = readU32LE(raw, offset);
+  offset += 4;
+  if (raw.length < offset + dataLen + 32 + 8 + 32) return null;
+  const attestationData = raw.slice(offset, offset + dataLen);
+  offset += dataLen;
+  offset += 32;
+  const expiry = readI64LE(raw, offset);
+  if (attestationData.length < 11) return null;
+  let dataOffset = 0;
+  const isHuman = attestationData[dataOffset] === 1;
+  dataOffset += 1;
+  const trustScore = readU16LE(attestationData, dataOffset);
+  dataOffset += 2;
+  const verifiedAt = readI64LE(attestationData, dataOffset);
+  dataOffset += 8;
+  let mode = "unknown";
+  if (dataOffset + 4 <= attestationData.length) {
+    const modeLen = readU32LE(attestationData, dataOffset);
+    dataOffset += 4;
+    if (dataOffset + modeLen <= attestationData.length) {
+      mode = new TextDecoder().decode(
+        attestationData.slice(dataOffset, dataOffset + modeLen)
+      );
+    }
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const expired = expiry > 0 && now >= expiry;
+  return { isHuman, trustScore, verifiedAt, mode, expired };
+}
+
+// src/agent/anchor.ts
+function getRegistryProgramId(cluster) {
+  return cluster === "mainnet-beta" ? AGENT_REGISTRY_CONFIG.programIdMainnet : AGENT_REGISTRY_CONFIG.programIdDevnet;
+}
+async function sha256(data) {
+  const ab = new ArrayBuffer(data.length);
+  new Uint8Array(ab).set(data);
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", ab));
+}
+async function attestAgentOperator(agentAsset, options) {
+  try {
+    const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = await import("@solana/web3.js");
+    const walletPubkey = options.wallet.adapter?.publicKey ?? options.wallet.publicKey;
+    if (!walletPubkey) {
+      return {
+        success: false,
+        error: "Wallet not connected. Call wallet.connect() before attestAgentOperator()."
+      };
+    }
+    const programId = new PublicKey(PROGRAM_IDS.entrosAnchor);
+    const [identityPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("identity"), walletPubkey.toBuffer()],
+      programId
+    );
+    const accountInfo = await options.connection.getAccountInfo(identityPda);
+    if (!accountInfo || accountInfo.data.length < 62) {
+      return {
+        success: false,
+        error: "No Entros Anchor found. Complete a verification first."
+      };
+    }
+    const data = accountInfo.data;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const lastVerificationTimestamp = Number(view.getBigInt64(48, true));
+    const trustScore = view.getUint16(60, true);
+    const metadata = {
+      anchorPda: identityPda.toBase58(),
+      trustScore,
+      verifiedAt: lastVerificationTimestamp,
+      wallet: walletPubkey.toBase58()
+    };
+    const metadataValue = JSON.stringify(metadata);
+    const metadataKey = AGENT_REGISTRY_CONFIG.metadataKey;
+    const registryProgramId = new PublicKey(
+      getRegistryProgramId(options.cluster)
+    );
+    const assetPubkey = new PublicKey(agentAsset);
+    const [agentPda] = PublicKey.findProgramAddressSync(
+      [new TextEncoder().encode("agent"), assetPubkey.toBuffer()],
+      registryProgramId
+    );
+    const keyBytes = new TextEncoder().encode(metadataKey);
+    const keyHashFull = await sha256(keyBytes);
+    const keyHash = keyHashFull.slice(0, 16);
+    const [metadataEntryPda] = PublicKey.findProgramAddressSync(
+      [
+        new TextEncoder().encode("agent_meta"),
+        assetPubkey.toBuffer(),
+        keyHash
+      ],
+      registryProgramId
+    );
+    const valueBytes = new TextEncoder().encode(metadataValue);
+    const discriminator = new Uint8Array([236, 60, 23, 48, 138, 69, 196, 153]);
+    const ixDataSize = 8 + // discriminator
+    16 + // key_hash [u8; 16]
+    4 + keyBytes.length + // key (Borsh string: 4-byte len + utf8)
+    4 + valueBytes.length + // value (Borsh Vec<u8>: 4-byte len + bytes)
+    1;
+    const ixData = new Uint8Array(ixDataSize);
+    const ixView = new DataView(ixData.buffer);
+    let offset = 0;
+    ixData.set(discriminator, offset);
+    offset += 8;
+    ixData.set(keyHash, offset);
+    offset += 16;
+    ixView.setUint32(offset, keyBytes.length, true);
+    offset += 4;
+    ixData.set(keyBytes, offset);
+    offset += keyBytes.length;
+    ixView.setUint32(offset, valueBytes.length, true);
+    offset += 4;
+    ixData.set(valueBytes, offset);
+    offset += valueBytes.length;
+    ixData[offset] = 1;
+    offset += 1;
+    const { Buffer: SolBuffer } = await import("buffer");
+    const instruction = new TransactionInstruction({
+      programId: registryProgramId,
+      keys: [
+        { pubkey: metadataEntryPda, isSigner: false, isWritable: true },
+        { pubkey: agentPda, isSigner: false, isWritable: false },
+        { pubkey: assetPubkey, isSigner: false, isWritable: false },
+        { pubkey: walletPubkey, isSigner: true, isWritable: true },
+        {
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false
+        }
+      ],
+      data: SolBuffer.from(ixData)
+    });
+    const tx = new Transaction().add(instruction);
+    tx.feePayer = walletPubkey;
+    const { blockhash } = await options.connection.getLatestBlockhash(
+      "confirmed"
+    );
+    tx.recentBlockhash = blockhash;
+    const signFn = options.wallet.adapter?.signTransaction ?? options.wallet.signTransaction;
+    if (!signFn) {
+      return {
+        success: false,
+        error: "Wallet adapter does not expose signTransaction. Use a wallet that implements the standard Solana Wallet Adapter interface (Phantom, Solflare, Backpack)."
+      };
+    }
+    const signed = await signFn.call(
+      options.wallet.adapter ?? options.wallet,
+      tx
+    );
+    const sig = await options.connection.sendRawTransaction(
+      signed.serialize(),
+      { skipPreflight: false, preflightCommitment: "confirmed" }
+    );
+    await options.connection.confirmTransaction(sig, "confirmed");
+    return { success: true, signature: sig };
+  } catch (err) {
+    return { success: false, error: err.message ?? String(err) };
+  }
+}
+async function getAgentHumanOperator(agentAsset, connection, cluster) {
+  try {
+    const { PublicKey } = await import("@solana/web3.js");
+    const registryProgramId = new PublicKey(
+      getRegistryProgramId(cluster)
+    );
+    const assetPubkey = new PublicKey(agentAsset);
+    const metadataKey = AGENT_REGISTRY_CONFIG.metadataKey;
+    const keyBytes = new TextEncoder().encode(metadataKey);
+    const keyHashFull = await sha256(keyBytes);
+    const keyHash = keyHashFull.slice(0, 16);
+    const [metadataEntryPda] = PublicKey.findProgramAddressSync(
+      [
+        new TextEncoder().encode("agent_meta"),
+        assetPubkey.toBuffer(),
+        keyHash
+      ],
+      registryProgramId
+    );
+    const conn = connection ?? new (await import("@solana/web3.js")).Connection(
+      "https://api.devnet.solana.com",
+      "confirmed"
+    );
+    const accountInfo = await conn.getAccountInfo(metadataEntryPda);
+    if (!accountInfo) return null;
+    const raw = accountInfo.data;
+    if (raw.length < 46) return null;
+    let offset = 8 + 32 + 1 + 1;
+    const keyLen = new DataView(
+      raw.buffer,
+      raw.byteOffset + offset,
+      4
+    ).getUint32(0, true);
+    offset += 4 + keyLen;
+    if (offset + 4 > raw.length) return null;
+    const valueLen = new DataView(
+      raw.buffer,
+      raw.byteOffset + offset,
+      4
+    ).getUint32(0, true);
+    offset += 4;
+    if (offset + valueLen > raw.length) return null;
+    const valueBytes = raw.slice(offset, offset + valueLen);
+    const valueStr = new TextDecoder().decode(valueBytes);
+    return JSON.parse(valueStr);
+  } catch {
+    return null;
+  }
+}
+
+// src/challenge/phrase.ts
+var SYLLABLES = [
+  "ba",
+  "da",
+  "fa",
+  "ga",
+  "ha",
+  "ja",
+  "ka",
+  "la",
+  "ma",
+  "na",
+  "pa",
+  "ra",
+  "sa",
+  "ta",
+  "wa",
+  "za",
+  "be",
+  "de",
+  "fe",
+  "ge",
+  "ke",
+  "le",
+  "me",
+  "ne",
+  "pe",
+  "re",
+  "se",
+  "te",
+  "we",
+  "ze",
+  "bi",
+  "di",
+  "fi",
+  "gi",
+  "ki",
+  "li",
+  "mi",
+  "ni",
+  "pi",
+  "ri",
+  "si",
+  "ti",
+  "wi",
+  "zi",
+  "bo",
+  "do",
+  "fo",
+  "go",
+  "ko",
+  "lo",
+  "mo",
+  "no",
+  "po",
+  "ro",
+  "so",
+  "to",
+  "wo",
+  "zo",
+  "bu",
+  "du",
+  "fu",
+  "gu",
+  "ku",
+  "lu",
+  "mu",
+  "nu",
+  "pu",
+  "ru",
+  "su",
+  "tu"
+];
+function secureRandom(max) {
+  const arr = new Uint32Array(1);
+  crypto.getRandomValues(arr);
+  return arr[0] % max;
+}
+function generatePhrase(wordCount = 5) {
+  const words = [];
+  for (let w = 0; w < wordCount; w++) {
+    const syllableCount = 2 + secureRandom(2);
+    let word = "";
+    for (let s = 0; s < syllableCount; s++) {
+      word += SYLLABLES[secureRandom(SYLLABLES.length)];
+    }
+    words.push(word);
+  }
+  return words.join(" ");
+}
+function generatePhraseSequence(count = 3, wordCount = 4) {
+  const subsetSize = Math.floor(SYLLABLES.length / count);
+  const phrases = [];
+  for (let p = 0; p < count; p++) {
+    const start = p * subsetSize % SYLLABLES.length;
+    const subset = [
+      ...SYLLABLES.slice(start, start + subsetSize),
+      ...SYLLABLES.slice(0, Math.max(0, start + subsetSize - SYLLABLES.length))
+    ];
+    const words = [];
+    for (let w = 0; w < wordCount; w++) {
+      const syllableCount = 2 + secureRandom(2);
+      let word = "";
+      for (let s = 0; s < syllableCount; s++) {
+        word += subset[secureRandom(subset.length)];
+      }
+      words.push(word);
+    }
+    phrases.push(words.join(" "));
+  }
+  return phrases;
+}
+
+// src/challenge/lissajous.ts
+function randomLissajousParams() {
+  const ratios = [
+    [1, 2],
+    [2, 3],
+    [3, 4],
+    [3, 5],
+    [4, 5]
+  ];
+  const arr = new Uint32Array(2);
+  crypto.getRandomValues(arr);
+  const pair = ratios[arr[0] % ratios.length];
+  return {
+    a: pair[0],
+    b: pair[1],
+    delta: Math.PI * (0.25 + arr[1] / 4294967295 * 0.5),
+    points: 200
+  };
+}
+function generateLissajousPoints(params) {
+  const { a, b, delta, points } = params;
+  const result = [];
+  for (let i = 0; i < points; i++) {
+    const t = i / points * 2 * Math.PI;
+    result.push({
+      x: (Math.sin(a * t + delta) + 1) / 2,
+      y: (Math.sin(b * t) + 1) / 2
+    });
+  }
+  return result;
+}
+function generateLissajousSequence(count = 2) {
+  const allRatios = [
+    [1, 2],
+    [2, 3],
+    [3, 4],
+    [3, 5],
+    [4, 5],
+    [1, 3],
+    [2, 5],
+    [5, 6],
+    [3, 7],
+    [4, 7]
+  ];
+  const shuffled = [...allRatios];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const arr = new Uint32Array(1);
+    crypto.getRandomValues(arr);
+    const j = arr[0] % (i + 1);
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  const sequence = [];
+  for (let i = 0; i < count; i++) {
+    const pair = shuffled[i % shuffled.length];
+    const deltaArr = new Uint32Array(1);
+    crypto.getRandomValues(deltaArr);
+    const params = {
+      a: pair[0],
+      b: pair[1],
+      delta: Math.PI * (0.1 + deltaArr[0] / 4294967295 * 0.8),
+      points: 200
+    };
+    sequence.push({ params, points: generateLissajousPoints(params) });
+  }
+  return sequence;
+}
+
+// src/challenge/fetch.ts
+async function fetchChallenge(executorUrl, walletAddress, apiKey) {
+  const base = new URL(executorUrl);
+  const url = new URL("/challenge", base.origin);
+  url.searchParams.set("wallet", walletAddress);
+  const headers = { Accept: "application/json" };
+  if (apiKey) headers["X-API-Key"] = apiKey;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5e3);
+  let response;
+  try {
+    response = await fetch(url.toString(), {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sdkWarn(`[Entros SDK] /challenge fetch failed: ${msg}`);
+    throw new Error(`Unable to fetch challenge from executor: ${msg}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Executor returned ${response.status} for /challenge. Check the wallet address and try again.`
+    );
+  }
+  const body = await response.json();
+  if (!Array.isArray(body.nonce) || body.nonce.length !== 32) {
+    throw new Error("Executor returned malformed nonce; expected 32-byte array");
+  }
+  if (typeof body.phrase !== "string" || body.phrase.trim().length === 0) {
+    throw new Error("Executor returned empty challenge phrase");
+  }
+  return {
+    nonce: Uint8Array.from(body.nonce),
+    phrase: body.phrase,
+    expiresIn: body.expires_in ?? 60
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CAPTURE_MS,
+  DEFAULT_MIN_DISTANCE,
+  DEFAULT_THRESHOLD,
+  FINGERPRINT_BITS,
+  MAX_CAPTURE_MS,
+  MIN_CAPTURE_MS,
+  PROGRAM_IDS,
+  PulseSDK,
+  PulseSession,
+  SPEAKER_FEATURE_COUNT,
+  attestAgentOperator,
+  autocorrelation,
+  bigintToBytes32,
+  computeCommitment,
+  condense,
+  encodeAudioAsBase64,
+  entropy,
+  extractAccelerationMagnitude,
+  extractMotionFeatures,
+  extractMouseDynamics,
+  extractSpeakerFeatures,
+  extractSpeakerFeaturesDetailed,
+  extractTouchFeatures,
+  fetchChallenge,
+  fetchIdentityState,
+  fuseFeatures,
+  fuseRawFeatures,
+  generateLissajousPoints,
+  generateLissajousSequence,
+  generatePhrase,
+  generatePhraseSequence,
+  generateProof,
+  generateSalt,
+  generateSolanaProof,
+  generateTBH,
+  getAgentHumanOperator,
+  hammingDistance,
+  kurtosis,
+  loadVerificationData,
+  mean,
+  packBits,
+  prepareCircuitInput,
+  randomLissajousParams,
+  serializeProof,
+  simhash,
+  skewness,
+  storeVerificationData,
+  submitResetViaWallet,
+  submitViaRelayer,
+  submitViaWallet,
+  toBigEndian32,
+  variance,
+  verifyEntrosAttestation
+});
+//# sourceMappingURL=index.js.map