@absolutejs/voice 0.0.22-beta.313 → 0.0.22-beta.315

package/dist/index.d.ts

@@ -15,8 +15,6 @@ export type { VoiceRealtimeChannelAssertionInput, VoiceRealtimeChannelAssertionR
 export { assertVoiceRealtimeProviderContractEvidence, buildVoiceRealtimeProviderContractMatrix, createVoiceRealtimeProviderContractMatrixPreset, createVoiceRealtimeProviderContractRoutes, evaluateVoiceRealtimeProviderContractEvidence, renderVoiceRealtimeProviderContractHTML } from './realtimeProviderContracts';
 export type { VoiceRealtimeProviderContractAssertionInput, VoiceRealtimeProviderContractAssertionReport, VoiceRealtimeProviderContractCapability, VoiceRealtimeProviderContractCheck, VoiceRealtimeProviderContractDefinition, VoiceRealtimeProviderContractMatrixPresetOptions, VoiceRealtimeProviderContractMatrixInput, VoiceRealtimeProviderContractMatrixReport, VoiceRealtimeProviderContractRoutesOptions, VoiceRealtimeProviderContractRow, VoiceRealtimeProviderPresetProvider, VoiceRealtimeProviderContractStatus } from './realtimeProviderContracts';
 export { buildVoiceDiagnosticsMarkdown, createVoiceDiagnosticsRoutes, resolveVoiceDiagnosticsTraceFilter } from './diagnosticsRoutes';
-export { buildVoiceMediaTransportReport, buildVoiceMediaInterruptionReport, buildVoiceMediaPipelineCalibrationReport, buildVoiceMediaResamplingPlan, buildVoiceMediaProcessorGraphReport, buildVoiceMediaVadReport, createVoiceMediaFrame, createVoiceMediaFrameTransformPipeline, createVoiceMediaProcessorGraph, createVoiceMediaTransport } from './mediaPipeline';
-export type { VoiceMediaFrame, VoiceMediaFrameKind, VoiceMediaFrameSource, VoiceMediaFrameTransform, VoiceMediaFrameTransformPipeline, VoiceMediaInterruptionInput, VoiceMediaInterruptionReport, VoiceMediaPipelineCalibrationInput, VoiceMediaPipelineCalibrationIssue, VoiceMediaPipelineCalibrationReport, VoiceMediaPipelineStatus, VoiceMediaProcessorGraph, VoiceMediaProcessorGraphReport, VoiceMediaProcessorNode, VoiceMediaProcessorNodeEvent, VoiceMediaProcessorNodeKind, VoiceMediaProcessorNodeReport, VoiceMediaResamplingPlan, VoiceMediaTransport, VoiceMediaTransportAdapter, VoiceMediaTransportEvent, VoiceMediaTransportEventKind, VoiceMediaTransportOptions, VoiceMediaTransportReport, VoiceMediaTransportState, VoiceMediaVadInput, VoiceMediaVadReport, VoiceMediaVadSegment } from './mediaPipeline';
 export { assertVoiceMediaPipelineEvidence, buildVoiceMediaPipelineReport, createVoiceMediaPipelineRoutes, evaluateVoiceMediaPipelineEvidence, renderVoiceMediaPipelineHTML, renderVoiceMediaPipelineMarkdown } from './mediaPipelineRoutes';
 export type { VoiceMediaPipelineAssertionInput, VoiceMediaPipelineAssertionReport, VoiceMediaPipelineReport, VoiceMediaPipelineReportOptions, VoiceMediaPipelineRoutesOptions } from './mediaPipelineRoutes';
 export { buildVoiceDemoReadyReport, createVoiceDemoReadyRoutes, renderVoiceDemoReadyHTML } from './demoReadyRoutes';

package/dist/index.js

@@ -11609,7 +11609,10 @@ var createVoiceDiagnosticsRoutes = (options) => {
   });
   return routes;
 };
