@storyteller-platform/ghost-story 0.0.1

package/dist/utilities/WhisperTimeline.js

@@ -0,0 +1,313 @@
+const WHISPER_SAMPLE_RATE = 16e3;
+function calculateWhisperSplits(durationSeconds, numProcessors, sampleRate = WHISPER_SAMPLE_RATE) {
+  if (numProcessors <= 1) return [];
+  const totalSamples = Math.floor(durationSeconds * sampleRate);
+  const samplesPerProcessor = Math.floor(totalSamples / numProcessors);
+  const splits = [];
+  for (let i = 1; i < numProcessors; i++) {
+    const splitSamples = i * samplesPerProcessor;
+    const splitSeconds = splitSamples / sampleRate;
+    splits.push(splitSeconds);
+  }
+  return splits;
+}
+const specialTokenPattern = /\[_.+\]|<\|[a-z_]+\|>/g;
+function parseWhisperCppOutput(transcription) {
+  return transcription.map((segment) => {
+    var _a, _b;
+    const words = [];
+    let lastTokenEndMs = 0;
+    for (const token of segment.tokens) {
+      const cleanedText = token.text.replace(specialTokenPattern, "");
+      if (cleanedText.trim().length === 0) continue;
+      const offsetFrom = ((_a = token.offsets) == null ? void 0 : _a.from) ?? lastTokenEndMs;
+      const offsetTo = ((_b = token.offsets) == null ? void 0 : _b.to) ?? lastTokenEndMs;
+      if (token.offsets) {
+        lastTokenEndMs = token.offsets.to;
+      }
+      words.push({
+        text: cleanedText,
+        start: offsetFrom / 1e3,
+        end: offsetTo / 1e3,
+        confidence: token.p
+      });
+    }
+    return {
+      text: segment.text,
+      segmentStart: segment.offsets.from / 1e3,
+      segmentEnd: segment.offsets.to / 1e3,
+      words
+    };
+  });
+}
+function parseWhisperServerOutput(segments) {
+  return segments.map((segment) => {
+    const words = (segment.words ?? []).map((word) => ({
+      text: word.word,
+      start: word.start,
+      end: word.end,
+      confidence: word.probability ?? 0
+    }));
+    return {
+      text: segment.text,
+      segmentStart: segment.start,
+      segmentEnd: segment.end,
+      words
+    };
+  });
+}
+const MS_PER_CHAR = 0.15;
+const MAX_REASONABLE_WORD_DURATION = 5;
+const LOW_CONFIDENCE_THRESHOLD = 0.3;
+function estimateReasonableDuration(text) {
+  const charCount = text.trim().length;
+  return Math.max(0.1, charCount * MS_PER_CHAR);
+}
+function detectProcessorBoundary(segment, state) {
+  if (segment.words.length === 0) return false;
+  const firstWord = segment.words[0];
+  if (!firstWord) return false;
+  const wordStartsNearZero = firstWord.start < 1;
+  if (!wordStartsNearZero) return false;
+  const segmentJumpsForward = segment.segmentStart > state.lastSegmentEnd + 1;
+  if (segmentJumpsForward) return true;
+  const segmentGoesBackwards = segment.segmentEnd < segment.segmentStart;
+  if (segmentGoesBackwards) return true;
+  const significantTimeAccumulated = state.lastWordEnd > 30;
+  if (significantTimeAccumulated && firstWord.start < 0.5) return true;
+  return false;
+}
+function countProcessorBoundaries(segments) {
+  if (segments.length === 0) return 0;
+  let boundaryCount = 0;
+  const state = {
+    cumulativeOffset: 0,
+    lastSegmentEnd: 0,
+    lastWordEnd: 0
+  };
+  for (const segment of segments) {
+    if (detectProcessorBoundary(segment, state)) {
+      boundaryCount++;
+    }
+    const segmentEnd = segment.segmentEnd < segment.segmentStart ? segment.segmentStart : segment.segmentEnd;
+    state.lastSegmentEnd = segmentEnd;
+    const lastWord = segment.words[segment.words.length - 1];
+    if (lastWord) {
+      state.lastWordEnd = Math.max(state.lastWordEnd, lastWord.end);
+    }
+  }
+  return boundaryCount;
+}
+const MIN_SECONDS_PER_PROCESSOR = 30;
+function calculateEffectiveProcessors(durationSeconds, requestedProcessors) {
+  const maxProcessors = Math.max(
+    1,
+    Math.floor(durationSeconds / MIN_SECONDS_PER_PROCESSOR)
+  );
+  return Math.min(requestedProcessors, maxProcessors);
+}
+function correctWordTimestamps(word, state, segmentBounds) {
+  let startTime = word.start + state.cumulativeOffset;
+  let endTime = word.end + state.cumulativeOffset;
+  const duration = endTime - startTime;
+  if (duration > MAX_REASONABLE_WORD_DURATION && word.confidence < LOW_CONFIDENCE_THRESHOLD) {
+    const reasonableDuration = estimateReasonableDuration(word.text);
+    endTime = startTime + reasonableDuration;
+  }
+  if (startTime < state.lastWordEnd) {
+    const shift = state.lastWordEnd - startTime;
+    startTime = state.lastWordEnd;
+    endTime = endTime + shift;
+  }
+  if (endTime < startTime) {
+    endTime = startTime;
+  }
+  const segmentDuration = segmentBounds.end - segmentBounds.start;
+  if (segmentDuration > 0 && endTime > segmentBounds.end + state.cumulativeOffset) {
+    endTime = Math.max(startTime, segmentBounds.end + state.cumulativeOffset);
+  }
+  return { startTime, endTime };
+}
+function extractCorrectedTimeline(segments, options = {}) {
+  var _a;
+  if (segments.length === 0) return [];
+  const { splitBoundaries = [] } = options;
+  const usedSplits = /* @__PURE__ */ new Set();
+  const timeline = [];
+  const state = {
+    cumulativeOffset: 0,
+    lastSegmentEnd: 0,
+    lastWordEnd: 0
+  };
+  for (const segment of segments) {
+    const segmentStart = segment.segmentStart;
+    const segmentEnd = segment.segmentEnd < segment.segmentStart ? segment.segmentStart : segment.segmentEnd;
+    if (detectProcessorBoundary(segment, state)) {
+      const firstWord = segment.words[0];
+      const firstWordStart = (firstWord == null ? void 0 : firstWord.start) ?? 0;
+      if (splitBoundaries.length > 0) {
+        const expectedTime = state.lastWordEnd > 0 ? state.lastWordEnd : segmentStart;
+        let bestSplit = null;
+        for (const split of splitBoundaries) {
+          if (usedSplits.has(split)) continue;
+          if (Math.abs(split - expectedTime) < 30 || Math.abs(split - segmentStart) < 30) {
+            bestSplit = split;
+            break;
+          }
+        }
+        if (bestSplit !== null) {
+          state.cumulativeOffset = bestSplit - firstWordStart;
+          usedSplits.add(bestSplit);
+        } else if (state.lastWordEnd > 0) {
+          state.cumulativeOffset = state.lastWordEnd - firstWordStart;
+        } else {
+          state.cumulativeOffset = segmentStart - firstWordStart;
+        }
+      } else {
+        if (state.lastWordEnd > 0) {
+          state.cumulativeOffset = state.lastWordEnd - firstWordStart;
+        } else {
+          state.cumulativeOffset = segmentStart - firstWordStart;
+        }
+      }
+    }
+    for (const word of segment.words) {
+      const trimmedText = word.text.trim();
+      if (trimmedText.length === 0) continue;
+      if (trimmedText.includes("BLANK_AUDIO")) continue;
+      const { startTime, endTime } = correctWordTimestamps(word, state, {
+        start: segmentStart,
+        end: segmentEnd
+      });
+      const lastEntry = timeline[timeline.length - 1];
+      if (lastEntry && !word.text.startsWith(" ")) {
+        lastEntry.text += trimmedText;
+        if (lastEntry.confidence !== void 0) {
+          lastEntry.confidence = Math.min(lastEntry.confidence, word.confidence);
+        }
+        const mergedDuration = endTime - lastEntry.startTime;
+        const mergedConfidence = lastEntry.confidence ?? 1;
+        if (mergedDuration > MAX_REASONABLE_WORD_DURATION && mergedConfidence < LOW_CONFIDENCE_THRESHOLD) {
+          lastEntry.endTime = lastEntry.startTime + estimateReasonableDuration(lastEntry.text);
+        } else {
+          lastEntry.endTime = endTime;
+        }
+      } else {
+        timeline.push({
+          type: "word",
+          text: trimmedText,
+          startTime,
+          endTime,
+          confidence: word.confidence
+        });
+      }
+      state.lastWordEnd = ((_a = timeline[timeline.length - 1]) == null ? void 0 : _a.endTime) ?? endTime;
+    }
+    state.lastSegmentEnd = segmentEnd;
+  }
+  return ensureMonotonicTimeline(timeline);
+}
+function ensureMonotonicTimeline(timeline) {
+  if (timeline.length === 0) return [];
+  const sorted = [...timeline].sort((a, b) => a.startTime - b.startTime);
+  const result = [];
+  let lastEndTime = 0;
+  for (const entry of sorted) {
+    let startTime = entry.startTime;
+    let endTime = entry.endTime;
+    if (startTime < lastEndTime) {
+      const shift = lastEndTime - startTime;
+      startTime = lastEndTime;
+      endTime = endTime + shift;
+    }
+    if (endTime < startTime) {
+      endTime = startTime;
+    }
+    result.push({
+      ...entry,
+      startTime,
+      endTime
+    });
+    lastEndTime = endTime;
+  }
+  return result;
+}
+function scoreTimeline(timeline) {
+  if (timeline.length === 0) {
+    return {
+      totalWords: 0,
+      maxWordDuration: 0,
+      averageWordDuration: 0,
+      medianWordDuration: 0,
+      suspiciousTokenCount: 0,
+      suspiciousTokens: [],
+      totalDuration: 0
+    };
+  }
+  const durations = timeline.map((entry) => entry.endTime - entry.startTime);
+  const sortedDurations = [...durations].sort((a, b) => a - b);
+  const suspiciousTokens = [];
+  for (const entry of timeline) {
+    const duration = entry.endTime - entry.startTime;
+    const confidence = entry.confidence ?? 1;
+    if (duration > 3 && confidence < LOW_CONFIDENCE_THRESHOLD) {
+      suspiciousTokens.push({
+        text: entry.text,
+        duration,
+        confidence,
+        startTime: entry.startTime
+      });
+    }
+  }
+  const lastEntry = timeline[timeline.length - 1];
+  const totalDuration = lastEntry ? lastEntry.endTime : 0;
+  const sum = durations.reduce((acc, d) => acc + d, 0);
+  const medianIndex = Math.floor(sortedDurations.length / 2);
+  return {
+    totalWords: timeline.length,
+    maxWordDuration: Math.max(...durations),
+    averageWordDuration: sum / durations.length,
+    medianWordDuration: sortedDurations[medianIndex] ?? 0,
+    suspiciousTokenCount: suspiciousTokens.length,
+    suspiciousTokens,
+    totalDuration
+  };
+}
+function compareTimelines(baseline, test) {
+  const baselineText = baseline.map((e) => e.text).join(" ").toLowerCase();
+  const testText = test.map((e) => e.text).join(" ").toLowerCase();
+  const baselineWords = new Set(baselineText.split(/\s+/));
+  const testWords = new Set(testText.split(/\s+/));
+  const intersection = [...baselineWords].filter((w) => testWords.has(w));
+  const union = /* @__PURE__ */ new Set([...baselineWords, ...testWords]);
+  const textSimilarity = intersection.length / union.size;
+  const baselineMetrics = scoreTimeline(baseline);
+  const testMetrics = scoreTimeline(test);
+  const durationDifference = Math.abs(
+    baselineMetrics.totalDuration - testMetrics.totalDuration
+  );
+  const wordCountDifference = Math.abs(
+    baselineMetrics.totalWords - testMetrics.totalWords
+  );
+  const maxDurationDifference = Math.abs(
+    baselineMetrics.maxWordDuration - testMetrics.maxWordDuration
+  );
+  const isAcceptable = textSimilarity > 0.8 && testMetrics.suspiciousTokenCount === 0 && maxDurationDifference < 2;
+  return {
+    textSimilarity,
+    durationDifference,
+    wordCountDifference,
+    maxDurationDifference,
+    isAcceptable
+  };
+}
+export {
+  calculateEffectiveProcessors,
+  calculateWhisperSplits,
+  compareTimelines,
+  countProcessorBoundaries,
+  extractCorrectedTimeline,
+  parseWhisperCppOutput,
+  parseWhisperServerOutput,
+  scoreTimeline
+};

