@entros/pulse-sdk 1.5.3 → 2.0.0

package/dist/index.mjs

@@ -491,43 +491,445 @@ function findRoots(coefficients, maxIterations = 50) {
   }
   return roots;
 }
-function extractFormants(frame, sampleRate, lpcOrder = 12) {
+function extractFrameAnalysis(frame, sampleRate, lpcOrder = 12) {
   const r = autocorrelate(frame, lpcOrder);
   const coeffs = levinsonDurbin(r, lpcOrder);
   const roots = findRoots(coeffs);
-  const formantCandidates = [];
+  const candidates = [];
   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);
+      candidates.push({ freq, bandwidth });
     }
   }
-  formantCandidates.sort((a, b) => a - b);
-  if (formantCandidates.length < 3) return null;
-  return [formantCandidates[0], formantCandidates[1], formantCandidates[2]];
+  candidates.sort((a, b) => a.freq - b.freq);
+  if (candidates.length < 3) {
+    return { lpcCoefficients: coeffs, formants: null, bandwidths: null };
+  }
+  const formants = [
+    candidates[0].freq,
+    candidates[1].freq,
+    candidates[2].freq
+  ];
+  const bandwidths = [
+    candidates[0].bandwidth,
+    candidates[1].bandwidth,
+    candidates[2].bandwidth
+  ];
+  return { lpcCoefficients: coeffs, formants, bandwidths };
 }