-// src/mediaPipeline.ts
+// src/mediaPipelineRoutes.ts
+import { Elysia as Elysia12 } from "elysia";
+
+// node_modules/@absolutejs/media/dist/index.js
 var formatLabel2 = (format) => `${format.container}/${format.encoding}/${String(format.sampleRateHz)}hz/${String(format.channels)}ch`;
 var formatMatches2 = (actual, expected) => actual.container === expected.container && actual.encoding === expected.encoding && actual.sampleRateHz === expected.sampleRateHz && actual.channels === expected.channels;
 var pushIssue = (issues, severity, code, message) => {
@@ -11619,97 +11622,10 @@ var numericMetadata = (frame, key) => {
   const value = frame.metadata?.[key];
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 };
-var createVoiceMediaFrame = (frame) => frame;
-var buildVoiceMediaTransportReport = (input) => {
-  const events = input.events ?? [];
-  const state = input.state ?? events.at(-1)?.state ?? "idle";
-  const backpressureEvents = events.filter((event) => event.kind === "backpressure").length;
-  const failed = state === "failed" || events.some((event) => event.kind === "error");
-  return {
-    backpressureEvents,
-    checkedAt: Date.now(),
-    closed: state === "closed",
-    connected: state === "open",
-    events,
-    failed,
-    inputFrames: events.filter((event) => event.kind === "frame-in").length,
-    name: input.name,
-    outputFrames: events.filter((event) => event.kind === "frame-out").length,
-    state,
-    status: failed ? "fail" : backpressureEvents > 0 ? "warn" : "pass"
-  };
-};
-var createVoiceMediaTransport = (options) => {
-  let state = "idle";
-  const events = [];
-  const frameHandlers = new Set;
-  const record = (event) => {
-    events.push({ ...event, at: Date.now(), state });
-  };
-  return {
-    close: async () => {
-      state = "closing";
-      await options.onClose?.();
-      state = "closed";
-      record({ kind: "close" });
-    },
-    connect: async () => {
-      try {
-        await options.onConnect?.();
-        state = "open";
-        record({ kind: "connect" });
-      } catch (error) {
-        state = "failed";
-        record({
-          error: error instanceof Error ? error.message : String(error),
-          kind: "error"
-        });
-        throw error;
-      }
-    },
-    events: () => [...events],
-    inputFormat: options.inputFormat,
-    name: options.name,
-    onFrame: (handler) => {
-      frameHandlers.add(handler);
-      return () => frameHandlers.delete(handler);
-    },
-    outputFormat: options.outputFormat,
-    receive: async (frame) => {
-      record({ frameId: frame.id, kind: "frame-in" });
-      if (options.maxBufferedFrames !== undefined && events.filter((event) => event.kind === "frame-in").length > options.maxBufferedFrames) {
-        record({
-          bufferedFrames: events.filter((event) => event.kind === "frame-in").length,
-          kind: "backpressure"
-        });
-      }
-      for (const handler of frameHandlers) {
-        await handler(frame);
-      }
-    },
-    report: () => buildVoiceMediaTransportReport({
-      events,
-      name: options.name,
-      state
-    }),
-    send: async (frame) => {
-      try {
-        await options.onSend?.(frame);
-        record({ frameId: frame.id, kind: "frame-out" });
-      } catch (error) {
-        state = "failed";
-        record({
-          error: error instanceof Error ? error.message : String(error),
-          frameId: frame.id,
-          kind: "error"
-        });
-        throw error;
-      }
-    },
-    state: () => state
-  };
-};
-var buildVoiceMediaResamplingPlan = (input) => {
+var average = (values) => values.length === 0 ? undefined : values.reduce((total, value) => total + value, 0) / values.length;
+var max = (values) => values.length === 0 ? undefined : Math.max(...values);
+var min = (values) => values.length === 0 ? undefined : Math.min(...values);
+var buildMediaResamplingPlan = (input) => {
   const required = !formatMatches2(input.inputFormat, input.outputFormat);
   return {
     inputFormat: input.inputFormat,
@@ -11719,126 +11635,6 @@ var buildVoiceMediaResamplingPlan = (input) => {
     status: input.inputFormat.container === input.outputFormat.container && input.inputFormat.encoding === input.outputFormat.encoding && input.inputFormat.channels === input.outputFormat.channels ? "pass" : "warn"
   };
 };
-var createVoiceMediaFrameTransformPipeline = (input = {}) => {
-  const transforms = input.transforms ?? [];
-  const push = async (frame) => {
-    let frames = [frame];
-    for (const transform of transforms) {
-      const nextFrames = [];
-      for (const current of frames) {
-        const transformed = await transform.transform(current);
-        if (transformed === undefined) {
-          continue;
-        }
-        if (Array.isArray(transformed)) {
-          nextFrames.push(...transformed);
-        } else {
-          nextFrames.push(transformed);
-        }
-      }
-      frames = nextFrames;
-    }
-    return frames;
-  };
-  return {
-    push,
-    pushMany: async (frames) => {
-      const output = [];
-      for (const frame of frames) {
-        output.push(...await push(frame));
-      }
-      return output;
-    },
-    transforms
-  };
-};
-var normalizeProcessorResult = (frame, result) => {
-  if (result === false || result === undefined) {
-    return [];
-  }
-  if (result === true) {
-    return [frame];
-  }
-  if (Array.isArray(result)) {
-    return result;
-  }
-  return [result];
-};
-var buildVoiceMediaProcessorGraphReport = (input) => {
-  const events = input.events ?? [];
-  const nodes = input.nodes.map((node) => {
-    const nodeEvents = events.filter((event) => event.node === node.name);
-    const droppedFrames2 = nodeEvents.reduce((total, event) => total + event.dropped, 0);
-    const emittedFrames2 = nodeEvents.reduce((total, event) => total + event.emitted, 0);
-    const inputFrames2 = nodeEvents.reduce((total, event) => total + event.inputs, 0);
-    return {
-      droppedFrames: droppedFrames2,
-      emittedFrames: emittedFrames2,
-      events: nodeEvents,
-      inputFrames: inputFrames2,
-      kind: node.kind ?? "processor",
-      name: node.name,
-      status: inputFrames2 > 0 && emittedFrames2 === 0 && node.kind !== "sink" ? "warn" : "pass"
-    };
-  });
-  const inputFrames = events.filter((event) => event.node === input.nodes[0]?.name).length;
-  const droppedFrames = events.reduce((total, event) => total + event.dropped, 0);
-  const emittedFrames = input.nodes.at(-1) ? events.filter((event) => event.node === input.nodes.at(-1)?.name).reduce((total, event) => total + event.emitted, 0) : 0;
-  const status = nodes.some((node) => node.status === "warn") ? "warn" : "pass";
-  return {
-    checkedAt: Date.now(),
-    droppedFrames,
-    emittedFrames,
-    events,
-    inputFrames,
-    name: input.name,
-    nodes,
-    status
-  };
-};
-var createVoiceMediaProcessorGraph = (input = {}) => {
-  const nodes = input.nodes ?? [];
-  const events = [];
-  const process = async (frame) => {
-    let frames = [frame];
-    for (const node of nodes) {
-      const nextFrames = [];
-      for (const current of frames) {
-        const output = normalizeProcessorResult(current, await node.process(current));
-        events.push({
-          at: Date.now(),
-          dropped: output.length === 0 ? 1 : 0,
-          emitted: output.length,
-          frameId: current.id,
-          inputs: 1,
-          node: node.name
-        });
-        nextFrames.push(...output);
-      }
-      frames = nextFrames;
-      if (frames.length === 0) {
-        break;
-      }
-    }
-    return frames;
-  };
-  return {
-    nodes,
-    process,
-    processMany: async (frames) => {
-      const output = [];
-      for (const frame of frames) {
-        output.push(...await process(frame));
-      }
-      return output;
-    },
-    report: () => buildVoiceMediaProcessorGraphReport({
-      events,
-      name: input.name ?? "voice-media-processor-graph",
-      nodes
-    })
-  };
-};
 var speechProbability = (frame) => {
   if (frame.metadata?.isSpeech === true) {
     return 1;
@@ -11854,7 +11650,7 @@ var speechProbability = (frame) => {
   }
   return 0;
 };
-var buildVoiceMediaVadReport = (input = {}) => {
+var buildMediaVadReport = (input = {}) => {
   const frames = (input.frames ?? []).filter((frame) => frame.kind === "input-audio");
   const speechStartThreshold = input.speechStartThreshold ?? 0.6;
   const speechEndThreshold = input.speechEndThreshold ?? 0.35;
@@ -11912,7 +11708,7 @@ var buildVoiceMediaVadReport = (input = {}) => {
     status: frames.length === 0 ? "warn" : "pass"
   };
 };
-var buildVoiceMediaInterruptionReport = (input = {}) => {
+var buildMediaInterruptionReport = (input = {}) => {
   const issues = [];
   const interruptionFrames = (input.frames ?? []).filter((frame) => frame.kind === "interruption");
   const latenciesMs = interruptionFrames.map((frame) => frame.latencyMs).filter((latency) => typeof latency === "number");
@@ -11931,7 +11727,77 @@ var buildVoiceMediaInterruptionReport = (input = {}) => {
     status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass"
   };
 };
-var buildVoiceMediaPipelineCalibrationReport = (input = {}) => {
+var buildMediaQualityReport = (input = {}) => {
+  const frames = [...input.frames ?? []].sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+  const audioFrames = frames.filter((frame) => frame.kind === "input-audio" || frame.kind === "assistant-audio");
+  const inputAudioFrames = frames.filter((frame) => frame.kind === "input-audio");
+  const assistantAudioFrames = frames.filter((frame) => frame.kind === "assistant-audio");
+  const issues = [];
+  const gapsMs = [];
+  for (const [index, frame] of audioFrames.entries()) {
+    const previous = audioFrames[index - 1];
+    if (previous?.at === undefined || frame.at === undefined || previous.durationMs === undefined) {
+      continue;
+    }
+    const gap = frame.at - (previous.at + previous.durationMs);
+    if (gap > 0) {
+      gapsMs.push(gap);
+    }
+  }
+  const jitterMs = audioFrames.map((frame) => numericMetadata(frame, "jitterMs")).filter((value) => value !== undefined).at(-1) ?? max(gapsMs);
+  const first = audioFrames.find((frame) => frame.at !== undefined);
+  const last = audioFrames.toReversed().find((frame) => frame.at !== undefined);
+  const durationMs = first?.at !== undefined && last?.at !== undefined ? last.at - first.at + (last.durationMs ?? 0) : undefined;
+  const expectedDurationMs = audioFrames.length > 0 ? audioFrames.reduce((total, frame) => total + (frame.durationMs ?? 0), 0) : undefined;
+  const timestampDriftMs = durationMs !== undefined && expectedDurationMs !== undefined ? Math.max(0, durationMs - expectedDurationMs) : undefined;
+  const speechScores = inputAudioFrames.map(speechProbability);
+  const speechFrames = speechScores.filter((score) => score >= 0.6).length;
+  const silenceFrames = speechScores.filter((score) => score <= 0.35).length;
+  const unknownSpeechFrames = Math.max(0, inputAudioFrames.length - speechFrames - silenceFrames);
+  const speechRatio = inputAudioFrames.length === 0 ? 0 : speechFrames / inputAudioFrames.length;
+  const silenceRatio = inputAudioFrames.length === 0 ? 0 : silenceFrames / inputAudioFrames.length;
+  const levels = audioFrames.map((frame) => numericMetadata(frame, "level") ?? numericMetadata(frame, "rms") ?? numericMetadata(frame, "energy")).filter((value) => value !== undefined);
+  const backpressureEvents = input.transport?.backpressureEvents ?? 0;
+  const maxGapMs = input.maxGapMs;
+  if (maxGapMs !== undefined && gapsMs.some((gap) => gap > maxGapMs)) {
+    pushIssue(issues, "warning", "media.quality_gap", `Observed media gap above ${String(maxGapMs)}ms.`);
+  }
+  if (input.maxJitterMs !== undefined && jitterMs !== undefined && jitterMs > input.maxJitterMs) {
+    pushIssue(issues, "warning", "media.quality_jitter", `Observed jitter ${String(jitterMs)}ms above ${String(input.maxJitterMs)}ms.`);
+  }
+  if (input.maxTimestampDriftMs !== undefined && timestampDriftMs !== undefined && timestampDriftMs > input.maxTimestampDriftMs) {
+    pushIssue(issues, "warning", "media.quality_timestamp_drift", `Observed timestamp drift ${String(timestampDriftMs)}ms above ${String(input.maxTimestampDriftMs)}ms.`);
+  }
+  if (input.minSpeechRatio !== undefined && inputAudioFrames.length > 0 && speechRatio < input.minSpeechRatio) {
+    pushIssue(issues, "warning", "media.quality_speech_ratio", `Observed speech ratio ${String(speechRatio)} below ${String(input.minSpeechRatio)}.`);
+  }
+  if (input.maxBackpressureEvents !== undefined && backpressureEvents > input.maxBackpressureEvents) {
+    pushIssue(issues, "warning", "media.quality_backpressure", `Observed ${String(backpressureEvents)} backpressure event(s), above ${String(input.maxBackpressureEvents)}.`);
+  }
+  return {
+    assistantAudioFrames: assistantAudioFrames.length,
+    backpressureEvents,
+    checkedAt: Date.now(),
+    durationMs,
+    gapCount: gapsMs.length,
+    gapsMs,
+    inputAudioFrames: inputAudioFrames.length,
+    issues,
+    jitterMs,
+    levelAverage: average(levels),
+    levelMax: max(levels),
+    levelMin: min(levels),
+    silenceFrames,
+    silenceRatio,
+    speechFrames,
+    speechRatio,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    timestampDriftMs,
+    totalFrames: frames.length,
+    unknownSpeechFrames
+  };
+};
+var buildMediaPipelineCalibrationReport = (input = {}) => {
   const frames = input.frames ?? [];
   const issues = [];
   const inputFrames = frames.filter((frame) => frame.kind === "input-audio");
@@ -11989,13 +11855,13 @@ var buildVoiceMediaPipelineCalibrationReport = (input = {}) => {
     resamplingRequired,
     resamplingTargetHz,
     status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
-    surface: input.surface ?? "voice-media-pipeline",
+    surface: input.surface ?? "media-pipeline",
     traceLinkedFrames,
     turnCommitFrames: turnCommitFrames.length
   };
 };
+
 // src/mediaPipelineRoutes.ts
-import { Elysia as Elysia12 } from "elysia";
 var escapeHtml15 = (value) => String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var statusRank2 = {
   pass: 0,
@@ -12005,19 +11871,28 @@ var statusRank2 = {
 var worstStatus = (statuses) => statuses.reduce((worst, status) => statusRank2[status] > statusRank2[worst] ? status : worst, "pass");
 var buildVoiceMediaPipelineReport = (options = {}) => {
   const frames = options.frames ?? [];
-  const calibration = buildVoiceMediaPipelineCalibrationReport(options);
-  const vad = buildVoiceMediaVadReport({
+  const calibration = buildMediaPipelineCalibrationReport(options);
+  const vad = buildMediaVadReport({
     frames,
     maxSilenceFrames: options.maxSilenceFrames,
     minSpeechFrames: options.minSpeechFrames,
     speechEndThreshold: options.speechEndThreshold,
     speechStartThreshold: options.speechStartThreshold
   });
-  const interruption = buildVoiceMediaInterruptionReport({
+  const interruption = buildMediaInterruptionReport({
     frames,
     maxInterruptionLatencyMs: options.maxInterruptionLatencyMs
   });
-  const resampling = calibration.inputFormat && calibration.outputFormat ? buildVoiceMediaResamplingPlan({
+  const quality = buildMediaQualityReport({
+    frames,
+    maxBackpressureEvents: options.maxMediaBackpressureEvents,
+    maxGapMs: options.maxMediaGapMs,
+    maxJitterMs: options.maxMediaJitterMs,
+    maxTimestampDriftMs: options.maxMediaTimestampDriftMs,
+    minSpeechRatio: options.minMediaSpeechRatio,
+    transport: options.transport
+  });
+  const resampling = calibration.inputFormat && calibration.outputFormat ? buildMediaResamplingPlan({
     inputFormat: calibration.inputFormat,
     outputFormat: calibration.outputFormat
   }) : undefined;
@@ -12025,6 +11900,7 @@ var buildVoiceMediaPipelineReport = (options = {}) => {
     calibration.status,
     vad.status,
     interruption.status,
+    quality.status,
     resampling?.status ?? "pass",
     options.processorGraph?.status ?? "pass",
     options.transport?.status ?? "pass"
@@ -12036,6 +11912,7 @@ var buildVoiceMediaPipelineReport = (options = {}) => {
     interruption,
     ok: status === "pass",
     processorGraph: options.processorGraph,
+    quality,
     resampling,
     status,
     surface: options.surface ?? "voice-media-pipeline",
@@ -12072,6 +11949,25 @@ var evaluateVoiceMediaPipelineEvidence = (report, input = {}) => {
   if (input.requireResamplingReady && report.calibration.resamplingRequired && !report.resampling) {
     issues.push("Expected resampling plan when calibration requires resampling.");
   }
+  if (input.requireQualityPass && report.quality.status !== "pass") {
+    issues.push(`Expected media quality proof to pass, found ${report.quality.status}.`);
+  }
+  const maxMediaGapMs = input.maxMediaGapMs;
+  if (maxMediaGapMs !== undefined && report.quality.gapsMs.some((gap) => gap > maxMediaGapMs)) {
+    issues.push(`Expected media gaps at or below ${String(maxMediaGapMs)}ms.`);
+  }
+  if (input.maxMediaJitterMs !== undefined && report.quality.jitterMs !== undefined && report.quality.jitterMs > input.maxMediaJitterMs) {
+    issues.push(`Expected media jitter at or below ${String(input.maxMediaJitterMs)}ms, found ${String(report.quality.jitterMs)}ms.`);
+  }
+  if (input.maxMediaTimestampDriftMs !== undefined && report.quality.timestampDriftMs !== undefined && report.quality.timestampDriftMs > input.maxMediaTimestampDriftMs) {
+    issues.push(`Expected media timestamp drift at or below ${String(input.maxMediaTimestampDriftMs)}ms, found ${String(report.quality.timestampDriftMs)}ms.`);
+  }
+  if (input.minMediaSpeechRatio !== undefined && report.quality.speechRatio < input.minMediaSpeechRatio) {
+    issues.push(`Expected media speech ratio at or above ${String(input.minMediaSpeechRatio)}, found ${String(report.quality.speechRatio)}.`);
+  }
+  if (input.maxMediaBackpressureEvents !== undefined && report.quality.backpressureEvents > input.maxMediaBackpressureEvents) {
+    issues.push(`Expected at most ${String(input.maxMediaBackpressureEvents)} media backpressure event(s), found ${String(report.quality.backpressureEvents)}.`);
+  }
   if (input.requireProcessorGraph && !report.processorGraph) {
     issues.push("Expected media processor graph evidence.");
   }
@@ -12120,6 +12016,10 @@ var renderVoiceMediaPipelineMarkdown = (report) => [
   `- Resampling required: ${report.calibration.resamplingRequired ? "yes" : "no"}`,
   `- VAD segments: ${String(report.vad.segments.length)}`,
   `- Interruption frames: ${String(report.interruption.interruptionFrames)}`,
+  `- Media quality: ${report.quality.status}`,
+  `- Media quality gaps: ${String(report.quality.gapCount)}`,
+  `- Media quality jitter: ${String(report.quality.jitterMs ?? "n/a")}ms`,
+  `- Media quality speech ratio: ${String(report.quality.speechRatio)}`,
   `- Processor graph: ${report.processorGraph ? `${report.processorGraph.name} (${String(report.processorGraph.nodes.length)} nodes)` : "n/a"}`,
   `- Processor graph emitted frames: ${String(report.processorGraph?.emittedFrames ?? 0)}`,
   `- Processor graph dropped frames: ${String(report.processorGraph?.droppedFrames ?? 0)}`,
@@ -12132,13 +12032,18 @@ var renderVoiceMediaPipelineMarkdown = (report) => [
   "",
   ...[
     ...report.calibration.issues,
-    ...report.interruption.issues
+    ...report.interruption.issues,
+    ...report.quality.issues
   ].map((issue) => `- ${issue.severity.toUpperCase()} ${issue.code}: ${issue.message}`),
-  ...report.calibration.issues.length + report.interruption.issues.length === 0 ? ["- None"] : []
+  ...report.calibration.issues.length + report.interruption.issues.length + report.quality.issues.length === 0 ? ["- None"] : []
 ].join(`
 `);
 var renderVoiceMediaPipelineHTML = (report, title = "Voice Media Pipeline Proof") => {
-  const issues = [...report.calibration.issues, ...report.interruption.issues].map((issue) => `<li class="${escapeHtml15(issue.severity)}"><strong>${escapeHtml15(issue.code)}</strong>: ${escapeHtml15(issue.message)}</li>`).join("");
+  const issues = [
+    ...report.calibration.issues,
+    ...report.interruption.issues,
+    ...report.quality.issues
+  ].map((issue) => `<li class="${escapeHtml15(issue.severity)}"><strong>${escapeHtml15(issue.code)}</strong>: ${escapeHtml15(issue.message)}</li>`).join("");
   const segments = report.vad.segments.map((segment) => `<tr><td>${escapeHtml15(segment.segmentId)}</td><td>${escapeHtml15(segment.frameCount)}</td><td>${escapeHtml15(segment.durationMs ?? "n/a")}</td><td>${escapeHtml15(segment.turnId ?? "n/a")}</td></tr>`).join("");
   return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width,initial-scale=1" /><title>${escapeHtml15(title)}</title><style>body{background:#101418;color:#f7f3e8;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1100px;padding:32px}.hero,.card{background:#17201d;border:1px solid #2e3d36;border-radius:24px;margin-bottom:16px;padding:22px}.hero{background:linear-gradient(135deg,rgba(20,184,166,.18),rgba(245,158,11,.12))}.eyebrow{color:#5eead4;font-weight:900;letter-spacing:.1em;text-transform:uppercase}h1{font-size:clamp(2.3rem,6vw,4.8rem);letter-spacing:-.06em;line-height:.9;margin:.2rem 0 1rem}.summary{display:grid;gap:12px;grid-template-columns:repeat(auto-fit,minmax(170px,1fr))}.metric{background:#101814;border:1px solid #2e3d36;border-radius:18px;padding:14px}.metric span{color:#a8b5ad;display:block;font-size:.78rem;text-transform:uppercase}.metric strong{display:block;font-size:1.65rem;margin-top:5px}.status{border:1px solid #64748b;border-radius:999px;display:inline-flex;font-weight:900;padding:7px 11px}.pass{color:#86efac}.warn,.warning{color:#fde68a}.fail,.error{color:#fecaca}table{border-collapse:collapse;width:100%}td,th{border-bottom:1px solid #2e3d36;padding:10px;text-align:left}</style></head><body><main><section class="hero"><p class="eyebrow">Native media pipeline</p><h1>${escapeHtml15(title)}</h1><p class="status ${escapeHtml15(report.status)}">${escapeHtml15(report.status)}</p><p>${escapeHtml15(report.surface)}</p><section class="summary"><div class="metric"><span>Frames</span><strong>${String(report.frames)}</strong></div><div class="metric"><span>Input audio</span><strong>${String(report.calibration.inputAudioFrames)}</strong></div><div class="metric"><span>Assistant audio</span><strong>${String(report.calibration.assistantAudioFrames)}</strong></div><div class="metric"><span>Trace linked</span><strong>${String(report.calibration.traceLinkedFrames)}</strong></div><div class="metric"><span>First audio</span><strong>${escapeHtml15(report.calibration.firstAudioLatencyMs ?? "n/a")}ms</strong></div><div class="metric"><span>VAD segments</span><strong>${String(report.vad.segments.length)}</strong></div><div class="metric"><span>Interruptions</span><strong>${String(report.interruption.interruptionFrames)}</strong></div><div class="metric"><span>Processor graph</span><strong>${String(report.processorGraph?.nodes.length ?? 0)} nodes</strong></div><div class="metric"><span>Graph out/drop</span><strong>${String(report.processorGraph?.emittedFrames ?? 0)}/${String(report.processorGraph?.droppedFrames ?? 0)}</strong></div><div class="metric"><span>Resampling</span><strong>${report.calibration.resamplingRequired ? "required" : "not required"}</strong></div><div class="metric"><span>Transport</span><strong>${escapeHtml15(report.transport?.state ?? "n/a")}</strong></div><div class="metric"><span>Transport in/out</span><strong>${String(report.transport?.inputFrames ?? 0)}/${String(report.transport?.outputFrames ?? 0)}</strong></div><div class="metric"><span>Backpressure</span><strong>${String(report.transport?.backpressureEvents ?? 0)}</strong></div></section></section><section class="card"><h2>Issues</h2><ul>${issues || '<li class="pass">No media pipeline issues.</li>'}</ul></section><section class="card"><h2>VAD Segments</h2><table><thead><tr><th>Segment</th><th>Frames</th><th>Duration ms</th><th>Turn</th></tr></thead><tbody>${segments || '<tr><td colspan="4">No VAD segments.</td></tr>'}</tbody></table></section></main></body></html>`;
 };
@@ -19472,7 +19377,7 @@ var percentile4 = (values, percentileValue) => {
   const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(percentileValue / 100 * sorted.length) - 1));
   return Math.round(sorted[index] ?? 0);
 };
-var average = (values) => values.length === 0 ? undefined : Math.round(values.reduce((total, value) => total + value, 0) / values.length);
+var average2 = (values) => values.length === 0 ? undefined : Math.round(values.reduce((total, value) => total + value, 0) / values.length);
 var resolveBudget = (stage, options) => ({
   failAfterMs: options.budgets?.[stage]?.failAfterMs ?? options.failAfterMs ?? DEFAULT_FAIL_AFTER_MS2,
   warnAfterMs: options.budgets?.[stage]?.warnAfterMs ?? options.warnAfterMs ?? DEFAULT_WARN_AFTER_MS2
@@ -19666,7 +19571,7 @@ var summarizeStage = (stage, measurements, options) => {
   const failed = stageMeasurements.filter((measurement) => measurement.status === "fail").length;
   const warnings = stageMeasurements.filter((measurement) => measurement.status === "warn").length;
   return {
-    averageMs: average(latencies),
+    averageMs: average2(latencies),
     budget: resolveBudget(stage, options),
     failed,
     label: STAGE_LABELS[stage],
@@ -31490,7 +31395,7 @@ var statusRank6 = {
   warn: 1,
   fail: 2
 };
-var statusExceeds2 = (actual, max) => statusRank6[actual] > statusRank6[max];
+var statusExceeds2 = (actual, max2) => statusRank6[actual] > statusRank6[max2];
 var buildVoiceProviderContractMatrix = (input) => {
   const rows = input.contracts.map((contract) => {
     const configured = contract.configured !== false;
@@ -34971,11 +34876,7 @@ export {
   createVoiceMemoryAuditSinkDeliveryStore,
   createVoiceMemoryAuditEventStore,
   createVoiceMemoryAssistantMemoryStore,
-  createVoiceMediaTransport,
-  createVoiceMediaProcessorGraph,
   createVoiceMediaPipelineRoutes,
-  createVoiceMediaFrameTransformPipeline,
-  createVoiceMediaFrame,
   createVoiceLiveOpsRoutes,
   createVoiceLiveOpsController,
   createVoiceLiveLatencyRoutes,
@@ -35124,13 +35025,7 @@ export {
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
   buildVoiceMonitorRunReport,
-  buildVoiceMediaVadReport,
-  buildVoiceMediaTransportReport,
-  buildVoiceMediaResamplingPlan,
-  buildVoiceMediaProcessorGraphReport,
   buildVoiceMediaPipelineReport,
-  buildVoiceMediaPipelineCalibrationReport,
-  buildVoiceMediaInterruptionReport,
   buildVoiceLiveOpsControlState,
   buildVoiceLatencySLOGate,
   buildVoiceIncidentBundle,

package/dist/mediaPipelineRoutes.d.ts

@@ -1,33 +1,44 @@
 import { Elysia } from 'elysia';
-import { type VoiceMediaFrame, type VoiceMediaInterruptionReport, type VoiceMediaPipelineCalibrationInput, type VoiceMediaPipelineCalibrationReport, type VoiceMediaPipelineStatus, type VoiceMediaProcessorGraphReport, type VoiceMediaResamplingPlan, type VoiceMediaTransportReport, type VoiceMediaVadReport } from './mediaPipeline';
-export type VoiceMediaPipelineReportOptions = VoiceMediaPipelineCalibrationInput & {
-    frames?: readonly VoiceMediaFrame[];
+import { type MediaFrame, type MediaInterruptionReport, type MediaPipelineCalibrationInput, type MediaPipelineCalibrationReport, type MediaPipelineStatus, type MediaProcessorGraphReport, type MediaQualityReport, type MediaResamplingPlan, type MediaTransportReport, type MediaVadReport } from '@absolutejs/media';
+export type VoiceMediaPipelineReportOptions = MediaPipelineCalibrationInput & {
+    frames?: readonly MediaFrame[];
     maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
     maxSilenceFrames?: number;
+    minMediaSpeechRatio?: number;
     minSpeechFrames?: number;
-    processorGraph?: VoiceMediaProcessorGraphReport;
+    processorGraph?: MediaProcessorGraphReport;
     speechEndThreshold?: number;
     speechStartThreshold?: number;
-    transport?: VoiceMediaTransportReport;
+    transport?: MediaTransportReport;
 };
 export type VoiceMediaPipelineReport = {
-    calibration: VoiceMediaPipelineCalibrationReport;
+    calibration: MediaPipelineCalibrationReport;
     checkedAt: number;
     frames: number;
-    interruption: VoiceMediaInterruptionReport;
+    interruption: MediaInterruptionReport;
     ok: boolean;
-    resampling?: VoiceMediaResamplingPlan;
-    processorGraph?: VoiceMediaProcessorGraphReport;
-    status: VoiceMediaPipelineStatus;
+    quality: MediaQualityReport;
+    resampling?: MediaResamplingPlan;
+    processorGraph?: MediaProcessorGraphReport;
+    status: MediaPipelineStatus;
     surface: string;
-    transport?: VoiceMediaTransportReport;
-    vad: VoiceMediaVadReport;
+    transport?: MediaTransportReport;
+    vad: MediaVadReport;
 };
 export type VoiceMediaPipelineAssertionInput = {
     maxFirstAudioLatencyMs?: number;
     maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
     minAssistantAudioFrames?: number;
     minInputAudioFrames?: number;
+    minMediaSpeechRatio?: number;
     minProcessorGraphEmittedFrames?: number;
     minProcessorGraphNodes?: number;
     minTransportInputFrames?: number;
@@ -38,13 +49,14 @@ export type VoiceMediaPipelineAssertionInput = {
     requireInterruptionFrame?: boolean;
     requirePass?: boolean;
     requireProcessorGraph?: boolean;
+    requireQualityPass?: boolean;
     requireResamplingReady?: boolean;
     requireTransportConnected?: boolean;
 };
 export type VoiceMediaPipelineAssertionReport = {
     issues: string[];
     ok: boolean;
-    status: VoiceMediaPipelineStatus;
+    status: MediaPipelineStatus;
     surface: string;
 };
 export type VoiceMediaPipelineRoutesOptions = VoiceMediaPipelineReportOptions & {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.313",
+	"version": "0.0.22-beta.315",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",
@@ -245,6 +245,9 @@
 			"optional": true
 		}
 	},
+	"dependencies": {
+		"@absolutejs/media": "0.0.1-beta.2"
+	},
 	"devDependencies": {
 		"@absolutejs/absolute": "0.19.0-beta.646",
 		"@angular/core": "^21.0.0",

package/dist/mediaPipeline.d.ts

@@ -1,219 +0,0 @@
-import type { AudioFormat } from './types';
-export type VoiceMediaFrameKind = 'assistant-audio' | 'input-audio' | 'interruption' | 'metadata' | 'transcript' | 'turn-commit';
-export type VoiceMediaFrameSource = 'browser' | 'provider' | 'telephony' | 'voice-runtime';
-export type VoiceMediaPipelineStatus = 'fail' | 'pass' | 'warn';
-export type VoiceMediaResamplingPlan = {
-    inputFormat: AudioFormat;
-    outputFormat: AudioFormat;
-    ratio: number;
-    required: boolean;
-    status: VoiceMediaPipelineStatus;
-};
-export type VoiceMediaFrame = {
-    at?: number;
-    audio?: ArrayBuffer | ArrayBufferView;
-    durationMs?: number;
-    format?: AudioFormat;
-    id: string;
-    kind: VoiceMediaFrameKind;
-    latencyMs?: number;
-    metadata?: Record<string, unknown>;
-    sessionId?: string;
-    source: VoiceMediaFrameSource | (string & {});
-    traceEventId?: string;
-    turnId?: string;
-};
-export type VoiceMediaFrameTransform = {
-    inputFormat?: AudioFormat;
-    name: string;
-    outputFormat?: AudioFormat;
-    transform: (frame: VoiceMediaFrame) => VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined | Promise<VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined>;
-};
-export type VoiceMediaFrameTransformPipeline = {
-    push: (frame: VoiceMediaFrame) => Promise<readonly VoiceMediaFrame[]>;
-    pushMany: (frames: readonly VoiceMediaFrame[]) => Promise<readonly VoiceMediaFrame[]>;
-    transforms: readonly VoiceMediaFrameTransform[];
-};
-export type VoiceMediaProcessorNodeKind = 'branch' | 'filter' | 'processor' | 'sink';
-export type VoiceMediaProcessorNodeEvent = {
-    at: number;
-    dropped: number;
-    emitted: number;
-    frameId: string;
-    inputs: number;
-    node: string;
-};
-export type VoiceMediaProcessorNodeReport = {
-    droppedFrames: number;
-    emittedFrames: number;
-    events: readonly VoiceMediaProcessorNodeEvent[];
-    inputFrames: number;
-    kind: VoiceMediaProcessorNodeKind;
-    name: string;
-    status: VoiceMediaPipelineStatus;
-};
-export type VoiceMediaProcessorGraphReport = {
-    checkedAt: number;
-    droppedFrames: number;
-    emittedFrames: number;
-    events: readonly VoiceMediaProcessorNodeEvent[];
-    inputFrames: number;
-    name: string;
-    nodes: readonly VoiceMediaProcessorNodeReport[];
-    status: VoiceMediaPipelineStatus;
-};
-export type VoiceMediaProcessorNode = {
-    inputFormat?: AudioFormat;
-    kind?: VoiceMediaProcessorNodeKind;
-    name: string;
-    outputFormat?: AudioFormat;
-    process: (frame: VoiceMediaFrame) => boolean | VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined | Promise<boolean | VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined>;
-};
-export type VoiceMediaProcessorGraph = {
-    nodes: readonly VoiceMediaProcessorNode[];
-    process: (frame: VoiceMediaFrame) => Promise<readonly VoiceMediaFrame[]>;
-    processMany: (frames: readonly VoiceMediaFrame[]) => Promise<readonly VoiceMediaFrame[]>;
-    report: () => VoiceMediaProcessorGraphReport;
-};
-export type VoiceMediaTransportAdapter = {
-    close?: () => Promise<void> | void;
-    connect?: () => Promise<void> | void;
-    inputFormat?: AudioFormat;
-    name: string;
-    onFrame?: (handler: (frame: VoiceMediaFrame) => Promise<void> | void) => () => void;
-    outputFormat?: AudioFormat;
-    send: (frame: VoiceMediaFrame) => Promise<void> | void;
-};
-export type VoiceMediaTransportState = 'closed' | 'closing' | 'failed' | 'idle' | 'open';
-export type VoiceMediaTransportEventKind = 'backpressure' | 'close' | 'connect' | 'error' | 'frame-in' | 'frame-out';
-export type VoiceMediaTransportEvent = {
-    at: number;
-    bufferedFrames?: number;
-    error?: string;
-    frameId?: string;
-    kind: VoiceMediaTransportEventKind;
-    state: VoiceMediaTransportState;
-};
-export type VoiceMediaTransportReport = {
-    backpressureEvents: number;
-    checkedAt: number;
-    closed: boolean;
-    connected: boolean;
-    events: readonly VoiceMediaTransportEvent[];
-    failed: boolean;
-    inputFrames: number;
-    name: string;
-    outputFrames: number;
-    state: VoiceMediaTransportState;
-    status: VoiceMediaPipelineStatus;
-};
-export type VoiceMediaTransport = VoiceMediaTransportAdapter & {
-    events: () => readonly VoiceMediaTransportEvent[];
-    receive: (frame: VoiceMediaFrame) => Promise<void>;
-    report: () => VoiceMediaTransportReport;
-    state: () => VoiceMediaTransportState;
-};
-export type VoiceMediaTransportOptions = {
-    inputFormat?: AudioFormat;
-    maxBufferedFrames?: number;
-    name: string;
-    onClose?: () => Promise<void> | void;
-    onConnect?: () => Promise<void> | void;
-    onSend?: (frame: VoiceMediaFrame) => Promise<void> | void;
-    outputFormat?: AudioFormat;
-};
-export type VoiceMediaPipelineCalibrationInput = {
-    expectedInputFormat?: AudioFormat;
-    expectedOutputFormat?: AudioFormat;
-    frames?: readonly VoiceMediaFrame[];
-    inputFormat?: AudioFormat;
-    maxBackpressureFrames?: number;
-    maxFirstAudioLatencyMs?: number;
-    maxJitterMs?: number;
-    outputFormat?: AudioFormat;
-    requireInterruptionFrame?: boolean;
-    requireTraceEvidence?: boolean;
-    surface?: string;
-};
-export type VoiceMediaPipelineCalibrationIssue = {
-    code: string;
-    message: string;
-    severity: 'error' | 'warning';
-};
-export type VoiceMediaPipelineCalibrationReport = {
-    assistantAudioFrames: number;
-    backpressureFrames: number;
-    checkedAt: number;
-    firstAudioLatencyMs?: number;
-    inputAudioFrames: number;
-    inputFormat?: AudioFormat;
-    interruptionFrames: number;
-    issues: VoiceMediaPipelineCalibrationIssue[];
-    jitterMs?: number;
-    outputFormat?: AudioFormat;
-    resamplingRequired: boolean;
-    resamplingTargetHz?: number;
-    status: VoiceMediaPipelineStatus;
-    surface: string;
-    traceLinkedFrames: number;
-    turnCommitFrames: number;
-};
-export type VoiceMediaVadInput = {
-    frames?: readonly VoiceMediaFrame[];
-    maxSilenceFrames?: number;
-    minSpeechFrames?: number;
-    speechEndThreshold?: number;
-    speechStartThreshold?: number;
-};
-export type VoiceMediaVadSegment = {
-    durationMs?: number;
-    endAt?: number;
-    frameCount: number;
-    segmentId: string;
-    sessionId?: string;
-    startAt?: number;
-    turnId?: string;
-};
-export type VoiceMediaVadReport = {
-    checkedAt: number;
-    inputAudioFrames: number;
-    segments: VoiceMediaVadSegment[];
-    status: VoiceMediaPipelineStatus;
-};
-export type VoiceMediaInterruptionInput = {
-    frames?: readonly VoiceMediaFrame[];
-    maxInterruptionLatencyMs?: number;
-};
-export type VoiceMediaInterruptionReport = {
-    checkedAt: number;
-    interruptionFrames: number;
-    issues: VoiceMediaPipelineCalibrationIssue[];
-    latenciesMs: number[];
-    status: VoiceMediaPipelineStatus;
-};
-export declare const createVoiceMediaFrame: (frame: VoiceMediaFrame) => VoiceMediaFrame;
-export declare const buildVoiceMediaTransportReport: (input: {
-    events?: readonly VoiceMediaTransportEvent[];
-    name: string;
-    state?: VoiceMediaTransportState;
-}) => VoiceMediaTransportReport;
-export declare const createVoiceMediaTransport: (options: VoiceMediaTransportOptions) => VoiceMediaTransport;
-export declare const buildVoiceMediaResamplingPlan: (input: {
-    inputFormat: AudioFormat;
-    outputFormat: AudioFormat;
-}) => VoiceMediaResamplingPlan;
-export declare const createVoiceMediaFrameTransformPipeline: (input?: {
-    transforms?: readonly VoiceMediaFrameTransform[];
-}) => VoiceMediaFrameTransformPipeline;
-export declare const buildVoiceMediaProcessorGraphReport: (input: {
-    events?: readonly VoiceMediaProcessorNodeEvent[];
-    name: string;
-    nodes: readonly VoiceMediaProcessorNode[];
-}) => VoiceMediaProcessorGraphReport;
-export declare const createVoiceMediaProcessorGraph: (input?: {
-    name?: string;
-    nodes?: readonly VoiceMediaProcessorNode[];
-}) => VoiceMediaProcessorGraph;
-export declare const buildVoiceMediaVadReport: (input?: VoiceMediaVadInput) => VoiceMediaVadReport;
-export declare const buildVoiceMediaInterruptionReport: (input?: VoiceMediaInterruptionInput) => VoiceMediaInterruptionReport;
-export declare const buildVoiceMediaPipelineCalibrationReport: (input?: VoiceMediaPipelineCalibrationInput) => VoiceMediaPipelineCalibrationReport;