@absolutejs/voice 0.0.22-beta.470 → 0.0.22-beta.472

package/dist/index.js

@@ -34851,6 +34851,280 @@ var createVoiceApiRequestTool = (options) => {
     resultToMessage: options.formatResult ?? ((result) => result.ok ? `API request ${options.name} succeeded (${String(result.status)}).` : `API request ${options.name} failed with status ${String(result.status)}.`)
   });
 };
+// src/vapiAdapter.ts
+var VAPI_BUILT_IN_VARIABLES = {
+  date: () => new Date().toISOString().slice(0, 10),
+  now: () => new Date().toISOString(),
+  time: () => new Date().toISOString().slice(11, 19)
+};
+var VAPI_TEMPLATE_REGEX = /\{\{\s*([^}|]+?)\s*(?:\|[^}]*)?\}\}/g;
+var VAPI_TEMPLATE_FILTER_REGEX = /\{\{[^}]*\|[^}]*\}\}/;
+var extractSystemPrompt = (model, fallback) => {
+  if (model?.systemPrompt)
+    return model.systemPrompt;
+  const systemMessage = model?.messages?.find((message) => message.role === "system" && typeof message.content === "string");
+  if (systemMessage?.content)
+    return systemMessage.content;
+  return fallback;
+};
+var compileVapiSystem = (template, variableResolver) => {
+  if (!template)
+    return;
+  if (!VAPI_TEMPLATE_REGEX.test(template)) {
+    return template;
+  }
+  VAPI_TEMPLATE_REGEX.lastIndex = 0;
+  return (input) => template.replace(VAPI_TEMPLATE_REGEX, (match, rawPath) => {
+    const path = rawPath.trim();
+    const builtIn = VAPI_BUILT_IN_VARIABLES[path];
+    if (builtIn) {
+      return builtIn({ context: input.context, session: input.session });
+    }
+    if (variableResolver) {
+      const resolved = variableResolver(path, input);
+      if (resolved !== undefined)
+        return String(resolved);
+    }
+    return match;
+  });
+};
+var httpMethodFor = (raw) => {
+  const upper = (raw ?? "GET").toUpperCase();
+  if (upper === "GET" || upper === "POST" || upper === "PUT" || upper === "DELETE" || upper === "PATCH") {
+    return upper;
+  }
+  return "GET";
+};
+var buildToolFromVapi = (raw, options, unsupported) => {
+  const type = raw.type ?? "function";
+  if (type === "endCall") {
+    return createVoiceEndCallTool({
+      description: raw.function?.description ?? raw.description,
+      name: raw.function?.name ?? "endCall"
+    });
+  }
+  if (type === "transferCall") {
+    const destinations = (raw.destinations ?? []).map((entry, index) => {
+      const target = entry.number ?? entry.sipUri;
+      if (!target)
+        return;
+      return {
+        description: entry.description,
+        id: target.replace(/[^a-zA-Z0-9_-]/g, "-") || `destination-${String(index)}`,
+        message: entry.message,
+        metadata: entry.metadata,
+        target
+      };
+    }).filter((entry) => entry !== undefined);
+    if (destinations.length === 0) {
+      unsupported.push({
+        detail: "transferCall tool has no usable destinations (need number or sipUri).",
+        field: "tools[].destinations"
+      });
+      return;
+    }
+    return createVoiceTransferCallTool({
+      description: raw.function?.description ?? raw.description,
+      destinations,
+      name: raw.function?.name ?? "transferCall"
+    });
+  }
+  if (type === "dtmf") {
+    const send = options.dtmfSendFactory?.({ raw });
+    if (!send) {
+      unsupported.push({
+        detail: "dtmf tool requires a dtmfSendFactory to map to the telephony adapter.",
+        field: "tools[].type=dtmf"
+      });
+      return;
+    }
+    return createVoiceDTMFTool({
+      description: raw.function?.description ?? raw.description,
+      name: raw.function?.name ?? "sendDTMF",
+      send
+    });
+  }
+  if (type === "voicemail") {
+    return createVoiceVoicemailDetectionTool({
+      description: raw.function?.description ?? raw.description,
+      name: raw.function?.name ?? "markVoicemail"
+    });
+  }
+  if (type === "apiRequest") {
+    if (!raw.url) {
+      unsupported.push({
+        detail: "apiRequest tool is missing url.",
+        field: "tools[].url"
+      });
+      return;
+    }
+    return createVoiceApiRequestTool({
+      description: raw.function?.description ?? raw.description ?? `Call ${raw.url}`,
+      fetch: options.fetch,
+      headers: raw.headers,
+      method: httpMethodFor(raw.method),
+      name: raw.function?.name ?? raw.name ?? "apiRequest",
+      parameters: raw.function?.parameters,
+      url: raw.url
+    });
+  }
+  if (type === "query") {
+    if (!options.knowledgeBase) {
+      unsupported.push({
+        detail: "query tool requires a knowledgeBase option (a VoiceRAGCollectionLike).",
+        field: "tools[].type=query"
+      });
+      return;
+    }
+    return createVoiceRAGTool(options.knowledgeBase.collection, {
+      description: raw.function?.description ?? raw.description,
+      name: raw.function?.name ?? "searchKnowledgeBase",
+      ...options.knowledgeBase.toolOptions ?? {}
+    });
+  }
+  if (type === "function") {
+    if (raw.server?.url) {
+      return createVoiceApiRequestTool({
+        description: raw.function?.description ?? raw.description ?? `Custom function tool (server: ${raw.server.url}).`,
+        fetch: options.fetch,
+        headers: raw.server.headers,
+        method: "POST",
+        name: raw.function?.name ?? raw.name ?? "customFunction",
+        parameters: raw.function?.parameters,
+        url: raw.server.url
+      });
+    }
+    const customTool = options.customToolFactory?.({ raw });
+    if (customTool)
+      return customTool;
+    unsupported.push({
+      detail: "function tool without server.url; provide customToolFactory to handle it.",
+      field: `tools[].name=${raw.function?.name ?? raw.name ?? "<unnamed>"}`
+    });
+    return;
+  }
+  unsupported.push({
+    detail: `Unrecognized Vapi tool type "${type}".`,
+    field: "tools[].type"
+  });
+  return;
+};
+var collectRouteHints = (config) => ({
+  backgroundDenoisingEnabled: config.backgroundDenoisingEnabled,
+  backgroundSound: config.backgroundSound,
+  endCallMessage: config.endCallMessage,
+  endCallPhrases: config.endCallPhrases,
+  firstMessage: config.firstMessage,
+  firstMessageMode: config.firstMessageMode,
+  hipaaEnabled: config.compliancePlan?.hipaaEnabled,
+  maxDurationSeconds: config.maxDurationSeconds,
+  pciEnabled: config.compliancePlan?.pciEnabled,
+  recordingEnabled: config.recordingEnabled,
+  silenceTimeoutSeconds: config.silenceTimeoutSeconds,
+  stt: config.transcriber ? {
+    confidenceThreshold: config.transcriber.confidenceThreshold,
+    language: config.transcriber.language,
+    model: config.transcriber.model,
+    provider: config.transcriber.provider
+  } : undefined,
+  tts: config.voice ? {
+    provider: config.voice.provider,
+    speed: config.voice.speed,
+    stability: config.voice.stability,
+    style: config.voice.style,
+    voiceId: config.voice.voiceId
+  } : undefined,
+  voicemailMessage: config.voicemailMessage
+});
+var collectAssistantLevelUnsupported = (config, unsupported, hasKnowledgeBaseOption) => {
+  if (config.knowledgeBaseId && !hasKnowledgeBaseOption) {
+    unsupported.push({
+      detail: "knowledgeBaseId is set but no knowledgeBase option was provided; configure one to surface a query tool.",
+      field: "knowledgeBaseId"
+    });
+  }
+  if (config.voicemailDetection?.provider) {
+    unsupported.push({
+      detail: "voicemailDetection.provider (ML detection) has no direct voice equivalent; wire your carrier's AMD callback and call VoiceSessionHandle.markVoicemail yourself.",
+      field: "voicemailDetection.provider"
+    });
+  }
+  if (config.startSpeakingPlan) {
+    unsupported.push({
+      detail: "startSpeakingPlan is a route-level concern; map it to the voice() plugin / barge-in config.",
+      field: "startSpeakingPlan"
+    });
+  }
+  if (config.stopSpeakingPlan) {
+    unsupported.push({
+      detail: "stopSpeakingPlan is a route-level concern; map it to the voice() plugin / barge-in config.",
+      field: "stopSpeakingPlan"
+    });
+  }
+  if (config.monitorPlan) {
+    unsupported.push({
+      detail: "monitorPlan (listenUrl / controlUrl) has no direct voice equivalent yet; use live-ops routes for control.",
+      field: "monitorPlan"
+    });
+  }
+  if (config.firstMessageMode) {
+    unsupported.push({
+      detail: `firstMessageMode "${config.firstMessageMode}" is a route concern; the system/firstMessage hints are in routeHints.`,
+      field: "firstMessageMode"
+    });
+  }
+  const systemPromptText = extractSystemPrompt(config.model, undefined);
+  if (systemPromptText && VAPI_TEMPLATE_FILTER_REGEX.test(systemPromptText)) {
+    unsupported.push({
+      detail: "system prompt uses LiquidJS filter syntax (e.g. {{ now | date: ... }}); only bare {{var}} expansion is auto-translated.",
+      field: "model.messages[0].content (filters)"
+    });
+  }
+};
+var fromVapiAssistantConfig = (config, options) => {
+  const unsupported = [];
+  const model = options.modelFactory({
+    model: config.model?.model,
+    provider: config.model?.provider,
+    raw: config.model ?? {},
+    temperature: config.model?.temperature
+  });
+  const system = compileVapiSystem(extractSystemPrompt(config.model, options.systemFallback), options.variableResolver);
+  const tools = [];
+  for (const raw of config.model?.tools ?? []) {
+    const tool = buildToolFromVapi(raw, options, unsupported);
+    if (tool)
+      tools.push(tool);
+  }
+  if (config.knowledgeBaseId && options.knowledgeBase) {
+    const alreadyHas = tools.some((tool) => tool.name === (options.knowledgeBase.toolOptions?.name ?? "searchKnowledgeBase"));
+    if (!alreadyHas) {
+      tools.push(createVoiceRAGTool(options.knowledgeBase.collection, options.knowledgeBase.toolOptions));
+    }
+  }
+  if (config.model?.toolIds && config.model.toolIds.length > 0) {
+    unsupported.push({
+      detail: "model.toolIds references saved Vapi tools; provide their definitions via tools[] or customToolFactory.",
+      field: "model.toolIds"
+    });
+  }
+  collectAssistantLevelUnsupported(config, unsupported, Boolean(options.knowledgeBase));
+  const assistantOptions = {
+    id: options.assistantId ?? "vapi-imported-assistant",
+    model,
+    system,
+    tools
+  };
+  const assistant = createVoiceAssistant(assistantOptions);
+  return {
+    assistant,
+    assistantOptions,
+    modelAgent: assistant.agent,
+    routeHints: collectRouteHints(config),
+    tools,
+    unsupported
+  };
+};
 // src/agentSquadContract.ts
 var normalizeIncludes = (value) => value.trim().toLowerCase();
 var resolveOutcome4 = (result) => {
@@ -43099,6 +43373,1087 @@ var createVoiceProofPackRoutes = (options) => {
   }
   return app;
 };