package/dist/vad/ActiveGate.cjs

@@ -0,0 +1,357 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ActiveGate_exports = {};
+__export(ActiveGate_exports, {
+  StreamingVad: () => StreamingVad,
+  defaultVadOptions: () => defaultVadOptions,
+  detectVoiceActivity: () => detectVoiceActivity,
+  vadFromFile: () => vadFromFile,
+  vadFromStream: () => vadFromStream
+});
+module.exports = __toCommonJS(ActiveGate_exports);
+var import_ffmpeg_stream = require("ffmpeg-stream");
+const defaultVadOptions = {
+  lowCutoff: 100,
+  highCutoff: 1e3,
+  positiveAdaptationRate: 400,
+  negativeAdaptationRate: 10,
+  peakLoudnessDecay: 4,
+  backwardExtensionDuration: 0.2,
+  relativeThreshold: -15
+};
+function detectVoiceActivity(rawAudio, options = {}) {
+  var _a;
+  const channelCount = rawAudio.audioChannels.length;
+  const firstChannel = rawAudio.audioChannels[0];
+  if (!firstChannel || channelCount === 0) return [];
+  const vad = new StreamingVad(rawAudio.sampleRate, channelCount, options);
+  for (let i = 0; i < firstChannel.length; i++) {
+    for (let ch = 0; ch < channelCount; ch++) {
+      const sample = ((_a = rawAudio.audioChannels[ch]) == null ? void 0 : _a[i]) ?? 0;
+      vad.process(sample, ch);
+    }
+  }
+  return vad.finalize();
+}
+const defaultStreamOptions = {
+  sampleRate: 16e3,
+  channelCount: 1
+};
+async function vadFromFile(path, options = {}) {
+  const converter = new import_ffmpeg_stream.Converter();
+  converter.createInputFromFile(path);
+  const outputStream = converter.createOutputStream({
+    f: "f32le",
+    ar: "16000",
+    ac: "1",
+    acodec: "pcm_f32le"
+  });
+  const segments = [];
+  const run = converter.run();
+  try {
+    for await (const seg of vadFromStream(outputStream, options)) {
+      segments.push(seg);
+    }
+  } catch (error) {
+    converter.kill();
+    throw error;
+  } finally {
+    await run;
+  }
+  return segments;
+}
+async function* vadFromStream(stream, options = {}) {
+  const sampleRate = options.sampleRate ?? defaultStreamOptions.sampleRate;
+  const channelCount = options.channelCount ?? defaultStreamOptions.channelCount;
+  const vad = new StreamingVad(sampleRate, channelCount, options);
+  let leftover = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    const combined = Buffer.concat([leftover, chunk]);
+    const bytesPerSample = 4;
+    const bytesPerFrame = bytesPerSample * channelCount;
+    const completeFrames = Math.floor(combined.length / bytesPerFrame);
+    const usableBytes = completeFrames * bytesPerFrame;
+    for (let offset = 0; offset < usableBytes; offset += bytesPerFrame) {
+      for (let ch = 0; ch < channelCount; ch++) {
+        const sample = combined.readFloatLE(offset + ch * bytesPerSample);
+        vad.process(sample, ch);
+      }
+    }
+    leftover = combined.subarray(usableBytes);
+    for (const seg of vad.flush()) {
+      yield seg;
+    }
+  }
+  for (const seg of vad.flush(true)) {
+    yield seg;
+  }
+}
+class StreamingVad {
+  constructor(sampleRate, channelCount, options = {}) {
+    this.sampleRate = sampleRate;
+    this.channelCount = channelCount;
+    this.opts = { ...defaultVadOptions, ...options };
+    this.ticksPerSecond = sampleRate * channelCount;
+    this.backwardFrameCount = Math.ceil(
+      this.opts.backwardExtensionDuration / this.frameDuration
+    );
+    this.channelFilters = Array.from({ length: channelCount }, () => ({
+      highpass: createBiquadFilter("highpass", sampleRate, this.opts.lowCutoff),
+      lowpass: createBiquadFilter("lowpass", sampleRate, this.opts.highCutoff)
+    }));
+    const initialPower = dbToGain(-60) ** 2;
+    this.loudness = new SmoothEstimator(
+      this.opts.positiveAdaptationRate / this.ticksPerSecond,
+      this.opts.negativeAdaptationRate / this.ticksPerSecond,
+      initialPower
+    );
+    this.minLoudness = new DecayingPeak(
+      "min",
+      -60,
+      this.opts.peakLoudnessDecay / this.ticksPerSecond
+    );
+    this.maxLoudness = new DecayingPeak(
+      "max",
+      -60,
+      this.opts.peakLoudnessDecay / this.ticksPerSecond
+    );
+  }
+  opts;
+  channelFilters;
+  loudness;
+  minLoudness;
+  maxLoudness;
+  frameDuration = 0.01;
+  ticksPerSecond;
+  backwardFrameCount;
+  frameBuffer = [];
+  currentSampleIndex = 0;
+  emittedUpToTime = 0;
+  pendingSegment = null;
+  process(sample, channel) {
+    const filter = this.channelFilters[channel];
+    if (!filter) return;
+    sample = filter.highpass.process(sample);
+    sample = filter.lowpass.process(sample);
+    this.loudness.update(sample ** 2);
+    const currentDb = gainToDb(
+      Math.sqrt(Math.max(this.loudness.value, dbToGain(-60) ** 2))
+    );
+    this.minLoudness.update(currentDb);
+    if (currentDb >= -60) {
+      this.maxLoudness.update(currentDb);
+    }
+    const time = this.currentSampleIndex / this.sampleRate;
+    const lastFrame = this.frameBuffer[this.frameBuffer.length - 1];
+    if (!lastFrame || time > lastFrame.time + this.frameDuration) {
+      this.frameBuffer.push({
+        time,
+        loudness: currentDb,
+        maxLoudness: this.maxLoudness.value
+      });
+    }
+    if (channel === this.channelCount - 1) {
+      this.currentSampleIndex++;
+    }
+  }
+  // flush finalized segments, keeping buffer for backward extension
+  // call with final=true when done processing to get remaining segments
+  flush(final = false) {
+    var _a;
+    const segments = [];
+    const frameCount = this.frameBuffer.length;
+    if (frameCount === 0) return segments;
+    const finalizeCount = final ? frameCount : Math.max(0, frameCount - this.backwardFrameCount);
+    if (finalizeCount === 0) return segments;
+    const active = this.computeActivity(finalizeCount, final);
+    for (let i = 0; i < finalizeCount; i++) {
+      const frame = this.frameBuffer[i];
+      if (!frame) continue;
+      const isActive = active[i] ?? false;
+      const startTime = frame.time;
+      const endTime = startTime + this.frameDuration;
+      if (this.pendingSegment && this.pendingSegment.isActive === isActive) {
+        this.pendingSegment.endTime = endTime;
+      } else {
+        if (this.pendingSegment) {
+          segments.push(this.pendingSegment);
+        }
+        this.pendingSegment = { startTime, endTime, isActive };
+      }
+    }
+    if (final && this.pendingSegment) {
+      segments.push(this.pendingSegment);
+      this.pendingSegment = null;
+    }
+    this.frameBuffer.splice(0, finalizeCount);
+    this.emittedUpToTime = ((_a = segments[segments.length - 1]) == null ? void 0 : _a.endTime) ?? this.emittedUpToTime;
+    return segments;
+  }
+  computeActivity(count, includeBuffer) {
+    const active = new Array(count).fill(false);
+    const lookAheadEnd = includeBuffer ? this.frameBuffer.length : Math.min(count + this.backwardFrameCount, this.frameBuffer.length);
+    let extendTo = count;
+    for (let i = lookAheadEnd - 1; i >= 0; i--) {
+      const frame = this.frameBuffer[i];
+      if (!frame) continue;
+      const refLoudness = Math.max(frame.maxLoudness, -30);
+      const isLoud = frame.loudness >= refLoudness + this.opts.relativeThreshold;
+      if (isLoud) {
+        extendTo = Math.max(i - this.backwardFrameCount, 0);
+      }
+      if (i < count) {
+        if (i >= extendTo || isLoud) {
+          active[i] = true;
+        }
+      }
+    }
+    return active;
+  }
+  finalize() {
+    const segments = this.flush(true);
+    return segments;
+  }
+  getSegments() {
+    return this.flush(true);
+  }
+  // reset all state to process a new audio stream
+  reset() {
+    this.frameBuffer = [];
+    this.currentSampleIndex = 0;
+    this.emittedUpToTime = 0;
+    this.pendingSegment = null;
+    this.loudness.reset(dbToGain(-60) ** 2);
+    this.minLoudness.reset(-60);
+    this.maxLoudness.reset(-60);
+    for (const filter of this.channelFilters) {
+      filter.highpass.reset();
+      filter.lowpass.reset();
+    }
+  }
+}
+class SmoothEstimator {
+  constructor(upRate, downRate, initial) {
+    this.upRate = upRate;
+    this.downRate = downRate;
+    this.value = initial;
+  }
+  value;
+  update(target) {
+    const diff = target - this.value;
+    const rate = diff >= 0 ? this.upRate : this.downRate;
+    this.value += diff * rate;
+  }
+  reset(value) {
+    this.value = value;
+  }
+}
+class DecayingPeak {
+  constructor(kind, initial, decay) {
+    this.kind = kind;
+    this.decay = decay;
+    this.value = initial;
+  }
+  value;
+  update(v) {
+    if (this.kind === "max") {
+      this.value -= this.decay;
+      this.value = Math.max(v, this.value);
+    } else {
+      this.value += this.decay;
+      this.value = Math.min(v, this.value);
+    }
+  }
+  reset(value) {
+    this.value = value;
+  }
+}
+class BiquadFilter {
+  constructor(c) {
+    this.c = c;
+  }
+  x1 = 0;
+  x2 = 0;
+  y1 = 0;
+  y2 = 0;
+  process(x) {
+    const y = this.c.b0 * x + this.c.b1 * this.x1 + this.c.b2 * this.x2 - this.c.a1 * this.y1 - this.c.a2 * this.y2;
+    this.x2 = this.x1;
+    this.x1 = x;
+    this.y2 = this.y1;
+    this.y1 = y;
+    return y;
+  }
+  reset() {
+    this.x1 = 0;
+    this.x2 = 0;
+    this.y1 = 0;
+    this.y2 = 0;
+  }
+}
+function createBiquadFilter(type, sampleRate, freq, q = 0.7071) {
+  const nyquist = sampleRate / 2;
+  const w = Math.min(freq / nyquist, 1);
+  if (w === 1) {
+    return new BiquadFilter(
+      type === "lowpass" ? { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 } : { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 }
+    );
+  }
+  if (w === 0 && type === "highpass") {
+    return new BiquadFilter({ b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 });
+  }
+  const theta = Math.PI * w;
+  const alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+  const cosw = Math.cos(theta);
+  let b0, b1, b2;
+  if (type === "lowpass") {
+    const beta = (1 - cosw) / 2;
+    b0 = beta;
+    b1 = 2 * beta;
+    b2 = beta;
+  } else {
+    const beta = (1 + cosw) / 2;
+    b0 = beta;
+    b1 = -2 * beta;
+    b2 = beta;
+  }
+  const a0 = 1 + alpha;
+  const a1 = -2 * cosw;
+  const a2 = 1 - alpha;
+  return new BiquadFilter({
+    b0: b0 / a0,
+    b1: b1 / a0,
+    b2: b2 / a0,
+    a1: a1 / a0,
+    a2: a2 / a0
+  });
+}
+function gainToDb(gain) {
+  return gain <= 1e-5 ? -100 : 20 * Math.log10(gain);
+}
+function dbToGain(db) {
+  return db <= -100 ? 0 : Math.pow(10, db / 20);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingVad,
+  defaultVadOptions,
+  detectVoiceActivity,
+  vadFromFile,
+  vadFromStream
+});