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

package/README.md

@@ -8,6 +8,47 @@ Use it when you want Vapi/Retell/Bland-style voice-agent capability, but you wan
 
 ## What's new
 
+### 0.0.22-beta.472 · Phase 6 — multilingual STT proof gate
+
+`runVoiceMultilingualProof(...)` turns the `voice-fixtures-multilingual` corpus (FLEURS + BSC Catalan-Spanish code-switch + CoSHE Hindi-English code-switch) into a gateable readiness/proof artifact. Buyers evaluating Vapi-replacement can now run any combination of STT adapters against the multilingual corpus and assert per-language WER / pass-rate / term-recall budgets in CI.
+
+```ts
+import {
+  buildVoiceMultilingualProofReadinessCheck,
+  renderVoiceMultilingualProofMarkdown,
+  runVoiceMultilingualProof,
+} from "@absolutejs/voice";
+import { deepgram } from "@absolutejs/voice-deepgram";
+import { speechmatics } from "@absolutejs/voice-speechmatics";
+import { soniox } from "@absolutejs/voice-soniox";
+
+const report = await runVoiceMultilingualProof({
+  adapters: [
+    { adapter: deepgram({ apiKey, model: "nova-3" }), adapterId: "deepgram-nova3" },
+    { adapter: speechmatics({ apiKey, region: "eu2" }), adapterId: "speechmatics-enhanced" },
+    { adapter: soniox({ apiKey, enableLanguageIdentification: true }), adapterId: "soniox" },
+  ],
+  defaultThresholds: { maxAverageWordErrorRate: 0.30, minPassRate: 0.7 },
+  perLanguage: [
+    { language: "ca-es", label: "Catalan-Spanish code-switch", maxAverageWordErrorRate: 0.45 },
+    { language: "hi-en", label: "Hindi-English code-switch", maxAverageWordErrorRate: 0.50 },
+  ],
+});
+
+const readiness = buildVoiceMultilingualProofReadinessCheck(report, {
+  baseHref: "/voice/multilingual-proof",
+});
+// drop `readiness` into your VoiceProductionReadinessReport.checks array
+
+await Bun.write("docs/multilingual-proof.md", renderVoiceMultilingualProofMarkdown(report));
+```
+
+Highlights:
+- Loads fixtures from `VOICE_FIXTURE_DIR` (or any caller-supplied directory list / pre-loaded `VoiceTestFixture[]`), filters by an optional predicate, and runs each adapter through the existing `runSTTAdapterBenchmark` harness — no new STT plumbing required.
+- Buckets fixture results by `fixture.language` and applies per-language thresholds (`maxAverageWordErrorRate`, `minAverageWordAccuracyRate`, `minPassRate`, `minTermRecall`) layered over caller-provided `defaultThresholds`.
+- Returns a structured report (`adapters[].languageReports[]` with metrics + failures, plus per-adapter and global `passes` flags) plus a Markdown renderer for human review and a `VoiceProductionReadinessCheck`-shaped helper for drop-in readiness wiring.
+- Pairs naturally with every STT adapter shipped in `voice-adapters` (deepgram, assemblyai, azure streaming, speechmatics, gladia, soniox, google-speech streaming + buffered, openai-whisper buffered).
+
 ### 0.0.22-beta.471 · Vapi parity — `fromVapiAssistantConfig` adapter
 
 Mechanical migration from a Vapi Assistant JSON to a voice assistant. Pass the JSON dump (or a typed subset), provide a `modelFactory` that maps Vapi's `model.provider`+`model.model` to a voice `VoiceAgentModel`, and get back `{ assistant, tools, routeHints, unsupported }`.

package/dist/index.d.ts

@@ -223,4 +223,6 @@ export { shapeTelephonyAssistantText } from "./telephony/response";
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions, } from "./telephony/response";
 export { buildVoiceProofPackInput, buildVoiceProofPack, buildVoiceProofPackFromObservabilityExport, createVoiceProofPackBuildContext, createVoiceProofRefreshSnapshot, createVoiceProofPackStaleWhileRefreshSource, createVoiceProofPackArtifacts, createVoiceProofPackOperationsRecordSection, createVoiceProofPackProductionReadinessSection, createVoiceProofPackProviderSloSection, createVoiceProofPackRoutes, createVoiceProofPackSupportBundleSection, renderVoiceProofPackMarkdown, writeVoiceProofPack, } from "./proofPack";
 export type { VoiceProofPack, VoiceProofPackBuildContext, VoiceProofPackBuildContextOptions, VoiceProofPackBuildTiming, VoiceProofPackEvidence, VoiceProofPackInput, VoiceProofPackInputBuilderLoaderInput, VoiceProofPackInputBuilderOperationsLoaderInput, VoiceProofPackInputBuilderOptions, VoiceProofPackInputBuilderSupportBundle, VoiceProofPackRefreshState, VoiceProofPackRefreshStatus, VoiceProofPackRoutesOptions, VoiceProofPackSection, VoiceProofPackSourceValue, VoiceProofPackStatus, VoiceProofPackStaleWhileRefreshSource, VoiceProofPackStaleWhileRefreshSourceOptions, VoiceProofPackWriteResult, VoiceProofRefreshSnapshot, VoiceProofRefreshSnapshotOptions, } from "./proofPack";
