@absolutejs/voice 0.0.19 → 0.0.21

package/dist/testing/index.js

@@ -95,6 +95,61 @@ var measureAudioLevel = (audio) => {
   return Math.sqrt(sumSquares / samples.length);
 };
 var normalizeText = (value) => value.trim().replace(/\s+/g, " ");
+var countWords = (value) => value.length > 0 ? value.split(" ").length : 0;
+var selectPreferredTranscriptText = (currentText, nextText) => {
+  const current = normalizeText(currentText);
+  const next = normalizeText(nextText);
+  if (!current) {
+    return next;
+  }
+  if (!next) {
+    return current;
+  }
+  if (current === next || current.includes(next)) {
+    return current;
+  }
+  if (next.includes(current)) {
+    return next;
+  }
+  if (countWords(next) > countWords(current)) {
+    return next;
+  }
+  return current;
+};
+var mergeSequentialTranscriptText = (currentText, nextText) => {
+  const current = normalizeText(currentText);
+  const next = normalizeText(nextText);
+  if (!current) {
+    return next;
+  }
+  if (!next) {
+    return current;
+  }
+  const currentWords = current.split(" ");
+  const nextWords = next.split(" ");
+  const maxOverlap = Math.min(currentWords.length, nextWords.length);
+  for (let overlap = maxOverlap;overlap > 0; overlap -= 1) {
+    const currentSuffix = currentWords.slice(-overlap).join(" ");
+    const nextPrefix = nextWords.slice(0, overlap).join(" ");
+    if (currentSuffix === nextPrefix) {
+      return [...currentWords, ...nextWords.slice(overlap)].join(" ");
+    }
+  }
+  return `${current} ${next}`.trim();
+};
+var countCommonPrefixWords = (currentText, nextText) => {
+  const currentWords = normalizeText(currentText).split(" ").filter(Boolean);
+  const nextWords = normalizeText(nextText).split(" ").filter(Boolean);
+  const maxWords = Math.min(currentWords.length, nextWords.length);
+  let count = 0;
+  for (let index = 0;index < maxWords; index += 1) {
+    if (currentWords[index] !== nextWords[index]) {
+      break;
+    }
+    count += 1;
+  }
+  return count;
+};
 var mergeTranscriptTexts = (transcripts) => {
   const merged = [];
   for (const transcript of transcripts) {
@@ -118,12 +173,14 @@ var mergeTranscriptTexts = (transcripts) => {
   }
   return merged.join(" ").trim();
 };
-var buildTurnText = (transcripts, partialText) => {
+var buildTurnText = (transcripts, partialText, options = {}) => {
   const finalText = mergeTranscriptTexts(transcripts);
-  if (finalText) {
-    return finalText;
+  const nextPartial = normalizeText(partialText);
+  const lastFinalEndedAtMs = [...transcripts].reverse().find((transcript) => typeof transcript.endedAtMs === "number")?.endedAtMs;
+  if (finalText && nextPartial && typeof lastFinalEndedAtMs === "number" && typeof options.partialStartedAtMs === "number" && options.partialStartedAtMs - lastFinalEndedAtMs >= 250 && countCommonPrefixWords(finalText, nextPartial) === 0) {
+    return mergeSequentialTranscriptText(finalText, nextPartial);
   }
-  return normalizeText(partialText);
+  return selectPreferredTranscriptText(finalText, nextPartial);
 };
 
 // src/testing/accuracy.ts
@@ -204,6 +261,7 @@ var runSTTAdapterFixture = async (adapter, fixture, options = {}) => {
   const settleMs = options.settleMs ?? 500;
   const waitForRealtimeMs = options.waitForRealtimeMs ?? 0;
   let lastActivityAt = Date.now();
+  let speechEndedAt = startedAt;
   const markActive = () => {
     lastActivityAt = Date.now();
   };
@@ -240,12 +298,15 @@ var runSTTAdapterFixture = async (adapter, fixture, options = {}) => {
     const realtimeDelayMs = waitForRealtimeMs > 0 ? waitForRealtimeMs : chunkDurationMs;
     for (const chunk of chunks) {
       await session.send(chunk);
+      markActive();
       await Bun.sleep(realtimeDelayMs);
     }
+    speechEndedAt = Date.now();
     if (tailPaddingMs > 0) {
       const tailBytes = Math.max(2, Math.floor(bytesPerMillisecond * tailPaddingMs));
       for (const chunk of chunkAudio(createSilence(tailBytes), bytesPerChunk)) {
         await session.send(chunk);
+        markActive();
         await Bun.sleep(realtimeDelayMs);
       }
     }
@@ -265,11 +326,30 @@ var runSTTAdapterFixture = async (adapter, fixture, options = {}) => {
     finalEvents,
     finalText,
     partialEvents,
+    speechEndedAt,
     startedAt
   };
 };
 
 // src/testing/benchmark.ts
+var resolveFixtureEnvironment = (fixture) => {
+  const tags = new Set(fixture.tags ?? []);
+  const hasAccent = tags.has("accent") || tags.has("speech-accent-archive");
+  const hasNoisy = tags.has("noisy") || tags.has("synthetic-noise") || tags.has("stress");
+  if (hasAccent && hasNoisy) {
+    return "accent-noisy";
+  }
+  if (hasAccent) {
+    return "accent";
+  }
+  if (hasNoisy) {
+    return "noisy";
+  }
+  if (tags.has("clean")) {
+    return "clean";
+  }
+  return "other";
+};
 var normalizeBenchmarkText = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
 var scoreExpectedTerms = (actualText, expectedTerms) => {
   const normalizedActual = normalizeBenchmarkText(actualText);
@@ -300,10 +380,46 @@ var roundMetric = (value, digits = 4) => {
   const factor = 10 ** digits;
   return Math.round(value * factor) / factor;
 };
+var calculateGroupSummary = (fixtures) => {
+  const grouped = new Map;
+  for (const fixture of fixtures) {
+    const existing = grouped.get(fixture.group) ?? [];
+    existing.push(fixture);
+    grouped.set(fixture.group, existing);
+  }
+  return Array.from(grouped.entries()).map(([group, results]) => {
+    const fixtureCount = results.length;
+    const passCount = results.filter((fixture) => fixture.passes).length;
+    const averageWordErrorRate = average(results.map((result) => result.accuracy.wordErrorRate)) ?? 0;
+    const averageTermRecall = average(results.map((result) => result.expectedTerms.recall)) ?? 0;
+    const averageElapsedMs = average(results.map((result) => result.elapsedMs));
+    const accuracy = 1 - averageWordErrorRate;
+    return {
+      averageElapsedMs: roundMetric(averageElapsedMs, 2) ?? 0,
+      averageTermRecall: roundMetric(averageTermRecall) ?? 0,
+      averageWordErrorRate: roundMetric(averageWordErrorRate) ?? 0,
+      fixturesWithErrors: results.filter((fixture) => fixture.errorCount > 0).length,
+      fixturesWithFragments: results.filter((fixture) => fixture.fragmentationCount > 0).length,
+      fixtureCount,
+      group,
+      passCount,
+      passRate: fixtureCount > 0 ? roundMetric(passCount / fixtureCount) ?? 0 : 0,
+      wordAccuracyRate: roundMetric(accuracy) ?? 0
+    };
+  }).sort((a, b) => a.group.localeCompare(b.group));
+};
 var toFixtureBenchmarkResult = (fixture, result, elapsedMs) => {
+  const toPostSpeechLatency = (timestamp) => {
+    if (typeof timestamp !== "number") {
+      return;
+    }
+    return Math.max(0, timestamp - result.speechEndedAt);
+  };
   const timeToFirstPartialMs = result.partialEvents[0] ? result.partialEvents[0].receivedAt - result.startedAt : undefined;
   const timeToFirstFinalMs = result.finalEvents[0] ? result.finalEvents[0].receivedAt - result.startedAt : undefined;
   const timeToEndOfTurnMs = result.endOfTurnEvents[0] ? result.endOfTurnEvents[0].receivedAt - result.startedAt : undefined;
+  const postSpeechTimeToFirstFinalMs = toPostSpeechLatency(result.finalEvents[0]?.receivedAt);
+  const postSpeechTimeToEndOfTurnMs = toPostSpeechLatency(result.endOfTurnEvents[0]?.receivedAt);
   const expectedTerms = scoreExpectedTerms(result.finalText, fixture.expectedTerms);
   return {
     accuracy: result.accuracy,
@@ -317,8 +433,11 @@ var toFixtureBenchmarkResult = (fixture, result, elapsedMs) => {
     finalText: result.finalText,
     fixtureId: fixture.id,
     fragmentationCount: Math.max(0, result.finalEvents.length - 1),
+    group: resolveFixtureEnvironment(fixture),
     passes: result.errorEvents.length === 0 && result.finalText.trim().length > 0 && result.accuracy.passesThreshold,
     partialCount: result.partialEvents.length,
+    postSpeechTimeToEndOfTurnMs,
+    postSpeechTimeToFirstFinalMs,
     tags: fixture.tags ?? [],
     timeToEndOfTurnMs,
     timeToFirstFinalMs,
@@ -336,6 +455,8 @@ var summarizeSTTBenchmark = (adapterId, fixtures) => {
     averageEndOfTurnCount: roundMetric(average(fixtures.map((fixture) => fixture.endOfTurnCount)), 2) ?? 0,
     averageFinalCount: roundMetric(average(fixtures.map((fixture) => fixture.finalCount)), 2) ?? 0,
     averageTermRecall: roundMetric(average(fixtures.map((fixture) => fixture.expectedTerms.recall))) ?? 0,
+    averagePostSpeechTimeToEndOfTurnMs: roundMetric(average(fixtures.map((fixture) => fixture.postSpeechTimeToEndOfTurnMs)), 2),
+    averagePostSpeechTimeToFirstFinalMs: roundMetric(average(fixtures.map((fixture) => fixture.postSpeechTimeToFirstFinalMs)), 2),
     averageTimeToEndOfTurnMs: roundMetric(average(fixtures.map((fixture) => fixture.timeToEndOfTurnMs)), 2),
     averageTimeToFirstFinalMs: roundMetric(average(fixtures.map((fixture) => fixture.timeToFirstFinalMs)), 2),
     averageTimeToFirstPartialMs: roundMetric(average(fixtures.map((fixture) => fixture.timeToFirstPartialMs)), 2),
@@ -343,12 +464,51 @@ var summarizeSTTBenchmark = (adapterId, fixtures) => {
     fixtureCount,
     fixturesWithErrors: fixtures.filter((fixture) => fixture.errorCount > 0).length,
     fixturesWithFragmentation: fixtures.filter((fixture) => fixture.fragmentationCount > 0).length,
+    groupSummaries: calculateGroupSummary(fixtures),
     passCount,
     passRate: fixtureCount > 0 ? roundMetric(passCount / fixtureCount) ?? 0 : 0,
     totalErrorCount: fixtures.reduce((sum, fixture) => sum + fixture.errorCount, 0),
     wordAccuracyRate: fixtureCount > 0 ? roundMetric(1 - (average(fixtures.map((fixture) => fixture.accuracy.wordErrorRate)) ?? 0)) ?? 0 : 0
   };
 };
+var evaluateSTTBenchmarkAcceptance = (report, thresholds = {}) => {
+  const failures = [];
+  const details = thresholds;
+  const overallPassRate = details.overallPassRate;
+  if (overallPassRate !== undefined && report.summary.passRate < overallPassRate) {
+    failures.push(`overall passRate ${(report.summary.passRate * 100).toFixed(2)}% below ${(overallPassRate * 100).toFixed(2)}%`);
+  }
+  const minTermRecall = details.termRecall;
+  if (minTermRecall !== undefined && report.summary.averageTermRecall < minTermRecall) {
+    failures.push(`overall term recall ${report.summary.averageTermRecall.toFixed(4)} below ${minTermRecall.toFixed(4)}`);
+  }
+  const minWordAccuracy = details.wordAccuracyRate;
+  if (minWordAccuracy !== undefined && report.summary.wordAccuracyRate < minWordAccuracy) {
+    failures.push(`overall word accuracy ${(report.summary.wordAccuracyRate * 100).toFixed(2)}% below ${(minWordAccuracy * 100).toFixed(2)}%`);
+  }
+  const groupThresholds = details.groupPassRate;
+  if (groupThresholds) {
+    for (const groupSummary of report.summary.groupSummaries) {
+      const threshold = groupThresholds[groupSummary.group];
+      if (!threshold) {
+        continue;
+      }
+      if (threshold.passRate !== undefined && groupSummary.passRate < threshold.passRate) {
+        failures.push(`${groupSummary.group} passRate ${(groupSummary.passRate * 100).toFixed(2)}% below ${(threshold.passRate * 100).toFixed(2)}%`);
+      }
+      if (threshold.wordAccuracyRate !== undefined && groupSummary.wordAccuracyRate < threshold.wordAccuracyRate) {
+        failures.push(`${groupSummary.group} wordAccuracy ${(groupSummary.wordAccuracyRate * 100).toFixed(2)}% below ${(threshold.wordAccuracyRate * 100).toFixed(2)}%`);
+      }
+    }
+  }
+  const score = roundMetric(report.summary.passRate * 0.45 + report.summary.wordAccuracyRate * 0.35 + report.summary.averageTermRecall * 0.2, 3) ?? 0;
+  return {
+    adapterId: report.adapterId,
+    failures,
+    passed: failures.length === 0,
+    score
+  };
+};
 var compareSTTBenchmarks = (reports) => {
   const entries = reports.map((report) => ({
     adapterId: report.adapterId,
@@ -434,13 +594,1824 @@ var loadVoiceTestFixtures = async (fixtureDirectory) => {
     };
   }));
 };
+// src/store.ts
+var createId = () => crypto.randomUUID();
+var createVoiceSessionRecord = (id, scenarioId) => ({
+  committedTurnIds: [],
+  createdAt: Date.now(),
+  currentTurn: {
+    finalText: "",
+    lastSpeechAt: undefined,
+    lastTranscriptAt: undefined,
+    partialEndedAt: undefined,
+    partialStartedAt: undefined,
+    partialText: "",
+    silenceStartedAt: undefined,
+    transcripts: []
+  },
+  id,
+  scenarioId,
+  reconnect: { attempts: 0 },
+  status: "active",
+  transcripts: [],
+  turns: [],
+  lastCommittedTurn: {
+    committedAt: 0,
+    signature: "",
+    text: "",
+    transcriptIds: []
+  }
+});
+var resetVoiceSessionRecord = (id, existing, scenarioId) => ({
+  ...createVoiceSessionRecord(id, scenarioId),
+  metadata: existing?.metadata
+});
+var toVoiceSessionSummary = (session) => ({
+  createdAt: session.createdAt,
+  id: session.id,
+  lastActivityAt: session.lastActivityAt,
+  status: session.status,
+  turnCount: session.turns.length
+});
+
+// src/memoryStore.ts
+var createVoiceMemoryStore = () => {
+  const sessions = new Map;
+  const get = async (id) => sessions.get(id);
+  const getOrCreate = async (id) => {
+    let session = sessions.get(id);
+    if (!session) {
+      session = createVoiceSessionRecord(id);
+      sessions.set(id, session);
+    }
+    return session;
+  };
+  const set = async (id, value) => {
+    sessions.set(id, value);
+  };
+  const list = async () => Array.from(sessions.values()).map((session) => toVoiceSessionSummary(session)).sort((first, second) => (second.lastActivityAt ?? second.createdAt) - (first.lastActivityAt ?? first.createdAt));
+  const remove = async (id) => {
+    sessions.delete(id);
+  };
+  return { get, getOrCreate, list, remove, set };
+};
+
+// src/audioConditioning.ts
+var DEFAULT_TARGET_LEVEL = 0.08;
+var DEFAULT_MAX_GAIN = 3;
+var DEFAULT_NOISE_GATE_THRESHOLD = 0.006;
+var DEFAULT_NOISE_GATE_ATTENUATION = 0.15;
+var toInt16Array = (audio) => {
+  if (audio instanceof ArrayBuffer) {
+    return new Int16Array(audio, 0, Math.floor(audio.byteLength / 2));
+  }
+  return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
+};
+var computeRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sumSquares = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sumSquares += normalized * normalized;
+  }
+  return Math.sqrt(sumSquares / samples.length);
+};
+var resolveAudioConditioningConfig = (config) => {
+  if (!config || config.enabled === false) {
+    return;
+  }
+  return {
+    enabled: true,
+    maxGain: config.maxGain ?? DEFAULT_MAX_GAIN,
+    noiseGateAttenuation: config.noiseGateAttenuation ?? DEFAULT_NOISE_GATE_ATTENUATION,
+    noiseGateThreshold: config.noiseGateThreshold ?? DEFAULT_NOISE_GATE_THRESHOLD,
+    targetLevel: config.targetLevel ?? DEFAULT_TARGET_LEVEL
+  };
+};
+var conditionAudioChunk = (audio, config) => {
+  if (!config) {
+    return audio;
+  }
+  const source = toInt16Array(audio);
+  if (source.length === 0) {
+    return audio;
+  }
+  const rms = computeRms(source);
+  const output = new Int16Array(source.length);
+  const gateFactor = rms < config.noiseGateThreshold ? config.noiseGateAttenuation : 1;
+  const baseLevel = Math.max(rms * gateFactor, 0.000001);
+  const gain = Math.min(config.maxGain, config.targetLevel / baseLevel);
+  const appliedGain = Math.max(0.25, gain) * gateFactor;
+  for (let index = 0;index < source.length; index += 1) {
+    const next = Math.round(source[index] * appliedGain);
+    output[index] = Math.max(-32768, Math.min(32767, next));
+  }
+  return new Uint8Array(output.buffer);
+};
+
+// src/logger.ts
+var noop = () => {};
+var createNoopLogger = () => ({
+  debug: noop,
+  error: noop,
+  info: noop,
+  warn: noop
+});
+var resolveLogger = (logger) => ({
+  ...createNoopLogger(),
+  ...logger
+});
+
+// src/session.ts
+var DEFAULT_RECONNECT_TIMEOUT = 30000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_TRANSCRIPT_STABILITY_MS = 450;
+var DEFAULT_FALLBACK_REPLAY_MS = 8000;
+var DEFAULT_FALLBACK_SETTLE_MS = 220;
+var DEFAULT_FALLBACK_COMPLETION_TIMEOUT_MS = 2500;
+var DEFAULT_FALLBACK_CONFIDENCE_THRESHOLD = 0.6;
+var DEFAULT_FALLBACK_MIN_TEXT_LENGTH = 2;
+var DEFAULT_FALLBACK_MAX_ATTEMPTS_PER_TURN = 1;
+var DEFAULT_DUPLICATE_TURN_WINDOW_MS = 5000;
+var FALLBACK_CONFIDENCE_SELECTION_DELTA = 0.05;
+var FALLBACK_WORD_COUNT_SELECTION_MARGIN_RATIO = 0.12;
+var DEFAULT_FORMAT = {
+  channels: 1,
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRateHz: 16000
+};
+var toError = (value) => value instanceof Error ? value : new Error(String(value));
+var createEmptyCurrentTurn = () => ({
+  finalText: "",
+  lastSpeechAt: undefined,
+  lastTranscriptAt: undefined,
+  partialEndedAt: undefined,
+  partialStartedAt: undefined,
+  partialText: "",
+  silenceStartedAt: undefined,
+  transcripts: []
+});
+var cloneTranscript = (transcript) => ({ ...transcript });
+var countWords2 = (text) => text.trim().split(/\s+/).filter(Boolean).length;
+var normalizeText2 = (text) => text.trim().replace(/\s+/g, " ");
+var getAudioChunkDurationMs = (chunk) => chunk.byteLength / (DEFAULT_FORMAT.sampleRateHz * DEFAULT_FORMAT.channels * 2) * 1000;
+var getBufferedAudioDurationMs = (chunks) => chunks.reduce((total, chunk) => total + getAudioChunkDurationMs(chunk), 0);
+var calculateMeanConfidence = (transcripts) => {
+  let sum = 0;
+  let total = 0;
+  for (const transcript of transcripts) {
+    if (typeof transcript.confidence === "number") {
+      sum += transcript.confidence;
+      total += 1;
+    }
+  }
+  if (total === 0) {
+    return 0;
+  }
+  return sum / total;
+};
+var createTurnQuality = (transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics) => {
+  const sampledTranscripts = transcripts.filter((transcript) => typeof transcript.confidence === "number");
+  const confidenceSampleCount = sampledTranscripts.length;
+  return {
+    averageConfidence: confidenceSampleCount > 0 ? sampledTranscripts.reduce((sum, transcript) => sum + transcript.confidence, 0) / confidenceSampleCount : undefined,
+    confidenceSampleCount,
+    correction: correctionDiagnostics,
+    fallback: fallbackDiagnostics,
+    fallbackUsed,
+    finalTranscriptCount: transcripts.filter((transcript) => transcript.isFinal).length,
+    partialTranscriptCount: transcripts.filter((transcript) => !transcript.isFinal).length,
+    selectedTranscriptCount: transcripts.length,
+    source
+  };
+};
+var normalizeCorrectionText = (text) => normalizeText2(text);
+var isFallbackNeeded = (candidate, config) => {
+  const trimmed = normalizeText2(candidate.text);
+  const wordCount = countWords2(trimmed);
+  if (config.trigger === "always") {
+    return true;
+  }
+  if (config.trigger === "empty-turn") {
+    return wordCount < config.minTextLength;
+  }
+  const averageConfidence = calculateMeanConfidence(candidate.transcripts);
+  if (config.trigger === "low-confidence") {
+    return averageConfidence > 0 && averageConfidence < config.confidenceThreshold;
+  }
+  return averageConfidence > 0 && averageConfidence < config.confidenceThreshold || wordCount < config.minTextLength;
+};
+var selectBetterTurnText = (candidate, fallback) => {
+  if (!fallback.text) {
+    return {
+      reason: "fallback-empty",
+      winner: candidate
+    };
+  }
+  if (!candidate.text) {
+    return {
+      reason: "primary-empty",
+      winner: fallback
+    };
+  }
+  const largestWordCount = Math.max(candidate.wordCount, fallback.wordCount, 1);
+  const wordCountDelta = fallback.wordCount - candidate.wordCount;
+  const wordCountDeltaRatio = Math.abs(wordCountDelta) / largestWordCount;
+  if (wordCountDeltaRatio >= FALLBACK_WORD_COUNT_SELECTION_MARGIN_RATIO && wordCountDelta !== 0) {
+    return {
+      reason: "word-count-margin",
+      winner: wordCountDelta > 0 ? fallback : candidate
+    };
+  }
+  if (fallback.confidence > candidate.confidence + FALLBACK_CONFIDENCE_SELECTION_DELTA) {
+    return {
+      reason: "confidence-margin",
+      winner: fallback
+    };
+  }
+  if (candidate.confidence > fallback.confidence + FALLBACK_CONFIDENCE_SELECTION_DELTA) {
+    return {
+      reason: "kept-primary",
+      winner: candidate
+    };
+  }
+  if (fallback.wordCount > candidate.wordCount) {
+    return {
+      reason: "word-count-tiebreak",
+      winner: fallback
+    };
+  }
+  return {
+    reason: "kept-primary",
+    winner: candidate
+  };
+};
+var setTurnResult = (session, turnId, input) => {
+  session.turns = session.turns.map((turn) => turn.id === turnId ? {
+    ...turn,
+    assistantText: input.assistantText ?? turn.assistantText,
+    result: input.result ?? turn.result
+  } : turn);
+};
+var createVoiceSession = (options) => {
+  const logger = resolveLogger(options.logger);
+  const reconnect = {
+    maxAttempts: options.reconnect.maxAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS,
+    strategy: options.reconnect.strategy ?? "resume-last-turn",
+    timeout: options.reconnect.timeout ?? DEFAULT_RECONNECT_TIMEOUT
+  };
+  const turnDetection = {
+    silenceMs: options.turnDetection.silenceMs ?? DEFAULT_SILENCE_MS,
+    speechThreshold: options.turnDetection.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD,
+    transcriptStabilityMs: options.turnDetection.transcriptStabilityMs ?? DEFAULT_TRANSCRIPT_STABILITY_MS
+  };
+  const sttFallback = options.sttFallback ? {
+    adapter: options.sttFallback.adapter,
+    completionTimeoutMs: options.sttFallback.completionTimeoutMs ?? DEFAULT_FALLBACK_COMPLETION_TIMEOUT_MS,
+    confidenceThreshold: options.sttFallback.confidenceThreshold ?? DEFAULT_FALLBACK_CONFIDENCE_THRESHOLD,
+    maxAttemptsPerTurn: options.sttFallback.maxAttemptsPerTurn ?? DEFAULT_FALLBACK_MAX_ATTEMPTS_PER_TURN,
+    minTextLength: options.sttFallback.minTextLength ?? DEFAULT_FALLBACK_MIN_TEXT_LENGTH,
+    replayWindowMs: options.sttFallback.replayWindowMs ?? DEFAULT_FALLBACK_REPLAY_MS,
+    settleMs: options.sttFallback.settleMs ?? DEFAULT_FALLBACK_SETTLE_MS,
+    trigger: options.sttFallback.trigger ?? "empty-or-low-confidence"
+  } : undefined;
+  const phraseHints = options.phraseHints ?? [];
+  let socket = options.socket;
+  let sttSession = null;
+  let silenceTimer = null;
+  let speechDetected = false;
+  let operationQueue = Promise.resolve();
+  let adapterGenerationCounter = 0;
+  let activeAdapterGeneration = 0;
+  const currentTurnAudio = [];
+  let fallbackAttemptsForCurrentTurn = 0;
+  const pruneTurnAudio = () => {
+    const replayWindowMs = sttFallback?.replayWindowMs ?? DEFAULT_FALLBACK_REPLAY_MS;
+    const cutoffAt = Date.now() - replayWindowMs;
+    let index = 0;
+    while (index < currentTurnAudio.length && currentTurnAudio[index].recordedAt < cutoffAt) {
+      index += 1;
+    }
+    if (index > 0) {
+      currentTurnAudio.splice(0, index);
+    }
+  };
+  const pushTurnAudio = (audio) => {
+    const chunk = audio instanceof ArrayBuffer ? new Uint8Array(audio.slice(0)) : new Uint8Array(audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength));
+    currentTurnAudio.push({
+      chunk,
+      recordedAt: Date.now()
+    });
+    pruneTurnAudio();
+  };
+  const getFallbackWindowAudio = () => {
+    if (!sttFallback?.adapter) {
+      return [];
+    }
+    pruneTurnAudio();
+    return currentTurnAudio.map((audio) => audio.chunk);
+  };
+  const clearSilenceTimer = () => {
+    if (!silenceTimer) {
+      return;
+    }
+    clearTimeout(silenceTimer);
+    silenceTimer = null;
+  };
+  const send = async (message) => {
+    try {
+      await Promise.resolve(socket.send(JSON.stringify(message)));
+    } catch (error) {
+      logger.warn("voice socket send failed", {
+        error: toError(error).message,
+        sessionId: options.id,
+        type: message.type
+      });
+    }
+  };
+  const readSession = async () => options.store.getOrCreate(options.id);
+  const writeSession = async (mutate) => {
+    const session = await options.store.getOrCreate(options.id);
+    mutate(session);
+    await options.store.set(options.id, session);
+    return session;
+  };
+  const runSerial = (phase, operation) => {
+    const result = operationQueue.then(async () => {
+      logger.debug("voice session operation", {
+        phase,
+        sessionId: options.id
+      });
+      return await operation();
+    });
+    operationQueue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+  const closeAdapter = async (reason) => {
+    if (!sttSession) {
+      return;
+    }
+    const activeSession = sttSession;
+    sttSession = null;
+    activeAdapterGeneration = 0;
+    try {
+      await activeSession.close(reason);
+    } catch (error) {
+      logger.warn("voice stt close failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    }
+  };
+  const scheduleTurnCommit = (delayMs, reason, reset = true) => {
+    if (!reset && silenceTimer) {
+      return;
+    }
+    if (reset) {
+      clearSilenceTimer();
+    }
+    silenceTimer = setTimeout(() => {
+      silenceTimer = null;
+      api.commitTurn(reason);
+    }, delayMs);
+  };
+  const scheduleSilenceCommit = (delayMs = turnDetection.silenceMs, reset = true) => scheduleTurnCommit(delayMs, "silence", reset);
+  const requestTurnCommit = async (reason) => {
+    const session = await readSession();
+    const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    if (!text) {
+      return;
+    }
+    const transcriptStabilityAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : undefined;
+    if (reason !== "manual" && typeof transcriptStabilityAge === "number" && transcriptStabilityAge < turnDetection.transcriptStabilityMs) {
+      scheduleTurnCommit(turnDetection.transcriptStabilityMs - transcriptStabilityAge, reason);
+      return;
+    }
+    await commitTurnInternal(reason);
+  };
+  const failInternal = async (error) => {
+    clearSilenceTimer();
+    const session = await writeSession((currentSession) => {
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "failed";
+    });
+    const resolvedError = toError(error);
+    await send({
+      message: resolvedError.message,
+      recoverable: false,
+      type: "error"
+    });
+    await closeAdapter("failed");
+    speechDetected = false;
+    rewindFallbackTurnAudio();
+    await options.route.onError?.({
+      api,
+      context: options.context,
+      error: resolvedError,
+      session,
+      sessionId: options.id
+    });
+  };
+  const completeInternal = async (result) => {
+    clearSilenceTimer();
+    const session = await writeSession((currentSession) => {
+      if (currentSession.status === "completed") {
+        return;
+      }
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "completed";
+      if (result !== undefined && currentSession.turns.length > 0) {
+        const lastTurn = currentSession.turns.at(-1);
+        if (lastTurn) {
+          setTurnResult(currentSession, lastTurn.id, {
+            result
+          });
+        }
+      }
+    });
+    await send({
+      sessionId: options.id,
+      type: "complete"
+    });
+    await closeAdapter("complete");
+    speechDetected = false;
+    rewindFallbackTurnAudio();
+    await options.route.onComplete({
+      api,
+      context: options.context,
+      session
+    });
+  };
+  const handleError = async (event) => {
+    await send({
+      message: event.error.message,
+      recoverable: event.recoverable,
+      type: "error"
+    });
+    if (!event.recoverable) {
+      await failInternal(event.error);
+    }
+  };
+  const handleClose = async (event) => {
+    if (event.recoverable === false) {
+      await failInternal(new Error(event.reason ?? "Speech-to-text session closed"));
+      return;
+    }
+    if (!event.reason) {
+      await closeAdapter("provider stream closed");
+      return;
+    }
+    await closeAdapter(event.reason);
+  };
+  const rewindFallbackTurnAudio = () => {
+    fallbackAttemptsForCurrentTurn = 0;
+    currentTurnAudio.length = 0;
+  };
+  const runFallbackTranscription = async (primaryText, primaryTranscripts) => {
+    if (!sttFallback?.adapter || fallbackAttemptsForCurrentTurn >= sttFallback.maxAttemptsPerTurn) {
+      return null;
+    }
+    const candidate = {
+      text: primaryText,
+      transcripts: primaryTranscripts
+    };
+    if (!isFallbackNeeded(candidate, sttFallback)) {
+      return null;
+    }
+    fallbackAttemptsForCurrentTurn += 1;
+    const replayAudio = getFallbackWindowAudio();
+    if (replayAudio.length === 0) {
+      return null;
+    }
+    let fallbackSession = null;
+    const fallbackTranscripts = [];
+    let fallbackClosed = false;
+    let fallbackEndOfTurnReceived = false;
+    let fallbackFinalReceived = false;
+    let lastFallbackTranscriptAt = 0;
+    try {
+      fallbackSession = await sttFallback.adapter.open({
+        format: DEFAULT_FORMAT,
+        phraseHints,
+        sessionId: `${options.id}:fallback:${fallbackAttemptsForCurrentTurn}`
+      });
+    } catch (error) {
+      logger.warn("voice stt fallback open failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+      return null;
+    }
+    const unsubscribers = [
+      fallbackSession.on("final", ({ transcript }) => {
+        fallbackFinalReceived = true;
+        lastFallbackTranscriptAt = Date.now();
+        fallbackTranscripts.push(cloneTranscript(transcript));
+      }),
+      fallbackSession.on("partial", ({ transcript }) => {
+        lastFallbackTranscriptAt = Date.now();
+        fallbackTranscripts.push(cloneTranscript(transcript));
+      }),
+      fallbackSession.on("endOfTurn", () => {
+        fallbackEndOfTurnReceived = true;
+      }),
+      fallbackSession.on("error", (event) => {
+        logger.warn("voice stt fallback error", {
+          error: toError(event.error).message,
+          sessionId: options.id
+        });
+      }),
+      fallbackSession.on("close", () => {
+        fallbackClosed = true;
+      })
+    ];
+    const closeFallback = async (reason) => {
+      if (!fallbackSession) {
+        return;
+      }
+      try {
+        await fallbackSession.close(reason);
+      } catch (error) {
+        logger.warn("voice stt fallback close failed", {
+          error: toError(error).message,
+          sessionId: options.id
+        });
+      } finally {
+        fallbackSession = null;
+      }
+    };
+    try {
+      for (const chunk of replayAudio) {
+        await fallbackSession.send(chunk);
+      }
+      const replayDurationMs = getBufferedAudioDurationMs(replayAudio);
+      const completionTimeoutMs = Math.max(sttFallback.completionTimeoutMs, Math.min(4000, Math.max(sttFallback.settleMs * 4, Math.round(replayDurationMs * 0.18))));
+      const waitStartedAt = Date.now();
+      while (Date.now() - waitStartedAt < completionTimeoutMs) {
+        const idleMs = lastFallbackTranscriptAt > 0 ? Date.now() - lastFallbackTranscriptAt : Date.now() - waitStartedAt;
+        if (fallbackEndOfTurnReceived && idleMs >= sttFallback.settleMs) {
+          break;
+        }
+        if (fallbackFinalReceived && idleMs >= sttFallback.settleMs) {
+          break;
+        }
+        if (fallbackClosed && (lastFallbackTranscriptAt === 0 || idleMs >= sttFallback.settleMs)) {
+          break;
+        }
+        await Bun.sleep(Math.min(75, Math.max(25, sttFallback.settleMs / 2)));
+      }
+    } catch (error) {
+      logger.warn("voice stt fallback failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    } finally {
+      await closeFallback("fallback-complete");
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+      }
+    }
+    if (fallbackTranscripts.length === 0) {
+      return null;
+    }
+    const fallbackText = buildTurnText(fallbackTranscripts, "", {});
+    const fallbackConfidence = calculateMeanConfidence(fallbackTranscripts);
+    const fallbackCandidate = {
+      confidence: fallbackConfidence,
+      text: fallbackText,
+      wordCount: countWords2(normalizeText2(fallbackText))
+    };
+    const primaryCandidate = {
+      confidence: calculateMeanConfidence(primaryTranscripts),
+      text: primaryText,
+      wordCount: countWords2(normalizeText2(primaryText))
+    };
+    const selection = selectBetterTurnText(primaryCandidate, fallbackCandidate);
+    const diagnostics = {
+      attempted: true,
+      fallbackConfidence: fallbackCandidate.confidence,
+      fallbackText: fallbackCandidate.text,
+      fallbackWordCount: fallbackCandidate.wordCount,
+      primaryConfidence: primaryCandidate.confidence,
+      primaryText,
+      primaryWordCount: primaryCandidate.wordCount,
+      selected: selection.winner.text === fallbackCandidate.text,
+      selectionReason: selection.reason,
+      trigger: sttFallback.trigger
+    };
+    if (selection.winner.text === primaryCandidate.text) {
+      return {
+        diagnostics,
+        fallbackUsed: false,
+        source: "primary",
+        text: primaryText,
+        transcripts: primaryTranscripts.map((transcript) => ({
+          ...transcript,
+          isFinal: true
+        }))
+      };
+    }
+    const candidateTranscripts = fallbackText === fallbackCandidate.text ? fallbackTranscripts : [];
+    return {
+      diagnostics,
+      fallbackUsed: true,
+      source: "fallback",
+      text: selection.winner.text,
+      transcripts: candidateTranscripts.length > 0 ? candidateTranscripts.map((transcript) => ({
+        ...transcript,
+        isFinal: true
+      })) : [{ id: createId(), isFinal: false, text: selection.winner.text }]
+    };
+  };
+  const getFinalTranscriptIds = (transcripts) => {
+    const finalTranscriptIds = transcripts.filter((transcript) => transcript.isFinal).map((transcript) => transcript.id);
+    const fallbackIds = transcripts.map((transcript) => transcript.id);
+    return finalTranscriptIds.length > 0 ? finalTranscriptIds : fallbackIds;
+  };
+  const runTurnCorrection = async (input) => {
+    if (!options.route.correctTurn) {
+      return;
+    }
+    const originalText = input.text;
+    const result = await options.route.correctTurn({
+      api,
+      context: options.context,
+      fallback: input.fallbackDiagnostics,
+      phraseHints,
+      session: input.session,
+      text: originalText,
+      transcripts: input.transcripts.map(cloneTranscript)
+    });
+    const nextText = typeof result === "string" ? result : typeof result?.text === "string" ? result.text : originalText;
+    const correctedText = normalizeCorrectionText(nextText);
+    const normalizedOriginal = normalizeCorrectionText(originalText);
+    return {
+      diagnostics: {
+        attempted: true,
+        changed: correctedText.length > 0 && correctedText !== normalizedOriginal,
+        correctedText: correctedText.length > 0 ? correctedText : normalizedOriginal,
+        metadata: typeof result === "object" ? result.metadata : undefined,
+        originalText,
+        provider: typeof result === "object" ? result.provider : undefined,
+        reason: typeof result === "object" ? result.reason : undefined
+      },
+      text: correctedText.length > 0 ? correctedText : originalText
+    };
+  };
+  const ensureCommittedTurnGuard = (session) => {
+    if (!session.lastCommittedTurn) {
+      session.lastCommittedTurn = {
+        committedAt: 0,
+        signature: "",
+        text: "",
+        transcriptIds: []
+      };
+    }
+    return session;
+  };
+  const buildTurnSignature = (session, finalText, transcriptIdsOverride) => {
+    const finalTranscriptIds = transcriptIdsOverride ?? getFinalTranscriptIds(session.currentTurn.transcripts);
+    return `${normalizeText2(finalText)}|${finalTranscriptIds.join(",")}`;
+  };
+  const isDuplicateTurnCommit = (session, finalText) => {
+    const signature = buildTurnSignature(session, finalText);
+    const committedTurn = session.lastCommittedTurn;
+    const isRecent = committedTurn && committedTurn.committedAt > 0 && Date.now() - committedTurn.committedAt < DEFAULT_DUPLICATE_TURN_WINDOW_MS;
+    const committedSignature = committedTurn?.signature ?? "";
+    const committedTranscriptIds = committedTurn?.transcriptIds ?? [];
+    const committedText = normalizeText2(committedTurn?.text ?? "");
+    const isSameText = normalizeText2(finalText) === committedText;
+    const hasNoNewAudioSinceCommit = (session.currentTurn.lastAudioAt ?? 0) <= (committedTurn?.committedAt ?? 0);
+    if (!isRecent) {
+      return false;
+    }
+    if (isSameText && hasNoNewAudioSinceCommit) {
+      return true;
+    }
+    if (signature !== committedSignature) {
+      return false;
+    }
+    const lastSignatureIds = new Set(committedTranscriptIds);
+    const hasNoNewFinalIds = session.currentTurn.transcripts.every((transcript) => !transcript.isFinal || lastSignatureIds.has(transcript.id));
+    return isRecent && hasNoNewFinalIds;
+  };
+  const markTurnCommitted = (session, finalText, committedTranscripts) => {
+    session.lastCommittedTurn = {
+      ...session.lastCommittedTurn ?? {},
+      committedAt: Date.now(),
+      signature: buildTurnSignature(session, finalText, getFinalTranscriptIds(committedTranscripts)),
+      text: normalizeText2(finalText),
+      transcriptIds: getFinalTranscriptIds(committedTranscripts)
+    };
+  };
+  const handlePartial = async (transcript) => {
+    await writeSession((session) => {
+      const nextPartialStartedAt = transcript.startedAtMs ?? session.currentTurn.partialStartedAt;
+      const nextPartialEndedAt = transcript.endedAtMs ?? session.currentTurn.partialEndedAt;
+      const preferredPartial = selectPreferredTranscriptText(session.currentTurn.partialText, transcript.text);
+      session.currentTurn.lastTranscriptAt = Date.now();
+      session.currentTurn.partialStartedAt = nextPartialStartedAt;
+      session.currentTurn.partialEndedAt = nextPartialEndedAt;
+      session.currentTurn.partialText = buildTurnText(session.currentTurn.transcripts, preferredPartial, {
+        partialEndedAtMs: nextPartialEndedAt,
+        partialStartedAtMs: nextPartialStartedAt
+      });
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "partial"
+    });
+  };
+  const handleFinal = async (transcript) => {
+    await writeSession((session) => {
+      const alreadyPresent = session.currentTurn.transcripts.some((existing) => existing.id === transcript.id);
+      if (!alreadyPresent) {
+        session.currentTurn.transcripts = [
+          ...session.currentTurn.transcripts,
+          cloneTranscript(transcript)
+        ];
+        session.transcripts = [
+          ...session.transcripts,
+          cloneTranscript(transcript)
+        ];
+      }
+      session.currentTurn.finalText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+        partialEndedAtMs: session.currentTurn.partialEndedAt,
+        partialStartedAtMs: session.currentTurn.partialStartedAt
+      });
+      session.currentTurn.lastTranscriptAt = Date.now();
+      session.lastActivityAt = Date.now();
+      session.status = "active";
+    });
+    await send({
+      transcript,
+      type: "final"
+    });
+  };
+  const resumePendingTurnCommit = (session) => {
+    const pendingText = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    if (!pendingText) {
+      speechDetected = false;
+      return;
+    }
+    speechDetected = true;
+    const audioAge = session.currentTurn.silenceStartedAt !== undefined ? Date.now() - session.currentTurn.silenceStartedAt : session.currentTurn.lastSpeechAt !== undefined ? Date.now() - session.currentTurn.lastSpeechAt : 0;
+    const transcriptAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : turnDetection.transcriptStabilityMs;
+    const delayMs = Math.max(0, turnDetection.silenceMs - audioAge, turnDetection.transcriptStabilityMs - transcriptAge);
+    scheduleSilenceCommit(delayMs);
+  };
+  const ensureAdapter = async () => {
+    if (sttSession) {
+      return sttSession;
+    }
+    const openedSession = await options.stt.open({
+      format: DEFAULT_FORMAT,
+      phraseHints,
+      sessionId: options.id
+    });
+    const generation = ++adapterGenerationCounter;
+    sttSession = openedSession;
+    activeAdapterGeneration = generation;
+    const runAdapterEvent = (phase, handler) => {
+      runSerial(phase, async () => {
+        if (activeAdapterGeneration !== generation) {
+          return;
+        }
+        await handler();
+      });
+    };
+    openedSession.on("partial", ({ transcript }) => {
+      runAdapterEvent("adapter.partial", () => handlePartial(transcript));
+    });
+    openedSession.on("final", ({ transcript }) => {
+      runAdapterEvent("adapter.final", () => handleFinal(transcript));
+    });
+    openedSession.on("endOfTurn", ({ reason }) => {
+      runAdapterEvent("adapter.endOfTurn", async () => {
+        clearSilenceTimer();
+        await requestTurnCommit(reason);
+      });
+    });
+    openedSession.on("error", (event) => {
+      runAdapterEvent("adapter.error", () => handleError(event));
+    });
+    openedSession.on("close", (event) => {
+      runAdapterEvent("adapter.close", () => handleClose(event));
+    });
+    return openedSession;
+  };
+  const completeTurn = async (session, turn) => {
+    const output = await options.route.onTurn({
+      api,
+      context: options.context,
+      session,
+      turn
+    });
+    if (output?.assistantText) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          assistantText: output.assistantText
+        });
+      });
+      await send({
+        text: output.assistantText,
+        turnId: turn.id,
+        type: "assistant"
+      });
+    }
+    if (output?.result !== undefined) {
+      await writeSession((currentSession) => {
+        setTurnResult(currentSession, turn.id, {
+          result: output.result
+        });
+      });
+    }
+    if (output?.complete) {
+      await completeInternal(output.result);
+    }
+  };
+  const commitTurnInternal = async (reason = "manual") => {
+    clearSilenceTimer();
+    const session = await readSession();
+    if (session.status === "completed" || session.status === "failed") {
+      return;
+    }
+    const text = buildTurnText(session.currentTurn.transcripts, session.currentTurn.partialText, {
+      partialEndedAtMs: session.currentTurn.partialEndedAt,
+      partialStartedAtMs: session.currentTurn.partialStartedAt
+    });
+    let transcripts = session.currentTurn.transcripts.length ? session.currentTurn.transcripts.map(cloneTranscript) : [];
+    let finalText = text;
+    const transcriptStabilityAge = session.currentTurn.lastTranscriptAt !== undefined ? Date.now() - session.currentTurn.lastTranscriptAt : undefined;
+    const fallbackSelection = await runFallbackTranscription(text, session.currentTurn.transcripts);
+    const source = fallbackSelection?.source ?? "primary";
+    const fallbackUsed = fallbackSelection?.fallbackUsed ?? false;
+    const fallbackDiagnostics = fallbackSelection?.diagnostics;
+    if (fallbackSelection) {
+      finalText = fallbackSelection.text;
+      transcripts = fallbackSelection.transcripts.length ? fallbackSelection.transcripts.map(cloneTranscript) : transcripts.length ? transcripts : [
+        {
+          id: createId(),
+          isFinal: false,
+          text: finalText
+        }
+      ];
+      if (fallbackSelection.fallbackUsed) {
+        logger.info("voice fallback turn selected", {
+          reason,
+          sessionId: options.id,
+          text: finalText
+        });
+      }
+    }
+    const correctionSelection = await runTurnCorrection({
+      fallbackDiagnostics,
+      fallbackUsed,
+      session,
+      source,
+      text: finalText,
+      transcripts
+    });
+    const correctionDiagnostics = correctionSelection?.diagnostics;
+    if (correctionSelection) {
+      finalText = correctionSelection.text;
+    }
+    if (!finalText) {
+      return;
+    }
+    if (isDuplicateTurnCommit(session, finalText)) {
+      logger.debug("voice turn commit deduped", {
+        reason,
+        sessionId: options.id
+      });
+      return;
+    }
+    if (typeof transcriptStabilityAge === "number" && transcriptStabilityAge < turnDetection.transcriptStabilityMs && reason !== "manual") {
+      scheduleTurnCommit(turnDetection.transcriptStabilityMs - transcriptStabilityAge, reason, false);
+      return;
+    }
+    const turn = {
+      committedAt: Date.now(),
+      id: createId(),
+      text: finalText,
+      quality: createTurnQuality(transcripts, source, fallbackUsed, fallbackDiagnostics, correctionDiagnostics),
+      transcripts: transcripts.length > 0 ? transcripts : [
+        {
+          id: createId(),
+          isFinal: false,
+          text: finalText
+        }
+      ]
+    };
+    const updatedSession = await writeSession((currentSession) => {
+      currentSession.committedTurnIds = [
+        ...currentSession.committedTurnIds,
+        turn.id
+      ];
+      currentSession.currentTurn = createEmptyCurrentTurn();
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "active";
+      currentSession.turns = [...currentSession.turns, turn];
+      markTurnCommitted(currentSession, finalText, transcripts);
+    });
+    speechDetected = false;
+    rewindFallbackTurnAudio();
+    logger.info("voice turn committed", {
+      reason,
+      sessionId: options.id,
+      turnId: turn.id
+    });
+    await send({
+      turn,
+      type: "turn"
+    });
+    if (options.sttLifecycle === "turn-scoped") {
+      await closeAdapter("turn-commit");
+    }
+    await completeTurn(updatedSession, turn);
+  };
+  const connectInternal = async (nextSocket) => {
+    socket = nextSocket;
+    const existingSession = await options.store.get(options.id);
+    let session = existingSession ?? createVoiceSessionRecord(options.id, options.scenarioId);
+    if (options.scenarioId && session.scenarioId !== options.scenarioId) {
+      session.scenarioId = options.scenarioId;
+    }
+    ensureCommittedTurnGuard(session);
+    let shouldFireOnSession = !existingSession;
+    if (existingSession?.scenarioId && options.scenarioId && existingSession.scenarioId !== options.scenarioId) {
+      session = resetVoiceSessionRecord(options.id, existingSession, options.scenarioId);
+      shouldFireOnSession = true;
+    }
+    rewindFallbackTurnAudio();
+    if (existingSession?.status === "reconnecting") {
+      const nextAttempts = existingSession.reconnect.attempts + 1;
+      const reconnectExpired = existingSession.reconnect.lastDisconnectAt !== undefined && Date.now() - existingSession.reconnect.lastDisconnectAt > reconnect.timeout;
+      const tooManyAttempts = nextAttempts > reconnect.maxAttempts;
+      if (reconnect.strategy === "fail" && (reconnectExpired || tooManyAttempts)) {
+        await failInternal(new Error("Voice session reconnect policy exhausted"));
+        return;
+      }
+      if (reconnect.strategy === "restart" && (reconnectExpired || tooManyAttempts)) {
+        session = resetVoiceSessionRecord(options.id, existingSession, options.scenarioId);
+        shouldFireOnSession = true;
+      } else {
+        session = {
+          ...existingSession,
+          reconnect: {
+            ...existingSession.reconnect,
+            attempts: nextAttempts
+          },
+          status: "active"
+        };
+      }
+    }
+    await options.store.set(options.id, session);
+    await send({
+      sessionId: options.id,
+      status: session.status,
+      scenarioId: session.scenarioId,
+      type: "session"
+    });
+    if (shouldFireOnSession) {
+      await options.route.onSession?.({
+        api,
+        context: options.context,
+        session
+      });
+    }
+    if (session.status === "completed") {
+      await send({
+        sessionId: options.id,
+        type: "complete"
+      });
+      return;
+    }
+    resumePendingTurnCommit(session);
+    await ensureAdapter();
+  };
+  const disconnectInternal = async (event) => {
+    clearSilenceTimer();
+    await closeAdapter(event?.reason);
+    rewindFallbackTurnAudio();
+    if (reconnect.strategy === "fail") {
+      await failInternal(new Error(event?.reason ?? "Voice socket disconnected"));
+      return;
+    }
+    await writeSession((session) => {
+      if (session.status === "completed" || session.status === "failed") {
+        return;
+      }
+      session.lastActivityAt = Date.now();
+      session.reconnect.lastDisconnectAt = Date.now();
+      session.status = "reconnecting";
+    });
+    speechDetected = false;
+  };
+  const receiveAudioInternal = async (audio) => {
+    const session = await readSession();
+    if (session.status === "completed" || session.status === "failed") {
+      return;
+    }
+    const adapter = await ensureAdapter();
+    const conditionedAudio = conditionAudioChunk(audio, options.audioConditioning);
+    const audioLevel = measureAudioLevel(conditionedAudio);
+    const shouldStoreAudio = speechDetected || audioLevel >= turnDetection.speechThreshold;
+    await writeSession((currentSession) => {
+      currentSession.currentTurn.lastAudioAt = Date.now();
+      currentSession.lastActivityAt = Date.now();
+      currentSession.status = "active";
+      if (audioLevel >= turnDetection.speechThreshold) {
+        currentSession.currentTurn.lastSpeechAt = Date.now();
+        currentSession.currentTurn.silenceStartedAt = undefined;
+      } else if (speechDetected && currentSession.currentTurn.silenceStartedAt === undefined) {
+        currentSession.currentTurn.silenceStartedAt = Date.now();
+      }
+    });
+    if (shouldStoreAudio) {
+      pushTurnAudio(conditionedAudio);
+    }
+    if (audioLevel >= turnDetection.speechThreshold) {
+      speechDetected = true;
+      clearSilenceTimer();
+    } else if (speechDetected) {
+      const currentSession = await readSession();
+      const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText, {
+        partialEndedAtMs: currentSession.currentTurn.partialEndedAt,
+        partialStartedAtMs: currentSession.currentTurn.partialStartedAt
+      }));
+      if (hasTurnText) {
+        scheduleSilenceCommit(turnDetection.silenceMs, false);
+      }
+    }
+    await adapter.send(conditionedAudio);
+  };
+  const api = {
+    id: options.id,
+    close: async (reason) => {
+      await runSerial("api.close", async () => {
+        clearSilenceTimer();
+        await closeAdapter(reason);
+        await Promise.resolve(socket.close(1000, reason));
+      });
+    },
+    commitTurn: async (reason = "manual") => runSerial("api.commitTurn", async () => {
+      await commitTurnInternal(reason);
+    }),
+    complete: async (result) => runSerial("api.complete", async () => {
+      await completeInternal(result);
+    }),
+    connect: async (nextSocket) => runSerial("api.connect", async () => {
+      await connectInternal(nextSocket);
+    }),
+    disconnect: async (event) => runSerial("api.disconnect", async () => {
+      await disconnectInternal(event);
+    }),
+    fail: async (error) => runSerial("api.fail", async () => {
+      await failInternal(error);
+    }),
+    receiveAudio: async (audio) => runSerial("api.receiveAudio", async () => {
+      await receiveAudioInternal(audio);
+    }),
+    snapshot: async () => runSerial("api.snapshot", async () => readSession())
+  };
+  return api;
+};
+
+// src/turnProfiles.ts
+var TURN_PROFILE_DEFAULTS = {
+  balanced: {
+    qualityProfile: "general",
+    silenceMs: 1400,
+    speechThreshold: 0.012,
+    transcriptStabilityMs: 1000
+  },
+  fast: {
+    qualityProfile: "general",
+    silenceMs: 700,
+    speechThreshold: 0.015,
+    transcriptStabilityMs: 450
+  },
+  "long-form": {
+    qualityProfile: "general",
+    silenceMs: 2200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1500
+  }
+};
+var QUALITY_PROFILE_DEFAULTS = {
+  general: {},
+  "accent-heavy": {
+    silenceMs: 1200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1200
+  },
+  "noisy-room": {
+    silenceMs: 2000,
+    speechThreshold: 0.02,
+    transcriptStabilityMs: 1600
+  },
+  "short-command": {
+    silenceMs: 500,
+    speechThreshold: 0.016,
+    transcriptStabilityMs: 420
+  }
+};
+var DEFAULT_TURN_PROFILE = "fast";
+var DEFAULT_QUALITY_PROFILE = "general";
+var resolveTurnDetectionConfig = (config) => {
+  const profile = config?.profile ?? DEFAULT_TURN_PROFILE;
+  const qualityProfile = config?.qualityProfile ?? DEFAULT_QUALITY_PROFILE;
+  const preset = TURN_PROFILE_DEFAULTS[profile];
+  const quality = QUALITY_PROFILE_DEFAULTS[qualityProfile];
+  return {
+    profile,
+    qualityProfile,
+    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
+    speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
+    transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
+  };
+};
+
+// src/testing/resilience.ts
+var roundMetric2 = (value, digits = 4) => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var createMockSocket = () => ({
+  close: async () => {},
+  send: async () => {}
+});
+var createSpeechChunk = (sample) => new Int16Array(160).fill(sample);
+var createFakeAdapter = () => {
+  const listeners = {
+    close: [],
+    endOfTurn: [],
+    error: [],
+    final: [],
+    partial: []
+  };
+  const session = {
+    close: async () => {},
+    emit: async (event, payload) => {
+      for (const listener of listeners[event]) {
+        await listener(payload);
+      }
+    },
+    on: (event, handler) => {
+      listeners[event].push(handler);
+      return () => {
+        const index = listeners[event].indexOf(handler);
+        if (index >= 0) {
+          listeners[event].splice(index, 1);
+        }
+      };
+    },
+    send: async (_audio) => {}
+  };
+  return {
+    adapter: {
+      kind: "stt",
+      open: () => session
+    },
+    session
+  };
+};
+var runScenario = async (id, title, run) => {
+  const store = createVoiceMemoryStore();
+  const adapter = createFakeAdapter();
+  const turns = [];
+  const voice = createVoiceSession({
+    context: {},
+    id,
+    logger: {},
+    reconnect: {
+      maxAttempts: 2,
+      strategy: "resume-last-turn",
+      timeout: 5000
+    },
+    route: {
+      onComplete: async () => {},
+      onTurn: async ({ turn }) => {
+        turns.push(turn.text);
+      }
+    },
+    socket: createMockSocket(),
+    store,
+    stt: adapter.adapter,
+    sttLifecycle: "continuous",
+    turnDetection: resolveTurnDetectionConfig({
+      silenceMs: 20,
+      speechThreshold: 0.01,
+      transcriptStabilityMs: 5
+    })
+  });
+  await voice.connect(createMockSocket());
+  try {
+    await run({
+      adapter,
+      commit: async (text, transcriptId = `${id}-${turns.length}`) => {
+        await adapter.session.emit("final", {
+          receivedAt: Date.now(),
+          transcript: {
+            id: transcriptId,
+            isFinal: true,
+            text
+          },
+          type: "final"
+        });
+        await voice.receiveAudio(createSpeechChunk(16000));
+        await voice.receiveAudio(createSpeechChunk(0));
+        await Bun.sleep(60);
+      },
+      connectNewSocket: async () => {
+        await voice.connect(createMockSocket());
+      },
+      disconnect: async () => {
+        await voice.disconnect({
+          recoverable: true,
+          type: "close"
+        });
+      },
+      emitEndOfTurn: async () => {
+        await adapter.session.emit("endOfTurn", {
+          reason: "vendor",
+          receivedAt: Date.now(),
+          type: "endOfTurn"
+        });
+      },
+      emitFinal: async (text, transcriptId = `${id}-${turns.length}`) => {
+        await adapter.session.emit("final", {
+          receivedAt: Date.now(),
+          transcript: {
+            id: transcriptId,
+            isFinal: true,
+            text
+          },
+          type: "final"
+        });
+      },
+      turns
+    });
+  } finally {
+    await voice.close("resilience-complete");
+  }
+  const uniqueTurns = new Set(turns.map((turn) => turn.toLowerCase()));
+  const replayedTurns = turns.length - uniqueTurns.size;
+  return {
+    actualTurns: turns,
+    id,
+    passes: replayedTurns === 0,
+    replayedTurns,
+    title
+  };
+};
+var runVoiceResilienceBenchmark = async () => {
+  const scenarios = await Promise.all([
+    runScenario("resume-no-replay", "Reconnect after first turn does not replay committed text", async ({ commit, connectNewSocket, disconnect }) => {
+      await commit("Reconnect should not duplicate prior turns");
+      await disconnect();
+      await connectNewSocket();
+      await commit("A second turn should still commit after resume");
+    }),
+    runScenario("duplicate-final-id", "Duplicate transcript ids do not create replayed turns", async ({ adapter, connectNewSocket, disconnect, turns, commit }) => {
+      await commit("Duplicate final ids should still produce one turn", "same-id");
+      await disconnect();
+      await connectNewSocket();
+      await adapter.session.emit("final", {
+        receivedAt: Date.now(),
+        transcript: {
+          id: "same-id",
+          isFinal: true,
+          text: "Duplicate final ids should still produce one turn"
+        },
+        type: "final"
+      });
+      if (turns.length === 1) {
+        await commit("Fresh transcripts should still commit later");
+      }
+    }),
+    runScenario("duplicate-end-of-turn", "Repeated end-of-turn events for the same turn stay deduped", async ({ emitFinal, emitEndOfTurn, turns }) => {
+      await emitFinal("Repeated end-of-turn should only commit once", "dup-endofturn");
+      await emitEndOfTurn();
+      await emitEndOfTurn();
+      await Bun.sleep(80);
+      if (turns.length !== 1) {
+        throw new Error("Repeated end-of-turn events created duplicate turns");
+      }
+    }),
+    runScenario("duplicate-end-of-turn-jitter", "End-of-turn jitter does not trigger extra commits", async ({ emitFinal, emitEndOfTurn, turns }) => {
+      await emitFinal("Noisy end-of-turn signals should still commit once", "dup-endofturn-jitter");
+      for (const delayMs of [40, 95, 180, 120]) {
+        await Bun.sleep(delayMs);
+        await emitEndOfTurn();
+      }
+      await Bun.sleep(80);
+      if (turns.length !== 1) {
+        throw new Error("Jittered end-of-turn signals created duplicate turns");
+      }
+    }),
+    runScenario("reconnect-duplicate-text-no-new-audio", "Reconnect duplicate text with different ids and no audio does not replay turn", async ({
+      adapter,
+      connectNewSocket,
+      disconnect,
+      emitEndOfTurn,
+      emitFinal,
+      turns
+    }) => {
+      await emitFinal("Reconnect duplicate text should be suppressed", "dup-text-reconnect-1");
+      await emitEndOfTurn();
+      await Bun.sleep(60);
+      await disconnect();
+      await connectNewSocket();
+      await adapter.session.emit("final", {
+        receivedAt: Date.now(),
+        transcript: {
+          id: "dup-text-reconnect-2",
+          isFinal: true,
+          text: "Reconnect duplicate text should be suppressed"
+        },
+        type: "final"
+      });
+      for (const delayMs of [40, 70, 110]) {
+        await Bun.sleep(delayMs);
+        await emitEndOfTurn();
+      }
+      await Bun.sleep(60);
+      if (turns.length !== 1) {
+        throw new Error("Reconnect duplicate text was committed twice");
+      }
+    }),
+    runScenario("reconnect-end-of-turn-jitter", "End-of-turn jitter after reconnect does not replay committed turns", async ({
+      adapter,
+      connectNewSocket,
+      disconnect,
+      emitEndOfTurn,
+      emitFinal,
+      turns
+    }) => {
+      await emitFinal("Reconnect duplicate end-of-turn should dedupe", "resume-jitter");
+      await emitEndOfTurn();
+      await Bun.sleep(60);
+      await disconnect();
+      await connectNewSocket();
+      await adapter.session.emit("final", {
+        receivedAt: Date.now(),
+        transcript: {
+          id: "resume-jitter",
+          isFinal: true,
+          text: "Reconnect duplicate end-of-turn should dedupe"
+        },
+        type: "final"
+      });
+      for (const delayMs of [50, 80, 120, 180]) {
+        await Bun.sleep(delayMs);
+        await emitEndOfTurn();
+      }
+      await Bun.sleep(80);
+      if (turns.length !== 1) {
+        throw new Error("Reconnected jittered end-of-turn signals replayed a committed turn");
+      }
+    })
+  ]);
+  const passCount = scenarios.filter((scenario) => scenario.passes).length;
+  const replayFailures = scenarios.filter((scenario) => scenario.replayedTurns > 0).length;
+  return {
+    generatedAt: Date.now(),
+    scenarios,
+    summary: {
+      duplicateTurnRate: roundMetric2(scenarios.length > 0 ? replayFailures / scenarios.length : 0),
+      passCount,
+      passRate: roundMetric2(scenarios.length > 0 ? passCount / scenarios.length : 0),
+      replayFailureRate: roundMetric2(scenarios.length > 0 ? replayFailures / scenarios.length : 0),
+      scenarioCount: scenarios.length
+    }
+  };
+};
+// src/testing/sessionBenchmark.ts
+var average2 = (values) => values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+var normalizeTurnText = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
+var roundMetric3 = (value, digits = 4) => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var resolveBenchmarkFallbackConfig = (config) => {
+  if (!config) {
+    return;
+  }
+  return {
+    adapter: config.adapter,
+    completionTimeoutMs: config.completionTimeoutMs ?? 2500,
+    confidenceThreshold: config.confidenceThreshold ?? 0.6,
+    maxAttemptsPerTurn: config.maxAttemptsPerTurn ?? 1,
+    minTextLength: config.minTextLength ?? 2,
+    replayWindowMs: config.replayWindowMs ?? 8000,
+    settleMs: config.settleMs ?? 220,
+    trigger: config.trigger ?? "empty-or-low-confidence"
+  };
+};
+var chunkAudio2 = (audio, bytesPerChunk) => {
+  const chunks = [];
+  for (let offset = 0;offset < audio.byteLength; offset += bytesPerChunk) {
+    chunks.push(audio.slice(offset, offset + bytesPerChunk));
+  }
+  return chunks;
+};
+var createSilence2 = (byteLength) => new Uint8Array(byteLength);
+var countUnexpectedDuplicateTurns = (actualTurns, expectedTurns) => {
+  const expectedCounts = new Map;
+  for (const turn of expectedTurns) {
+    const key = normalizeTurnText(turn);
+    expectedCounts.set(key, (expectedCounts.get(key) ?? 0) + 1);
+  }
+  const actualCounts = new Map;
+  for (const turn of actualTurns) {
+    const key = normalizeTurnText(turn);
+    actualCounts.set(key, (actualCounts.get(key) ?? 0) + 1);
+  }
+  let duplicates = 0;
+  for (const [key, actualCount] of actualCounts.entries()) {
+    const expectedCount = expectedCounts.get(key) ?? 0;
+    const allowedOccurrences = Math.max(expectedCount, 1);
+    if (actualCount > allowedOccurrences) {
+      duplicates += actualCount - allowedOccurrences;
+    }
+  }
+  return duplicates;
+};
+var normalizeSocketMessage = (data) => {
+  if (typeof data !== "string") {
+    return {
+      byteLength: data instanceof ArrayBuffer ? data.byteLength : data.byteLength,
+      kind: "binary"
+    };
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+};
+var createMockSocket2 = (onEvent) => ({
+  close: async (code, reason) => {
+    onEvent?.({
+      data: {
+        code,
+        reason
+      },
+      phase: "socket.close"
+    });
+  },
+  send: async (data) => {
+    onEvent?.({
+      data: normalizeSocketMessage(data),
+      phase: "socket.send"
+    });
+  }
+});
+var waitForSessionIdle = async (session, settleMs, idleTimeoutMs) => {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < idleTimeoutMs) {
+    const snapshot = await session.snapshot();
+    const pendingText = snapshot.currentTurn.finalText || snapshot.currentTurn.partialText;
+    const lastActivityAt = snapshot.lastActivityAt ?? snapshot.createdAt;
+    if (!pendingText && Date.now() - lastActivityAt >= settleMs) {
+      return;
+    }
+    await Bun.sleep(Math.min(100, settleMs));
+  }
+};
+var runVoiceSessionBenchmarkScenario = async (adapter, fixture, options = {}) => {
+  const store = createVoiceMemoryStore();
+  const committedTurns = [];
+  const traceStartedAt = Date.now();
+  const trace = [];
+  const pushTrace = (entry) => {
+    if (!options.trace) {
+      return;
+    }
+    trace.push({
+      ...entry,
+      atMs: Date.now() - traceStartedAt
+    });
+  };
+  const captureSnapshot = async (phase) => {
+    if (!options.trace) {
+      return;
+    }
+    const snapshot = await store.getOrCreate(`session-bench-${fixture.id}`);
+    pushTrace({
+      data: {
+        currentTurn: {
+          finalText: snapshot.currentTurn.finalText,
+          lastAudioAt: snapshot.currentTurn.lastAudioAt,
+          lastSpeechAt: snapshot.currentTurn.lastSpeechAt,
+          lastTranscriptAt: snapshot.currentTurn.lastTranscriptAt,
+          partialText: snapshot.currentTurn.partialText,
+          silenceStartedAt: snapshot.currentTurn.silenceStartedAt,
+          transcriptCount: snapshot.currentTurn.transcripts.length
+        },
+        lastActivityAt: snapshot.lastActivityAt,
+        status: snapshot.status,
+        turns: snapshot.turns.map((turn) => turn.text)
+      },
+      phase
+    });
+  };
+  const logger = {
+    debug: (message, meta) => {
+      pushTrace({
+        data: meta,
+        phase: `logger.debug:${message}`
+      });
+    },
+    error: (message, meta) => {
+      pushTrace({
+        data: meta,
+        phase: `logger.error:${message}`
+      });
+    },
+    info: (message, meta) => {
+      pushTrace({
+        data: meta,
+        phase: `logger.info:${message}`
+      });
+    },
+    warn: (message, meta) => {
+      pushTrace({
+        data: meta,
+        phase: `logger.warn:${message}`
+      });
+    }
+  };
+  const session = createVoiceSession({
+    audioConditioning: resolveAudioConditioningConfig(fixture.audioConditioning),
+    context: {},
+    id: `session-bench-${fixture.id}`,
+    logger,
+    reconnect: {
+      maxAttempts: 2,
+      strategy: "resume-last-turn",
+      timeout: 5000
+    },
+    route: {
+      correctTurn: options.correctTurn,
+      onComplete: async () => {},
+      onTurn: async ({ turn }) => {
+        committedTurns.push({
+          quality: turn.quality,
+          text: turn.text
+        });
+        pushTrace({
+          data: {
+            quality: turn.quality,
+            text: turn.text,
+            transcriptCount: turn.transcripts.length,
+            turnId: turn.id
+          },
+          phase: "route.onTurn"
+        });
+      }
+    },
+    phraseHints: fixture.phraseHints,
+    socket: createMockSocket2(pushTrace),
+    store,
+    stt: adapter,
+    sttFallback: resolveBenchmarkFallbackConfig(options.sttFallback),
+    sttLifecycle: fixture.sttLifecycle ?? "continuous",
+    turnDetection: resolveTurnDetectionConfig({
+      profile: fixture.turnProfile ?? "balanced",
+      silenceMs: fixture.silenceMs ?? DEFAULT_SILENCE_MS,
+      speechThreshold: fixture.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD,
+      transcriptStabilityMs: fixture.transcriptStabilityMs ?? 900
+    })
+  });
+  const startedAt = Date.now();
+  let reconnectTriggered = false;
+  await session.connect(createMockSocket2(pushTrace));
+  await captureSnapshot("session.connected");
+  try {
+    const chunkDurationMs = fixture.chunkDurationMs ?? 100;
+    const bytesPerMillisecond = fixture.format.sampleRateHz * fixture.format.channels * 2 / 1000;
+    const bytesPerChunk = Math.max(2, Math.floor(bytesPerMillisecond * chunkDurationMs));
+    const chunks = chunkAudio2(fixture.audio, bytesPerChunk);
+    for (const [index, chunk] of chunks.entries()) {
+      await session.receiveAudio(chunk);
+      await Bun.sleep(chunkDurationMs);
+      if (fixture.reconnectAtChunkIndex !== undefined && index === fixture.reconnectAtChunkIndex && !reconnectTriggered) {
+        reconnectTriggered = true;
+        pushTrace({
+          data: {
+            chunkIndex: index
+          },
+          phase: "reconnect.begin"
+        });
+        await captureSnapshot("reconnect.pre-disconnect");
+        await session.disconnect({
+          reason: "benchmark-reconnect",
+          recoverable: true,
+          type: "close"
+        });
+        await captureSnapshot("reconnect.post-disconnect");
+        await Bun.sleep(fixture.reconnectPauseMs ?? 150);
+        await session.connect(createMockSocket2(pushTrace));
+        await captureSnapshot("reconnect.post-connect");
+      }
+    }
+    const tailPaddingMs = fixture.tailPaddingMs ?? 1200;
+    if (tailPaddingMs > 0) {
+      const tailBytes = Math.max(2, Math.floor(bytesPerMillisecond * tailPaddingMs));
+      for (const chunk of chunkAudio2(createSilence2(tailBytes), bytesPerChunk)) {
+        await session.receiveAudio(chunk);
+        await Bun.sleep(chunkDurationMs);
+      }
+    }
+    await waitForSessionIdle(session, Math.max(1200, (fixture.silenceMs ?? DEFAULT_SILENCE_MS) + (fixture.transcriptStabilityMs ?? 900)), 8000);
+    await captureSnapshot("session.idle");
+  } finally {
+    await captureSnapshot("session.pre-close");
+    await session.close("session-benchmark-complete");
+  }
+  const duplicateTurnCount = countUnexpectedDuplicateTurns(committedTurns.map((turn) => turn.text), fixture.expectedTurnTexts);
+  const turnResults = fixture.expectedTurnTexts.map((expectedText, index) => {
+    const actualTurn = committedTurns[index];
+    const actualText = actualTurn?.text;
+    if (!actualText) {
+      return {
+        actualText: "",
+        expectedText,
+        index,
+        passes: false
+      };
+    }
+    const accuracy = scoreTranscriptAccuracy(actualText, expectedText, fixture.transcriptThreshold ?? 0.35);
+    return {
+      actualText,
+      accuracy,
+      expectedText,
+      index,
+      passes: accuracy.passesThreshold,
+      quality: actualTurn?.quality
+    };
+  });
+  for (let index = fixture.expectedTurnTexts.length;index < committedTurns.length; index += 1) {
+    turnResults.push({
+      actualText: committedTurns[index]?.text ?? "",
+      expectedText: undefined,
+      index,
+      passes: false,
+      quality: committedTurns[index]?.quality
+    });
+  }
+  const turnCountDelta = committedTurns.length - fixture.expectedTurnTexts.length;
+  return {
+    actualTurns: committedTurns.map((turn) => turn.text),
+    duplicateTurnCount,
+    elapsedMs: Date.now() - startedAt,
+    expectedTurns: fixture.expectedTurnTexts,
+    fixtureId: fixture.id,
+    passes: duplicateTurnCount === 0 && turnCountDelta === 0 && turnResults.every((result) => result.passes),
+    reconnectTriggered,
+    tags: fixture.tags ?? [],
+    title: fixture.title,
+    turnCountDelta,
+    turnResults,
+    trace: options.trace ? trace : undefined
+  };
+};
+var summarizeVoiceSessionBenchmark = (adapterId, scenarios) => {
+  const passCount = scenarios.filter((scenario) => scenario.passes).length;
+  const reconnectScenarios = scenarios.filter((scenario) => scenario.reconnectTriggered);
+  const reconnectSuccessCount = reconnectScenarios.filter((scenario) => scenario.passes).length;
+  const turnAccuracies = scenarios.flatMap((scenario) => scenario.turnResults.map((turn) => turn.accuracy?.wordErrorRate).filter((value) => typeof value === "number"));
+  return {
+    adapterId,
+    averageElapsedMs: roundMetric3(average2(scenarios.map((scenario) => scenario.elapsedMs)), 2),
+    averageWordErrorRate: roundMetric3(average2(turnAccuracies)),
+    duplicateTurnRate: roundMetric3(scenarios.length > 0 ? scenarios.filter((scenario) => scenario.duplicateTurnCount > 0).length / scenarios.length : 0),
+    passCount,
+    passRate: roundMetric3(scenarios.length > 0 ? passCount / scenarios.length : 0),
+    reconnectSuccessRate: roundMetric3(reconnectScenarios.length > 0 ? reconnectSuccessCount / reconnectScenarios.length : 1),
+    scenarioCount: scenarios.length,
+    scenariosWithDuplicateTurns: scenarios.filter((scenario) => scenario.duplicateTurnCount > 0).length,
+    scenariosWithTurnCountMismatch: scenarios.filter((scenario) => scenario.turnCountDelta !== 0).length
+  };
+};
+var summarizeVoiceSessionBenchmarkSeries = (input) => {
+  const scenarioMap = new Map;
+  for (const report of input.reports) {
+    for (const scenario of report.scenarios) {
+      const entries = scenarioMap.get(scenario.fixtureId) ?? [];
+      entries.push(scenario);
+      scenarioMap.set(scenario.fixtureId, entries);
+    }
+  }
+  const scenarioAggregates = [...scenarioMap.entries()].map(([fixtureId, results]) => {
+    const wordErrorRates = results.flatMap((scenario) => scenario.turnResults.map((turn) => turn.accuracy?.wordErrorRate).filter((value) => typeof value === "number"));
+    const reconnectRuns = results.filter((scenario) => scenario.reconnectTriggered);
+    const passCount = results.filter((scenario) => scenario.passes).length;
+    const sample = results[0];
+    return {
+      averageElapsedMs: roundMetric3(average2(results.map((scenario) => scenario.elapsedMs)), 2),
+      averageWordErrorRate: roundMetric3(average2(wordErrorRates)),
+      bestWordErrorRate: roundMetric3(wordErrorRates.length > 0 ? Math.min(...wordErrorRates) : 0),
+      fixtureId,
+      passCount,
+      passRate: roundMetric3(results.length > 0 ? passCount / results.length : 0),
+      reconnectSuccessRate: roundMetric3(reconnectRuns.length > 0 ? reconnectRuns.filter((scenario) => scenario.passes).length / reconnectRuns.length : 1),
+      runCount: results.length,
+      tags: sample.tags,
+      title: sample.title,
+      worstWordErrorRate: roundMetric3(wordErrorRates.length > 0 ? Math.max(...wordErrorRates) : 0)
+    };
+  });
+  const totalRunCount = input.reports.reduce((sum, report) => sum + report.scenarios.length, 0);
+  const totalPassCount = input.reports.reduce((sum, report) => sum + report.summary.passCount, 0);
+  const reconnectRates = scenarioAggregates.map((scenario) => scenario.reconnectSuccessRate).filter((value) => Number.isFinite(value));
+  return {
+    adapterId: input.adapterId,
+    generatedAt: Date.now(),
+    runCount: input.reports.length,
+    scenarios: scenarioAggregates,
+    summary: {
+      adapterId: input.adapterId,
+      averageElapsedMs: roundMetric3(average2(scenarioAggregates.map((scenario) => scenario.averageElapsedMs)), 2),
+      averagePassRate: roundMetric3(average2(scenarioAggregates.map((scenario) => scenario.passRate))),
+      averageWordErrorRate: roundMetric3(average2(scenarioAggregates.map((scenario) => scenario.averageWordErrorRate))),
+      flakyScenarioCount: scenarioAggregates.filter((scenario) => scenario.passRate > 0 && scenario.passRate < 1).length,
+      generatedRunCount: input.reports.length,
+      reconnectSuccessRate: roundMetric3(average2(reconnectRates)),
+      scenarioCount: scenarioAggregates.length,
+      stableScenarioCount: scenarioAggregates.filter((scenario) => scenario.passRate === 1).length,
+      totalPassCount,
+      totalRunCount
+    }
+  };
+};
+var runVoiceSessionBenchmark = async (input) => {
+  const scenarioResults = [];
+  for (const scenario of input.scenarios) {
+    scenarioResults.push(await runVoiceSessionBenchmarkScenario(input.adapter, scenario, {
+      correctTurn: input.correctTurn,
+      sttFallback: input.sttFallback,
+      trace: input.trace
+    }));
+  }
+  return {
+    adapterId: input.adapterId,
+    generatedAt: Date.now(),
+    scenarios: scenarioResults,
+    summary: summarizeVoiceSessionBenchmark(input.adapterId, scenarioResults)
+  };
+};
+var runVoiceSessionBenchmarkSeries = async (input) => {
+  const reports = [];
+  const runCount = Math.max(1, Math.floor(input.runs));
+  for (let runIndex = 0;runIndex < runCount; runIndex += 1) {
+    reports.push(await runVoiceSessionBenchmark({
+      adapter: input.adapter,
+      adapterId: input.adapterId,
+      correctTurn: input.correctTurn,
+      scenarios: input.scenarios,
+      sttFallback: input.sttFallback,
+      trace: input.trace
+    }));
+  }
+  return summarizeVoiceSessionBenchmarkSeries({
+    adapterId: input.adapterId,
+    reports
+  });
+};
 export {
+  summarizeVoiceSessionBenchmarkSeries,
+  summarizeVoiceSessionBenchmark,
   summarizeSTTBenchmark,
   scoreTranscriptAccuracy,
+  runVoiceSessionBenchmarkSeries,
+  runVoiceSessionBenchmarkScenario,
+  runVoiceSessionBenchmark,
+  runVoiceResilienceBenchmark,
   runSTTAdapterFixture,
   runSTTAdapterBenchmark,
+  resolveFixtureEnvironment,
   mergeFinalTranscriptText,
   loadVoiceTestFixtures,
   getVoiceFixtureDirectory,
+  evaluateSTTBenchmarkAcceptance,
   compareSTTBenchmarks
 };