@iam-protocol/pulse-sdk 0.2.5 → 0.3.0

package/dist/index.js

@@ -12986,11 +12986,16 @@ __export(index_exports, {
   PROGRAM_IDS: () => PROGRAM_IDS,
   PulseSDK: () => PulseSDK,
   PulseSession: () => PulseSession,
+  SPEAKER_FEATURE_COUNT: () => SPEAKER_FEATURE_COUNT,
   autocorrelation: () => autocorrelation,
   bigintToBytes32: () => bigintToBytes32,
   computeCommitment: () => computeCommitment,
   condense: () => condense,
   entropy: () => entropy,
+  extractMotionFeatures: () => extractMotionFeatures,
+  extractMouseDynamics: () => extractMouseDynamics,
+  extractSpeakerFeatures: () => extractSpeakerFeatures,
+  extractTouchFeatures: () => extractTouchFeatures,
   fetchIdentityState: () => fetchIdentityState,
   fuseFeatures: () => fuseFeatures,
   generateLissajousPoints: () => generateLissajousPoints,
@@ -13027,7 +13032,7 @@ var BN254_SCALAR_FIELD = BigInt(
   "21888242871839275222246405745257275088548364400416034343698204186575808495617"
 );
 var FINGERPRINT_BITS = 256;
-var DEFAULT_THRESHOLD = 30;
+var DEFAULT_THRESHOLD = 96;
 var DEFAULT_MIN_DISTANCE = 3;
 var NUM_PUBLIC_INPUTS = 4;
 var PROOF_A_SIZE = 64;
@@ -13312,11 +13317,153 @@ function fuseFeatures(audio, motion, touch) {
   return [...audio, ...motion, ...touch];
 }
 
-// src/extraction/mfcc.ts
-var FRAME_SIZE = 400;
+// 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
+var FRAME_SIZE = 512;
 var HOP_SIZE = 160;
-var NUM_MFCC = 13;
+var SPEAKER_FEATURE_COUNT = 44;
+var pitchDetector = null;
 var meydaModule = null;
+async function getPitchDetector() {
+  if (!pitchDetector) {
+    const PitchFinder = await import("pitchfinder");
+    pitchDetector = PitchFinder.YIN({ sampleRate: 16e3 });
+  }
+  return pitchDetector;
+}
 async function getMeyda() {
   if (!meydaModule) {
     try {
@@ -13327,66 +13474,230 @@ async function getMeyda() {
   }
   return meydaModule.default ?? meydaModule;
 }
-async function extractMFCC(audio) {
-  const { samples, sampleRate } = audio;
-  const Meyda = await getMeyda();
-  if (!Meyda) {
-    console.warn("[IAM SDK] Meyda library failed to load. Audio features will be zeros.");
-    return new Array(NUM_MFCC * 3 * 4 + NUM_MFCC).fill(0);
-  }
+async function detectF0Contour(samples, sampleRate) {
+  const detect = await getPitchDetector();
+  const f0 = [];
+  const amplitudes = [];
+  const periods = [];
   const numFrames = Math.floor((samples.length - FRAME_SIZE) / HOP_SIZE) + 1;
-  if (numFrames < 3) {
-    console.warn(`[IAM SDK] Too few audio frames (${numFrames}). Need at least 3.`);
-    return new Array(NUM_MFCC * 3 * 4 + NUM_MFCC).fill(0);
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * HOP_SIZE;
+    const frame = samples.slice(start, start + FRAME_SIZE);
+    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 hnr = [];
+  const numFrames = Math.floor((samples.length - FRAME_SIZE) / HOP_SIZE) + 1;
+  for (let i = 0; i < numFrames && i < f0Contour.length; i++) {
+    const f0 = f0Contour[i];
+    if (f0 <= 0) continue;
+    const start = i * HOP_SIZE;
+    const frame = samples.slice(start, start + FRAME_SIZE);
+    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)));
+    }
   }
-  const mfccFrames = [];
+  return hnr;
+}
+async function computeLTAS(samples, 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 - FRAME_SIZE) / HOP_SIZE) + 1;
   for (let i = 0; i < numFrames; i++) {
     const start = i * HOP_SIZE;
     const frame = samples.slice(start, start + FRAME_SIZE);
     const paddedFrame = new Float32Array(FRAME_SIZE);
     paddedFrame.set(frame);
-    const features2 = Meyda.extract(["mfcc"], paddedFrame, {
-      sampleRate,
-      bufferSize: FRAME_SIZE,
-      numberOfMFCCCoefficients: NUM_MFCC
-    });
-    if (features2?.mfcc) {
-      mfccFrames.push(features2.mfcc);
-    }
-  }
-  if (mfccFrames.length < 3) return new Array(NUM_MFCC * 3 * 4 + NUM_MFCC).fill(0);
-  const deltaFrames = computeDeltas(mfccFrames);
-  const deltaDeltaFrames = computeDeltas(deltaFrames);
-  const features = [];
-  for (let c = 0; c < NUM_MFCC; c++) {
-    const raw = mfccFrames.map((f) => f[c] ?? 0);
-    const stats = condense(raw);
-    features.push(stats.mean, stats.variance, stats.skewness, stats.kurtosis);
-  }
-  for (let c = 0; c < NUM_MFCC; c++) {
-    const delta = deltaFrames.map((f) => f[c] ?? 0);
-    const stats = condense(delta);
-    features.push(stats.mean, stats.variance, stats.skewness, stats.kurtosis);
-  }
-  for (let c = 0; c < NUM_MFCC; c++) {
-    const dd = deltaDeltaFrames.map((f) => f[c] ?? 0);
-    const stats = condense(dd);
-    features.push(stats.mean, stats.variance, stats.skewness, stats.kurtosis);
-  }
-  for (let c = 0; c < NUM_MFCC; c++) {
-    const raw = mfccFrames.map((f) => f[c] ?? 0);
-    features.push(entropy(raw));
-  }
-  return features;
+    const features = Meyda.extract(
+      ["spectralCentroid", "spectralRolloff", "spectralFlatness", "spectralSpread"],
+      paddedFrame,
+      { sampleRate, bufferSize: FRAME_SIZE }
+    );
+    if (features) {
+      if (typeof features.spectralCentroid === "number") centroids.push(features.spectralCentroid);
+      if (typeof features.spectralRolloff === "number") rolloffs.push(features.spectralRolloff);
+      if (typeof features.spectralFlatness === "number") flatnesses.push(features.spectralFlatness);
+      if (typeof features.spectralSpread === "number") 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 computeDeltas(frames) {
-  const deltas = [];
-  for (let i = 1; i < frames.length; i++) {
-    const prev = frames[i - 1];
-    const curr = frames[i];
-    deltas.push(curr.map((v, j) => v - (prev[j] ?? 0)));
+function derivative(values) {
+  const d = [];
+  for (let i = 1; i < values.length; i++) {
+    d.push(values[i] - values[i - 1]);
   }
-  return deltas;
+  return d;
+}
+async function extractSpeakerFeatures(audio) {
+  const { samples, sampleRate } = audio;
+  const numFrames = Math.floor((samples.length - FRAME_SIZE) / HOP_SIZE) + 1;
+  if (numFrames < 5) {
+    console.warn(`[IAM SDK] Too few audio frames (${numFrames}). Speaker features will be zeros.`);
+    return new Array(SPEAKER_FEATURE_COUNT).fill(0);
+  }
+  const { f0, amplitudes, periods } = await detectF0Contour(samples, sampleRate);
+  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(samples, 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(samples, sampleRate, FRAME_SIZE, HOP_SIZE);
+  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;
 }
 
 // src/extraction/kinematic.ts
@@ -13402,8 +13713,8 @@ function extractMotionFeatures(samples) {
   };
   const features = [];
   for (const values of Object.values(axes)) {
-    const jerk = derivative(values);
-    const jounce = derivative(jerk);
+    const jerk = derivative2(values);
+    const jounce = derivative2(jerk);
     const jerkStats = condense(jerk);
     const jounceStats = condense(jounce);
     features.push(
@@ -13418,7 +13729,7 @@ function extractMotionFeatures(samples) {
     );
   }
   for (const values of Object.values(axes)) {
-    const jerk = derivative(values);
+    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) {
@@ -13435,18 +13746,18 @@ function extractTouchFeatures(samples) {
   const pressure = samples.map((s) => s.pressure);
   const area = samples.map((s) => s.width * s.height);
   const features = [];
-  const vx = derivative(x);
-  const accX = derivative(vx);
+  const vx = derivative2(x);
+  const accX = derivative2(vx);
   features.push(...Object.values(condense(vx)));
   features.push(...Object.values(condense(accX)));
-  const vy = derivative(y);
-  const accY = derivative(vy);
+  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 = derivative(accX);
-  const jerkY = derivative(accY);
+  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]) {
@@ -13459,13 +13770,170 @@ function extractTouchFeatures(samples) {
   }
   return features;
 }
-function derivative(values) {
+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) {
@@ -13504,7 +13972,7 @@ function getHyperplanes(dimension) {
   cachedDimension = dimension;
   return planes;
 }
-var EXPECTED_FEATURE_DIMENSION = 259;
+var EXPECTED_FEATURE_DIMENSION = 134;
 function simhash(features) {
   if (features.length === 0) {
     return new Array(FINGERPRINT_BITS).fill(0);
@@ -13890,8 +14358,9 @@ var inMemoryStore = null;
 
 // src/pulse.ts
 async function extractFeatures(data) {
-  const audioFeatures = data.audio ? await extractMFCC(data.audio) : new Array(169).fill(0);
-  const motionFeatures = extractMotionFeatures(data.motion);
+  const audioFeatures = data.audio ? await extractSpeakerFeatures(data.audio) : new Array(SPEAKER_FEATURE_COUNT).fill(0);
+  const hasMotion = data.motion.length >= MIN_MOTION_SAMPLES;
+  const motionFeatures = hasMotion ? extractMotionFeatures(data.motion) : extractMouseDynamics(data.touch);
   const touchFeatures = extractTouchFeatures(data.touch);
   return fuseFeatures(audioFeatures, motionFeatures, touchFeatures);
 }
@@ -13934,6 +14403,10 @@ async function processSensorData(sensorData, config, wallet, connection) {
       commitment: BigInt(previousData.commitment),
       commitmentBytes: bigintToBytes32(BigInt(previousData.commitment))
     };
+    const distance = hammingDistance(fingerprint, previousData.fingerprint);
+    console.log(
+      `[IAM SDK] Re-verification: Hamming distance = ${distance} / 256 bits (threshold = ${config.threshold})`
+    );
     const circuitInput = prepareCircuitInput(
       tbh,
       previousTBH,
@@ -14378,11 +14851,16 @@ function generateLissajousSequence(count = 2) {
   PROGRAM_IDS,
   PulseSDK,
   PulseSession,
+  SPEAKER_FEATURE_COUNT,
   autocorrelation,
   bigintToBytes32,
   computeCommitment,
   condense,
   entropy,
+  extractMotionFeatures,
+  extractMouseDynamics,
+  extractSpeakerFeatures,
+  extractTouchFeatures,
   fetchIdentityState,
   fuseFeatures,
   generateLissajousPoints,