@absolutejs/voice 0.0.22-beta.464 → 0.0.22-beta.465

package/dist/angular/index.js

@@ -2008,934 +2008,12 @@ var serverMessageToAction = (message) => {
   }
 };
 
-// node_modules/@absolutejs/media/dist/index.js
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-var formatLabel = (format) => `${format.container}/${format.encoding}/${String(format.sampleRateHz)}hz/${String(format.channels)}ch`;
-var formatMatches = (actual, expected) => actual.container === expected.container && actual.encoding === expected.encoding && actual.sampleRateHz === expected.sampleRateHz && actual.channels === expected.channels;
-var pushIssue = (issues, severity, code, message) => {
-  issues.push({ code, message, severity });
-};
-var numericMetadata = (frame, key) => {
-  const value = frame.metadata?.[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-};
-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 numericStat = (stat, key) => {
-  const value = stat[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-};
-var booleanStat = (stat, key) => {
-  const value = stat[key];
-  return typeof value === "boolean" ? value : undefined;
-};
-var stringStat = (stat, key) => {
-  const value = stat[key];
-  return typeof value === "string" ? value : undefined;
-};
-var statKey = (stat) => String(stat.id ?? stringStat(stat, "ssrc") ?? numericStat(stat, "ssrc") ?? stringStat(stat, "trackIdentifier") ?? stringStat(stat, "mid") ?? "unknown");
-var secondsToMs = (value) => value === undefined ? undefined : value * 1000;
-var DEFAULT_TELEPHONY_FORMAT = {
-  channels: 1,
-  container: "raw",
-  encoding: "mulaw",
-  sampleRateHz: 8000
-};
-var bytesToBase64 = (audio) => {
-  const bytes = audio instanceof ArrayBuffer ? new Uint8Array(audio) : new Uint8Array(audio.buffer, audio.byteOffset, audio.byteLength);
-  return Buffer.from(bytes).toString("base64");
-};
-var base64ToBytes = (value) => new Uint8Array(Buffer.from(value, "base64"));
-var unknownRecord = (value) => value && typeof value === "object" ? value : {};
-var firstString = (records, keys) => {
-  for (const record of records) {
-    for (const key of keys) {
-      const value = record[key];
-      if (typeof value === "string" && value.length > 0) {
-        return value;
-      }
-      if (typeof value === "number" && Number.isFinite(value)) {
-        return String(value);
-      }
-    }
-  }
-  return;
-};
-var firstNumber = (records, keys) => {
-  for (const record of records) {
-    for (const key of keys) {
-      const value = record[key];
-      if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-      }
-      if (typeof value === "string") {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-          return parsed;
-        }
-      }
-    }
-  }
-  return;
-};
-var telephonyDirection = (track) => {
-  const normalized = track?.toLowerCase();
-  if (!normalized) {
-    return "unknown";
-  }
-  if (normalized.includes("inbound") || normalized.includes("caller") || normalized.includes("in")) {
-    return "inbound";
-  }
-  if (normalized.includes("outbound") || normalized.includes("assistant") || normalized.includes("out")) {
-    return "outbound";
-  }
-  return "unknown";
-};
-var telephonyFrameKind = (direction) => direction === "outbound" ? "assistant-audio" : "input-audio";
-var telephonyEventKind = (envelope) => {
-  const raw = firstString([envelope], ["event", "type", "eventType"]) ?? firstString([unknownRecord(envelope.message)], ["event", "type"]);
-  const normalized = raw?.toLowerCase().replace(/[_\s-]+/g, "-");
-  if (!normalized) {
-    return "unknown";
-  }
-  if (normalized.includes("connected")) {
-    return "connected";
-  }
-  if (normalized.includes("start")) {
-    return "start";
-  }
-  if (normalized.includes("media")) {
-    return "media";
-  }
-  if (normalized.includes("stop") || normalized.includes("closed")) {
-    return "stop";
-  }
-  if (normalized.includes("error") || normalized.includes("failed")) {
-    return "error";
-  }
-  return "unknown";
-};
-var normalizeWebRTCStat = (stat) => {
-  const sample = {};
-  for (const [key, value] of Object.entries(stat)) {
-    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-      sample[key] = value;
-    }
-  }
-  return sample;
-};
-var parseTelephonyMediaFrame = (input) => {
-  const envelope = input.envelope;
-  const media = unknownRecord(envelope.media);
-  const payload = firstString([media, envelope], ["payload", "audio", "data"]) ?? firstString([unknownRecord(envelope.message)], ["payload"]);
-  if (!payload) {
-    return;
-  }
-  const carrier = input.carrier ?? firstString([envelope], ["provider"]) ?? "telephony";
-  const streamId = firstString([media, envelope], ["streamSid", "stream_id", "streamId", "streamId", "callSid", "call_id"]);
-  const sequenceNumber = firstString([media, envelope], ["sequenceNumber", "sequence_number", "chunk"]);
-  const track = firstString([media, envelope], ["track", "direction"]);
-  const direction = telephonyDirection(track);
-  const timestamp = firstNumber([media, envelope], ["timestamp", "time", "startedAt"]);
-  return {
-    at: timestamp,
-    audio: base64ToBytes(payload),
-    format: input.format ?? DEFAULT_TELEPHONY_FORMAT,
-    id: [
-      carrier,
-      streamId ?? input.sessionId ?? "stream",
-      sequenceNumber ?? timestamp ?? Date.now()
-    ].join(":"),
-    kind: telephonyFrameKind(direction),
-    metadata: {
-      carrier,
-      direction,
-      event: firstString([envelope], ["event", "type"]),
-      sequenceNumber,
-      streamId,
-      track
-    },
-    sessionId: input.sessionId ?? streamId,
-    source: "telephony"
-  };
-};
-var serializeTelephonyMediaFrame = (input) => {
-  const carrier = input.carrier ?? input.frame.metadata?.carrier ?? "telephony";
-  const streamId = input.streamId ?? (typeof input.frame.metadata?.streamId === "string" ? input.frame.metadata.streamId : input.frame.sessionId);
-  const sequenceNumber = input.sequenceNumber ?? (typeof input.frame.metadata?.sequenceNumber === "string" || typeof input.frame.metadata?.sequenceNumber === "number" ? input.frame.metadata.sequenceNumber : undefined);
-  const direction = input.frame.kind === "assistant-audio" ? "outbound" : "inbound";
-  const payload = input.frame.audio ? bytesToBase64(input.frame.audio) : "";
-  if (carrier === "twilio") {
-    return {
-      event: "media",
-      sequenceNumber,
-      streamSid: streamId,
-      media: {
-        payload,
-        timestamp: input.frame.at,
-        track: direction
-      }
-    };
-  }
-  if (carrier === "telnyx") {
-    return {
-      event: "media",
-      stream_id: streamId,
-      sequence_number: sequenceNumber,
-      media: {
-        payload,
-        timestamp: input.frame.at,
-        track: direction
-      }
-    };
-  }
-  if (carrier === "plivo") {
-    return {
-      event: "media",
-      streamId,
-      sequenceNumber,
-      media: {
-        payload,
-        timestamp: input.frame.at,
-        track: direction
-      }
-    };
-  }
-  return {
-    event: "media",
-    provider: carrier,
-    sequenceNumber,
-    streamId,
-    media: {
-      payload,
-      timestamp: input.frame.at,
-      track: direction
-    }
-  };
-};
-var createTelephonyMediaSerializer = (input) => {
-  const format = input.format ?? DEFAULT_TELEPHONY_FORMAT;
-  return {
-    carrier: input.carrier,
-    format,
-    parse: (envelope) => parseTelephonyMediaFrame({
-      carrier: input.carrier,
-      envelope,
-      format,
-      sessionId: input.sessionId ?? input.streamId
-    }),
-    serialize: (frame) => serializeTelephonyMediaFrame({
-      carrier: input.carrier,
-      frame,
-      streamId: input.streamId
-    })
-  };
-};
-var parseTelephonyStreamEvent = (input) => {
-  const envelope = input.envelope;
-  const media = unknownRecord(envelope.media);
-  const start = unknownRecord(envelope.start);
-  const stop = unknownRecord(envelope.stop);
-  const errorRecord = unknownRecord(envelope.error);
-  const kind = telephonyEventKind(envelope);
-  const carrier = input.carrier ?? firstString([envelope], ["provider", "carrier"]) ?? "telephony";
-  const frame = kind === "media" ? parseTelephonyMediaFrame({
-    carrier,
-    envelope,
-    format: input.format,
-    sessionId: input.sessionId
-  }) : undefined;
-  const streamId = firstString([media, start, stop, envelope], ["streamSid", "stream_id", "streamId", "callSid", "call_id"]) ?? input.sessionId;
-  const sequenceNumber = firstString([media, envelope], ["sequenceNumber", "sequence_number", "chunk"]);
-  const track = firstString([media, envelope], ["track", "direction"]);
-  return {
-    audioBytes: frame?.audio ? frame.audio instanceof ArrayBuffer ? frame.audio.byteLength : frame.audio.byteLength : 0,
-    at: frame?.at ?? firstNumber([media, start, stop, envelope], ["timestamp", "time", "startedAt"]),
-    carrier,
-    direction: telephonyDirection(track),
-    error: firstString([errorRecord, envelope], ["message", "error", "reason"]),
-    kind,
-    sequenceNumber,
-    streamId
-  };
-};
-var buildMediaTelephonyStreamLifecycleReport = (input = {}) => {
-  const envelopes = input.envelopes ?? [];
-  const events = envelopes.map((envelope) => parseTelephonyStreamEvent({
-    carrier: input.carrier,
-    envelope
-  }));
-  const issues = [];
-  const startedIndex = events.findIndex((event) => event.kind === "start");
-  const firstMediaIndex = events.findIndex((event) => event.kind === "media");
-  const stoppedIndex = events.findIndex((event) => event.kind === "stop");
-  const started = startedIndex >= 0;
-  const stopped = stoppedIndex >= 0;
-  const mediaEvents = events.filter((event) => event.kind === "media");
-  const audioBytes = events.reduce((total, event) => total + event.audioBytes, 0);
-  const minAudioBytes = input.minAudioBytes ?? 1;
-  const streamIds = Array.from(new Set(events.map((event) => event.streamId).filter(Boolean)));
-  if ((input.requireStart ?? true) && !started) {
-    pushIssue(issues, "error", "media.telephony_missing_start", "Telephony media stream did not include a start event.");
-  }
-  if ((input.requireMedia ?? true) && mediaEvents.length === 0) {
-    pushIssue(issues, "error", "media.telephony_missing_media", "Telephony media stream did not include media payload events.");
-  }
-  if ((input.requireStop ?? true) && !stopped) {
-    pushIssue(issues, input.maxMissingStop === false ? "warning" : "error", "media.telephony_missing_stop", "Telephony media stream did not include a stop event.");
-  }
-  if (started && firstMediaIndex >= 0 && firstMediaIndex < startedIndex) {
-    pushIssue(issues, "error", "media.telephony_media_before_start", "Telephony media payload arrived before the stream start event.");
-  }
-  if (stopped && firstMediaIndex >= 0 && stoppedIndex < firstMediaIndex) {
-    pushIssue(issues, "error", "media.telephony_stop_before_media", "Telephony media stream stopped before any media payload arrived.");
-  }
-  if (mediaEvents.length > 0 && audioBytes < minAudioBytes) {
-    pushIssue(issues, "error", "media.telephony_no_audio_bytes", `Telephony media stream parsed ${String(audioBytes)} audio byte(s), below required ${String(minAudioBytes)}.`);
-  }
-  for (const event of events) {
-    if (event.kind === "error") {
-      pushIssue(issues, "error", "media.telephony_stream_error", event.error ?? "Telephony media stream emitted an error event.");
-    }
-  }
-  return {
-    audioBytes,
-    carrier: input.carrier,
-    checkedAt: Date.now(),
-    events,
-    issues,
-    mediaEvents: mediaEvents.length,
-    started,
-    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
-    stopped,
-    streamIds
-  };
-};
-var buildMediaResamplingPlan = (input) => {
-  const required = !formatMatches(input.inputFormat, input.outputFormat);
-  return {
-    inputFormat: input.inputFormat,
-    outputFormat: input.outputFormat,
-    ratio: input.outputFormat.sampleRateHz / input.inputFormat.sampleRateHz,
-    required,
-    status: input.inputFormat.container === input.outputFormat.container && input.inputFormat.encoding === input.outputFormat.encoding && input.inputFormat.channels === input.outputFormat.channels ? "pass" : "warn"
-  };
-};
-var speechProbability = (frame) => {
-  if (frame.metadata?.isSpeech === true) {
-    return 1;
-  }
-  if (frame.metadata?.isSpeech === false) {
-    return 0;
-  }
-  for (const key of ["speechProbability", "voiceProbability", "rms", "energy"]) {
-    const value = numericMetadata(frame, key);
-    if (value !== undefined) {
-      return value;
-    }
-  }
-  return 0;
-};
-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;
-  const minSpeechFrames = input.minSpeechFrames ?? 1;
-  const maxSilenceFrames = input.maxSilenceFrames ?? 1;
-  const segments = [];
-  let activeFrames = [];
-  let silenceFrames = 0;
-  const closeSegment = () => {
-    if (activeFrames.length < minSpeechFrames) {
-      activeFrames = [];
-      silenceFrames = 0;
-      return;
-    }
-    const first = activeFrames[0];
-    const last = activeFrames.at(-1);
-    if (!first) {
-      return;
-    }
-    segments.push({
-      durationMs: first.at !== undefined && last?.at !== undefined ? last.at - first.at + (last.durationMs ?? 0) : undefined,
-      endAt: last?.at !== undefined ? last.at + (last.durationMs ?? 0) : undefined,
-      frameCount: activeFrames.length,
-      segmentId: `vad:${String(segments.length + 1)}`,
-      sessionId: first.sessionId,
-      startAt: first.at,
-      turnId: first.turnId
-    });
-    activeFrames = [];
-    silenceFrames = 0;
-  };
-  for (const frame of frames) {
-    const probability = speechProbability(frame);
-    if (activeFrames.length === 0) {
-      if (probability >= speechStartThreshold) {
-        activeFrames.push(frame);
-      }
-      continue;
-    }
-    activeFrames.push(frame);
-    if (probability <= speechEndThreshold) {
-      silenceFrames += 1;
-    } else {
-      silenceFrames = 0;
-    }
-    if (silenceFrames > maxSilenceFrames) {
-      closeSegment();
-    }
-  }
-  closeSegment();
-  return {
-    checkedAt: Date.now(),
-    inputAudioFrames: frames.length,
-    segments,
-    status: frames.length === 0 ? "warn" : "pass"
-  };
-};
-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");
-  const maxInterruptionLatencyMs = input.maxInterruptionLatencyMs;
-  if (interruptionFrames.length === 0) {
-    pushIssue(issues, "warning", "media.interruption_missing", "No interruption frame was observed.");
-  }
-  if (maxInterruptionLatencyMs !== undefined && latenciesMs.some((latency) => latency > maxInterruptionLatencyMs)) {
-    pushIssue(issues, "error", "media.interruption_latency", `Interruption latency exceeded ${String(maxInterruptionLatencyMs)}ms.`);
-  }
-  return {
-    checkedAt: Date.now(),
-    interruptionFrames: interruptionFrames.length,
-    issues,
-    latenciesMs,
-    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass"
-  };
-};
-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 buildMediaWebRTCStatsReport = (input = {}) => {
-  const stats = input.stats ?? [];
-  const issues = [];
-  const inbound = stats.filter((stat) => stat.type === "inbound-rtp" && stringStat(stat, "kind") !== "video");
-  const outbound = stats.filter((stat) => stat.type === "outbound-rtp" && stringStat(stat, "kind") !== "video");
-  const candidatePairs = stats.filter((stat) => stat.type === "candidate-pair");
-  const audioTracks = stats.filter((stat) => (stat.type === "track" || stat.type === "media-source") && stringStat(stat, "kind") === "audio");
-  const activeCandidatePairs = candidatePairs.filter((stat) => booleanStat(stat, "selected") === true || booleanStat(stat, "nominated") === true || stringStat(stat, "state") === "succeeded").length;
-  const liveAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") !== "ended" && stringStat(stat, "trackState") !== "ended" && booleanStat(stat, "ended") !== true).length;
-  const endedAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") === "ended" || stringStat(stat, "trackState") === "ended" || booleanStat(stat, "ended") === true).length;
-  const inboundPackets = inbound.reduce((total, stat) => total + (numericStat(stat, "packetsReceived") ?? 0), 0);
-  const outboundPackets = outbound.reduce((total, stat) => total + (numericStat(stat, "packetsSent") ?? 0), 0);
-  const packetsLost = [...inbound, ...outbound].reduce((total, stat) => total + Math.max(0, numericStat(stat, "packetsLost") ?? 0), 0);
-  const packetLossDenominator = inboundPackets + packetsLost;
-  const packetLossRatio = packetLossDenominator === 0 ? 0 : packetsLost / packetLossDenominator;
-  const bytesReceived = inbound.reduce((total, stat) => total + (numericStat(stat, "bytesReceived") ?? 0), 0);
-  const bytesSent = outbound.reduce((total, stat) => total + (numericStat(stat, "bytesSent") ?? 0), 0);
-  const roundTripTimeMs = max(candidatePairs.map((stat) => secondsToMs(numericStat(stat, "currentRoundTripTime") ?? numericStat(stat, "roundTripTime"))).filter((value) => value !== undefined));
-  const jitterMs = max([...inbound, ...outbound].map((stat) => secondsToMs(numericStat(stat, "jitter"))).filter((value) => value !== undefined));
-  const jitterBufferDelayMs = max(inbound.map((stat) => {
-    const delay = numericStat(stat, "jitterBufferDelay");
-    const emitted = numericStat(stat, "jitterBufferEmittedCount");
-    return delay !== undefined && emitted !== undefined && emitted > 0 ? delay / emitted * 1000 : undefined;
-  }).filter((value) => value !== undefined));
-  const audioLevels = audioTracks.map((stat) => numericStat(stat, "audioLevel")).filter((value) => value !== undefined);
-  if (input.requireConnectedCandidatePair && candidatePairs.length > 0 && activeCandidatePairs === 0) {
-    pushIssue(issues, "error", "media.webrtc_candidate_pair_missing", "No active WebRTC candidate pair was observed.");
-  }
-  if (input.requireLiveAudioTrack && liveAudioTracks === 0) {
-    pushIssue(issues, "error", "media.webrtc_audio_track_missing", "No live WebRTC audio track was observed.");
-  }
-  if (input.maxPacketLossRatio !== undefined && packetLossRatio > input.maxPacketLossRatio) {
-    pushIssue(issues, "warning", "media.webrtc_packet_loss", `Observed WebRTC packet loss ratio ${String(packetLossRatio)} above ${String(input.maxPacketLossRatio)}.`);
-  }
-  if (input.maxRoundTripTimeMs !== undefined && roundTripTimeMs !== undefined && roundTripTimeMs > input.maxRoundTripTimeMs) {
-    pushIssue(issues, "warning", "media.webrtc_round_trip_time", `Observed WebRTC RTT ${String(roundTripTimeMs)}ms above ${String(input.maxRoundTripTimeMs)}ms.`);
-  }
-  if (input.maxJitterMs !== undefined && jitterMs !== undefined && jitterMs > input.maxJitterMs) {
-    pushIssue(issues, "warning", "media.webrtc_jitter", `Observed WebRTC jitter ${String(jitterMs)}ms above ${String(input.maxJitterMs)}ms.`);
-  }
-  return {
-    activeCandidatePairs,
-    audioLevelAverage: average(audioLevels),
-    bytesReceived,
-    bytesSent,
-    checkedAt: Date.now(),
-    endedAudioTracks,
-    inboundPackets,
-    issues,
-    jitterBufferDelayMs,
-    jitterMs,
-    liveAudioTracks,
-    outboundPackets,
-    packetLossRatio,
-    packetsLost,
-    roundTripTimeMs,
-    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
-    totalStats: stats.length
-  };
-};
-var collectMediaWebRTCStats = async (input) => {
-  const report = await input.peerConnection.getStats(input.selector ?? null);
-  return [...report.values()].map(normalizeWebRTCStat);
-};
-var buildMediaWebRTCStreamContinuityReport = (input = {}) => {
-  const stats = input.stats ?? [];
-  const previousStats = input.previousStats ?? [];
-  const issues = [];
-  const previousByKey = new Map(previousStats.map((stat) => [statKey(stat), stat]));
-  const audioRtp = stats.filter((stat) => (stat.type === "inbound-rtp" || stat.type === "outbound-rtp") && stringStat(stat, "kind") !== "video" && stringStat(stat, "mediaType") !== "video");
-  const streams = audioRtp.map((stat) => {
-    const direction = stat.type === "outbound-rtp" ? "outbound" : "inbound";
-    const packetsKey = direction === "outbound" ? "packetsSent" : "packetsReceived";
-    const bytesKey = direction === "outbound" ? "bytesSent" : "bytesReceived";
-    const previous = previousByKey.get(statKey(stat));
-    const currentPackets = numericStat(stat, packetsKey);
-    const previousPackets = previous ? numericStat(previous, packetsKey) : undefined;
-    const currentBytes = numericStat(stat, bytesKey);
-    const previousBytes = previous ? numericStat(previous, bytesKey) : undefined;
-    const timeDeltaMs = stat.timestamp !== undefined && previous?.timestamp !== undefined ? stat.timestamp - previous.timestamp : undefined;
-    return {
-      bytesDelta: currentBytes !== undefined && previousBytes !== undefined ? currentBytes - previousBytes : undefined,
-      currentPackets,
-      direction,
-      id: statKey(stat),
-      packetDelta: currentPackets !== undefined && previousPackets !== undefined ? currentPackets - previousPackets : undefined,
-      previousPackets,
-      timeDeltaMs
-    };
-  });
-  const inbound = streams.filter((stream) => stream.direction === "inbound");
-  const outbound = streams.filter((stream) => stream.direction === "outbound");
-  const maxObservedGapMs = max(streams.map((stream) => stream.timeDeltaMs).filter((value) => value !== undefined));
-  const stalledInboundStreams = inbound.filter((stream) => input.maxInboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxInboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
-  const stalledOutboundStreams = outbound.filter((stream) => input.maxOutboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxOutboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
-  if (input.requireInboundAudio && inbound.length === 0) {
-    pushIssue(issues, "error", "media.webrtc_inbound_audio_missing", "No inbound WebRTC audio RTP stream was observed.");
-  }
-  if (input.requireOutboundAudio && outbound.length === 0) {
-    pushIssue(issues, "error", "media.webrtc_outbound_audio_missing", "No outbound WebRTC audio RTP stream was observed.");
-  }
-  if (input.maxGapMs !== undefined && maxObservedGapMs !== undefined && maxObservedGapMs > input.maxGapMs) {
-    pushIssue(issues, "warning", "media.webrtc_stream_gap", `Observed WebRTC stream sample gap ${String(maxObservedGapMs)}ms above ${String(input.maxGapMs)}ms.`);
-  }
-  if (stalledInboundStreams > 0) {
-    pushIssue(issues, "error", "media.webrtc_inbound_stalled", `${String(stalledInboundStreams)} inbound WebRTC audio stream(s) stopped receiving packets.`);
-  }
-  if (stalledOutboundStreams > 0) {
-    pushIssue(issues, "error", "media.webrtc_outbound_stalled", `${String(stalledOutboundStreams)} outbound WebRTC audio stream(s) stopped sending packets.`);
-  }
-  return {
-    checkedAt: Date.now(),
-    inboundAudioStreams: inbound.length,
-    issues,
-    maxObservedGapMs,
-    outboundAudioStreams: outbound.length,
-    stalledInboundStreams,
-    stalledOutboundStreams,
-    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
-    streams,
-    totalStats: stats.length
-  };
-};
-var buildMediaPipelineCalibrationReport = (input = {}) => {
-  const frames = input.frames ?? [];
-  const issues = [];
-  const inputFrames = frames.filter((frame) => frame.kind === "input-audio");
-  const assistantFrames = frames.filter((frame) => frame.kind === "assistant-audio");
-  const turnCommitFrames = frames.filter((frame) => frame.kind === "turn-commit");
-  const interruptionFrameRecords = frames.filter((frame) => frame.kind === "interruption");
-  const traceLinkedFrames = frames.filter((frame) => frame.traceEventId).length;
-  const backpressureFrames = frames.filter((frame) => Boolean(frame.metadata?.backpressure)).length;
-  const audioLatencies = assistantFrames.map((frame) => frame.latencyMs).filter((latency) => typeof latency === "number");
-  const firstAudioLatencyMs = audioLatencies.length > 0 ? Math.min(...audioLatencies) : undefined;
-  const jitterValues = frames.map((frame) => numericMetadata(frame, "jitterMs")).filter((value) => value !== undefined);
-  const jitterMs = jitterValues.length > 0 ? Math.max(...jitterValues) : undefined;
-  const inputFormat = input.inputFormat ?? inputFrames.find((frame) => frame.format)?.format;
-  const outputFormat = input.outputFormat ?? assistantFrames.find((frame) => frame.format)?.format;
-  const resamplingRequired = Boolean(input.expectedInputFormat && inputFormat && inputFormat.sampleRateHz !== input.expectedInputFormat.sampleRateHz) || Boolean(input.expectedOutputFormat && outputFormat && outputFormat.sampleRateHz !== input.expectedOutputFormat.sampleRateHz);
-  const resamplingTargetHz = resamplingRequired && input.expectedInputFormat ? input.expectedInputFormat.sampleRateHz : resamplingRequired ? input.expectedOutputFormat?.sampleRateHz : undefined;
-  if (inputFrames.length === 0) {
-    pushIssue(issues, "warning", "media.input_audio_missing", "No input audio frames were observed.");
-  }
-  if (assistantFrames.length === 0) {
-    pushIssue(issues, "warning", "media.assistant_audio_missing", "No assistant audio frames were observed.");
-  }
-  if (input.expectedInputFormat && inputFormat && !formatMatches(inputFormat, input.expectedInputFormat)) {
-    pushIssue(issues, inputFormat.sampleRateHz === input.expectedInputFormat.sampleRateHz ? "warning" : "error", "media.input_format_mismatch", `Input format ${formatLabel(inputFormat)} does not match expected ${formatLabel(input.expectedInputFormat)}.`);
-  }
-  if (input.expectedOutputFormat && outputFormat && !formatMatches(outputFormat, input.expectedOutputFormat)) {
-    pushIssue(issues, outputFormat.sampleRateHz === input.expectedOutputFormat.sampleRateHz ? "warning" : "error", "media.output_format_mismatch", `Output format ${formatLabel(outputFormat)} does not match expected ${formatLabel(input.expectedOutputFormat)}.`);
-  }
-  if (firstAudioLatencyMs !== undefined && input.maxFirstAudioLatencyMs !== undefined && firstAudioLatencyMs > input.maxFirstAudioLatencyMs) {
-    pushIssue(issues, "error", "media.first_audio_latency", `First audio latency ${String(firstAudioLatencyMs)}ms exceeds budget ${String(input.maxFirstAudioLatencyMs)}ms.`);
-  }
-  if (jitterMs !== undefined && input.maxJitterMs !== undefined && jitterMs > input.maxJitterMs) {
-    pushIssue(issues, "warning", "media.jitter", `Media jitter ${String(jitterMs)}ms exceeds budget ${String(input.maxJitterMs)}ms.`);
-  }
-  if (input.maxBackpressureFrames !== undefined && backpressureFrames > input.maxBackpressureFrames) {
-    pushIssue(issues, "warning", "media.backpressure", `Backpressure frame count ${String(backpressureFrames)} exceeds budget ${String(input.maxBackpressureFrames)}.`);
-  }
-  if (input.requireInterruptionFrame && interruptionFrameRecords.length === 0) {
-    pushIssue(issues, "warning", "media.interruption_missing", "No interruption frame was observed.");
-  }
-  if (input.requireTraceEvidence && traceLinkedFrames === 0) {
-    pushIssue(issues, "warning", "media.trace_evidence_missing", "No media frames were linked to trace evidence.");
-  }
-  return {
-    assistantAudioFrames: assistantFrames.length,
-    backpressureFrames,
-    checkedAt: Date.now(),
-    firstAudioLatencyMs,
-    inputAudioFrames: inputFrames.length,
-    inputFormat,
-    interruptionFrames: interruptionFrameRecords.length,
-    issues,
-    jitterMs,
-    outputFormat,
-    resamplingRequired,
-    resamplingTargetHz,
-    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
-    surface: input.surface ?? "media-pipeline",
-    traceLinkedFrames,
-    turnCommitFrames: turnCommitFrames.length
-  };
-};
-var DEFAULT_METADATA_DENY = [
-  "audioPayload",
-  "auth",
-  "authorization",
-  "cookie",
-  "email",
-  "phone",
-  "phoneNumber",
-  "rawPayload",
-  "secret",
-  "token",
-  "transcript",
-  "utterance"
-];
-var DEFAULT_TRUNCATE = 8;
-var issueCodes = (issues) => Array.from(new Set(issues.map((issue) => issue.code)));
-var lastEventKind = (events) => events[events.length - 1]?.kind;
-var formatOptionalMs = (value) => value === undefined ? "n/a" : `${String(Math.round(value))}ms`;
-var formatRatio = (value) => `${(value * 100).toFixed(1)}%`;
-var escapeMarkdownCell = (value) => value.replace(/\|/g, "\\|").replace(/\n/g, " ");
-var renderIssuesTable = (issues) => {
-  if (issues.length === 0) {
-    return `- No issues.
-`;
-  }
-  const rows = issues.map((issue) => `| ${issue.severity} | ${escapeMarkdownCell(issue.code)} | ${escapeMarkdownCell(issue.message)} |`).join(`
-`);
-  return `| Severity | Code | Message |
-| --- | --- | --- |
-${rows}
-`;
-};
-var summarizeMediaQualityReport = (report) => ({
-  backpressureEvents: report.backpressureEvents,
-  description: `${report.totalFrames} frame(s), ${report.gapCount} gap(s), speech ${formatRatio(report.speechRatio)}, status ${report.status}.`,
-  driftMs: report.timestampDriftMs,
-  frameCount: report.totalFrames,
-  gapCount: report.gapCount,
-  issueCodes: issueCodes(report.issues),
-  issueCount: report.issues.length,
-  jitterMs: report.jitterMs,
-  silenceRatio: report.silenceRatio,
-  speechRatio: report.speechRatio,
-  status: report.status
-});
-var summarizeMediaTransportReport = (report) => ({
-  backpressureEvents: report.backpressureEvents,
-  description: `${report.name}: ${report.state}, in ${report.inputFrames}, out ${report.outputFrames}, backpressure ${report.backpressureEvents}.`,
-  errors: report.events.filter((event) => event.kind === "error").length,
-  inputFrames: report.inputFrames,
-  lastEventKind: lastEventKind(report.events),
-  name: report.name,
-  outputFrames: report.outputFrames,
-  state: report.state,
-  status: report.status
-});
-var summarizeMediaProcessorGraphReport = (report) => {
-  const errorIssueCodes = Array.from(new Set(report.errors.map((event) => event.kind)));
-  return {
-    backpressureEvents: report.backpressure.events.length,
-    description: `${report.name}: ${report.state}, ${report.nodes.length} node(s), in ${report.inputFrames}, out ${report.emittedFrames}, dropped ${report.droppedFrames}.`,
-    droppedFrames: report.droppedFrames,
-    edgeCount: report.edges.length,
-    edgeEventCount: report.edgeEvents.length,
-    emittedFrames: report.emittedFrames,
-    errorCount: report.errors.length,
-    inputFrames: report.inputFrames,
-    issueCodes: errorIssueCodes,
-    lifecycleEventCount: report.lifecycleEvents.length,
-    name: report.name,
-    nodeCount: report.nodes.length,
-    state: report.state,
-    status: report.status,
-    timingMaxMs: report.timing.maxNodeMs
-  };
-};
-var renderMediaQualityMarkdown = (report, options = {}) => {
-  const title = options.title ?? "Media Quality Report";
-  const lines = [
-    `# ${title}`,
-    "",
-    `Status: **${report.status}**`,
-    "",
-    "| Metric | Value |",
-    "| --- | ---: |",
-    `| Total frames | ${report.totalFrames} |`,
-    `| Input audio | ${report.inputAudioFrames} |`,
-    `| Assistant audio | ${report.assistantAudioFrames} |`,
-    `| Gaps | ${report.gapCount} |`,
-    `| Jitter | ${formatOptionalMs(report.jitterMs)} |`,
-    `| Timestamp drift | ${formatOptionalMs(report.timestampDriftMs)} |`,
-    `| Speech ratio | ${formatRatio(report.speechRatio)} |`,
-    `| Silence ratio | ${formatRatio(report.silenceRatio)} |`,
-    `| Backpressure events | ${report.backpressureEvents} |`,
-    "",
-    "## Issues",
-    "",
-    renderIssuesTable(report.issues).trimEnd()
-  ];
-  return `${lines.join(`
-`)}
-`;
-};
-var renderMediaTransportMarkdown = (report, options = {}) => {
-  const title = options.title ?? `Media Transport: ${report.name}`;
-  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
-  const events = report.events.slice(-limit);
-  const eventRows = events.length === 0 ? "- No transport events recorded." : ["| At | Kind | State | Buffered | Error |", "| --- | --- | --- | ---: | --- |"].concat(events.map((event) => `| ${event.at} | ${event.kind} | ${event.state} | ${event.bufferedFrames ?? ""} | ${escapeMarkdownCell(event.error ?? "")} |`)).join(`
-`);
-  const lines = [
-    `# ${title}`,
-    "",
-    `Status: **${report.status}** \xB7 State: **${report.state}**`,
-    "",
-    "| Metric | Value |",
-    "| --- | ---: |",
-    `| Input frames | ${report.inputFrames} |`,
-    `| Output frames | ${report.outputFrames} |`,
-    `| Backpressure events | ${report.backpressureEvents} |`,
-    `| Connected | ${report.connected ? "yes" : "no"} |`,
-    `| Closed | ${report.closed ? "yes" : "no"} |`,
-    `| Failed | ${report.failed ? "yes" : "no"} |`,
-    "",
-    `## Last ${events.length} event(s)`,
-    "",
-    eventRows
-  ];
-  return `${lines.join(`
-`)}
-`;
-};
-var renderMediaProcessorGraphMarkdown = (report, options = {}) => {
-  const title = options.title ?? `Media Processor Graph: ${report.name}`;
-  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
-  const nodeRows = report.nodes.map((node) => `| ${escapeMarkdownCell(node.name)} | ${node.kind} | ${node.status} | ${node.inputFrames} | ${node.emittedFrames} | ${node.droppedFrames} | ${node.errors.length} |`).join(`
-`);
-  const edgeRows = report.edges.slice(0, limit).map((edge) => `| ${escapeMarkdownCell(edge.from)} | ${escapeMarkdownCell(edge.to)} | ${edge.status} | ${edge.emittedFrames} |`).join(`
-`);
-  const issues = report.errors.map((event) => ({
-    code: event.kind,
-    message: event.error ?? `Processor graph ${event.kind} (state ${event.state}).`,
-    severity: "error"
-  }));
-  const lines = [
-    `# ${title}`,
-    "",
-    `Status: **${report.status}** \xB7 State: **${report.state}**`,
-    "",
-    "| Metric | Value |",
-    "| --- | ---: |",
-    `| Nodes | ${report.nodes.length} |`,
-    `| Input frames | ${report.inputFrames} |`,
-    `| Emitted frames | ${report.emittedFrames} |`,
-    `| Dropped frames | ${report.droppedFrames} |`,
-    `| Lifecycle events | ${report.lifecycleEvents.length} |`,
-    `| Edge events | ${report.edgeEvents.length} |`,
-    `| Backpressure events | ${report.backpressure.events.length} |`,
-    `| Timing max | ${formatOptionalMs(report.timing.maxNodeMs)} |`,
-    `| Timing average | ${formatOptionalMs(report.timing.averageNodeMs)} |`,
-    "",
-    "## Nodes",
-    "",
-    nodeRows ? `| Node | Kind | Status | In | Out | Dropped | Errors |
-| --- | --- | --- | ---: | ---: | ---: | ---: |
-${nodeRows}` : "- No nodes.",
-    "",
-    `## Edges (showing up to ${limit})`,
-    "",
-    edgeRows ? `| From | To | Status | Frames |
-| --- | --- | --- | ---: |
-${edgeRows}` : "- No edges.",
-    "",
-    "## Errors",
-    "",
-    renderIssuesTable(issues).trimEnd()
-  ];
-  return `${lines.join(`
-`)}
-`;
-};
-var truncateArrays = (value, limit, seen) => {
-  if (Array.isArray(value)) {
-    const head = value.slice(0, limit).map((entry) => truncateArrays(entry, limit, seen));
-    if (value.length > limit) {
-      return [...head, { truncated: value.length - limit }];
-    }
-    return head;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value))
-      return value;
-    seen.add(value);
-    const next = {};
-    for (const [key, entry] of Object.entries(value)) {
-      next[key] = truncateArrays(entry, limit, seen);
-    }
-    return next;
-  }
-  return value;
-};
-var applyRedaction = (value, options, seen) => {
-  const mode = options.mode ?? "omit";
-  const maskValue = options.maskValue ?? "[redacted]";
-  const allow = new Set(options.metadataAllow ?? []);
-  const deny = new Set(options.metadataDeny ?? DEFAULT_METADATA_DENY);
-  const walk = (input) => {
-    if (Array.isArray(input)) {
-      return input.map((entry) => walk(entry));
-    }
-    if (input && typeof input === "object") {
-      if (seen.has(input))
-        return input;
-      seen.add(input);
-      const next = {};
-      for (const [key, entry] of Object.entries(input)) {
-        if (allow.has(key)) {
-          next[key] = entry;
-          continue;
-        }
-        if (deny.has(key)) {
-          if (mode === "mask")
-            next[key] = maskValue;
-          continue;
-        }
-        next[key] = walk(entry);
-      }
-      return next;
-    }
-    return input;
-  };
-  return walk(value);
-};
-var redactMediaReport = (report, options = {}) => {
-  const limit = options.truncateArraysAt ?? DEFAULT_TRUNCATE;
-  const truncated = truncateArrays(report, limit, new WeakSet);
-  return applyRedaction(truncated, options, new WeakSet);
-};
-var buildArtifactPair = (report, summary, markdown, options) => {
-  const jsonValue = options.redact ? redactMediaReport(report, options.redact) : report;
-  return {
-    json: JSON.stringify(jsonValue, null, 2),
-    jsonValue,
-    markdown,
-    summary
-  };
-};
-var buildMediaQualityArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaQualityReport(report), renderMediaQualityMarkdown(report, options), options);
-var buildMediaTransportArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaTransportReport(report), renderMediaTransportMarkdown(report, options), options);
-var buildMediaProcessorGraphArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaProcessorGraphReport(report), renderMediaProcessorGraphMarkdown(report, options), options);
-var writeMediaArtifact = async (input) => {
-  await mkdir(input.dir, { recursive: true });
-  const jsonPath = join(input.dir, `${input.slug}.json`);
-  const markdownPath = join(input.dir, `${input.slug}.md`);
-  await Promise.all([
-    writeFile(jsonPath, input.json, "utf8"),
-    writeFile(markdownPath, input.markdown, "utf8")
-  ]);
-  return {
-    jsonPath,
-    markdownPath,
-    summary: input.summary
-  };
-};
-
 // src/client/browserMedia.ts
+import {
+  buildMediaWebRTCStatsReport,
+  buildMediaWebRTCStreamContinuityReport,
+  collectMediaWebRTCStats
+} from "@absolutejs/media";
 var DEFAULT_BROWSER_MEDIA_PATH = "/api/voice/browser-media";
 var DEFAULT_BROWSER_MEDIA_INTERVAL_MS = 5000;
 var resolvePeerConnection = async (options) => options.peerConnection ?? await options.getPeerConnection?.() ?? null;