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

package/dist/index.d.ts

@@ -15,8 +15,8 @@ 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 { buildVoiceMediaInterruptionReport, buildVoiceMediaPipelineCalibrationReport, buildVoiceMediaResamplingPlan, buildVoiceMediaVadReport, createVoiceMediaFrame, createVoiceMediaFrameTransformPipeline } from './mediaPipeline';
-export type { VoiceMediaFrame, VoiceMediaFrameKind, VoiceMediaFrameSource, VoiceMediaFrameTransform, VoiceMediaFrameTransformPipeline, VoiceMediaInterruptionInput, VoiceMediaInterruptionReport, VoiceMediaPipelineCalibrationInput, VoiceMediaPipelineCalibrationIssue, VoiceMediaPipelineCalibrationReport, VoiceMediaPipelineStatus, VoiceMediaResamplingPlan, VoiceMediaTransportAdapter, VoiceMediaVadInput, VoiceMediaVadReport, VoiceMediaVadSegment } from './mediaPipeline';
+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

@@ -11620,6 +11620,95 @@ var numericMetadata = (frame, 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) => {
   const required = !formatMatches2(input.inputFormat, input.outputFormat);
   return {
@@ -11663,6 +11752,93 @@ var createVoiceMediaFrameTransformPipeline = (input = {}) => {
     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;
@@ -11849,7 +12025,9 @@ var buildVoiceMediaPipelineReport = (options = {}) => {
     calibration.status,
     vad.status,
     interruption.status,
-    resampling?.status ?? "pass"
+    resampling?.status ?? "pass",
+    options.processorGraph?.status ?? "pass",
+    options.transport?.status ?? "pass"
   ]);
   return {
     calibration,
@@ -11857,9 +12035,11 @@ var buildVoiceMediaPipelineReport = (options = {}) => {
     frames: frames.length,
     interruption,
     ok: status === "pass",
+    processorGraph: options.processorGraph,
     resampling,
     status,
     surface: options.surface ?? "voice-media-pipeline",
+    transport: options.transport,
     vad
   };
 };
@@ -11892,6 +12072,27 @@ var evaluateVoiceMediaPipelineEvidence = (report, input = {}) => {
   if (input.requireResamplingReady && report.calibration.resamplingRequired && !report.resampling) {
     issues.push("Expected resampling plan when calibration requires resampling.");
   }
+  if (input.requireProcessorGraph && !report.processorGraph) {
+    issues.push("Expected media processor graph evidence.");
+  }
+  if (input.minProcessorGraphNodes !== undefined && (report.processorGraph?.nodes.length ?? 0) < input.minProcessorGraphNodes) {
+    issues.push(`Expected at least ${String(input.minProcessorGraphNodes)} media processor node(s), found ${String(report.processorGraph?.nodes.length ?? 0)}.`);
+  }
+  if (input.minProcessorGraphEmittedFrames !== undefined && (report.processorGraph?.emittedFrames ?? 0) < input.minProcessorGraphEmittedFrames) {
+    issues.push(`Expected at least ${String(input.minProcessorGraphEmittedFrames)} processor graph output frame(s), found ${String(report.processorGraph?.emittedFrames ?? 0)}.`);
+  }
+  if (input.requireTransportConnected && !report.transport?.connected) {
+    issues.push("Expected connected media transport evidence.");
+  }
+  if (input.minTransportInputFrames !== undefined && (report.transport?.inputFrames ?? 0) < input.minTransportInputFrames) {
+    issues.push(`Expected at least ${String(input.minTransportInputFrames)} transport input frame(s), found ${String(report.transport?.inputFrames ?? 0)}.`);
+  }
+  if (input.minTransportOutputFrames !== undefined && (report.transport?.outputFrames ?? 0) < input.minTransportOutputFrames) {
+    issues.push(`Expected at least ${String(input.minTransportOutputFrames)} transport output frame(s), found ${String(report.transport?.outputFrames ?? 0)}.`);
+  }
+  if (input.maxTransportBackpressureEvents !== undefined && (report.transport?.backpressureEvents ?? 0) > input.maxTransportBackpressureEvents) {
+    issues.push(`Expected at most ${String(input.maxTransportBackpressureEvents)} transport backpressure event(s), found ${String(report.transport?.backpressureEvents ?? 0)}.`);
+  }
   return {
     issues,
     ok: issues.length === 0,
@@ -11919,6 +12120,13 @@ var renderVoiceMediaPipelineMarkdown = (report) => [
   `- Resampling required: ${report.calibration.resamplingRequired ? "yes" : "no"}`,
   `- VAD segments: ${String(report.vad.segments.length)}`,
   `- Interruption frames: ${String(report.interruption.interruptionFrames)}`,
+  `- 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)}`,
+  `- Transport: ${report.transport ? `${report.transport.name} (${report.transport.state})` : "n/a"}`,
+  `- Transport input frames: ${String(report.transport?.inputFrames ?? 0)}`,
+  `- Transport output frames: ${String(report.transport?.outputFrames ?? 0)}`,
+  `- Transport backpressure events: ${String(report.transport?.backpressureEvents ?? 0)}`,
   "",
   "## Issues",
   "",
@@ -11932,7 +12140,7 @@ var renderVoiceMediaPipelineMarkdown = (report) => [
 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 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>Resampling</span><strong>${report.calibration.resamplingRequired ? "required" : "not required"}</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>`;
+  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>`;
 };
 var createVoiceMediaPipelineRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice/media-pipeline";
@@ -34763,6 +34971,8 @@ export {
   createVoiceMemoryAuditSinkDeliveryStore,
   createVoiceMemoryAuditEventStore,
   createVoiceMemoryAssistantMemoryStore,
+  createVoiceMediaTransport,
+  createVoiceMediaProcessorGraph,
   createVoiceMediaPipelineRoutes,
   createVoiceMediaFrameTransformPipeline,
   createVoiceMediaFrame,
@@ -34915,7 +35125,9 @@ export {
   buildVoiceObservabilityArtifactIndex,
   buildVoiceMonitorRunReport,
   buildVoiceMediaVadReport,
+  buildVoiceMediaTransportReport,
   buildVoiceMediaResamplingPlan,
+  buildVoiceMediaProcessorGraphReport,
   buildVoiceMediaPipelineReport,
   buildVoiceMediaPipelineCalibrationReport,
   buildVoiceMediaInterruptionReport,

package/dist/mediaPipeline.d.ts

@@ -34,6 +34,47 @@ export type VoiceMediaFrameTransformPipeline = {
     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;
@@ -43,6 +84,44 @@ export type VoiceMediaTransportAdapter = {
     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;
@@ -113,6 +192,12 @@ export type VoiceMediaInterruptionReport = {
     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;
@@ -120,6 +205,15 @@ export declare const buildVoiceMediaResamplingPlan: (input: {
 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;

package/dist/mediaPipelineRoutes.d.ts

@@ -1,12 +1,14 @@
 import { Elysia } from 'elysia';
-import { type VoiceMediaFrame, type VoiceMediaInterruptionReport, type VoiceMediaPipelineCalibrationInput, type VoiceMediaPipelineCalibrationReport, type VoiceMediaPipelineStatus, type VoiceMediaResamplingPlan, type VoiceMediaVadReport } from './mediaPipeline';
+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[];
     maxInterruptionLatencyMs?: number;
     maxSilenceFrames?: number;
     minSpeechFrames?: number;
+    processorGraph?: VoiceMediaProcessorGraphReport;
     speechEndThreshold?: number;
     speechStartThreshold?: number;
+    transport?: VoiceMediaTransportReport;
 };
 export type VoiceMediaPipelineReport = {
     calibration: VoiceMediaPipelineCalibrationReport;
@@ -15,8 +17,10 @@ export type VoiceMediaPipelineReport = {
     interruption: VoiceMediaInterruptionReport;
     ok: boolean;
     resampling?: VoiceMediaResamplingPlan;
+    processorGraph?: VoiceMediaProcessorGraphReport;
     status: VoiceMediaPipelineStatus;
     surface: string;
+    transport?: VoiceMediaTransportReport;
     vad: VoiceMediaVadReport;
 };
 export type VoiceMediaPipelineAssertionInput = {
@@ -24,11 +28,18 @@ export type VoiceMediaPipelineAssertionInput = {
     maxInterruptionLatencyMs?: number;
     minAssistantAudioFrames?: number;
     minInputAudioFrames?: number;
+    minProcessorGraphEmittedFrames?: number;
+    minProcessorGraphNodes?: number;
+    minTransportInputFrames?: number;
+    minTransportOutputFrames?: number;
     minTraceLinkedFrames?: number;
     minVadSegments?: number;
+    maxTransportBackpressureEvents?: number;
     requireInterruptionFrame?: boolean;
     requirePass?: boolean;
+    requireProcessorGraph?: boolean;
     requireResamplingReady?: boolean;
+    requireTransportConnected?: boolean;
 };
 export type VoiceMediaPipelineAssertionReport = {
     issues: string[];

package/package.json

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