-function extractFormantRatios(samples, sampleRate, frameSize, hopSize) {
+function extractLpcAnalysis(samples, sampleRate, frameSize, hopSize, lpcOrder = 12) {
+  const lpcCoefficients = Array.from({ length: lpcOrder }, () => []);
+  const f1 = [];
+  const f2 = [];
+  const f3 = [];
+  const b1 = [];
+  const b2 = [];
+  const b3 = [];
   const f1f2 = [];
   const f2f3 = [];
   const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  let numFramesAnalyzed = 0;
+  if (numFrames < 1) {
+    return {
+      lpcCoefficients,
+      f1,
+      f2,
+      f3,
+      b1,
+      b2,
+      b3,
+      f1f2,
+      f2f3,
+      numFramesAnalyzed: 0
+    };
+  }
+  const windowed = new Float32Array(frameSize);
   for (let i = 0; i < numFrames; i++) {
     const start = i * hopSize;
     const frame = samples.subarray(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);
+    const analysis = extractFrameAnalysis(windowed, sampleRate, lpcOrder);
+    numFramesAnalyzed++;
+    for (let c = 0; c < lpcOrder; c++) {
+      const coeff = analysis.lpcCoefficients[c];
+      if (Number.isFinite(coeff)) {
+        lpcCoefficients[c].push(coeff);
+      }
+    }
+    if (analysis.formants && analysis.bandwidths) {
+      const [F1, F2, F3] = analysis.formants;
+      const [B1, B2, B3] = analysis.bandwidths;
+      f1.push(F1);
+      f2.push(F2);
+      f3.push(F3);
+      b1.push(B1);
+      b2.push(B2);
+      b3.push(B3);
+      if (F2 > 0) f1f2.push(F1 / F2);
+      if (F3 > 0) f2f3.push(F2 / F3);
+    }
+  }
+  return {
+    lpcCoefficients,
+    f1,
+    f2,
+    f3,
+    b1,
+    b2,
+    b3,
+    f1f2,
+    f2f3,
+    numFramesAnalyzed
+  };
+}
+
+// src/extraction/mfcc.ts
+var NUM_MFCC_COEFFICIENTS = 13;
+var DELTA_REGRESSION_HALF_WIDTH = 2;
+var MFCC_FEATURE_COUNT = NUM_MFCC_COEFFICIENTS * 4 + // mean, var, skew, kurt per coefficient
+NUM_MFCC_COEFFICIENTS * 2;
+function computeDelta(series, halfWidth) {
+  const n = series.length;
+  const out = new Array(n);
+  const fullDenom = halfWidth * (halfWidth + 1) * (2 * halfWidth + 1) / 3;
+  for (let t = 0; t < n; t++) {
+    let num = 0;
+    let denom = fullDenom;
+    for (let k = 1; k <= halfWidth; k++) {
+      const tPlus = t + k;
+      const tMinus = t - k;
+      if (tPlus >= n || tMinus < 0) {
+        denom -= 2 * k * k;
+        continue;
+      }
+      num += k * (series[tPlus] - series[tMinus]);
+    }
+    if (denom <= 0) {
+      out[t] = 0;
+      continue;
+    }
+    out[t] = num / denom;
+  }
+  return out;
+}
+var meydaModule = null;
+async function getMeyda() {
+  if (!meydaModule) {
+    try {
+      meydaModule = await import("meyda");
+    } catch {
+      return null;
+    }
+  }
+  return meydaModule.default ?? meydaModule;
+}
+async function extractMfccFeatures(samples, sampleRate, frameSize, hopSize) {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0 || samples.length === 0 || frameSize <= 0 || hopSize <= 0) {
+    return new Array(MFCC_FEATURE_COUNT).fill(0);
+  }
+  const Meyda = await getMeyda();
+  if (!Meyda) {
+    sdkWarn("[Entros SDK] Meyda unavailable; MFCC features will be zeros.");
+    return new Array(MFCC_FEATURE_COUNT).fill(0);
+  }
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  if (numFrames < 5) {
+    return new Array(MFCC_FEATURE_COUNT).fill(0);
+  }
+  const mfccTracks = Array.from(
+    { length: NUM_MFCC_COEFFICIENTS },
+    () => []
+  );
+  const frame = new Float32Array(frameSize);
+  Meyda.bufferSize = frameSize;
+  Meyda.sampleRate = sampleRate;
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    frame.set(samples.subarray(start, start + frameSize), 0);
+    const result = Meyda.extract("mfcc", frame);
+    if (!Array.isArray(result) || result.length !== NUM_MFCC_COEFFICIENTS) {
+      continue;
+    }
+    let allFinite = true;
+    for (let c = 0; c < NUM_MFCC_COEFFICIENTS; c++) {
+      if (!Number.isFinite(result[c])) {
+        allFinite = false;
+        break;
+      }
+    }
+    if (!allFinite) continue;
+    for (let c = 0; c < NUM_MFCC_COEFFICIENTS; c++) {
+      mfccTracks[c].push(result[c]);
+    }
+  }
+  const out = [];
+  out.length = MFCC_FEATURE_COUNT;
+  let writeIdx = 0;
+  for (let c = 0; c < NUM_MFCC_COEFFICIENTS; c++) {
+    const stats = condense(mfccTracks[c]);
+    out[writeIdx++] = stats.mean;
+    out[writeIdx++] = stats.variance;
+    out[writeIdx++] = stats.skewness;
+    out[writeIdx++] = stats.kurtosis;
+  }
+  for (let c = 0; c < NUM_MFCC_COEFFICIENTS; c++) {
+    const delta = computeDelta(mfccTracks[c], DELTA_REGRESSION_HALF_WIDTH);
+    const muDelta = mean(delta);
+    out[writeIdx++] = muDelta;
+    out[writeIdx++] = variance(delta, muDelta);
+  }
+  return out;
+}
+
+// src/extraction/voice-quality.ts
+var VOICE_QUALITY_FEATURE_COUNT = 9;
+var LOW_BAND_HZ = 1e3;
+var MID_BAND_HZ = 3e3;
+var HIGH_BAND_HZ = 8e3;
+function cppQuefrencyRange(sampleRate) {
+  return {
+    qMin: Math.max(2, Math.floor(sampleRate / 400)),
+    qMax: Math.floor(sampleRate / 60)
+  };
+}
+var meydaModule2 = null;
+async function getMeyda2() {
+  if (!meydaModule2) {
+    try {
+      meydaModule2 = await import("meyda");
+    } catch {
+      return null;
+    }
+  }
+  return meydaModule2.default ?? meydaModule2;
+}
+function cepstralPeakProminence(powerSpectrum, sampleRate) {
+  const N = powerSpectrum.length;
+  if (N < 8) return 0;
+  const { qMin, qMax } = cppQuefrencyRange(sampleRate);
+  if (qMax >= N || qMax <= qMin) return 0;
+  const FLOOR = 1e-12;
+  const logPower = new Array(N);
+  for (let i = 0; i < N; i++) {
+    const p = Math.max(powerSpectrum[i], FLOOR);
+    const l = Math.log(p);
+    if (!Number.isFinite(l)) return 0;
+    logPower[i] = l;
+  }
+  const bandLen = qMax - qMin + 1;
+  const cepstrumBand = new Array(bandLen);
+  const piOverN = Math.PI / N;
+  for (let bIdx = 0; bIdx < bandLen; bIdx++) {
+    const k = qMin + bIdx;
+    let sum = 0;
+    for (let n = 0; n < N; n++) {
+      sum += logPower[n] * Math.cos(piOverN * (n + 0.5) * k);
+    }
+    cepstrumBand[bIdx] = sum;
+  }
+  let peakBIdx = 0;
+  let peakVal = cepstrumBand[0];
+  for (let bIdx = 1; bIdx < bandLen; bIdx++) {
+    if (cepstrumBand[bIdx] > peakVal) {
+      peakVal = cepstrumBand[bIdx];
+      peakBIdx = bIdx;
+    }
+  }
+  const peakQuefrency = qMin + peakBIdx;
+  const M = bandLen;
+  let sx = 0;
+  let sy = 0;
+  let sxx = 0;
+  let sxy = 0;
+  for (let bIdx = 0; bIdx < bandLen; bIdx++) {
+    const x = qMin + bIdx;
+    const y = cepstrumBand[bIdx];
+    sx += x;
+    sy += y;
+    sxx += x * x;
+    sxy += x * y;
+  }
+  const denom = M * sxx - sx * sx;
+  if (Math.abs(denom) < 1e-12) return 0;
+  const slope = (M * sxy - sx * sy) / denom;
+  const intercept = (sy - slope * sx) / M;
+  const baselineAtPeak = intercept + slope * peakQuefrency;
+  return peakVal - baselineAtPeak;
+}
+function spectralTilt(powerSpectrum, sampleRate) {
+  const N = powerSpectrum.length;
+  if (N < 8) return 0;
+  const FLOOR = 1e-12;
+  let sx = 0;
+  let sy = 0;
+  let sxx = 0;
+  let sxy = 0;
+  let count = 0;
+  const minBin = Math.max(1, Math.floor(100 * 2 * (N - 1) / sampleRate));
+  for (let k = minBin; k < N; k++) {
+    const p = powerSpectrum[k];
+    if (p < FLOOR) continue;
+    const x = Math.log(k);
+    const y = Math.log(p);
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+    sx += x;
+    sy += y;
+    sxx += x * x;
+    sxy += x * y;
+    count++;
+  }
+  if (count < 4) return 0;
+  const denom = count * sxx - sx * sx;
+  if (Math.abs(denom) < 1e-12) return 0;
+  return (count * sxy - sx * sy) / denom;
+}
+function h1MinusH2(powerSpectrum, sampleRate, f0) {
+  if (!Number.isFinite(f0) || f0 <= 0) return 0;
+  const N = powerSpectrum.length;
+  if (N < 8) return 0;
+  const binPerHz = 2 * (N - 1) / sampleRate;
+  const k1 = Math.round(f0 * binPerHz);
+  const k2 = Math.round(2 * f0 * binPerHz);
+  const window2 = 2;
+  function peakNear(k) {
+    let best = -Infinity;
+    for (let i = k - window2; i <= k + window2; i++) {
+      if (i <= 0 || i >= N) continue;
+      const p = powerSpectrum[i];
+      if (p > best) best = p;
+    }
+    return best;
+  }
+  const h1 = peakNear(k1);
+  const h2 = peakNear(k2);
+  if (!Number.isFinite(h1) || !Number.isFinite(h2) || h1 <= 0 || h2 <= 0) return 0;
+  return 10 * Math.log10(h1 / h2);
+}
+function subbandRatios(powerSpectrum, sampleRate) {
+  const N = powerSpectrum.length;
+  if (N < 4) return [0, 0, 0];
+  const binPerHz = 2 * (N - 1) / sampleRate;
+  const lowBin = Math.min(N - 1, Math.round(LOW_BAND_HZ * binPerHz));
+  const midBin = Math.min(N - 1, Math.round(MID_BAND_HZ * binPerHz));
+  const highBin = Math.min(N - 1, Math.round(HIGH_BAND_HZ * binPerHz));
+  let total = 0;
+  let low = 0;
+  let mid = 0;
+  let high = 0;
+  for (let k = 1; k < N; k++) {
+    const p = powerSpectrum[k];
+    if (!Number.isFinite(p) || p < 0) continue;
+    total += p;
+    if (k <= lowBin) low += p;
+    else if (k <= midBin) mid += p;
+    else if (k <= highBin) high += p;
+  }
+  if (total < 1e-12) return [0, 0, 0];
+  return [low / total, mid / total, high / total];
+}
+async function extractVoiceQualityFeatures(samples, sampleRate, frameSize, hopSize, f0PerFrame) {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0 || samples.length === 0 || frameSize <= 0 || hopSize <= 0) {
+    return new Array(VOICE_QUALITY_FEATURE_COUNT).fill(0);
+  }
+  const Meyda = await getMeyda2();
+  if (!Meyda) {
+    sdkWarn("[Entros SDK] Meyda unavailable; voice quality features will be zeros.");
+    return new Array(VOICE_QUALITY_FEATURE_COUNT).fill(0);
+  }
+  const numFrames = Math.floor((samples.length - frameSize) / hopSize) + 1;
+  if (numFrames < 5) {
+    return new Array(VOICE_QUALITY_FEATURE_COUNT).fill(0);
+  }
+  const cppValues = [];
+  const tiltValues = [];
+  const h1h2Values = [];
+  const lowRatios = [];
+  const midRatios = [];
+  const highRatios = [];
+  const frame = new Float32Array(frameSize);
+  Meyda.bufferSize = frameSize;
+  Meyda.sampleRate = sampleRate;
+  for (let i = 0; i < numFrames; i++) {
+    const start = i * hopSize;
+    frame.set(samples.subarray(start, start + frameSize), 0);
+    const features = Meyda.extract("powerSpectrum", frame);
+    const power = features;
+    if (!power || power.length === 0) continue;
+    const cpp = cepstralPeakProminence(power, sampleRate);
+    if (Number.isFinite(cpp)) cppValues.push(cpp);
+    const tilt = spectralTilt(power, sampleRate);
+    if (Number.isFinite(tilt)) tiltValues.push(tilt);
+    const f0 = f0PerFrame[i] ?? 0;
+    if (f0 > 0) {
+      const h1h2 = h1MinusH2(power, sampleRate, f0);
+      if (Number.isFinite(h1h2)) h1h2Values.push(h1h2);
+    }
+    const [low, mid, high] = subbandRatios(power, sampleRate);
+    lowRatios.push(low);
+    midRatios.push(mid);
+    highRatios.push(high);
+  }
+  const cppMean = mean(cppValues);
+  const cppVar = variance(cppValues, cppMean);
+  const tiltMean = mean(tiltValues);
+  const tiltVar = variance(tiltValues, tiltMean);
+  const h1h2Mean = mean(h1h2Values);
+  const h1h2Var = variance(h1h2Values, h1h2Mean);
+  const lowMean = mean(lowRatios);
+  const midMean = mean(midRatios);
+  const highMean = mean(highRatios);
+  return [
+    cppMean,
+    cppVar,
+    tiltMean,
+    tiltVar,
+    h1h2Mean,
+    h1h2Var,
+    lowMean,
+    midMean,
+    highMean
+  ];
+}
+
+// src/extraction/dct.ts
+function dctII(input, numCoefficients) {
+  const N = input.length;
+  const K = Math.max(0, numCoefficients);
+  const output = new Array(K).fill(0);
+  if (N === 0 || K === 0) return output;
+  const upper = Math.min(K, N);
+  const piOverN = Math.PI / N;
+  for (let k = 0; k < upper; k++) {
+    let sum = 0;
+    for (let n = 0; n < N; n++) {
+      sum += input[n] * Math.cos(piOverN * (n + 0.5) * k);
     }
+    output[k] = sum;
   }
-  return { f1f2, f2f3 };
+  return output;
+}
+function pitchContourShape(contour, numCoefficients = 5) {
+  if (numCoefficients <= 0) return [];
+  const zero = () => new Array(numCoefficients).fill(0);
+  const voiced = [];
+  for (const v of contour) {
+    if (Number.isFinite(v) && v > 0) voiced.push(v);
+  }
+  if (voiced.length < numCoefficients * 2) return zero();
+  let sum = 0;
+  for (const v of voiced) sum += v;
+  const mu = sum / voiced.length;
+  const centered = voiced.map((v) => v - mu);
+  const N = centered.length;
+  const norm = 1 / Math.sqrt(N);
+  return dctII(centered, numCoefficients).map((c) => c * norm);
 }
