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

package/dist/index.js

@@ -43373,6 +43373,1496 @@ 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
+  };
+};
+// src/monitor.ts
+import { Elysia as Elysia70 } from "elysia";
+var buildAudioFanout = () => {
+  const handlers = new Set;
+  return {
+    emit: (event) => {
+      for (const handler of handlers)
+        handler(event);
+    },
+    onAudio: (handler) => {
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+      };
+    }
+  };
+};
+var buildCloseFanout = () => {
+  const handlers = new Set;
+  return {
+    emitClose: (reason) => {
+      for (const handler of handlers)
+        handler(reason);
+    },
+    onClose: (handler) => {
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+      };
+    }
+  };
+};
+var createVoiceMonitorSession = (input) => {
+  const audio = buildAudioFanout();
+  const close = buildCloseFanout();
+  return {
+    emit: audio.emit,
+    emitClose: close.emitClose,
+    handle: input.handle,
+    metadata: input.metadata,
+    onAudio: audio.onAudio,
+    onClose: close.onClose,
+    sessionId: input.sessionId
+  };
+};
+var createVoiceInMemoryMonitorRegistry = () => {
+  const records = new Map;
+  return {
+    emit: (sessionId, event) => {
+      records.get(sessionId)?.emit(event);
+    },
+    emitClose: (sessionId, reason) => {
+      records.get(sessionId)?.emitClose(reason);
+    },
+    get: (sessionId) => records.get(sessionId),
+    list: () => Array.from(records.keys()).map((sessionId) => ({ sessionId })),
+    register: (record) => {
+      const existing = records.get(record.sessionId);
+      if (existing) {
+        throw new Error(`VoiceMonitorRegistry already has a session "${record.sessionId}"; deregister it before re-registering.`);
+      }
+      const wrapped = "emit" in record && typeof record.emit === "function" ? record : createVoiceMonitorSession({
+        handle: record.handle,
+        metadata: record.metadata,
+        sessionId: record.sessionId
+      });
+      if (wrapped !== record) {
+        record.onAudio((event) => wrapped.emit(event));
+        record.onClose((reason) => wrapped.emitClose(reason));
+      }
+      records.set(record.sessionId, wrapped);
+      return () => {
+        records.delete(record.sessionId);
+        wrapped.emitClose("deregistered");
+      };
+    }
+  };
+};
+var buildDefaultControlHandler = (type) => {
+  if (type === "transfer") {
+    return async ({ message, session }) => {
+      if (message.type !== "transfer") {
+        return { error: "internal: type mismatch", ok: false, type };
+      }
+      await session.handle.transfer({
+        metadata: message.metadata,
+        reason: message.reason,
+        target: message.target
+      });
+      return { detail: `Transferred to ${message.target}.`, ok: true, type };
+    };
+  }
+  if (type === "hangup") {
+    return async ({ message, session }) => {
+      if (message.type !== "hangup") {
+        return { error: "internal: type mismatch", ok: false, type };
+      }
+      await session.handle.complete();
+      return {
+        detail: message.reason ? `Hangup: ${message.reason}` : "Hangup.",
+        ok: true,
+        type
+      };
+    };
+  }
+  if (type === "escalate") {
+    return async ({ message, session }) => {
+      if (message.type !== "escalate") {
+        return { error: "internal: type mismatch", ok: false, type };
+      }
+      await session.handle.escalate({
+        metadata: message.metadata,
+        reason: message.reason ?? "monitor-requested-escalation"
+      });
+      return { detail: "Escalated.", ok: true, type };
+    };
+  }
+  if (type === "voicemail") {
+    return async ({ message, session }) => {
+      if (message.type !== "voicemail") {
+        return { error: "internal: type mismatch", ok: false, type };
+      }
+      await session.handle.markVoicemail({ metadata: message.metadata });
+      return { detail: "Voicemail marked.", ok: true, type };
+    };
+  }
+  if (type === "no-answer") {
+    return async ({ message, session }) => {
+      if (message.type !== "no-answer") {
+        return { error: "internal: type mismatch", ok: false, type };
+      }
+      await session.handle.markNoAnswer({ metadata: message.metadata });
+      return { detail: "Marked no-answer.", ok: true, type };
+    };
+  }
+  return;
+};
+var parseControlMessage = (raw) => {
+  if (!raw || typeof raw !== "object")
+    return;
+  const record = raw;
+  const type = record.type;
+  if (typeof type !== "string")
+    return;
+  if (type === "transfer") {
+    if (typeof record.target !== "string")
+      return;
+    return {
+      metadata: record.metadata,
+      reason: typeof record.reason === "string" ? record.reason : undefined,
+      target: record.target,
+      type
+    };
+  }
+  if (type === "hangup") {
+    return {
+      reason: typeof record.reason === "string" ? record.reason : undefined,
+      type
+    };
+  }
+  if (type === "escalate") {
+    return {
+      metadata: record.metadata,
+      reason: typeof record.reason === "string" ? record.reason : undefined,
+      type
+    };
+  }
+  if (type === "voicemail" || type === "no-answer") {
+    return {
+      metadata: record.metadata,
+      type
+    };
+  }
+  if (type === "mute") {
+    if (typeof record.muted !== "boolean" || record.target !== "assistant" && record.target !== "caller") {
+      return;
+    }
+    return { muted: record.muted, target: record.target, type };
+  }
+  if (type === "say") {
+    if (typeof record.text !== "string")
+      return;
+    return {
+      interrupt: typeof record.interrupt === "boolean" ? record.interrupt : undefined,
+      text: record.text,
+      type
+    };
+  }
+  if (type === "inject") {
+    if (typeof record.text !== "string" || record.role !== "assistant" && record.role !== "system" && record.role !== "user") {
+      return;
+    }
+    return { role: record.role, text: record.text, type };
+  }
+  return;
+};
+var DEFAULT_BASE_PATH = "/api/voice/monitor";
+var DEFAULT_LISTEN_PATH = ":sessionId/listen";
+var DEFAULT_CONTROL_PATH = ":sessionId/control";
+var joinPath = (...parts) => parts.filter((part) => part.length > 0).map((part) => part.replace(/^\/+|\/+$/g, "")).filter((part) => part.length > 0).reduce((path, part) => `${path}/${part}`, "");
+var substituteSessionId = (template, sessionId) => template.replace(":sessionId", encodeURIComponent(sessionId));
+var buildVoiceMonitorPlan = (input) => {
+  const basePath = input.basePath ?? DEFAULT_BASE_PATH;
+  const listenTemplate = input.listenPath ?? joinPath(basePath, DEFAULT_LISTEN_PATH);
+  const controlTemplate = input.controlPath ?? joinPath(basePath, DEFAULT_CONTROL_PATH);
+  const baseUrl = input.baseUrl.replace(/\/+$/, "");
+  return {
+    controlUrl: `${baseUrl}${substituteSessionId(controlTemplate, input.sessionId)}`,
+    listenUrl: `${baseUrl}${substituteSessionId(listenTemplate, input.sessionId)}`
+  };
+};
+var resolveSessionId3 = (ws) => {
+  const params = ws.data?.params;
+  if (!params)
+    return;
+  const value = params.sessionId;
+  if (typeof value !== "string" || value.length === 0)
+    return;
+  return value;
+};
+var resolveAuthenticate = async (authenticate, input) => {
+  if (!authenticate)
+    return true;
+  return await authenticate(input);
+};
+var createVoiceLiveMonitorRoutes = (options) => {
+  const basePath = options.basePath ?? DEFAULT_BASE_PATH;
+  const listenPath = options.listenPath === undefined ? joinPath(basePath, DEFAULT_LISTEN_PATH) : options.listenPath;
+  const controlPath = options.controlPath === undefined ? joinPath(basePath, DEFAULT_CONTROL_PATH) : options.controlPath;
+  const handlers = {
+    escalate: options.controlHandlers?.escalate ?? buildDefaultControlHandler("escalate"),
+    hangup: options.controlHandlers?.hangup ?? buildDefaultControlHandler("hangup"),
+    inject: options.controlHandlers?.inject,
+    mute: options.controlHandlers?.mute,
+    "no-answer": options.controlHandlers?.["no-answer"] ?? buildDefaultControlHandler("no-answer"),
+    say: options.controlHandlers?.say,
+    transfer: options.controlHandlers?.transfer ?? buildDefaultControlHandler("transfer"),
+    voicemail: options.controlHandlers?.voicemail ?? buildDefaultControlHandler("voicemail")
+  };
+  const app = new Elysia70({ name: "absolutejs-voice-monitor" });
+  const unsubscribers = new WeakMap;
+  if (listenPath !== false && listenPath.length > 0) {
+    app.ws(`/${listenPath.replace(/^\/+/, "")}`, {
+      close: (ws) => {
+        const subs = unsubscribers.get(ws);
+        if (subs) {
+          for (const unsub of subs)
+            unsub();
+          unsubscribers.delete(ws);
+        }
+      },
+      open: async (ws) => {
+        const webSocket = ws;
+        const sessionId = resolveSessionId3(webSocket);
+        if (!sessionId) {
+          webSocket.send(JSON.stringify({
+            error: "missing sessionId in path params",
+            type: "error"
+          }));
+          webSocket.close(4400, "missing sessionId");
+          return;
+        }
+        const authed = await resolveAuthenticate(options.authenticate, {
+          request: webSocket.raw?.request,
+          route: "listen",
+          sessionId
+        });
+        if (!authed) {
+          webSocket.send(JSON.stringify({ error: "unauthorized", type: "error" }));
+          webSocket.close(4401, "unauthorized");
+          return;
+        }
+        const record = options.registry.get(sessionId);
+        if (!record) {
+          webSocket.send(JSON.stringify({
+            error: `session "${sessionId}" not found`,
+            type: "error"
+          }));
+          webSocket.close(4404, "session not found");
+          return;
+        }
+        const subs = [];
+        webSocket.send(JSON.stringify({
+          sessionId,
+          type: "subscribed"
+        }));
+        subs.push(record.onAudio((event) => {
+          webSocket.send(event.chunk);
+        }));
+        subs.push(record.onClose((reason) => {
+          webSocket.send(JSON.stringify({
+            reason,
+            sessionId,
+            type: "session-closed"
+          }));
+          webSocket.close(1000, reason ?? "session-closed");
+        }));
+        unsubscribers.set(ws, subs);
+      }
+    });
+  }
+  if (controlPath !== false && controlPath.length > 0) {
+    app.ws(`/${controlPath.replace(/^\/+/, "")}`, {
+      close: (ws) => {
+        unsubscribers.delete(ws);
+      },
+      message: async (ws, raw) => {
+        const webSocket = ws;
+        const sessionId = resolveSessionId3(webSocket);
+        if (!sessionId) {
+          webSocket.send(JSON.stringify({
+            error: "missing sessionId in path params",
+            ok: false,
+            type: "error"
+          }));
+          return;
+        }
+        const message = parseControlMessage(raw);
+        if (!message) {
+          webSocket.send(JSON.stringify({
+            error: "invalid control message",
+            ok: false,
+            type: "error"
+          }));
+          return;
+        }
+        const record = options.registry.get(sessionId);
+        if (!record) {
+          webSocket.send(JSON.stringify({
+            error: `session "${sessionId}" not found`,
+            ok: false,
+            type: message.type
+          }));
+          return;
+        }
+        const handler = handlers[message.type];
+        if (!handler) {
+          webSocket.send(JSON.stringify({
+            error: `no handler registered for control type "${message.type}"`,
+            ok: false,
+            type: message.type
+          }));
+          return;
+        }
+        try {
+          const ack = await handler({
+            message,
+            raw,
+            session: record
+          });
+          webSocket.send(JSON.stringify(ack));
+        } catch (error) {
+          webSocket.send(JSON.stringify({
+            error: error instanceof Error ? error.message : String(error),
+            ok: false,
+            type: message.type
+          }));
+        }
+      },
+      open: async (ws) => {
+        const webSocket = ws;
+        const sessionId = resolveSessionId3(webSocket);
+        if (!sessionId) {
+          webSocket.send(JSON.stringify({
+            error: "missing sessionId in path params",
+            type: "error"
+          }));
+          webSocket.close(4400, "missing sessionId");
+          return;
+        }
+        const authed = await resolveAuthenticate(options.authenticate, {
+          request: webSocket.raw?.request,
+          route: "control",
+          sessionId
+        });
+        if (!authed) {
+          webSocket.send(JSON.stringify({ error: "unauthorized", type: "error" }));
+          webSocket.close(4401, "unauthorized");
+          return;
+        }
+        const record = options.registry.get(sessionId);
+        if (!record) {
+          webSocket.send(JSON.stringify({
+            error: `session "${sessionId}" not found`,
+            type: "error"
+          }));
+          webSocket.close(4404, "session not found");
+          return;
+        }
+        webSocket.send(JSON.stringify({
+          sessionId,
+          supports: Object.entries(handlers).filter(([, value]) => value !== undefined).map(([key]) => key),
+          type: "ready"
+        }));
+      }
+    });
+  }
+  if (options.htmlPath !== undefined && options.htmlPath !== false) {
+    const path = options.htmlPath;
+    app.get(path, () => {
+      const sessions = options.registry.list().map((entry) => `<li><code>${entry.sessionId}</code></li>`).join("");
+      const body = `<!doctype html><html lang="en"><head><meta charset="utf-8" /><title>Voice Monitor</title><style>body{background:#0b1216;color:#f6f1e7;font-family:ui-sans-serif,system-ui,sans-serif;margin:0;padding:32px}main{margin:auto;max-width:960px}h1{font-size:clamp(2rem,5vw,3.2rem);letter-spacing:-.04em;margin:.2rem 0 1rem}code{background:#171f25;border:1px solid #2c3a44;border-radius:8px;padding:2px 6px}ul{margin:8px 0;padding-left:18px}p.muted{color:#9aa8b2}</style></head><body><main><h1>Voice Monitor</h1><p class="muted">Active sessions registered with this monitor registry.</p><ul>${sessions || "<li><em>None.</em></li>"}</ul><p class="muted">Open <code>${listenPath}</code> and <code>${controlPath}</code> via WebSocket per session for live listen + control.</p></main></body></html>`;
+      return new Response(body, {
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    });
+  }
+  return app;
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -43447,6 +44937,7 @@ export {
   runVoiceProfileSwitchPolicyProof,
   runVoicePhoneAgentProductionSmokeContract,
   runVoiceOutcomeContractSuite,
+  runVoiceMultilingualProof,
   runVoiceCommandProofTargets,
   runVoiceCommandProofTarget,
   runVoiceCampaignReadinessProof,
@@ -43535,6 +45026,7 @@ export {
   renderVoiceOperationalStatusHTML,
   renderVoiceObservabilityExportReplayHTML,
   renderVoiceObservabilityExportMarkdown,
+  renderVoiceMultilingualProofMarkdown,
   renderVoiceMonitorMarkdown,
   renderVoiceMonitorHTML,
   renderVoiceMediaPipelineMarkdown,
@@ -43865,6 +45357,7 @@ export {
   createVoiceObservabilityExportRoutes,
   createVoiceObservabilityExportReplayRoutes,
   createVoiceMonitorWebhookNotifier,
+  createVoiceMonitorSession,
   createVoiceMonitorRunnerRoutes,
   createVoiceMonitorRunner,
   createVoiceMonitorRoutes,
@@ -43884,6 +45377,7 @@ export {
   createVoiceMediaPipelineRoutes,
   createVoiceLiveOpsRoutes,
   createVoiceLiveOpsController,
+  createVoiceLiveMonitorRoutes,
   createVoiceLiveLatencyRoutes,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
@@ -43895,6 +45389,7 @@ export {
   createVoiceIncidentTimelineRoutes,
   createVoiceIncidentBundleRoutes,
   createVoiceInMemoryRealCallProfileRecoveryJobStore,
+  createVoiceInMemoryMonitorRegistry,
   createVoiceHubSpotTaskUpdateSink,
   createVoiceHubSpotTaskSyncSinks,
   createVoiceHubSpotTaskSink,
@@ -44068,7 +45563,9 @@ export {
   buildVoiceObservabilityExportDeliveryHistory,
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
+  buildVoiceMultilingualProofReadinessCheck,
   buildVoiceMonitorRunReport,
+  buildVoiceMonitorPlan,
   buildVoiceMediaPipelineReport,
   buildVoiceMediaPipelineReadinessChecks,
   buildVoiceMediaPipelineIncidentEvents,