@absolutejs/voice 0.0.22-beta.637 → 0.0.22-beta.638

package/dist/index.js

@@ -49422,18 +49422,72 @@ var levenshteinDistance2 = (left, right) => {
   }
   return previous[right.length];
 };
+var alignTranscriptWords = (actualWords, expectedWords) => {
+  const rows = expectedWords.length + 1;
+  const columns = actualWords.length + 1;
+  const costs = Array.from({ length: rows }, () => new Array(columns).fill(0));
+  for (let row2 = 0;row2 < rows; row2 += 1)
+    costs[row2][0] = row2;
+  for (let column2 = 0;column2 < columns; column2 += 1)
+    costs[0][column2] = column2;
+  for (let row2 = 1;row2 < rows; row2 += 1) {
+    for (let column2 = 1;column2 < columns; column2 += 1) {
+      const substitution = costs[row2 - 1][column2 - 1] + (expectedWords[row2 - 1] === actualWords[column2 - 1] ? 0 : 1);
+      costs[row2][column2] = Math.min(substitution, costs[row2 - 1][column2] + 1, costs[row2][column2 - 1] + 1);
+    }
+  }
+  const operations = [];
+  let row = expectedWords.length;
+  let column = actualWords.length;
+  while (row > 0 || column > 0) {
+    const expected = expectedWords[row - 1];
+    const actual = actualWords[column - 1];
+    if (row > 0 && column > 0 && expected === actual && costs[row][column] === costs[row - 1][column - 1]) {
+      operations.push({ actual, expected, type: "correct" });
+      row -= 1;
+      column -= 1;
+    } else if (row > 0 && column > 0 && costs[row][column] === costs[row - 1][column - 1] + 1) {
+      operations.push({ actual, expected, type: "substitution" });
+      row -= 1;
+      column -= 1;
+    } else if (row > 0 && costs[row][column] === costs[row - 1][column] + 1) {
+      operations.push({ expected, type: "deletion" });
+      row -= 1;
+    } else {
+      operations.push({ actual, type: "insertion" });
+      column -= 1;
+    }
+  }
+  operations.reverse();
+  const count = (type) => operations.filter((operation) => operation.type === type).length;
+  const substitutions = count("substitution");
+  const deletions = count("deletion");
+  const insertions = count("insertion");
+  return {
+    correct: count("correct"),
+    deletions,
+    hypothesisWordCount: actualWords.length,
+    insertions,
+    operations,
+    referenceWordCount: expectedWords.length,
+    sentenceError: substitutions + deletions + insertions > 0,
+    substitutions
+  };
+};
 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 alignment = alignTranscriptWords(actualWords, expectedWords);
+  const wordDistance = alignment.substitutions + alignment.deletions + alignment.insertions;
   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,
+    alignment,
     charDistance,
     charErrorRate,
     expectedText: normalizedExpected,
@@ -49641,6 +49695,42 @@ var scoreVoiceCriticalFields = (actualText, expectedFields = []) => {
   };
 };
 