+var PITCH_CONTOUR_SHAPE_FEATURE_COUNT = 5;
 
 // src/yield.ts
 function yieldToMainThread() {
@@ -560,10 +962,13 @@ function getFrameSize(sampleRate) {
 function getHopSize(sampleRate) {
   return Math.max(1, Math.round(sampleRate * 0.01));
 }
-var SPEAKER_FEATURE_COUNT = 44;
+var LEGACY_SPEAKER_FEATURE_COUNT = 44;
+var LPC_COEFFICIENT_STATS = 12 * 2;
+var FORMANT_TRAJECTORY_FEATURE_COUNT = 16;
+var SPEAKER_FEATURE_COUNT = LEGACY_SPEAKER_FEATURE_COUNT + MFCC_FEATURE_COUNT + LPC_COEFFICIENT_STATS + FORMANT_TRAJECTORY_FEATURE_COUNT + VOICE_QUALITY_FEATURE_COUNT + PITCH_CONTOUR_SHAPE_FEATURE_COUNT;
 var pitchDetector = null;
 var pitchDetectorRate = 0;
-var meydaModule = null;
+var meydaModule3 = null;
 async function getPitchDetector(sampleRate) {
   if (!pitchDetector || pitchDetectorRate !== sampleRate) {
     const PitchFinder = await import("pitchfinder");
@@ -572,15 +977,15 @@ async function getPitchDetector(sampleRate) {
   }
   return pitchDetector;
 }
-async function getMeyda() {
-  if (!meydaModule) {
+async function getMeyda3() {
+  if (!meydaModule3) {
     try {
-      meydaModule = await import("meyda");
+      meydaModule3 = await import("meyda");
     } catch {
       return null;
     }
   }
-  return meydaModule.default ?? meydaModule;
+  return meydaModule3.default ?? meydaModule3;
 }
 var F0_YIELD_EVERY_N_FRAMES = 16;
 async function detectF0Contour(samples, sampleRate) {
@@ -710,8 +1115,10 @@ function computeHNR(samples, sampleRate, f0Contour) {
 async function computeLTAS(samples, sampleRate) {
   const frameSize = getFrameSize(sampleRate);
   const hopSize = getHopSize(sampleRate);
-  const Meyda = await getMeyda();
+  const Meyda = await getMeyda3();
   if (!Meyda) return new Array(8).fill(0);
+  Meyda.bufferSize = frameSize;
+  Meyda.sampleRate = sampleRate;
   const centroids = [];
   const rolloffs = [];
   const flatnesses = [];
@@ -723,8 +1130,7 @@ async function computeLTAS(samples, sampleRate) {
     paddedFrame.set(samples.subarray(start, start + frameSize), 0);
     const features = Meyda.extract(
       ["spectralCentroid", "spectralRolloff", "spectralFlatness", "spectralSpread"],
-      paddedFrame,
-      { sampleRate, bufferSize: frameSize }
+      paddedFrame
     );
     if (features) {
       if (Number.isFinite(features.spectralCentroid)) centroids.push(features.spectralCentroid);
@@ -811,9 +1217,9 @@ async function extractSpeakerFeaturesDetailed(audio) {
   const hnrEntropy = entropy(hnrValues);
   const hnrFeatures = [hnrStats.mean, hnrStats.variance, hnrStats.skewness, hnrStats.kurtosis, hnrEntropy];
   await yieldToMainThread();
-  const { f1f2, f2f3 } = extractFormantRatios(normalizedSamples, sampleRate, frameSize, hopSize);
-  const f1f2Stats = condense(f1f2);
-  const f2f3Stats = condense(f2f3);
+  const lpc = extractLpcAnalysis(normalizedSamples, sampleRate, frameSize, hopSize);
+  const f1f2Stats = condense(lpc.f1f2);
+  const f2f3Stats = condense(lpc.f2f3);
   const formantFeatures = [
     f1f2Stats.mean,
     f1f2Stats.variance,
@@ -830,25 +1236,86 @@ async function extractSpeakerFeaturesDetailed(audio) {
   const ampStats = condense(amplitudes);
   const ampEntropy = entropy(amplitudes);
   const ampFeatures = [ampStats.mean, ampStats.variance, ampStats.skewness, ampStats.kurtosis, ampEntropy];
+  await yieldToMainThread();
+  const mfccFeatures = await extractMfccFeatures(
+    normalizedSamples,
+    sampleRate,
+    frameSize,
+    hopSize
+  );
+  const lpcStats = [];
+  for (let c = 0; c < 12; c++) {
+    const track = lpc.lpcCoefficients[c] ?? [];
+    const mu = mean(track);
+    lpcStats.push(mu, variance(track, mu));
+  }
+  const f1Stats = { mean: mean(lpc.f1), var: variance(lpc.f1) };
+  const f2Stats = { mean: mean(lpc.f2), var: variance(lpc.f2) };
+  const f3Stats = { mean: mean(lpc.f3), var: variance(lpc.f3) };
+  const f1Delta = derivative(lpc.f1);
+  const f2Delta = derivative(lpc.f2);
+  const f3Delta = derivative(lpc.f3);
+  const f1DeltaMu = mean(f1Delta);
+  const f2DeltaMu = mean(f2Delta);
+  const f3DeltaMu = mean(f3Delta);
+  const b1Mu = mean(lpc.b1);
+  const b2Mu = mean(lpc.b2);
+  const formantTrajectoryFeatures = [
+    f1Stats.mean,
+    f1Stats.var,
+    f2Stats.mean,
+    f2Stats.var,
+    f3Stats.mean,
+    f3Stats.var,
+    f1DeltaMu,
+    variance(f1Delta, f1DeltaMu),
+    f2DeltaMu,
+    variance(f2Delta, f2DeltaMu),
+    f3DeltaMu,
+    variance(f3Delta, f3DeltaMu),
+    b1Mu,
+    variance(lpc.b1, b1Mu),
+    b2Mu,
+    variance(lpc.b2, b2Mu)
+  ];
+  await yieldToMainThread();
+  const voiceQualityFeatures = await extractVoiceQualityFeatures(
+    normalizedSamples,
+    sampleRate,
+    frameSize,
+    hopSize,
+    f0
+  );
+  const pitchShapeFeatures = pitchContourShape(f0, PITCH_CONTOUR_SHAPE_FEATURE_COUNT);
   const features = [
     ...f0Features,
-    // 5
+    // 5     [0..5]    F0_STATS
     ...f0DeltaFeatures,
-    // 4
+    // 4     [5..9]    F0_DELTA
     ...jitterFeatures,
-    // 4
+    // 4     [9..13]   JITTER
     ...shimmerFeatures,
-    // 4
+    // 4     [13..17]  SHIMMER
     ...hnrFeatures,
-    // 5
+    // 5     [17..22]  HNR
     ...formantFeatures,
-    // 8
+    // 8     [22..30]  FORMANT_RATIOS
     ...ltasFeatures,
-    // 8
+    // 8     [30..38]  LTAS
     ...voicingFeatures,
-    // 1
-    ...ampFeatures
-    // 5
+    // 1     [38]      VOICING_RATIO
+    ...ampFeatures,
+    // 5     [39..44]  AMPLITUDE
+    ...mfccFeatures,
+    // 78    [44..122] MFCC + delta-MFCC
+    ...lpcStats,
+    // 24    [122..146] LPC coefficient stats
+    ...formantTrajectoryFeatures,
+    // 16    [146..162] Formant absolutes + dynamics + bandwidths
+    ...voiceQualityFeatures,
+    // 9     [162..171] Voice quality
+    ...pitchShapeFeatures
+    // 5     [171..176] Pitch contour shape DCT
   ];
   return { features, f0Contour: f0 };
 }
@@ -857,7 +1324,102 @@ async function extractSpeakerFeatures(audio) {
   return features;
 }
 
+// src/extraction/fft.ts
+function nextPow2(n) {
+  if (n <= 2) return 2;
+  let p = 2;
+  while (p < n) p <<= 1;
+  return p;
+}
+function realFFT(input, size) {
+  if (size <= 0 || (size & size - 1) !== 0) {
+    throw new Error(`FFT size must be a positive power of two, got ${size}`);
+  }
+  const real = new Array(size);
+  const imag = new Array(size).fill(0);
+  for (let i = 0; i < size; i++) {
+    real[i] = i < input.length ? input[i] ?? 0 : 0;
+  }
+  for (let i = 1, j = 0; i < size; i++) {
+    let bit = size >> 1;
+    for (; j & bit; bit >>= 1) j ^= bit;
+    j ^= bit;
+    if (i < j) {
+      const tr = real[i];
+      real[i] = real[j];
+      real[j] = tr;
+    }
+  }
+  for (let halfSize = 1; halfSize < size; halfSize <<= 1) {
+    const fullSize = halfSize << 1;
+    const phaseStep = -Math.PI / halfSize;
+    for (let chunkStart = 0; chunkStart < size; chunkStart += fullSize) {
+      for (let k = 0; k < halfSize; k++) {
+        const phase = phaseStep * k;
+        const wr = Math.cos(phase);
+        const wi = Math.sin(phase);
+        const ar = real[chunkStart + k];
+        const ai = imag[chunkStart + k];
+        const br = real[chunkStart + k + halfSize];
+        const bi = imag[chunkStart + k + halfSize];
+        const tr = wr * br - wi * bi;
+        const ti = wr * bi + wi * br;
+        real[chunkStart + k] = ar + tr;
+        imag[chunkStart + k] = ai + ti;
+        real[chunkStart + k + halfSize] = ar - tr;
+        imag[chunkStart + k + halfSize] = ai - ti;
+      }
+    }
+  }
+  return { real, imag };
+}
+function bandEnergy(real, imag, sampleRate, fLow, fHigh) {
+  const N = real.length;
+  if (N === 0 || !Number.isFinite(sampleRate) || sampleRate <= 0 || fLow >= fHigh || fLow < 0) {
+    return 0;
+  }
+  const binHz = sampleRate / N;
+  const kLow = Math.max(0, Math.ceil(fLow / binHz));
+  const kHigh = Math.min(Math.floor(N / 2), Math.floor((fHigh - 1e-9) / binHz));
+  let energy = 0;
+  for (let k = kLow; k <= kHigh; k++) {
+    const re = real[k] ?? 0;
+    const im = imag[k] ?? 0;
+    energy += re * re + im * im;
+  }
+  return energy / (N * N);
+}
+function peakInBand(real, imag, sampleRate, fLow, fHigh) {
+  const N = real.length;
+  if (N === 0 || !Number.isFinite(sampleRate) || sampleRate <= 0 || fLow >= fHigh || fLow < 0) {
+    return { freq: 0, amplitude: 0 };
+  }
+  const binHz = sampleRate / N;
+  const kLow = Math.max(0, Math.ceil(fLow / binHz));
+  const kHigh = Math.min(Math.floor(N / 2), Math.floor((fHigh - 1e-9) / binHz));
+  let bestK = -1;
+  let bestAmp = -Infinity;
+  for (let k = kLow; k <= kHigh; k++) {
+    const re = real[k] ?? 0;
+    const im = imag[k] ?? 0;
+    const amp = re * re + im * im;
+    if (amp > bestAmp) {
+      bestAmp = amp;
+      bestK = k;
+    }
+  }
+  if (bestK < 0) return { freq: 0, amplitude: 0 };
+  return { freq: bestK * binHz, amplitude: bestAmp / (N * N) };
+}
+
 // src/extraction/kinematic.ts
+var MOTION_LEGACY_COUNT = 54;
+var MOTION_V2_ADDITIONS = 27;
+var MOTION_FEATURE_COUNT = MOTION_LEGACY_COUNT + MOTION_V2_ADDITIONS;
+var TOUCH_LEGACY_COUNT = 36;
+var TOUCH_V2_ADDITIONS = 21;
+var TOUCH_FEATURE_COUNT = TOUCH_LEGACY_COUNT + TOUCH_V2_ADDITIONS;
+var MOUSE_DYNAMICS_FEATURE_COUNT = MOTION_FEATURE_COUNT;
 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));
@@ -875,7 +1437,7 @@ function extractAccelerationMagnitude(samples, targetFrameCount) {
   return out;
 }
 function extractMotionFeatures(samples) {
-  if (samples.length < 5) return new Array(54).fill(0);
+  if (samples.length < 5) return new Array(MOTION_FEATURE_COUNT).fill(0);
   const axes = {
     ax: samples.map((s) => s.ax),
     ay: samples.map((s) => s.ay),
@@ -910,10 +1472,68 @@ function extractMotionFeatures(samples) {
     }
     features.push(windowVariances.length >= 2 ? variance(windowVariances) : 0);
   }
+  features.push(...computeMotionV2(axes, samples));
   return features;
 }
+function computeMotionV2(axes, samples) {
+  const out = [];
+  const covPairs = [
+    [axes.ax, axes.gy],
+    [axes.ay, axes.gx],
+    [axes.az, axes.gz],
+    [axes.ax, axes.az],
+    [axes.ay, axes.az],
+    [axes.gx, axes.gy]
+  ];
+  for (const [a, b] of covPairs) out.push(covariance(a, b));
+  const sampleRate = sampleRateFromTimestamps(samples.map((s) => s.timestamp));
+  const fftSize = nextPow2(Math.max(64, axes.ax.length));
+  const bands = [
+    [0, 2],
+    [2, 6],
+    [6, 12],
+    [12, 30]
+  ];
+  const accelSpectra = [axes.ax, axes.ay, axes.az].map(
+    (axis) => realFFT(meanCenter(axis), fftSize)
+  );
+  for (const spectrum of accelSpectra) {
+    for (const [lo, hi] of bands) {
+      out.push(bandEnergy(spectrum.real, spectrum.imag, sampleRate, lo, hi));
+    }
+  }
+  const magnitude = samples.map(
+    (s) => Math.sqrt(s.ax * s.ax + s.ay * s.ay + s.az * s.az)
+  );
+  const magSpectrum = realFFT(meanCenter(magnitude), fftSize);
+  const tremor = peakInBand(
+    magSpectrum.real,
+    magSpectrum.imag,
+    sampleRate,
+    4,
+    12
+  );
+  out.push(tremor.freq, tremor.amplitude);
+  const duration = captureDurationSec(samples);
+  const reversalRates = [axes.ax, axes.ay, axes.az].map(
+    (axis) => duration > 0 ? signChangeCount(derivative2(axis)) / duration : 0
+  );
+  out.push(mean(reversalRates), variance(reversalRates));
+  let gyroSum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const gx = samples[i].gx;
+    const gy = samples[i].gy;
+    const gz = samples[i].gz;
+    gyroSum += Math.sqrt(gx * gx + gy * gy + gz * gz);
+  }
+  out.push(samples.length > 0 ? gyroSum / samples.length : 0);
+  for (const lag of [1, 5, 10, 25]) {
+    out.push(autocorrelation(magnitude, lag));
+  }
+  return out;
+}
 function extractTouchFeatures(samples) {
-  if (samples.length < 5) return new Array(36).fill(0);
+  if (samples.length < 5) return new Array(TOUCH_FEATURE_COUNT).fill(0);
   const x = samples.map((s) => s.x);
   const y = samples.map((s) => s.y);
   const pressure = samples.map((s) => s.pressure);
@@ -941,8 +1561,78 @@ function extractTouchFeatures(samples) {
     }
     features.push(windowVariances.length >= 2 ? variance(windowVariances) : 0);
   }
+  features.push(...computeTouchV2(samples, vx, vy));
   return features;
 }
+function computeTouchV2(samples, vx, vy) {
+  const out = [];
+  const pressure = samples.map((s) => s.pressure);
+  const dPressure = derivative2(pressure);
+  out.push(...Object.values(condense(dPressure)));
+  const aspect = samples.map((s) => {
+    const h = s.height;
+    return h > 0 ? s.width / h : 0;
+  });
+  out.push(mean(aspect), variance(aspect));
+  const area = samples.map((s) => s.width * s.height);
+  const dArea = derivative2(area);
+  out.push(mean(dArea), variance(dArea));
+  const CURVATURE_REST_EPS = 1e-3;
+  const curvatures = [];
+  for (let i = 1; i < vx.length; i++) {
+    const v1x = vx[i - 1] ?? 0;
+    const v1y = vy[i - 1] ?? 0;
+    const v2x = vx[i] ?? 0;
+    const v2y = vy[i] ?? 0;
+    if (Math.hypot(v1x, v1y) < CURVATURE_REST_EPS || Math.hypot(v2x, v2y) < CURVATURE_REST_EPS) {
+      continue;
+    }
+    const a1 = Math.atan2(v1y, v1x);
+    const a2 = Math.atan2(v2y, v2x);
+    let d = a2 - a1;
+    while (d > Math.PI) d -= 2 * Math.PI;
+    while (d < -Math.PI) d += 2 * Math.PI;
+    curvatures.push(Math.abs(d));
+  }
+  const curvStats = condense(curvatures);
+  out.push(curvStats.mean, curvStats.variance, curvStats.skewness);
+  const speed = vx.map((dx2, i) => {
+    const dy2 = vy[i] ?? 0;
+    return Math.sqrt(dx2 * dx2 + dy2 * dy2);
+  });
+  for (const lag of [1, 3, 5]) out.push(autocorrelation(speed, lag));
+  const gaps = [];
+  for (let i = 1; i < samples.length; i++) {
+    gaps.push((samples[i]?.timestamp ?? 0) - (samples[i - 1]?.timestamp ?? 0));
+  }
+  out.push(...Object.values(condense(gaps)));
+  const totalPath = speed.reduce((a, b) => a + b, 0);
+  const dx = (samples[samples.length - 1]?.x ?? 0) - (samples[0]?.x ?? 0);
+  const dy = (samples[samples.length - 1]?.y ?? 0) - (samples[0]?.y ?? 0);
+  const straight = Math.sqrt(dx * dx + dy * dy);
+  out.push(totalPath > 0 ? straight / totalPath : 0);
+  const strokeLengths = perStrokePathLengths(speed);
+  out.push(mean(strokeLengths), variance(strokeLengths));
+  return out;
+}
+function perStrokePathLengths(speed) {
+  const PAUSE_THRESHOLD = 0.5;
+  const lengths = [];
+  let acc = 0;
+  let inStroke = false;
+  for (const s of speed) {
+    if (s >= PAUSE_THRESHOLD) {
+      acc += s;
+      inStroke = true;
+    } else if (inStroke) {
+      lengths.push(acc);
+      acc = 0;
+      inStroke = false;
+    }
+  }
+  if (inStroke && acc > 0) lengths.push(acc);
+  return lengths;
+}
 function derivative2(values) {
   const d = [];
   for (let i = 1; i < values.length; i++) {
@@ -950,8 +1640,53 @@ function derivative2(values) {
   }
   return d;
 }
+function meanCenter(values) {
+  if (values.length === 0) return [];
+  let sum = 0;
+  for (const v of values) sum += v;
+  const m = sum / values.length;
+  return values.map((v) => v - m);
+}
+function covariance(a, b) {
+  const n = Math.min(a.length, b.length);
+  if (n < 2) return 0;
+  let sumA = 0;
+  let sumB = 0;
+  for (let i = 0; i < n; i++) {
+    sumA += a[i] ?? 0;
+    sumB += b[i] ?? 0;
+  }
+  const meanA = sumA / n;
+  const meanB = sumB / n;
+  let cov = 0;
+  for (let i = 0; i < n; i++) {
+    cov += ((a[i] ?? 0) - meanA) * ((b[i] ?? 0) - meanB);
+  }
+  return cov / (n - 1);
+}
+function signChangeCount(values) {
+  let count = 0;
+  let last = 0;
+  for (const v of values) {
+    if (v > 0 && last < 0) count++;
+    else if (v < 0 && last > 0) count++;
+    if (v !== 0) last = v;
+  }
+  return count;
+}
+function sampleRateFromTimestamps(timestampsMs) {
+  if (timestampsMs.length < 2) return 0;
+  const span = (timestampsMs[timestampsMs.length - 1] ?? 0) - (timestampsMs[0] ?? 0);
+  if (!Number.isFinite(span) || span <= 0) return 0;
+  return (timestampsMs.length - 1) * 1e3 / span;
+}
+function captureDurationSec(samples) {
+  if (samples.length < 2) return 0;
+  const span = (samples[samples.length - 1]?.timestamp ?? 0) - (samples[0]?.timestamp ?? 0);
+  return Number.isFinite(span) && span > 0 ? span / 1e3 : 0;
+}
 function extractMouseDynamics(samples) {
-  if (samples.length < 10) return new Array(54).fill(0);
+  if (samples.length < 10) return new Array(MOUSE_DYNAMICS_FEATURE_COUNT).fill(0);
   const x = samples.map((s) => s.x);
   const y = samples.map((s) => s.y);
   const pressure = samples.map((s) => s.pressure);
@@ -1050,7 +1785,7 @@ function extractMouseDynamics(samples) {
   const pressureStats = condense(pressure);
   const moveDurStats = condense(movementDurations);
   const segLenStats = condense(segmentLengths);
-  return [
+  const legacyMouseDynamics = [
     curvatureStats.mean,
     curvatureStats.variance,
     curvatureStats.skewness,
@@ -1106,6 +1841,8 @@ function extractMouseDynamics(samples) {
     angleAutoCorr[2] ?? 0,
     normalizedPathLength
   ];
+  const padding = MOUSE_DYNAMICS_FEATURE_COUNT - legacyMouseDynamics.length;
+  return padding > 0 ? [...legacyMouseDynamics, ...new Array(padding).fill(0)] : legacyMouseDynamics;
 }
 
 // src/hashing/simhash.ts
@@ -1145,7 +1882,7 @@ function getHyperplanes(dimension) {
   cachedDimension = dimension;
   return planes;
 }
-var EXPECTED_FEATURE_DIMENSION = 134;
+var EXPECTED_FEATURE_DIMENSION = SPEAKER_FEATURE_COUNT + MOTION_FEATURE_COUNT + TOUCH_FEATURE_COUNT;
 function simhash(features) {
   if (features.length === 0) {
     return new Array(FINGERPRINT_BITS).fill(0);
@@ -4286,9 +5023,12 @@ async function extractFingerprintAndValidate(sensorData, config, walletAddress,
     f0Contour,
     accelMagnitude
   } = await extractFeatures(sensorData);
+  const AUDIO_END = SPEAKER_FEATURE_COUNT;
+  const MOTION_END = AUDIO_END + MOTION_FEATURE_COUNT;
+  const TOUCH_END = MOTION_END + TOUCH_FEATURE_COUNT;
   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.`
+    `[Entros SDK] Feature vector: ${features.length} dimensions, ${nonZero} non-zero. Audio[0..${AUDIO_END - 1}]: ${features.slice(0, AUDIO_END).filter((v) => v !== 0).length} non-zero. Motion/Mouse[${AUDIO_END}..${MOTION_END - 1}]: ${features.slice(AUDIO_END, MOTION_END).filter((v) => v !== 0).length} non-zero. Touch[${MOTION_END}..${TOUCH_END - 1}]: ${features.slice(MOTION_END, TOUCH_END).filter((v) => v !== 0).length} non-zero.`
   );
   const fingerprint = simhash(normalizedFeatures);
   const tbh = await generateTBH(fingerprint);
@@ -4492,9 +5232,12 @@ async function processSensorData(sensorData, config, wallet, connection, onProgr
       );
       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 motionStart = SPEAKER_FEATURE_COUNT;
+      const touchStart = motionStart + MOTION_FEATURE_COUNT;
+      const touchEnd = touchStart + TOUCH_FEATURE_COUNT;
+      const audioNZ = features.slice(0, motionStart).filter((v) => v !== 0).length;
+      const motionNZ = features.slice(motionStart, touchStart).filter((v) => v !== 0).length;
+      const touchNZ = features.slice(touchStart, touchEnd).filter((v) => v !== 0).length;
       const rawAudio = sensorData.audio?.samples.length ?? 0;
       const rawMotion = sensorData.motion.length;
       const rawTouch = sensorData.touch.length;