+// src/testing/fixtures.ts
+import { resolve as resolve2 } from "path";
+var JARGON_FIXTURE_IDS = [
+  "traveled-back-route-clean",
+  "dialogue-two-clean",
+  "dialogue-three-clean",
+  "dialogue-two-noisy",
+  "dialogue-three-mixed"
+];
+var DEFAULT_AUDIO_FORMAT = {
+  channels: 1,
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRateHz: 16000
+};
+var DEFAULT_TELEPHONY_SAMPLE_RATE_HZ = 8000;
+var DEFAULT_MULTI_SPEAKER_SILENCE_MS = 350;
+var FIXTURE_DIR_CANDIDATES = [
+  resolve2(import.meta.dir, "..", "..", "fixtures"),
+  resolve2(import.meta.dir, "..", "..", "..", "fixtures"),
+  resolve2(import.meta.dir, "..", "..", "..", "..", "fixtures")
+];
+var EXTERNAL_FIXTURE_ENV_KEYS = [
+  "VOICE_FIXTURE_DIR",
+  "VOICE_FIXTURE_DIRS"
+];
+var resolveFixtureDirectory = async () => {
+  for (const candidate of FIXTURE_DIR_CANDIDATES) {
+    if (await Bun.file(resolve2(candidate, "manifest.json")).exists()) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to locate the bundled voice test fixtures. Expected fixtures/manifest.json next to the package root.");
+};
+var getVoiceFixtureDirectory = async () => resolveFixtureDirectory();
+var toUniqueDirectories = (directories) => directories.filter((directory, index, list) => directory.trim().length > 0 && list.indexOf(directory) === index);
+var splitFixtureDirectoryValue = (value) => (value ?? "").split(/[\n,]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+var resolveFixtureInputDirectories = (input) => {
+  if (typeof input === "string") {
+    return [input];
+  }
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return input?.directories ?? [];
+};
+var shouldIncludeBundledFixtures = (input) => {
+  if (input && typeof input === "object" && !Array.isArray(input) && input.includeBundled === false) {
+    return false;
+  }
+  return true;
+};
+var resolveConfiguredFixtureDirectories = async (input) => {
+  const directories = [
+    ...resolveFixtureInputDirectories(input),
+    ...EXTERNAL_FIXTURE_ENV_KEYS.flatMap((key) => splitFixtureDirectoryValue(process.env[key]))
+  ];
+  const uniqueDirectories = toUniqueDirectories(directories.map((directory) => resolve2(directory)));
+  for (const directory of uniqueDirectories) {
+    const manifestExists = await Bun.file(resolve2(directory, "manifest.json")).exists();
+    if (!manifestExists) {
+      throw new Error(`Voice fixture directory "${directory}" is missing manifest.json.`);
+    }
+  }
+  return uniqueDirectories;
+};
+var resolveVoiceFixtureDirectories = async (input) => {
+  const directories = await resolveConfiguredFixtureDirectories(input);
+  if (!shouldIncludeBundledFixtures(input)) {
+    if (directories.length === 0) {
+      throw new Error("No voice fixture directories were configured. Provide directories or set VOICE_FIXTURE_DIR/VOICE_FIXTURE_DIRS.");
+    }
+    return directories;
+  }
+  return [await resolveFixtureDirectory(), ...directories];
+};
+var clampSample = (value) => Math.max(-32768, Math.min(32767, Math.round(value)));
+var toPcm16Samples = (audio) => new Int16Array(audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength));
+var toPcm16Bytes = (samples) => new Uint8Array(samples.buffer.slice(samples.byteOffset, samples.byteOffset + samples.byteLength));
+var createSilenceBytes = (sampleRateHz, durationMs) => new Uint8Array(Math.max(2, Math.round(sampleRateHz * 2 * durationMs / 1000)));
+var concatAudioChunks = (chunks) => {
+  const totalByteLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const output = new Uint8Array(totalByteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+};
+var resamplePcm16Mono = (samples, sourceRate, targetRate) => {
+  if (sourceRate === targetRate || samples.length === 0) {
+    return samples;
+  }
+  const ratio = targetRate / sourceRate;
+  const targetLength = Math.max(1, Math.round(samples.length * ratio));
+  const output = new Int16Array(targetLength);
+  for (let index = 0;index < targetLength; index += 1) {
+    const sourceIndex = index / ratio;
+    const previousIndex = Math.floor(sourceIndex);
+    const nextIndex = Math.min(previousIndex + 1, samples.length - 1);
+    const fraction = sourceIndex - previousIndex;
+    const previous = samples[previousIndex] ?? 0;
+    const next = samples[nextIndex] ?? previous;
+    output[index] = clampSample(previous + (next - previous) * fraction);
+  }
+  return output;
+};
+var toMuLaw = (sample) => {
+  const MU_LAW_MAX = 8191;
+  const MU_LAW_BIAS = 132;
+  const sign = sample < 0 ? 128 : 0;
+  const magnitude = Math.min(MU_LAW_MAX, Math.abs(sample) + MU_LAW_BIAS);
+  let exponent = 7;
+  for (let mask = 16384;(magnitude & mask) === 0 && exponent > 0; mask >>= 1) {
+    exponent -= 1;
+  }
+  const mantissa = magnitude >> exponent + 3 & 15;
+  return ~(sign | exponent << 4 | mantissa) & 255;
+};
+var fromMuLaw = (encoded) => {
+  const normalized = ~encoded & 255;
+  const sign = normalized & 128;
+  const exponent = normalized >> 4 & 7;
+  const mantissa = normalized & 15;
+  const magnitude = ((mantissa | 16) << exponent + 3) - 132;
+  return sign ? -magnitude : magnitude;
+};
+var applyTelephonyDegradation = (audio, format, targetSampleRateHz) => {
+  const sourceSamples = toPcm16Samples(audio);
+  const narrowbandSamples = resamplePcm16Mono(sourceSamples, format.sampleRateHz, targetSampleRateHz);
+  const degradedSamples = new Int16Array(narrowbandSamples.length);
+  for (let index = 0;index < narrowbandSamples.length; index += 1) {
+    const compressed = toMuLaw(narrowbandSamples[index] ?? 0);
+    degradedSamples[index] = clampSample(fromMuLaw(compressed) * 0.92);
+  }
+  return toPcm16Bytes(degradedSamples);
+};
+var shouldIncludeTelephonyFixture = (fixture, options) => {
+  const tags = new Set(fixture.tags ?? []);
+  if (!options.includeAccents && (tags.has("accent") || tags.has("speech-accent-archive"))) {
+    return false;
+  }
+  return true;
+};
+var createTelephonyVoiceTestFixtures = (fixtures, options = {}) => {
+  const targetSampleRateHz = options.targetSampleRateHz ?? DEFAULT_TELEPHONY_SAMPLE_RATE_HZ;
+  return fixtures.filter((fixture) => shouldIncludeTelephonyFixture(fixture, options)).map((fixture) => ({
+    ...fixture,
+    audio: applyTelephonyDegradation(fixture.audio, fixture.format, targetSampleRateHz),
+    format: {
+      ...fixture.format,
+      sampleRateHz: targetSampleRateHz
+    },
+    id: `${fixture.id}-telephony`,
+    tags: Array.from(new Set([...fixture.tags ?? [], "narrowband", "telephony"])),
+    title: `${fixture.title} (telephony narrowband)`
+  }));
+};
+var requireFixture = (fixtures, id) => {
+  const fixture = fixtures.find((entry) => entry.id === id);
+  if (!fixture) {
+    throw new Error(`Missing bundled voice fixture "${id}" required for multi-speaker benchmarks.`);
+  }
+  return fixture;
+};
+var createMultiSpeakerVoiceTestFixtures = (fixtures, options = {}) => {
+  const silenceMs = options.silenceMs ?? DEFAULT_MULTI_SPEAKER_SILENCE_MS;
+  const speakerA = requireFixture(fixtures, "quietly-alone-clean");
+  const speakerB = requireFixture(fixtures, "traveled-back-route-clean");
+  const speakerC = requireFixture(fixtures, "rainstorms-noisy");
+  const silence = createSilenceBytes(speakerA.format.sampleRateHz, silenceMs);
+  const handoff = concatAudioChunks([speakerA.audio, silence, speakerB.audio]);
+  const threeTurn = concatAudioChunks([
+    speakerA.audio,
+    silence,
+    speakerB.audio,
+    silence,
+    speakerC.audio
+  ]);
+  const buildTags = (...tags) => [
+    "multi-speaker",
+    "handoff",
+    "synthetic",
+    ...tags
+  ];
+  return [
+    {
+      ...speakerA,
+      audio: handoff,
+      audioPath: `${speakerA.audioPath}+${speakerB.audioPath}`,
+      expectedSpeakerTurns: [
+        { speaker: "speaker-a", text: speakerA.expectedText },
+        { speaker: "speaker-b", text: speakerB.expectedText }
+      ],
+      expectedTerms: Array.from(new Set([
+        ...speakerA.expectedTerms ?? [],
+        ...speakerB.expectedTerms ?? []
+      ])),
+      expectedText: `${speakerA.expectedText} ${speakerB.expectedText}`.trim(),
+      expectedTurnTexts: [speakerA.expectedText, speakerB.expectedText],
+      id: "multi-speaker-handoff-clean",
+      tags: buildTags("clean"),
+      title: "Synthetic two-speaker handoff"
+    },
+    {
+      ...speakerA,
+      audio: threeTurn,
+      audioPath: `${speakerA.audioPath}+${speakerB.audioPath}+${speakerC.audioPath}`,
+      expectedSpeakerTurns: [
+        { speaker: "speaker-a", text: speakerA.expectedText },
+        { speaker: "speaker-b", text: speakerB.expectedText },
+        { speaker: "speaker-c", text: speakerC.expectedText }
+      ],
+      expectedTerms: Array.from(new Set([
+        ...speakerA.expectedTerms ?? [],
+        ...speakerB.expectedTerms ?? [],
+        ...speakerC.expectedTerms ?? []
+      ])),
+      expectedText: `${speakerA.expectedText} ${speakerB.expectedText} ${speakerC.expectedText}`.trim(),
+      expectedTurnTexts: [
+        speakerA.expectedText,
+        speakerB.expectedText,
+        speakerC.expectedText
+      ],
+      id: "multi-speaker-handoff-three",
+      tags: buildTags("challenging", "noisy"),
+      title: "Synthetic three-speaker handoff (A-B-C)"
+    }
+  ];
+};
+var createJargonVoiceTestFixtures = (fixtures) => JARGON_FIXTURE_IDS.map((id) => requireFixture(fixtures, id)).filter((fixture) => (fixture.expectedTerms?.length ?? 0) > 0).map((fixture) => ({
+  ...fixture,
+  id: `${fixture.id}-jargon`,
+  tags: Array.from(new Set([...fixture.tags ?? [], "domain-heavy", "jargon"])),
+  title: `${fixture.title} (jargon)`
+}));
+var loadVoiceTestFixtures = async (fixtureDirectory) => {
+  const fixtureDirectories = await resolveVoiceFixtureDirectories(fixtureDirectory);
+  const fixtures = [];
+  const seenFixtureIds = new Set;
+  for (const directory of fixtureDirectories) {
+    const manifestFile = Bun.file(resolve2(directory, "manifest.json"));
+    const manifest = await manifestFile.json();
+    for (const entry of manifest) {
+      if (seenFixtureIds.has(entry.id)) {
+        throw new Error(`Duplicate voice fixture id "${entry.id}" found while loading "${directory}".`);
+      }
+      const audioPath = resolve2(directory, "pcm", entry.audioPath);
+      const audio = new Uint8Array(await Bun.file(audioPath).arrayBuffer());
+      fixtures.push({
+        ...entry,
+        audio,
+        audioPath,
+        format: {
+          ...DEFAULT_AUDIO_FORMAT,
+          ...entry.format
+        }
+      });
+      seenFixtureIds.add(entry.id);
+    }
+  }
+  return fixtures;
+};
+
+// src/testing/accuracy.ts
+var normalizeAccuracyText = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
+var levenshteinDistance2 = (left, right) => {
+  if (left.length === 0) {
+    return right.length;
+  }
+  if (right.length === 0) {
+    return left.length;
+  }
+  const previous = new Array(right.length + 1).fill(0);
+  const current = new Array(right.length + 1).fill(0);
+  for (let column = 0;column <= right.length; column += 1) {
+    previous[column] = column;
+  }
+  for (let row = 1;row <= left.length; row += 1) {
+    current[0] = row;
+    for (let column = 1;column <= right.length; column += 1) {
+      const substitutionCost = left[row - 1] === right[column - 1] ? 0 : 1;
+      current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + substitutionCost);
+    }
+    for (let column = 0;column <= right.length; column += 1) {
+      previous[column] = current[column];
+    }
+  }
+  return previous[right.length];
+};
+var mergeFinalTranscriptText = (transcripts) => buildTurnText(transcripts.filter((transcript) => transcript.isFinal), "");
+var scoreTranscriptAccuracy = (actualText, expectedText, threshold = 0.35) => {
+  const normalizedActual = normalizeAccuracyText(actualText);
+  const normalizedExpected = normalizeAccuracyText(expectedText);
+  const actualWords = normalizedActual ? normalizedActual.split(" ") : [];
+  const expectedWords = normalizedExpected ? normalizedExpected.split(" ") : [];
+  const wordDistance = levenshteinDistance2(actualWords, expectedWords);
+  const charDistance = levenshteinDistance2(Array.from(normalizedActual), Array.from(normalizedExpected));
+  const wordErrorRate = expectedWords.length > 0 ? wordDistance / expectedWords.length : 0;
+  const charErrorRate = normalizedExpected.length > 0 ? charDistance / normalizedExpected.length : 0;
+  return {
+    actualText: normalizedActual,
+    charDistance,
+    charErrorRate,
+    expectedText: normalizedExpected,
+    passesThreshold: wordErrorRate <= threshold,
+    threshold,
+    wordDistance,
+    wordErrorRate
+  };
+};
+
+// src/testing/stt.ts
+var chunkAudio = (audio, bytesPerChunk) => {
+  const chunks = [];
+  for (let offset = 0;offset < audio.byteLength; offset += bytesPerChunk) {
+    chunks.push(audio.slice(offset, offset + bytesPerChunk));
+  }
+  return chunks;
+};
+var createSilence = (byteLength3) => new Uint8Array(byteLength3);
+var waitForIdle = async (readLastActivityAt, idleTimeoutMs, settleMs) => {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < idleTimeoutMs) {
+    if (Date.now() - readLastActivityAt() >= settleMs) {
+      return;
+    }
+    await Bun.sleep(Math.min(50, settleMs));
+  }
+};
+var runSTTAdapterFixture = async (adapter, fixture, options = {}) => {
+  const startedAt = Date.now();
+  const partialEvents = [];
+  const finalEvents = [];
+  const endOfTurnEvents = [];
+  const errorEvents = [];
+  const closeEvents = [];
+  const chunkDurationMs = options.chunkDurationMs ?? fixture.chunkDurationMs ?? 100;
+  const tailPaddingMs = options.tailPaddingMs ?? fixture.tailPaddingMs ?? 1000;
+  const idleTimeoutMs = options.idleTimeoutMs ?? 8000;
+  const settleMs = options.settleMs ?? 500;
+  const waitForRealtimeMs = options.waitForRealtimeMs ?? 0;
+  let lastActivityAt = Date.now();
+  let speechEndedAt = startedAt;
+  const markActive = () => {
+    lastActivityAt = Date.now();
+  };
+  const resolvedOpenOptions = typeof options.openOptions === "function" ? options.openOptions(fixture) : options.openOptions;
+  const session = await adapter.open({
+    format: fixture.format,
+    sessionId: `fixture-${fixture.id}`,
+    ...resolvedOpenOptions ?? {}
+  });
+  const unsubscribers = [
+    session.on("partial", (event) => {
+      partialEvents.push(event);
+      markActive();
+    }),
+    session.on("final", (event) => {
+      finalEvents.push(event);
+      markActive();
+    }),
+    session.on("endOfTurn", (event) => {
+      endOfTurnEvents.push(event);
+      markActive();
+    }),
+    session.on("error", (event) => {
+      errorEvents.push(event);
+      markActive();
+    }),
+    session.on("close", (event) => {
+      closeEvents.push(event);
+      markActive();
+    })
+  ];
+  try {
+    const bytesPerMillisecond = fixture.format.sampleRateHz * fixture.format.channels * 2 / 1000;
+    const bytesPerChunk = Math.max(2, Math.floor(bytesPerMillisecond * chunkDurationMs));
+    const chunks = chunkAudio(fixture.audio, bytesPerChunk);
+    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);
+      }
+    }
+    await waitForIdle(() => lastActivityAt, idleTimeoutMs, settleMs);
+  } finally {
+    await session.close("fixture-complete");
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe();
+    }
+  }
+  const finalTranscripts = finalEvents.map((event) => ({
+    ...event.transcript,
+    endedAtMs: event.receivedAt - startedAt,
+    startedAtMs: event.receivedAt - startedAt
+  }));
+  const trailingPartial = [...partialEvents].reverse().find((event) => {
+    const text = event.transcript.text.trim();
+    if (!text) {
+      return false;
+    }
+    const lastFinalReceivedAt = finalEvents.at(-1)?.receivedAt ?? 0;
+    return event.receivedAt >= lastFinalReceivedAt;
+  });
+  const finalText = trailingPartial && finalTranscripts.length > 0 ? buildTurnText(finalTranscripts, trailingPartial.transcript.text, {
+    partialEndedAtMs: trailingPartial.receivedAt - startedAt,
+    partialStartedAtMs: trailingPartial.receivedAt - startedAt
+  }) : mergeFinalTranscriptText(finalTranscripts);
+  return {
+    accuracy: scoreTranscriptAccuracy(finalText, fixture.expectedText, options.transcriptThreshold),
+    closeEvents,
+    endOfTurnEvents,
+    errorEvents,
+    finalEvents,
+    finalText,
+    partialEvents,
+    speechEndedAt,
+    startedAt
+  };
+};
+
+// src/testing/benchmark.ts
+var resolveFixtureEnvironment = (fixture) => {
+  const tags = new Set(fixture.tags ?? []);
+  if (tags.has("telephony")) {
+    return "telephony";
+  }
+  if (tags.has("code-switch") || tags.has("code_switch")) {
+    return "code-switch";
+  }
+  if (tags.has("multi-speaker")) {
+    return "multi-speaker";
+  }
+  if (tags.has("jargon") || tags.has("domain-heavy")) {
+    return "jargon";
+  }
+  const hasAccent = tags.has("accent") || tags.has("speech-accent-archive");
+  const hasNoisy = tags.has("noisy") || tags.has("synthetic-noise") || tags.has("stress");
+  const language = fixture.language?.trim().toLowerCase();
+  const hasNonEnglishLanguage = typeof language === "string" && language.length > 0 && !language.startsWith("en");
+  const isMultilingual = tags.has("multilingual") || tags.has("bilingual") || hasNonEnglishLanguage;
+  if (hasAccent && hasNoisy) {
+    return "accent-noisy";
+  }
+  if (isMultilingual) {
+    return "multilingual";
+  }
+  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);
+  const normalizedExpectedTerms = (expectedTerms ?? []).map((entry) => normalizeBenchmarkText(entry));
+  const matchedTerms = normalizedExpectedTerms.filter((term) => term.length > 0 && normalizedActual.includes(term));
+  const missingTerms = normalizedExpectedTerms.filter((term) => term.length > 0 && !matchedTerms.includes(term));
+  const denominator = normalizedExpectedTerms.length;
+  const recall = denominator > 0 ? matchedTerms.length / denominator : 1;
+  return {
+    allMatched: missingTerms.length === 0,
+    expectedTerms: normalizedExpectedTerms,
+    matchedTerms,
+    missingTerms,
+    recall
+  };
+};
+var toPatternKeys = (speakers) => {
+  const mapping = new Map;
+  let nextKey = 0;
+  return speakers.map((speaker) => {
+    const key = String(speaker);
+    if (!mapping.has(key)) {
+      mapping.set(key, nextKey);
+      nextKey += 1;
+    }
+    return mapping.get(key);
+  });
+};
+var countNormalizedWords = (value) => normalizeBenchmarkText(value).split(" ").filter((token) => token.length > 0);
+var computeWordOverlap = (left, right) => {
+  const leftWords = new Set(countNormalizedWords(left));
+  const rightWords = new Set(countNormalizedWords(right));
+  if (leftWords.size === 0 || rightWords.size === 0) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const word of leftWords) {
+    if (rightWords.has(word)) {
+      overlap += 1;
+    }
+  }
+  return overlap / Math.max(leftWords.size, rightWords.size);
+};
+var repairSpeakerTurnReentry = (fixture, turns) => {
+  const expectedTurns = fixture.expectedSpeakerTurns ?? [];
+  const tags = new Set((fixture.tags ?? []).map((tag) => tag.trim().toLowerCase()));
+  if (expectedTurns.length < 3 || !tags.has("synthetic") || !tags.has("handoff")) {
+    return {
+      postClustered: false,
+      turns
+    };
+  }
+  const repairedTurns = turns.map((turn) => ({ ...turn }));
+  const firstTurnBySpeaker = new Map;
+  const seenRepairedSpeakers = new Set;
+  let postClustered = false;
+  let syntheticSpeakerIndex = 0;
+  for (let index = 0;index < repairedTurns.length; index += 1) {
+    const turn = repairedTurns[index];
+    const speakerKey = turn.speaker === undefined ? undefined : String(turn.speaker);
+    const previousTurn = repairedTurns[index - 1];
+    const previousSpeakerKey = previousTurn?.speaker === undefined ? undefined : String(previousTurn.speaker);
+    if (speakerKey === undefined) {
+      continue;
+    }
+    if (!firstTurnBySpeaker.has(speakerKey)) {
+      firstTurnBySpeaker.set(speakerKey, turn);
+    }
+    seenRepairedSpeakers.add(String(turn.speaker));
+    const originalSpeakerTurn = firstTurnBySpeaker.get(speakerKey);
+    const speakerReentered = previousSpeakerKey !== undefined && previousSpeakerKey !== speakerKey && index > 1;
+    const needsAdditionalSpeaker = seenRepairedSpeakers.size < expectedTurns.length;
+    const sameSpeakerOverlap = computeWordOverlap(turn.text, originalSpeakerTurn.text);
+    const currentWordCount = countNormalizedWords(turn.text).length;
+    if (speakerReentered && needsAdditionalSpeaker && currentWordCount >= 4 && sameSpeakerOverlap < 0.35) {
+      turn.speaker = `postcluster-${syntheticSpeakerIndex}`;
+      seenRepairedSpeakers.add(String(turn.speaker));
+      syntheticSpeakerIndex += 1;
+      postClustered = true;
+    }
+  }
+  return {
+    postClustered,
+    turns: repairedTurns
+  };
+};
+var scoreSpeakerTurns = (fixture, result) => {
+  const expectedTurns = fixture.expectedSpeakerTurns ?? [];
+  if (expectedTurns.length === 0) {
+    return;
+  }
+  const actualTurns = result.finalEvents.map((event) => ({
+    speaker: event.transcript.speaker,
+    text: event.transcript.text.trim()
+  })).filter((turn) => turn.text.length > 0);
+  const collapsedActualTurns = actualTurns.reduce((merged, turn) => {
+    const previous = merged[merged.length - 1];
+    if (previous && previous.speaker !== undefined && turn.speaker !== undefined && String(previous.speaker) === String(turn.speaker)) {
+      previous.text = `${previous.text} ${turn.text}`.trim();
+      return merged;
+    }
+    merged.push({ ...turn });
+    return merged;
+  }, []);
+  const repaired = repairSpeakerTurnReentry(fixture, collapsedActualTurns);
+  const scoredTurns = repaired.turns;
+  const available = scoredTurns.every((turn) => turn.speaker !== undefined);
+  if (!available) {
+    return {
+      available: false,
+      actualTurnCount: scoredTurns.length,
+      expectedTurnCount: expectedTurns.length,
+      passes: false,
+      patternMatchRate: 0,
+      postClustered: repaired.postClustered
+    };
+  }
+  const actualPattern = toPatternKeys(scoredTurns.map((turn) => turn.speaker));
+  const expectedPattern = toPatternKeys(expectedTurns.map((turn) => turn.speaker));
+  const maxLength = Math.max(actualPattern.length, expectedPattern.length, 1);
+  let matches = 0;
+  for (let index = 0;index < Math.min(actualPattern.length, expectedPattern.length); index += 1) {
+    if (actualPattern[index] === expectedPattern[index]) {
+      matches += 1;
+    }
+  }
+  const patternMatchRate = roundMetric4(matches / maxLength) ?? 0;
+  return {
+    available: true,
+    actualTurnCount: scoredTurns.length,
+    expectedTurnCount: expectedTurns.length,
+    passes: scoredTurns.length === expectedTurns.length && patternMatchRate === 1,
+    patternMatchRate,
+    postClustered: repaired.postClustered
+  };
+};
+var average2 = (values) => {
+  const filtered = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (filtered.length === 0) {
+    return;
+  }
+  return filtered.reduce((sum, value) => sum + value, 0) / filtered.length;
+};
+var roundMetric4 = (value, digits = 4) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return;
+  }
+  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 = average2(results.map((result) => result.accuracy.wordErrorRate)) ?? 0;
+    const averageTermRecall = average2(results.map((result) => result.expectedTerms.recall)) ?? 0;
+    const averageElapsedMs = average2(results.map((result) => result.elapsedMs));
+    const averageSpeakerTurnMatchRate = average2(results.map((result) => result.speakerTurns?.patternMatchRate));
+    const accuracy = 1 - averageWordErrorRate;
+    return {
+      averageElapsedMs: roundMetric4(averageElapsedMs, 2) ?? 0,
+      averageSpeakerTurnMatchRate: roundMetric4(averageSpeakerTurnMatchRate),
+      averageTermRecall: roundMetric4(averageTermRecall) ?? 0,
+      averageWordErrorRate: roundMetric4(averageWordErrorRate) ?? 0,
+      fixturesWithErrors: results.filter((fixture) => fixture.errorCount > 0).length,
+      fixturesWithFragments: results.filter((fixture) => fixture.fragmentationCount > 0).length,
+      fixtureCount,
+      group,
+      passCount,
+      passRate: fixtureCount > 0 ? roundMetric4(passCount / fixtureCount) ?? 0 : 0,
+      wordAccuracyRate: roundMetric4(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);
+  const speakerTurns = scoreSpeakerTurns(fixture, result);
+  return {
+    accuracy: result.accuracy,
+    closeCount: result.closeEvents.length,
+    difficulty: fixture.difficulty,
+    elapsedMs,
+    endOfTurnCount: result.endOfTurnEvents.length,
+    errorCount: result.errorEvents.length,
+    expectedTerms,
+    finalCount: result.finalEvents.length,
+    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 && (speakerTurns ? speakerTurns.passes : true),
+    partialCount: result.partialEvents.length,
+    speakerTurns,
+    postSpeechTimeToEndOfTurnMs,
+    postSpeechTimeToFirstFinalMs,
+    tags: fixture.tags ?? [],
+    timeToEndOfTurnMs,
+    timeToFirstFinalMs,
+    timeToFirstPartialMs,
+    title: fixture.title
+  };
+};
+var summarizeSTTBenchmark = (adapterId, fixtures) => {
+  const fixtureCount = fixtures.length;
+  const passCount = fixtures.filter((fixture) => fixture.passes).length;
+  return {
+    adapterId,
+    averageCharErrorRate: roundMetric4(average2(fixtures.map((fixture) => fixture.accuracy.charErrorRate))) ?? 0,
+    averageElapsedMs: roundMetric4(average2(fixtures.map((fixture) => fixture.elapsedMs)), 2) ?? 0,
+    averageEndOfTurnCount: roundMetric4(average2(fixtures.map((fixture) => fixture.endOfTurnCount)), 2) ?? 0,
+    averageFinalCount: roundMetric4(average2(fixtures.map((fixture) => fixture.finalCount)), 2) ?? 0,
+    averageSpeakerTurnMatchRate: roundMetric4(average2(fixtures.map((fixture) => fixture.speakerTurns?.patternMatchRate))),
+    averageTermRecall: roundMetric4(average2(fixtures.map((fixture) => fixture.expectedTerms.recall))) ?? 0,
+    averagePostSpeechTimeToEndOfTurnMs: roundMetric4(average2(fixtures.map((fixture) => fixture.postSpeechTimeToEndOfTurnMs)), 2),
+    averagePostSpeechTimeToFirstFinalMs: roundMetric4(average2(fixtures.map((fixture) => fixture.postSpeechTimeToFirstFinalMs)), 2),
+    averageTimeToEndOfTurnMs: roundMetric4(average2(fixtures.map((fixture) => fixture.timeToEndOfTurnMs)), 2),
+    averageTimeToFirstFinalMs: roundMetric4(average2(fixtures.map((fixture) => fixture.timeToFirstFinalMs)), 2),
+    averageTimeToFirstPartialMs: roundMetric4(average2(fixtures.map((fixture) => fixture.timeToFirstPartialMs)), 2),
+    averageWordErrorRate: roundMetric4(average2(fixtures.map((fixture) => fixture.accuracy.wordErrorRate))) ?? 0,
+    fixtureCount,
+    fixturesWithErrors: fixtures.filter((fixture) => fixture.errorCount > 0).length,
+    fixturesWithFragmentation: fixtures.filter((fixture) => fixture.fragmentationCount > 0).length,
+    groupSummaries: calculateGroupSummary(fixtures),
+    passCount,
+    passRate: fixtureCount > 0 ? roundMetric4(passCount / fixtureCount) ?? 0 : 0,
+    totalErrorCount: fixtures.reduce((sum, fixture) => sum + fixture.errorCount, 0),
+    wordAccuracyRate: fixtureCount > 0 ? roundMetric4(1 - (average2(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 = roundMetric4(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,
+    summary: report.summary
+  }));
+  const bestByMetric = (selectMetric, direction) => entries.reduce((best, entry) => {
+    if (!best) {
+      return entry;
+    }
+    const next = selectMetric(entry);
+    const current = selectMetric(best);
+    if (direction === "max" ? next > current : next < current) {
+      return entry;
+    }
+    return best;
+  }, undefined);
+  return {
+    bestByPassRate: bestByMetric((entry) => entry.summary.passRate, "max"),
+    bestByTermRecall: bestByMetric((entry) => entry.summary.averageTermRecall, "max"),
+    bestByWordErrorRate: bestByMetric((entry) => entry.summary.averageWordErrorRate, "min"),
+    entries
+  };
+};
+var runSTTAdapterBenchmark = async ({
+  adapter,
+  adapterId,
+  fixtures,
+  options = {}
+}) => {
+  const results = [];
+  for (const fixture of fixtures) {
+    const startedAt = Date.now();
+    const fixtureResult = await runSTTAdapterFixture(adapter, fixture, {
+      ...options,
+      ...options.fixtureOptions?.[fixture.id] ?? {}
+    });
+    results.push(toFixtureBenchmarkResult(fixture, fixtureResult, Date.now() - startedAt));
+  }
+  return {
+    adapterId,
+    fixtures: results,
+    generatedAt: Date.now(),
+    summary: summarizeSTTBenchmark(adapterId, results)
+  };
+};
+var summarizeSTTBenchmarkSeries = (input) => {
+  const fixtureMap = new Map;
+  for (const report of input.reports) {
+    for (const fixture of report.fixtures) {
+      const entries = fixtureMap.get(fixture.fixtureId) ?? [];
+      entries.push(fixture);
+      fixtureMap.set(fixture.fixtureId, entries);
+    }
+  }
+  const fixtureAggregates = [...fixtureMap.entries()].map(([fixtureId, results]) => {
+    const wordErrorRates = results.map((result) => result.accuracy.wordErrorRate);
+    const passCount = results.filter((result) => result.passes).length;
+    const sample = results[0];
+    return {
+      averageElapsedMs: roundMetric4(average2(results.map((result) => result.elapsedMs)), 2) ?? 0,
+      averagePassRate: roundMetric4(results.length > 0 ? passCount / results.length : 0) ?? 0,
+      averageWordErrorRate: roundMetric4(average2(wordErrorRates)) ?? 0,
+      bestWordErrorRate: roundMetric4(wordErrorRates.length > 0 ? Math.min(...wordErrorRates) : 0) ?? 0,
+      fixtureId,
+      group: sample.group,
+      passCount,
+      runCount: results.length,
+      tags: sample.tags,
+      title: sample.title,
+      worstWordErrorRate: roundMetric4(wordErrorRates.length > 0 ? Math.max(...wordErrorRates) : 0) ?? 0
+    };
+  });
+  const totalRunCount = input.reports.reduce((sum, report) => sum + report.fixtures.length, 0);
+  const totalPassCount = input.reports.reduce((sum, report) => sum + report.summary.passCount, 0);
+  return {
+    adapterId: input.adapterId,
+    fixtures: fixtureAggregates,
+    generatedAt: Date.now(),
+    runCount: input.reports.length,
+    summary: {
+      adapterId: input.adapterId,
+      averageElapsedMs: roundMetric4(average2(fixtureAggregates.map((fixture) => fixture.averageElapsedMs)), 2) ?? 0,
+      averagePassRate: roundMetric4(average2(fixtureAggregates.map((fixture) => fixture.averagePassRate))) ?? 0,
+      averageWordErrorRate: roundMetric4(average2(fixtureAggregates.map((fixture) => fixture.averageWordErrorRate))) ?? 0,
+      fixtureCount: fixtureAggregates.length,
+      flakyFixtureCount: fixtureAggregates.filter((fixture) => fixture.averagePassRate > 0 && fixture.averagePassRate < 1).length,
+      generatedRunCount: input.reports.length,
+      stableFixtureCount: fixtureAggregates.filter((fixture) => fixture.averagePassRate === 1).length,
+      totalPassCount,
+      totalRunCount
+    }
+  };
+};
+var runSTTAdapterBenchmarkSeries = async ({
+  adapter,
+  adapterId,
+  fixtures,
+  options = {},
+  runs
+}) => {
+  const reports = [];
+  const runCount = Math.max(1, Math.floor(runs));
+  for (let runIndex = 0;runIndex < runCount; runIndex += 1) {
+    reports.push(await runSTTAdapterBenchmark({
+      adapter,
+      adapterId,
+      fixtures,
+      options
+    }));
+  }
+  return summarizeSTTBenchmarkSeries({
+    adapterId,
+    reports
+  });
+};
+
+// src/multilingualProof.ts
+var average3 = (values) => {
+  if (values.length === 0)
+    return 0;
+  let total = 0;
+  for (const value of values)
+    total += value;
+  return total / values.length;
+};
+var computeMetrics = (results) => {
+  if (results.length === 0) {
+    return {
+      averageTermRecall: 0,
+      averageWordAccuracyRate: 0,
+      averageWordErrorRate: 0,
+      fixtureCount: 0,
+      passCount: 0,
+      passRate: 0
+    };
+  }
+  const wordErrorRates = results.map((result) => result.accuracy.wordErrorRate ?? 0);
+  const wordAccuracyRates = results.map((result) => 1 - (result.accuracy.wordErrorRate ?? 0));
+  const termRecalls = results.map((result) => result.expectedTerms.recall ?? 0);
+  const passCount = results.filter((result) => result.passes).length;
+  return {
+    averageTermRecall: average3(termRecalls),
+    averageWordAccuracyRate: average3(wordAccuracyRates),
+    averageWordErrorRate: average3(wordErrorRates),
+    fixtureCount: results.length,
+    passCount,
+    passRate: passCount / results.length
+  };
+};
+var resolveLanguageThreshold = (language, defaults, perLanguage) => {
+  const explicit = perLanguage?.find((entry) => entry.language.toLowerCase() === language.toLowerCase());
+  return {
+    label: explicit?.label,
+    language,
+    maxAverageWordErrorRate: explicit?.maxAverageWordErrorRate ?? defaults?.maxAverageWordErrorRate,
+    minAverageWordAccuracyRate: explicit?.minAverageWordAccuracyRate ?? defaults?.minAverageWordAccuracyRate,
+    minPassRate: explicit?.minPassRate ?? defaults?.minPassRate,
+    minTermRecall: explicit?.minTermRecall ?? defaults?.minTermRecall
+  };
+};
+var evaluateLanguage = (language, fixtureResults, thresholds) => {
+  const metrics = computeMetrics(fixtureResults);
+  const failures = [];
+  if (thresholds.maxAverageWordErrorRate !== undefined && metrics.averageWordErrorRate > thresholds.maxAverageWordErrorRate) {
+    failures.push(`${language}: avg WER ${metrics.averageWordErrorRate.toFixed(3)} exceeds budget ${thresholds.maxAverageWordErrorRate.toFixed(3)}.`);
+  }
+  if (thresholds.minAverageWordAccuracyRate !== undefined && metrics.averageWordAccuracyRate < thresholds.minAverageWordAccuracyRate) {
+    failures.push(`${language}: avg WAR ${metrics.averageWordAccuracyRate.toFixed(3)} below floor ${thresholds.minAverageWordAccuracyRate.toFixed(3)}.`);
+  }
+  if (thresholds.minPassRate !== undefined && metrics.passRate < thresholds.minPassRate) {
+    failures.push(`${language}: pass rate ${metrics.passRate.toFixed(3)} below floor ${thresholds.minPassRate.toFixed(3)}.`);
+  }
+  if (thresholds.minTermRecall !== undefined && metrics.averageTermRecall < thresholds.minTermRecall) {
+    failures.push(`${language}: term recall ${metrics.averageTermRecall.toFixed(3)} below floor ${thresholds.minTermRecall.toFixed(3)}.`);
+  }
+  return {
+    applied: thresholds,
+    failures,
+    fixtureIds: fixtureResults.map((result) => result.fixtureId),
+    label: thresholds.label,
+    language,
+    metrics,
+    passes: failures.length === 0
+  };
+};
+var collectFixtures = async (options) => {
+  if (options.fixtures !== undefined) {
+    return options.fixtures.slice();
+  }
+  const loaded = await loadVoiceTestFixtures(options.fixtureDirectories);
+  return options.filter ? loaded.filter(options.filter) : loaded;
+};
+var groupByLanguage = (results, fixtures) => {
+  const lookup = new Map;
+  for (const fixture of fixtures) {
+    lookup.set(fixture.id, fixture.language ?? "unknown");
+  }
+  const grouped = new Map;
+  for (const result of results) {
+    const language = lookup.get(result.fixtureId) ?? "unknown";
+    const bucket = grouped.get(language) ?? [];
+    bucket.push(result);
+    grouped.set(language, bucket);
+  }
+  return grouped;
+};
+var runVoiceMultilingualProof = async (options) => {
+  if (options.adapters.length === 0) {
+    throw new Error("runVoiceMultilingualProof requires at least one adapter entry.");
+  }
+  const fixtures = await collectFixtures(options);
+  if (fixtures.length === 0) {
+    throw new Error("runVoiceMultilingualProof found zero fixtures. Did you set VOICE_FIXTURE_DIR or pass fixtures/fixtureDirectories?");
+  }
+  const languageCodes = new Set(fixtures.map((fixture) => fixture.language ?? "unknown"));
+  const adapterReports = [];
+  for (const entry of options.adapters) {
+    const benchmark = await runSTTAdapterBenchmark({
+      adapter: entry.adapter,
+      adapterId: entry.adapterId,
+      fixtures,
+      options: entry.benchmarkOptions
+    });
+    const grouped = groupByLanguage(benchmark.fixtures, fixtures);
+    const languageReports = [];
+    for (const language of languageCodes) {
+      const bucket = grouped.get(language) ?? [];
+      if (bucket.length === 0)
+        continue;
+      const thresholds = resolveLanguageThreshold(language, options.defaultThresholds, options.perLanguage);
+      languageReports.push(evaluateLanguage(language, bucket, thresholds));
+    }
+    const overall = computeMetrics(benchmark.fixtures);
+    const failures = languageReports.flatMap((report) => report.failures);
+    adapterReports.push({
+      adapterId: entry.adapterId,
+      benchmark,
+      failures,
+      fixtureCount: benchmark.fixtures.length,
+      languageReports,
+      overall,
+      passes: failures.length === 0
+    });
+  }
+  const failedAdapters = adapterReports.filter((report) => !report.passes).map((report) => report.adapterId);
+  return {
+    adapters: adapterReports,
+    generatedAt: Date.now(),
+    passes: failedAdapters.length === 0,
+    summary: {
+      adapterCount: adapterReports.length,
+      failedAdapters,
+      fixtureCount: fixtures.length,
+      languageCount: languageCodes.size
+    }
+  };
+};
+var renderVoiceMultilingualProofMarkdown = (report) => {
+  const lines = [
+    `# Voice Multilingual STT Proof`,
+    "",
+    `Generated: ${new Date(report.generatedAt).toISOString()}`,
+    `Status: ${report.passes ? "**PASS**" : "**FAIL**"}`,
+    `Adapters: ${String(report.summary.adapterCount)}; Fixtures: ${String(report.summary.fixtureCount)}; Languages: ${String(report.summary.languageCount)}.`,
+    ""
+  ];
+  if (report.summary.failedAdapters.length > 0) {
+    lines.push(`Failed adapters: ${report.summary.failedAdapters.join(", ")}.`, "");
+  }
+  for (const adapter of report.adapters) {
+    lines.push(`## ${adapter.adapterId} \u2014 ${adapter.passes ? "pass" : "fail"}`, "", `- Fixtures: ${String(adapter.fixtureCount)}`, `- Avg WER: ${adapter.overall.averageWordErrorRate.toFixed(3)}`, `- Avg WAR: ${adapter.overall.averageWordAccuracyRate.toFixed(3)}`, `- Pass rate: ${(adapter.overall.passRate * 100).toFixed(1)}%`, "", `| Language | Fixtures | Avg WER | Avg WAR | Pass rate | Threshold | Status |`, `| --- | ---: | ---: | ---: | ---: | --- | --- |`);
+    for (const language of adapter.languageReports) {
+      const threshold = [];
+      if (language.applied.maxAverageWordErrorRate !== undefined) {
+        threshold.push(`WER<=${language.applied.maxAverageWordErrorRate.toFixed(3)}`);
+      }
+      if (language.applied.minAverageWordAccuracyRate !== undefined) {
+        threshold.push(`WAR>=${language.applied.minAverageWordAccuracyRate.toFixed(3)}`);
+      }
+      if (language.applied.minPassRate !== undefined) {
+        threshold.push(`pass>=${language.applied.minPassRate.toFixed(3)}`);
+      }
+      if (language.applied.minTermRecall !== undefined) {
+        threshold.push(`recall>=${language.applied.minTermRecall.toFixed(3)}`);
+      }
+      lines.push(`| ${language.language}${language.label ? ` (${language.label})` : ""} | ${String(language.metrics.fixtureCount)} | ${language.metrics.averageWordErrorRate.toFixed(3)} | ${language.metrics.averageWordAccuracyRate.toFixed(3)} | ${(language.metrics.passRate * 100).toFixed(1)}% | ${threshold.join(", ") || "\u2014"} | ${language.passes ? "pass" : "fail"} |`);
+    }
+    if (adapter.failures.length > 0) {
+      lines.push("", "Failures:");
+      for (const failure of adapter.failures) {
+        lines.push(`- ${failure}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+};
+var buildVoiceMultilingualProofReadinessCheck = (report, options = {}) => {
+  const label = options.label ?? "Multilingual STT proof";
+  if (report.adapters.length === 0) {
+    return {
+      detail: "No STT adapters were exercised against the multilingual corpus.",
+      href: options.baseHref,
+      label,
+      status: "warn",
+      value: 0
+    };
+  }
+  const failedAdapters = report.summary.failedAdapters;
+  if (failedAdapters.length === 0) {
+    const passingDetail = report.adapters.map((adapter) => `${adapter.adapterId}: WER ${adapter.overall.averageWordErrorRate.toFixed(3)} across ${String(adapter.fixtureCount)} fixtures`).join("; ");
+    return {
+      detail: passingDetail,
+      href: options.baseHref,
+      label,
+      status: "pass",
+      value: report.summary.adapterCount
+    };
+  }
+  return {
+    detail: `Failed adapters: ${failedAdapters.join(", ")}. ${report.adapters.filter((adapter) => !adapter.passes).flatMap((adapter) => adapter.failures.slice(0, 3)).join(" ")}`,
+    href: options.baseHref,
+    label,
+    status: "fail",
+    value: failedAdapters.length
+  };
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -43173,6 +44528,7 @@ export {
   runVoiceProfileSwitchPolicyProof,
   runVoicePhoneAgentProductionSmokeContract,
   runVoiceOutcomeContractSuite,
+  runVoiceMultilingualProof,
   runVoiceCommandProofTargets,
   runVoiceCommandProofTarget,
   runVoiceCampaignReadinessProof,
@@ -43261,6 +44617,7 @@ export {
   renderVoiceOperationalStatusHTML,
   renderVoiceObservabilityExportReplayHTML,
   renderVoiceObservabilityExportMarkdown,
+  renderVoiceMultilingualProofMarkdown,
   renderVoiceMonitorMarkdown,
   renderVoiceMonitorHTML,
   renderVoiceMediaPipelineMarkdown,
@@ -43341,6 +44698,7 @@ export {
   getLatestVoiceTelephonyMediaReport,
   getLatestVoiceBrowserMediaReport,
   getDefaultVoiceTelephonyBenchmarkScenarios,
+  fromVapiAssistantConfig,
   formatVoiceProofTrendAge,
   filterVoiceTraceEvents,
   filterVoiceAuditEvents,
@@ -43793,6 +45151,7 @@ export {
   buildVoiceObservabilityExportDeliveryHistory,
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
+  buildVoiceMultilingualProofReadinessCheck,
   buildVoiceMonitorRunReport,
   buildVoiceMediaPipelineReport,
   buildVoiceMediaPipelineReadinessChecks,