+export { buildVoiceMultilingualProofReadinessCheck, renderVoiceMultilingualProofMarkdown, runVoiceMultilingualProof, } from "./multilingualProof";
+export type { VoiceMultilingualLanguageCode, VoiceMultilingualProofAdapterEntry, VoiceMultilingualProofAdapterReport, VoiceMultilingualProofDefaultThresholds, VoiceMultilingualProofLanguageMetrics, VoiceMultilingualProofLanguageReport, VoiceMultilingualProofLanguageThresholds, VoiceMultilingualProofOptions, VoiceMultilingualProofReadinessCheck, VoiceMultilingualProofReadinessOptions, VoiceMultilingualProofReport, } from "./multilingualProof";
 export * from "./types";

package/dist/index.js

@@ -43373,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,
@@ -43447,6 +44528,7 @@ export {
   runVoiceProfileSwitchPolicyProof,
   runVoicePhoneAgentProductionSmokeContract,
   runVoiceOutcomeContractSuite,
+  runVoiceMultilingualProof,
   runVoiceCommandProofTargets,
   runVoiceCommandProofTarget,
   runVoiceCampaignReadinessProof,
@@ -43535,6 +44617,7 @@ export {
   renderVoiceOperationalStatusHTML,
   renderVoiceObservabilityExportReplayHTML,
   renderVoiceObservabilityExportMarkdown,
+  renderVoiceMultilingualProofMarkdown,
   renderVoiceMonitorMarkdown,
   renderVoiceMonitorHTML,
   renderVoiceMediaPipelineMarkdown,
@@ -44068,6 +45151,7 @@ export {
   buildVoiceObservabilityExportDeliveryHistory,
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
+  buildVoiceMultilingualProofReadinessCheck,
   buildVoiceMonitorRunReport,
   buildVoiceMediaPipelineReport,
   buildVoiceMediaPipelineReadinessChecks,

package/dist/multilingualProof.d.ts

@@ -0,0 +1,77 @@
+import type { STTAdapter } from "./types";
+import { type VoiceTestFixture } from "./testing/fixtures";
+import { type VoiceSTTBenchmarkOptions, type VoiceSTTBenchmarkReport } from "./testing/benchmark";
+export type VoiceMultilingualLanguageCode = string;
+export type VoiceMultilingualProofLanguageThresholds = {
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    maxAverageWordErrorRate?: number;
+    minAverageWordAccuracyRate?: number;
+    minPassRate?: number;
+    minTermRecall?: number;
+};
+export type VoiceMultilingualProofDefaultThresholds = Omit<VoiceMultilingualProofLanguageThresholds, "label" | "language">;
+export type VoiceMultilingualProofAdapterEntry = {
+    adapter: STTAdapter;
+    adapterId: string;
+    benchmarkOptions?: VoiceSTTBenchmarkOptions;
+};
+export type VoiceMultilingualProofOptions = {
+    adapters: readonly VoiceMultilingualProofAdapterEntry[];
+    defaultThresholds?: VoiceMultilingualProofDefaultThresholds;
+    filter?: (fixture: VoiceTestFixture) => boolean;
+    fixtureDirectories?: string | readonly string[];
+    fixtures?: readonly VoiceTestFixture[];
+    perLanguage?: readonly VoiceMultilingualProofLanguageThresholds[];
+};
+export type VoiceMultilingualProofLanguageMetrics = {
+    averageTermRecall: number;
+    averageWordAccuracyRate: number;
+    averageWordErrorRate: number;
+    fixtureCount: number;
+    passCount: number;
+    passRate: number;
+};
+export type VoiceMultilingualProofLanguageReport = {
+    applied: VoiceMultilingualProofLanguageThresholds;
+    failures: readonly string[];
+    fixtureIds: readonly string[];
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    metrics: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofAdapterReport = {
+    adapterId: string;
+    benchmark: VoiceSTTBenchmarkReport;
+    failures: readonly string[];
+    fixtureCount: number;
+    languageReports: readonly VoiceMultilingualProofLanguageReport[];
+    overall: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofReport = {
+    adapters: readonly VoiceMultilingualProofAdapterReport[];
+    generatedAt: number;
+    passes: boolean;
+    summary: {
+        adapterCount: number;
+        failedAdapters: readonly string[];
+        fixtureCount: number;
+        languageCount: number;
+    };
+};
+export declare const runVoiceMultilingualProof: (options: VoiceMultilingualProofOptions) => Promise<VoiceMultilingualProofReport>;
+export declare const renderVoiceMultilingualProofMarkdown: (report: VoiceMultilingualProofReport) => string;
+export type VoiceMultilingualProofReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export type VoiceMultilingualProofReadinessCheck = {
+    detail: string;
+    href?: string;
+    label: string;
+    status: "fail" | "pass" | "warn";
+    value?: number | string;
+};
+export declare const buildVoiceMultilingualProofReadinessCheck: (report: VoiceMultilingualProofReport, options?: VoiceMultilingualProofReadinessOptions) => VoiceMultilingualProofReadinessCheck;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.471",
+  "version": "0.0.22-beta.472",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",