+// src/testing/conformance.ts
+var evaluateSTTAdapterConformance = (result) => {
+  const transcripts = [
+    ...result.partialEvents.map((event) => event.transcript),
+    ...result.finalEvents.map((event) => event.transcript)
+  ];
+  const checks = [
+    {
+      detail: "The adapter emitted no error events for a valid fixture.",
+      id: "no-errors",
+      passed: result.errorEvents.length === 0
+    },
+    {
+      detail: "Every transcript has a stable id and finite start time.",
+      id: "transcript-identity",
+      passed: transcripts.every((transcript) => transcript.id.trim().length > 0 && Number.isFinite(transcript.startedAtMs))
+    },
+    {
+      detail: "Events marked final contain final transcripts.",
+      id: "final-semantics",
+      passed: result.finalEvents.every((event) => event.transcript.isFinal)
+    },
+    {
+      detail: "Events marked partial contain non-final transcripts.",
+      id: "partial-semantics",
+      passed: result.partialEvents.every((event) => !event.transcript.isFinal)
+    },
+    {
+      detail: "The assembled transcript is non-empty when finals were emitted.",
+      id: "assembly",
+      passed: result.finalEvents.length === 0 || result.finalText.trim().length > 0
+    }
+  ];
+  return { checks, passed: checks.every((check) => check.passed) };
+};
+
 // src/testing/benchmark.ts
 var resolveFixtureEnvironment = (fixture) => {
   const tags = new Set(fixture.tags ?? []);
@@ -49885,6 +49975,7 @@ var toFixtureBenchmarkResult = (fixture, result, elapsedMs) => {
   return {
     accuracy: result.accuracy,
     closeCount: result.closeEvents.length,
+    conformance: evaluateSTTAdapterConformance(result),
     criticalFields,
     difficulty: fixture.difficulty,
     elapsedMs,

package/dist/testing/accuracy.d.ts

@@ -8,6 +8,23 @@ export type VoiceTranscriptAccuracy = {
     threshold: number;
     wordDistance: number;
     wordErrorRate: number;
+    alignment?: VoiceWordAlignment;
 };
+export type VoiceWordAlignmentOperation = {
+    actual?: string;
+    expected?: string;
+    type: "correct" | "substitution" | "deletion" | "insertion";
+};
+export type VoiceWordAlignment = {
+    correct: number;
+    deletions: number;
+    hypothesisWordCount: number;
+    insertions: number;
+    operations: VoiceWordAlignmentOperation[];
+    referenceWordCount: number;
+    sentenceError: boolean;
+    substitutions: number;
+};
+export declare const alignTranscriptWords: (actualWords: string[], expectedWords: string[]) => VoiceWordAlignment;
 export declare const mergeFinalTranscriptText: (transcripts: Transcript[]) => string;
 export declare const scoreTranscriptAccuracy: (actualText: string, expectedText: string, threshold?: number) => VoiceTranscriptAccuracy;

package/dist/testing/audioMatrix.d.ts

@@ -0,0 +1,22 @@
+import type { VoiceTestFixture } from "./fixtures";
+export type VoiceAudioCondition = {
+    id: string;
+    type: "gain";
+    gain: number;
+} | {
+    id: string;
+    type: "clip";
+    ceiling: number;
+} | {
+    id: string;
+    type: "drop-chunks";
+    every: number;
+    chunkDurationMs: number;
+} | {
+    id: string;
+    type: "noise";
+    seed: number;
+    snrDb: number;
+};
+export declare const applyVoiceAudioCondition: (fixture: VoiceTestFixture, condition: VoiceAudioCondition) => VoiceTestFixture;
+export declare const buildVoiceAudioMatrix: (fixtures: VoiceTestFixture[], conditions: VoiceAudioCondition[]) => VoiceTestFixture[];

package/dist/testing/benchmark.d.ts

@@ -3,6 +3,7 @@ import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult }
 import type { VoiceTestFixture } from "./fixtures";
 import { type VoiceConfidenceCalibrationReport } from "./confidenceCalibration";
 import { type VoiceCriticalFieldAccuracy } from "./criticalFields";
+import { type VoiceSTTConformanceReport } from "./conformance";
 export type VoiceExpectedTermAccuracy = {
     allMatched: boolean;
     expectedTerms: string[];
@@ -22,6 +23,7 @@ export type VoiceSpeakerTurnAccuracy = {
 export type VoiceSTTBenchmarkFixtureResult = {
     accuracy: VoiceSTTAdapterHarnessResult["accuracy"];
     closeCount: number;
+    conformance?: VoiceSTTConformanceReport;
     difficulty?: VoiceTestFixture["difficulty"];
     elapsedMs: number;
     endOfTurnCount: number;

package/dist/testing/conformance.d.ts

@@ -0,0 +1,11 @@
+import type { VoiceSTTAdapterHarnessResult } from "./stt";
+export type VoiceSTTConformanceCheck = {
+    detail: string;
+    id: string;
+    passed: boolean;
+};
+export type VoiceSTTConformanceReport = {
+    checks: VoiceSTTConformanceCheck[];
+    passed: boolean;
+};
+export declare const evaluateSTTAdapterConformance: (result: VoiceSTTAdapterHarnessResult) => VoiceSTTConformanceReport;

package/dist/testing/fixtures.d.ts

@@ -15,6 +15,7 @@ export type VoiceTestFixtureManifestEntry = {
     tags?: string[];
     tailPaddingMs?: number;
     format?: Partial<AudioFormat>;
+    provenance?: Omit<import("./provenance").VoiceCorpusFixtureProvenance, "audioSha256" | "fixtureId">;
 };
 export type VoiceTestFixture = Omit<VoiceTestFixtureManifestEntry, "audioPath"> & {
     audio: Uint8Array;

package/dist/testing/index.d.ts

@@ -1,16 +1,21 @@
 export * from "./accuracy";
+export * from "./audioMatrix";
 export * from "./benchmark";
 export * from "./confidenceCalibration";
+export * from "./conformance";
 export * from "./criticalFields";
 export * from "./corrected";
 export * from "./duplex";
 export * from "./fixtures";
 export * from "./ioProviderSimulator";
+export * from "./outcomes";
 export * from "./providerSimulator";
+export * from "./provenance";
 export * from "./resilience";
 export * from "./review";
 export * from "./routingBenchmark";
 export * from "./sessionBenchmark";
 export * from "./stt";
+export * from "./statistics";
 export * from "./telephony";
 export * from "./tts";

package/dist/testing/index.js

@@ -227,18 +227,72 @@ var levenshteinDistance = (left, right) => {
   }
   return previous[right.length];
 };
+var alignTranscriptWords = (actualWords, expectedWords) => {
+  const rows = expectedWords.length + 1;
+  const columns = actualWords.length + 1;
+  const costs = Array.from({ length: rows }, () => new Array(columns).fill(0));
+  for (let row2 = 0;row2 < rows; row2 += 1)
+    costs[row2][0] = row2;
+  for (let column2 = 0;column2 < columns; column2 += 1)
+    costs[0][column2] = column2;
+  for (let row2 = 1;row2 < rows; row2 += 1) {
+    for (let column2 = 1;column2 < columns; column2 += 1) {
+      const substitution = costs[row2 - 1][column2 - 1] + (expectedWords[row2 - 1] === actualWords[column2 - 1] ? 0 : 1);
+      costs[row2][column2] = Math.min(substitution, costs[row2 - 1][column2] + 1, costs[row2][column2 - 1] + 1);
+    }
+  }
+  const operations = [];
+  let row = expectedWords.length;
+  let column = actualWords.length;
+  while (row > 0 || column > 0) {
+    const expected = expectedWords[row - 1];
+    const actual = actualWords[column - 1];
+    if (row > 0 && column > 0 && expected === actual && costs[row][column] === costs[row - 1][column - 1]) {
+      operations.push({ actual, expected, type: "correct" });
+      row -= 1;
+      column -= 1;
+    } else if (row > 0 && column > 0 && costs[row][column] === costs[row - 1][column - 1] + 1) {
+      operations.push({ actual, expected, type: "substitution" });
+      row -= 1;
+      column -= 1;
+    } else if (row > 0 && costs[row][column] === costs[row - 1][column] + 1) {
+      operations.push({ expected, type: "deletion" });
+      row -= 1;
+    } else {
+      operations.push({ actual, type: "insertion" });
+      column -= 1;
+    }
+  }
+  operations.reverse();
+  const count = (type) => operations.filter((operation) => operation.type === type).length;
+  const substitutions = count("substitution");
+  const deletions = count("deletion");
+  const insertions = count("insertion");
+  return {
+    correct: count("correct"),
+    deletions,
+    hypothesisWordCount: actualWords.length,
+    insertions,
+    operations,
+    referenceWordCount: expectedWords.length,
+    sentenceError: substitutions + deletions + insertions > 0,
+    substitutions
+  };
+};
 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 = levenshteinDistance(actualWords, expectedWords);
+  const alignment = alignTranscriptWords(actualWords, expectedWords);
+  const wordDistance = alignment.substitutions + alignment.deletions + alignment.insertions;
   const charDistance = levenshteinDistance(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,
+    alignment,
     charDistance,
     charErrorRate,
     expectedText: normalizedExpected,
@@ -248,6 +302,35 @@ var scoreTranscriptAccuracy = (actualText, expectedText, threshold = 0.35) => {
     wordErrorRate
   };
 };
+// src/testing/audioMatrix.ts
+var clamp = (value) => Math.max(-32768, Math.min(32767, Math.round(value)));
+var samples = (audio) => new Int16Array(audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength));
+var bytes = (audio) => new Uint8Array(audio.buffer);
+var applyVoiceAudioCondition = (fixture, condition) => {
+  const input = samples(fixture.audio);
+  const output = new Int16Array(input);
+  if (condition.type === "gain") {
+    for (let index = 0;index < output.length; index += 1)
+      output[index] = clamp(output[index] * condition.gain);
+  } else if (condition.type === "clip") {
+    const ceiling = Math.round(32767 * condition.ceiling);
+    for (let index = 0;index < output.length; index += 1)
+      output[index] = Math.max(-ceiling, Math.min(ceiling, output[index]));
+  } else if (condition.type === "drop-chunks") {
+    const chunkSamples = Math.max(1, Math.round(fixture.format.sampleRateHz * condition.chunkDurationMs / 1000));
+    for (let start = chunkSamples * (condition.every - 1);start < output.length; start += chunkSamples * condition.every)
+      output.fill(0, start, Math.min(output.length, start + chunkSamples));
+  } else {
+    let state = condition.seed >>> 0;
+    const random = () => (state = state * 1664525 + 1013904223 >>> 0) / 4294967296 * 2 - 1;
+    const signalPower = output.reduce((sum, value) => sum + value * value, 0) / Math.max(1, output.length);
+    const noiseRms = Math.sqrt(signalPower / 10 ** (condition.snrDb / 10));
+    for (let index = 0;index < output.length; index += 1)
+      output[index] = clamp(output[index] + random() * Math.sqrt(3) * noiseRms);
+  }
+  return { ...fixture, audio: bytes(output), id: `${fixture.id}--${condition.id}`, tags: [...fixture.tags ?? [], "conditioned", condition.id] };
+};
+var buildVoiceAudioMatrix = (fixtures, conditions) => fixtures.flatMap((fixture) => conditions.map((condition) => applyVoiceAudioCondition(fixture, condition)));
 // src/testing/stt.ts
 var chunkAudio = (audio, bytesPerChunk) => {
   const chunks = [];
@@ -369,7 +452,7 @@ var runSTTAdapterFixture = async (adapter, fixture, options = {}) => {
 
 // src/testing/confidenceCalibration.ts
 var clampConfidence = (value) => Math.max(0, Math.min(1, value));
-var calibrateVoiceConfidence = (samples, binCount = 10) => {
+var calibrateVoiceConfidence = (samples2, binCount = 10) => {
   const safeBinCount = Math.max(1, Math.round(binCount));
   const bins = Array.from({ length: safeBinCount }, (_, index) => {
     const lowerBound = index / safeBinCount;
@@ -382,7 +465,7 @@ var calibrateVoiceConfidence = (samples, binCount = 10) => {
     };
   });
   let brierTotal = 0;
-  for (const sample of samples) {
+  for (const sample of samples2) {
     const confidence = clampConfidence(sample.confidence);
     const binIndex = Math.min(safeBinCount - 1, Math.floor(confidence * safeBinCount));
     const bin = bins[binIndex];
@@ -397,13 +480,13 @@ var calibrateVoiceConfidence = (samples, binCount = 10) => {
       continue;
     bin.averageConfidence /= bin.count;
     bin.accuracy /= bin.count;
-    expectedCalibrationError += bin.count / Math.max(1, samples.length) * Math.abs(bin.accuracy - bin.averageConfidence);
+    expectedCalibrationError += bin.count / Math.max(1, samples2.length) * Math.abs(bin.accuracy - bin.averageConfidence);
   }
   return {
     bins,
-    brierScore: samples.length > 0 ? brierTotal / samples.length : 0,
+    brierScore: samples2.length > 0 ? brierTotal / samples2.length : 0,
     expectedCalibrationError,
-    sampleCount: samples.length
+    sampleCount: samples2.length
   };
 };
 
@@ -630,6 +713,42 @@ var scoreVoiceCriticalFields = (actualText, expectedFields = []) => {
   };
 };
 
+// src/testing/conformance.ts
+var evaluateSTTAdapterConformance = (result) => {
+  const transcripts = [
+    ...result.partialEvents.map((event) => event.transcript),
+    ...result.finalEvents.map((event) => event.transcript)
+  ];
+  const checks = [
+    {
+      detail: "The adapter emitted no error events for a valid fixture.",
+      id: "no-errors",
+      passed: result.errorEvents.length === 0
+    },
+    {
+      detail: "Every transcript has a stable id and finite start time.",
+      id: "transcript-identity",
+      passed: transcripts.every((transcript) => transcript.id.trim().length > 0 && Number.isFinite(transcript.startedAtMs))
+    },
+    {
+      detail: "Events marked final contain final transcripts.",
+      id: "final-semantics",
+      passed: result.finalEvents.every((event) => event.transcript.isFinal)
+    },
+    {
+      detail: "Events marked partial contain non-final transcripts.",
+      id: "partial-semantics",
+      passed: result.partialEvents.every((event) => !event.transcript.isFinal)
+    },
+    {
+      detail: "The assembled transcript is non-empty when finals were emitted.",
+      id: "assembly",
+      passed: result.finalEvents.length === 0 || result.finalText.trim().length > 0
+    }
+  ];
+  return { checks, passed: checks.every((check) => check.passed) };
+};
+
 // src/testing/benchmark.ts
 var resolveFixtureEnvironment = (fixture) => {
   const tags = new Set(fixture.tags ?? []);
@@ -874,6 +993,7 @@ var toFixtureBenchmarkResult = (fixture, result, elapsedMs) => {
   return {
     accuracy: result.accuracy,
     closeCount: result.closeEvents.length,
+    conformance: evaluateSTTAdapterConformance(result),
     criticalFields,
     difficulty: fixture.difficulty,
     elapsedMs,
@@ -2057,18 +2177,18 @@ var decodePCM16LEChunk = (audioContext, chunk) => {
   if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
     throw new Error(`Unsupported assistant audio format: ${format.container}/${format.encoding}`);
   }
-  const bytes = chunk.chunk;
+  const bytes2 = chunk.chunk;
   const channels = Math.max(1, format.channels);
-  const sampleCount = Math.floor(bytes.byteLength / 2);
+  const sampleCount = Math.floor(bytes2.byteLength / 2);
   const frameCount = Math.max(1, Math.floor(sampleCount / channels));
   const audioBuffer = audioContext.createBuffer(channels, frameCount, format.sampleRateHz);
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
     const channelData = audioBuffer.getChannelData(channelIndex);
     for (let frameIndex = 0;frameIndex < frameCount; frameIndex += 1) {
       const sampleIndex = frameIndex * channels + channelIndex;
       const sampleOffset = sampleIndex * 2;
-      if (sampleOffset + 1 >= bytes.byteLength) {
+      if (sampleOffset + 1 >= bytes2.byteLength) {
         channelData[frameIndex] = 0;
         continue;
       }
@@ -2570,20 +2690,20 @@ var floatTo16BitPCM = (input) => {
   return new Uint8Array(output.buffer);
 };
 var getPcmLevel = (audio) => {
-  const bytes = audio instanceof Uint8Array ? audio : new Uint8Array(audio);
-  if (bytes.byteLength < 2) {
+  const bytes2 = audio instanceof Uint8Array ? audio : new Uint8Array(audio);
+  if (bytes2.byteLength < 2) {
     return 0;
   }
-  const samples = new Int16Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 2));
-  if (samples.length === 0) {
+  const samples2 = new Int16Array(bytes2.buffer, bytes2.byteOffset, Math.floor(bytes2.byteLength / 2));
+  if (samples2.length === 0) {
     return 0;
   }
   let sumSquares = 0;
-  for (const sample of samples) {
+  for (const sample of samples2) {
     const normalized = sample / 32768;
     sumSquares += normalized * normalized;
   }
-  return Math.min(1, Math.max(0, Math.sqrt(sumSquares / samples.length) * 5.5));
+  return Math.min(1, Math.max(0, Math.sqrt(sumSquares / samples2.length) * 5.5));
 };
 var downsampleBuffer = (input, sourceRate, targetRate) => {
   if (sourceRate === targetRate) {
@@ -3461,16 +3581,16 @@ var toInt16Array = (audio) => {
   }
   return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
 };
-var computeRms = (samples) => {
-  if (samples.length === 0) {
+var computeRms = (samples2) => {
+  if (samples2.length === 0) {
     return 0;
   }
   let sumSquares = 0;
-  for (const sample of samples) {
+  for (const sample of samples2) {
     const normalized = sample / 32768;
     sumSquares += normalized * normalized;
   }
-  return Math.sqrt(sumSquares / samples.length);
+  return Math.sqrt(sumSquares / samples2.length);
 };
 var conditionAudioChunk = (audio, config) => {
   if (!config) {
@@ -4273,7 +4393,7 @@ var resolveVoiceFixtureDirectories = async (input) => {
 };
 var clampSample2 = (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 toPcm16Bytes = (samples2) => new Uint8Array(samples2.buffer.slice(samples2.byteOffset, samples2.byteOffset + samples2.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);
@@ -4285,20 +4405,20 @@ var concatAudioChunks = (chunks) => {
   }
   return output;
 };
-var resamplePcm16Mono = (samples, sourceRate, targetRate) => {
-  if (sourceRate === targetRate || samples.length === 0) {
-    return samples;
+var resamplePcm16Mono = (samples2, sourceRate, targetRate) => {
+  if (sourceRate === targetRate || samples2.length === 0) {
+    return samples2;
   }
   const ratio = targetRate / sourceRate;
-  const targetLength = Math.max(1, Math.round(samples.length * ratio));
+  const targetLength = Math.max(1, Math.round(samples2.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 nextIndex = Math.min(previousIndex + 1, samples2.length - 1);
     const fraction = sourceIndex - previousIndex;
-    const previous = samples[previousIndex] ?? 0;
-    const next = samples[nextIndex] ?? previous;
+    const previous = samples2[previousIndex] ?? 0;
+    const next = samples2[nextIndex] ?? previous;
     output[index] = clampSample2(previous + (next - previous) * fraction);
   }
   return output;
@@ -4576,6 +4696,21 @@ var createVoiceIOProviderFailureSimulator = (options) => {
     run
   };
 };
+// src/testing/outcomes.ts
+var summarizeVoiceBenchmarkOutcomes = (fixtures, costs) => {
+  const critical = fixtures.map((fixture) => fixture.criticalFields).filter((value) => value !== undefined);
+  const passingFixtureCount = fixtures.filter((fixture) => fixture.passes).length;
+  const requiredFields = critical.flatMap((value) => value.fields.filter((field) => field.required));
+  const completeRequiredProfileRate = critical.length > 0 ? critical.filter((value) => value.passesRequired).length / critical.length : 1;
+  return {
+    completeRequiredProfileRate,
+    costPerPassingFixture: costs && passingFixtureCount > 0 ? costs.total / passingFixtureCount : undefined,
+    fixtureCount: fixtures.length,
+    passingFixtureCount,
+    requiredFieldAccuracy: requiredFields.length > 0 ? requiredFields.filter((field) => field.matched).length / requiredFields.length : 1,
+    totalCost: costs?.total
+  };
+};
 // src/core/debugTiming.ts
 var timingEnabled = () => process.env.ABSOLUTEJS_VOICE_TIMING === "1" || process.env.ABSOLUTEJS_VOICE_TIMING === "true";
 var emitTiming = (sessionId, stage, elapsedMs, detail) => {
@@ -5857,6 +5992,22 @@ var createVoiceProviderFailureSimulator = (options) => {
     run
   };
 };
+// src/testing/provenance.ts
+import { createHash } from "crypto";
+var sha256Bytes = (value) => createHash("sha256").update(value).digest("hex");
+var stableBenchmarkJson = (value) => {
+  if (Array.isArray(value))
+    return `[${value.map(stableBenchmarkJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableBenchmarkJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+var buildVoiceBenchmarkArtifact = (manifest, report) => {
+  const payload = { manifest, report };
+  return { ...payload, artifactSha256: sha256Bytes(stableBenchmarkJson(payload)) };
+};
+var verifyVoiceBenchmarkArtifact = (artifact) => artifact.artifactSha256 === sha256Bytes(stableBenchmarkJson({ manifest: artifact.manifest, report: artifact.report }));
 // src/core/memoryStore.ts
 var createVoiceMemoryStore = () => {
   const sessions = new Map;
@@ -6042,7 +6193,7 @@ var createVoiceBackchannelDriver = (options) => {
 };
 
 // src/core/handoff.ts
-var toHex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var toHex = (bytes2) => Array.from(bytes2, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signHandoffBody = async (input) => {
   const encoder = new TextEncoder;
   const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
@@ -7041,7 +7192,7 @@ var createVoiceSession = (options) => {
   };
   const recordingFormats = {};
   let recordingPersisted = false;
-  const captureRecordingChunk = (channel, bytes, format) => {
+  const captureRecordingChunk = (channel, bytes2, format) => {
     if (!recordingConfig || recordingPersisted) {
       return;
     }
@@ -7056,7 +7207,7 @@ var createVoiceSession = (options) => {
       return;
     }
     const remaining = recordingMaxBytes - currentTotal;
-    const slice = bytes.byteLength <= remaining ? bytes : bytes.subarray(0, remaining);
+    const slice = bytes2.byteLength <= remaining ? bytes2 : bytes2.subarray(0, remaining);
     recordingBuffers[channel].push(new Uint8Array(slice));
     recordingByteTotals[channel] += slice.byteLength;
     recordingFormats[channel] = format;
@@ -10820,6 +10971,63 @@ var summarizeVoiceSessionBenchmarkSeries = (input) => {
     }
   };
 };
+// src/testing/statistics.ts
+var mean = (values) => values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
+var aggregateTranscriptAccuracy = (values) => {
+  const alignments = values.map((value) => value.alignment).filter(Boolean);
+  const sum = (key) => alignments.reduce((total, alignment) => total + alignment[key], 0);
+  const referenceWordCount = sum("referenceWordCount");
+  const errors = sum("substitutions") + sum("deletions") + sum("insertions");
+  return {
+    correct: sum("correct"),
+    deletions: sum("deletions"),
+    insertions: sum("insertions"),
+    macroWordErrorRate: mean(values.map((value) => value.wordErrorRate)),
+    microWordErrorRate: referenceWordCount > 0 ? errors / referenceWordCount : 0,
+    referenceWordCount,
+    sentenceErrorRate: values.length > 0 ? alignments.filter((alignment) => alignment.sentenceError).length / values.length : 0,
+    substitutions: sum("substitutions")
+  };
+};
+var seededRandom = (seed) => {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+};
+var comparePairedMetrics = (baseline, candidate, options = {}) => {
+  if (baseline.length !== candidate.length || baseline.length === 0) {
+    throw new Error("Paired comparisons require equal, non-empty samples.");
+  }
+  const samples2 = options.samples ?? 1e4;
+  const confidenceLevel = options.confidenceLevel ?? 0.95;
+  const random = seededRandom(options.seed ?? 20260722);
+  const deltas = [];
+  for (let sample = 0;sample < samples2; sample += 1) {
+    const selected = [];
+    for (let index = 0;index < baseline.length; index += 1) {
+      const selectedIndex = Math.floor(random() * baseline.length);
+      selected.push(candidate[selectedIndex] - baseline[selectedIndex]);
+    }
+    deltas.push(mean(selected));
+  }
+  deltas.sort((left, right) => left - right);
+  const alpha = (1 - confidenceLevel) / 2;
+  const percentile = (value) => deltas[Math.min(deltas.length - 1, Math.floor(value * deltas.length))] ?? 0;
+  return {
+    baselineMean: mean(baseline),
+    candidateMean: mean(candidate),
+    delta: mean(candidate) - mean(baseline),
+    deltaConfidenceInterval: {
+      confidenceLevel,
+      high: percentile(1 - alpha),
+      low: percentile(alpha),
+      samples: samples2
+    },
+    probabilityCandidateIsBetter: deltas.filter((delta) => delta < 0).length / deltas.length
+  };
+};
 // src/core/operationsRecord.ts
 import { Elysia as Elysia4 } from "elysia";
 import {
@@ -11182,7 +11390,7 @@ var sleep2 = async (delayMs) => {
   }
   await new Promise((resolve2) => setTimeout(resolve2, delayMs));
 };
-var toHex2 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var toHex2 = (bytes2) => Array.from(bytes2, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceTraceSinkBody = async (input) => {
   const encoder = new TextEncoder;
   const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
@@ -13799,7 +14007,7 @@ var flattenPayload = (value) => {
     ...isRecord(data?.payload) ? data.payload : undefined
   };
 };
-var toBase64 = (bytes) => Buffer.from(new Uint8Array(bytes)).toString("base64");
+var toBase64 = (bytes2) => Buffer.from(new Uint8Array(bytes2)).toString("base64");
 var timingSafeEqual = (left, right) => {
   const encoder = new TextEncoder;
   const leftBytes = encoder.encode(left);
@@ -14647,37 +14855,37 @@ var decodeMulawSample = (value) => {
   sample -= MULAW_BIAS;
   return sign ? -sample : sample;
 };
-var int16ArrayToBytes = (samples) => {
-  const output = new Uint8Array(samples.length * 2);
+var int16ArrayToBytes = (samples2) => {
+  const output = new Uint8Array(samples2.length * 2);
   const view = new DataView(output.buffer);
-  for (let index = 0;index < samples.length; index += 1) {
-    view.setInt16(index * 2, samples[index] ?? 0, true);
+  for (let index = 0;index < samples2.length; index += 1) {
+    view.setInt16(index * 2, samples2[index] ?? 0, true);
   }
   return output;
 };
-var bytesToInt16Array = (bytes) => {
-  const sampleCount = Math.floor(bytes.byteLength / 2);
+var bytesToInt16Array = (bytes2) => {
+  const sampleCount = Math.floor(bytes2.byteLength / 2);
   const output = new Int16Array(sampleCount);
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
   for (let index = 0;index < sampleCount; index += 1) {
     output[index] = view.getInt16(index * 2, true);
   }
   return output;
 };
 var decodeTwilioMulawBase64 = (payload) => {
-  const bytes = Uint8Array.from(Buffer3.from(payload, "base64"));
-  const samples = new Int16Array(bytes.length);
-  for (let index = 0;index < bytes.length; index += 1) {
-    samples[index] = decodeMulawSample(bytes[index] ?? 0);
+  const bytes2 = Uint8Array.from(Buffer3.from(payload, "base64"));
+  const samples2 = new Int16Array(bytes2.length);
+  for (let index = 0;index < bytes2.length; index += 1) {
+    samples2[index] = decodeMulawSample(bytes2[index] ?? 0);
   }
-  return samples;
+  return samples2;
 };
-var encodeTwilioMulawBase64 = (samples) => {
-  const bytes = new Uint8Array(samples.length);
-  for (let index = 0;index < samples.length; index += 1) {
-    bytes[index] = encodeMulawSample(samples[index] ?? 0);
+var encodeTwilioMulawBase64 = (samples2) => {
+  const bytes2 = new Uint8Array(samples2.length);
+  for (let index = 0;index < samples2.length; index += 1) {
+    bytes2[index] = encodeMulawSample(samples2[index] ?? 0);
   }
-  return Buffer3.from(bytes).toString("base64");
+  return Buffer3.from(bytes2).toString("base64");
 };
 var transcodePCMToTwilioOutboundPayload = (chunk, format) => {
   if (format.container === "raw" && format.encoding === "mulaw" && format.channels === 1 && format.sampleRateHz === TWILIO_MULAW_SAMPLE_RATE) {
@@ -15800,13 +16008,17 @@ var summarizeTTSBenchmark = (adapterId, fixtures) => {
 };
 export {
   withVoiceCallReviewId,
+  verifyVoiceBenchmarkArtifact,
   summarizeVoiceTelephonyBenchmark,
   summarizeVoiceSessionBenchmarkSeries,
   summarizeVoiceSessionBenchmark,
   summarizeVoiceDuplexBenchmark,
+  summarizeVoiceBenchmarkOutcomes,
   summarizeTTSBenchmark,
   summarizeSTTBenchmarkSeries,
   summarizeSTTBenchmark,
+  stableBenchmarkJson,
+  sha256Bytes,
   scoreVoiceCriticalFields,
   scoreTranscriptAccuracy,
   scoreCorrectedExpectedTerms,
@@ -15837,6 +16049,7 @@ export {
   getDefaultTTSBenchmarkFixtures,
   evaluateVoiceSTTRouting,
   evaluateSTTBenchmarkAcceptance,
+  evaluateSTTAdapterConformance,
   createVoiceProviderFailureSimulator,
   createVoiceIOProviderFailureSimulator,
   createVoiceCallReviewRecorder,
@@ -15847,13 +16060,19 @@ export {
   createCodeSwitchBenchmarkCorrectionHandler,
   createBenchmarkCorrectionHandler,
   compareSTTBenchmarks,
+  comparePairedMetrics,
   calibrateVoiceConfidence,
+  buildVoiceBenchmarkArtifact,
+  buildVoiceAudioMatrix,
   buildSessionCorrectionAudit,
   buildFixturePhraseHints,
   buildCorrectionBenchmarkAudit,
   buildCodeSwitchBenchmarkPhraseHints,
   buildCodeSwitchBenchmarkLexicon,
+  applyVoiceAudioCondition,
   applyLexiconCorrectedBenchmarkReport,
   applyExperimentalBenchmarkReport,
-  applyCorrectedBenchmarkReport
+  applyCorrectedBenchmarkReport,
+  alignTranscriptWords,
+  aggregateTranscriptAccuracy
 };

package/dist/testing/outcomes.d.ts

@@ -0,0 +1,12 @@
+import type { VoiceSTTBenchmarkFixtureResult } from "./benchmark";
+export type VoiceBenchmarkOutcomeSummary = {
+    completeRequiredProfileRate: number;
+    costPerPassingFixture?: number;
+    fixtureCount: number;
+    passingFixtureCount: number;
+    requiredFieldAccuracy: number;
+    totalCost?: number;
+};
+export declare const summarizeVoiceBenchmarkOutcomes: (fixtures: VoiceSTTBenchmarkFixtureResult[], costs?: {
+    total: number;
+}) => VoiceBenchmarkOutcomeSummary;

package/dist/testing/provenance.d.ts

@@ -0,0 +1,44 @@
+export type VoiceBenchmarkPromptTrack = "unprompted" | "production-context" | "oracle-seeded";
+export type VoiceCorpusSplit = "development" | "public-test" | "private-held-out";
+export type VoiceCorpusFixtureProvenance = {
+    audioSha256: string;
+    consent?: string;
+    fixtureId: string;
+    license: string;
+    licenseClass: "permissive" | "noncommercial" | "private";
+    source: string;
+    split: VoiceCorpusSplit;
+};
+export type VoiceBenchmarkRunManifest = {
+    adapter: {
+        id: string;
+        model?: string;
+        provider?: string;
+        version?: string;
+    };
+    corpus: {
+        fixtures: VoiceCorpusFixtureProvenance[];
+        manifestSha256: string;
+        name: string;
+        version: string;
+    };
+    createdAt: string;
+    environment: Record<string, string | number | boolean>;
+    git: Record<string, string>;
+    preprocessing: Record<string, unknown>;
+    pricing?: Record<string, number>;
+    promptTrack: VoiceBenchmarkPromptTrack;
+    seed: number;
+};
+export declare const sha256Bytes: (value: Uint8Array | string) => string;
+export declare const stableBenchmarkJson: (value: unknown) => string;
+export declare const buildVoiceBenchmarkArtifact: <T>(manifest: VoiceBenchmarkRunManifest, report: T) => {
+    artifactSha256: string;
+    manifest: VoiceBenchmarkRunManifest;
+    report: T;
+};
+export declare const verifyVoiceBenchmarkArtifact: (artifact: {
+    artifactSha256: string;
+    manifest: VoiceBenchmarkRunManifest;
+    report: unknown;
+}) => boolean;

package/dist/testing/statistics.d.ts

@@ -0,0 +1,30 @@
+import type { VoiceTranscriptAccuracy } from "./accuracy";
+export type VoiceAggregateErrorMetrics = {
+    correct: number;
+    deletions: number;
+    insertions: number;
+    macroWordErrorRate: number;
+    microWordErrorRate: number;
+    referenceWordCount: number;
+    sentenceErrorRate: number;
+    substitutions: number;
+};
+export type VoiceConfidenceInterval = {
+    confidenceLevel: number;
+    high: number;
+    low: number;
+    samples: number;
+};
+export type VoicePairedBootstrapComparison = {
+    baselineMean: number;
+    candidateMean: number;
+    delta: number;
+    deltaConfidenceInterval: VoiceConfidenceInterval;
+    probabilityCandidateIsBetter: number;
+};
+export declare const aggregateTranscriptAccuracy: (values: VoiceTranscriptAccuracy[]) => VoiceAggregateErrorMetrics;
+export declare const comparePairedMetrics: (baseline: number[], candidate: number[], options?: {
+    confidenceLevel?: number;
+    samples?: number;
+    seed?: number;
+}) => VoicePairedBootstrapComparison;

package/package.json

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