@absolutejs/voice 0.0.22-beta.329 → 0.0.22-beta.330

package/dist/testing/index.js

@@ -8990,12 +8990,2425 @@ var runVoiceSessionBenchmarkSeries = async (input) => {
     reports
   });
 };
+// src/operationsRecord.ts
+import { Elysia as Elysia4 } from "elysia";
+
+// src/audit.ts
+var includes = (filter, value) => {
+  if (!filter) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  return Array.isArray(filter) ? filter.includes(value) : filter === value;
+};
+var createVoiceAuditEvent = (event) => ({
+  ...event,
+  at: event.at ?? Date.now(),
+  id: event.id ?? crypto.randomUUID()
+});
+var filterVoiceAuditEvents = (events, filter = {}) => {
+  const sorted = events.filter((event) => {
+    if (!includes(filter.type, event.type)) {
+      return false;
+    }
+    if (!includes(filter.outcome, event.outcome)) {
+      return false;
+    }
+    if (filter.actorId && event.actor?.id !== filter.actorId) {
+      return false;
+    }
+    if (filter.resourceId && event.resource?.id !== filter.resourceId) {
+      return false;
+    }
+    if (filter.resourceType && event.resource?.type !== filter.resourceType) {
+      return false;
+    }
+    if (filter.sessionId && event.sessionId !== filter.sessionId) {
+      return false;
+    }
+    if (filter.traceId && event.traceId !== filter.traceId) {
+      return false;
+    }
+    if (typeof filter.after === "number" && event.at <= filter.after) {
+      return false;
+    }
+    if (typeof filter.afterOrAt === "number" && event.at < filter.afterOrAt) {
+      return false;
+    }
+    if (typeof filter.before === "number" && event.at >= filter.before) {
+      return false;
+    }
+    if (typeof filter.beforeOrAt === "number" && event.at > filter.beforeOrAt) {
+      return false;
+    }
+    return true;
+  }).sort((left, right) => left.at - right.at || left.id.localeCompare(right.id));
+  return typeof filter.limit === "number" && filter.limit >= 0 ? sorted.slice(0, filter.limit) : sorted;
+};
+var createVoiceMemoryAuditEventStore = () => {
+  const events = new Map;
+  return {
+    append: (event) => {
+      const stored = createVoiceAuditEvent(event);
+      events.set(stored.id, stored);
+      return stored;
+    },
+    get: (id) => events.get(id),
+    list: (filter) => filterVoiceAuditEvents([...events.values()], filter)
+  };
+};
+var recordVoiceAuditEvent = (store, event) => store.append(createVoiceAuditEvent(event));
+var recordVoiceProviderAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: `${input.kind}.provider.call`,
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    cost: input.cost,
+    elapsedMs: input.elapsedMs,
+    error: input.error,
+    kind: input.kind,
+    model: input.model,
+    provider: input.provider
+  },
+  resource: {
+    id: input.provider,
+    type: "provider"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "provider.call"
+});
+var recordVoiceToolAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: "tool.call",
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    elapsedMs: input.elapsedMs,
+    error: input.error,
+    toolCallId: input.toolCallId,
+    toolName: input.toolName
+  },
+  resource: {
+    id: input.toolName,
+    type: "tool"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "tool.call"
+});
+var recordVoiceHandoffAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: "handoff",
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome,
+  payload: {
+    fromAgentId: input.fromAgentId,
+    reason: input.reason,
+    target: input.target,
+    toAgentId: input.toAgentId
+  },
+  resource: {
+    id: input.toAgentId ?? input.target,
+    type: "handoff"
+  },
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "handoff"
+});
+var recordVoiceRetentionAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: input.dryRun ? "retention.plan" : "retention.apply",
+  actor: input.actor ?? {
+    id: "voice-retention",
+    kind: "system"
+  },
+  metadata: input.metadata,
+  outcome: "success",
+  payload: {
+    deletedCount: input.report.deletedCount,
+    dryRun: input.dryRun,
+    scopes: input.report.scopes
+  },
+  resource: {
+    type: "retention-policy"
+  },
+  type: "retention.policy"
+});
+var recordVoiceOperatorAuditEvent = (input) => recordVoiceAuditEvent(input.store, {
+  action: input.action,
+  actor: input.actor,
+  metadata: input.metadata,
+  outcome: input.outcome ?? "success",
+  payload: input.payload,
+  resource: input.resource,
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  type: "operator.action"
+});
+var createVoiceAuditLogger = (store) => ({
+  handoff: (input) => recordVoiceHandoffAuditEvent({ ...input, store }),
+  operatorAction: (input) => recordVoiceOperatorAuditEvent({ ...input, store }),
+  providerCall: (input) => recordVoiceProviderAuditEvent({ ...input, store }),
+  record: (event) => recordVoiceAuditEvent(store, event),
+  retention: (input) => recordVoiceRetentionAuditEvent({ ...input, store }),
+  toolCall: (input) => recordVoiceToolAuditEvent({ ...input, store })
+});
+
+// src/trace.ts
+var createVoiceTraceEventId = (event) => [
+  event.sessionId,
+  event.turnId ?? "session",
+  event.type,
+  String(event.at ?? Date.now()),
+  crypto.randomUUID()
+].map(encodeURIComponent).join(":");
+var createVoiceTraceEvent = (event) => ({
+  ...event,
+  at: event.at,
+  id: event.id ?? createVoiceTraceEventId({
+    at: event.at,
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    type: event.type
+  })
+});
+var createVoiceTraceSinkDeliveryId = (events) => {
+  const firstEvent = events[0];
+  return [
+    firstEvent?.sessionId ?? "trace",
+    firstEvent?.traceId ?? "sink",
+    String(firstEvent?.at ?? Date.now()),
+    crypto.randomUUID()
+  ].map(encodeURIComponent).join(":");
+};
+var createVoiceTraceSinkDeliveryRecord = (input) => {
+  const createdAt = input.createdAt ?? Date.now();
+  return {
+    createdAt,
+    deliveredAt: input.deliveredAt,
+    deliveryAttempts: input.deliveryAttempts,
+    deliveryError: input.deliveryError,
+    deliveryStatus: input.deliveryStatus ?? "pending",
+    events: input.events,
+    id: input.id ?? createVoiceTraceSinkDeliveryId(input.events),
+    sinkDeliveries: input.sinkDeliveries,
+    updatedAt: input.updatedAt ?? createdAt
+  };
+};
+var matchesTraceFilter = (event, filter) => {
+  if (filter.sessionId !== undefined && event.sessionId !== filter.sessionId) {
+    return false;
+  }
+  if (filter.turnId !== undefined && event.turnId !== filter.turnId) {
+    return false;
+  }
+  if (filter.scenarioId !== undefined && event.scenarioId !== filter.scenarioId) {
+    return false;
+  }
+  if (filter.traceId !== undefined && event.traceId !== filter.traceId) {
+    return false;
+  }
+  if (filter.type !== undefined) {
+    const types = Array.isArray(filter.type) ? filter.type : [filter.type];
+    if (!types.includes(event.type)) {
+      return false;
+    }
+  }
+  return true;
+};
+var filterVoiceTraceEvents = (events, filter = {}) => {
+  const sorted = events.filter((event) => matchesTraceFilter(event, filter)).sort((left, right) => left.at - right.at || left.id.localeCompare(right.id));
+  return typeof filter.limit === "number" && filter.limit >= 0 ? sorted.slice(0, filter.limit) : sorted;
+};
+var isPruneTimeMatch = (event, options) => {
+  if (typeof options.before === "number" && event.at >= options.before) {
+    return false;
+  }
+  if (typeof options.beforeOrAt === "number" && event.at > options.beforeOrAt) {
+    return false;
+  }
+  return true;
+};
+var selectVoiceTraceEventsForPrune = (events, options = {}) => {
+  let candidates = filterVoiceTraceEvents(events, options.filter).filter((event) => isPruneTimeMatch(event, options));
+  if (typeof options.keepNewest === "number" && options.keepNewest >= 0) {
+    const newestIds = new Set([...candidates].sort((left, right) => right.at - left.at || right.id.localeCompare(left.id)).slice(0, options.keepNewest).map((event) => event.id));
+    candidates = candidates.filter((event) => !newestIds.has(event.id));
+  }
+  return typeof options.limit === "number" && options.limit >= 0 ? candidates.slice(0, options.limit) : candidates;
+};
+var pruneVoiceTraceEvents = async (options) => {
+  const events = await options.store.list(options.filter);
+  const deleted = selectVoiceTraceEventsForPrune(events, options);
+  if (!options.dryRun) {
+    await Promise.all(deleted.map((event) => options.store.remove(event.id)));
+  }
+  return {
+    deleted,
+    deletedCount: deleted.length,
+    dryRun: Boolean(options.dryRun),
+    scannedCount: events.length
+  };
+};
+var sleep2 = async (delayMs) => {
+  if (delayMs <= 0) {
+    return;
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+};
+var toHex2 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signVoiceTraceSinkBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const payload = encoder.encode(`${input.timestamp}.${input.body}`);
+  const signature = await crypto.subtle.sign("HMAC", key, payload);
+  return `sha256=${toHex2(new Uint8Array(signature))}`;
+};
+var createVoiceTraceSinkDeliveryError = (input) => {
+  if (input.response) {
+    const statusText = input.response.statusText?.trim();
+    return `Attempt ${input.attempt} failed with trace sink response ${input.response.status}${statusText ? ` ${statusText}` : ""}.`;
+  }
+  if (input.error instanceof Error) {
+    return `Attempt ${input.attempt} failed: ${input.error.message}`;
+  }
+  return `Attempt ${input.attempt} failed: ${String(input.error)}`;
+};
+var normalizeVoiceTraceS3KeyPrefix = (prefix) => prefix?.trim().replace(/^\/+|\/+$/g, "") ?? "voice/trace-deliveries";
+var createVoiceTraceS3ObjectKey = (prefix, events) => {
+  const firstEvent = events[0];
+  const safeSessionId = encodeURIComponent(firstEvent?.sessionId ?? "trace");
+  const safeEventId = encodeURIComponent(firstEvent?.id ?? crypto.randomUUID());
+  return `${prefix}/${safeSessionId}/${Date.now()}-${safeEventId}.json`;
+};
+var resolveVoiceS3DeliveredTo = (options, key) => {
+  const bucket = options.bucket;
+  return bucket ? `s3://${bucket}/${key}` : `s3://${key}`;
+};
+var aggregateVoiceTraceSinkDeliveryStatus = (deliveries) => {
+  const statuses = Object.values(deliveries).map((delivery) => delivery.status);
+  if (statuses.length === 0 || statuses.every((status) => status === "skipped")) {
+    return "skipped";
+  }
+  if (statuses.some((status) => status === "failed")) {
+    return "failed";
+  }
+  return "delivered";
+};
+var createVoiceTraceHTTPSink = (options) => ({
+  deliver: async ({ events }) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      return {
+        attempts: 0,
+        deliveredTo: options.url,
+        error: "Trace sink delivery failed: fetch is not available in this runtime.",
+        eventCount: events.length,
+        status: "failed"
+      };
+    }
+    const maxRetries = Math.max(0, options.retries ?? 0);
+    const backoffMs = Math.max(0, options.backoffMs ?? 250);
+    const timeoutMs = Math.max(0, options.timeoutMs ?? 1e4);
+    const payload = options.body ? await options.body({ events }) : {
+      eventCount: events.length,
+      events,
+      source: "absolutejs-voice"
+    };
+    const body = JSON.stringify(payload);
+    let lastError = "Trace sink delivery failed.";
+    for (let attempt = 1;attempt <= maxRetries + 1; attempt += 1) {
+      let controller;
+      let timeout;
+      try {
+        const headers = {
+          "content-type": "application/json",
+          ...options.headers
+        };
+        if (options.signingSecret) {
+          const timestamp = String(Date.now());
+          headers["x-absolutejs-timestamp"] = timestamp;
+          headers["x-absolutejs-signature"] = await signVoiceTraceSinkBody({
+            body,
+            secret: options.signingSecret,
+            timestamp
+          });
+        }
+        controller = timeoutMs > 0 ? new AbortController : undefined;
+        if (controller && timeoutMs > 0) {
+          timeout = setTimeout(() => controller?.abort(), timeoutMs);
+        }
+        const response = await fetchImpl(options.url, {
+          body,
+          headers,
+          method: options.method ?? "POST",
+          signal: controller?.signal
+        });
+        if (response.ok) {
+          let responseBody;
+          try {
+            responseBody = await response.clone().json();
+          } catch {
+            responseBody = undefined;
+          }
+          return {
+            attempts: attempt,
+            deliveredAt: Date.now(),
+            deliveredTo: options.url,
+            eventCount: events.length,
+            responseBody,
+            status: "delivered"
+          };
+        }
+        lastError = createVoiceTraceSinkDeliveryError({
+          attempt,
+          response
+        });
+      } catch (error) {
+        lastError = createVoiceTraceSinkDeliveryError({
+          attempt,
+          error
+        });
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+      if (attempt <= maxRetries) {
+        await sleep2(backoffMs * attempt);
+      }
+    }
+    return {
+      attempts: maxRetries + 1,
+      deliveredTo: options.url,
+      error: lastError,
+      eventCount: events.length,
+      status: "failed"
+    };
+  },
+  eventTypes: options.eventTypes,
+  id: options.id,
+  kind: options.kind ?? "http"
+});
+var createVoiceTraceS3Sink = (options) => {
+  const client = options.client ?? new Bun.S3Client(options);
+  const keyPrefix = normalizeVoiceTraceS3KeyPrefix(options.keyPrefix);
+  return {
+    deliver: async ({ events }) => {
+      const key = createVoiceTraceS3ObjectKey(keyPrefix, events);
+      const payload = options.body ? await options.body({ events, key }) : {
+        eventCount: events.length,
+        events,
+        key,
+        source: "absolutejs-voice"
+      };
+      try {
+        const file = client.file(key, options);
+        await file.write(JSON.stringify(payload), {
+          type: options.contentType ?? "application/json"
+        });
+        return {
+          attempts: 1,
+          deliveredAt: Date.now(),
+          deliveredTo: resolveVoiceS3DeliveredTo(options, key),
+          eventCount: events.length,
+          responseBody: { key },
+          status: "delivered"
+        };
+      } catch (error) {
+        return {
+          attempts: 1,
+          deliveredTo: resolveVoiceS3DeliveredTo(options, key),
+          error: error instanceof Error ? error.message : String(error),
+          eventCount: events.length,
+          status: "failed"
+        };
+      }
+    },
+    eventTypes: options.eventTypes,
+    id: options.id,
+    kind: options.kind ?? "s3"
+  };
+};
+var deliverVoiceTraceEventsToSinks = async (input) => {
+  const events = input.redact ? redactVoiceTraceEvents(input.events, input.redact) : input.events;
+  const sinkDeliveries = {};
+  for (const sink of input.sinks) {
+    const sinkEvents = sink.eventTypes?.length ? events.filter((event) => sink.eventTypes?.includes(event.type)) : events;
+    if (sinkEvents.length === 0) {
+      sinkDeliveries[sink.id] = {
+        attempts: 0,
+        eventCount: 0,
+        status: "skipped"
+      };
+      continue;
+    }
+    try {
+      sinkDeliveries[sink.id] = await sink.deliver({
+        events: sinkEvents
+      });
+    } catch (error) {
+      sinkDeliveries[sink.id] = {
+        attempts: 1,
+        error: error instanceof Error ? error.message : String(error),
+        eventCount: sinkEvents.length,
+        status: "failed"
+      };
+    }
+  }
+  return {
+    deliveredAt: Date.now(),
+    eventCount: events.length,
+    sinkDeliveries,
+    status: aggregateVoiceTraceSinkDeliveryStatus(sinkDeliveries)
+  };
+};
+var createVoiceTraceSinkStore = (options) => {
+  const deliver = async (event) => {
+    const result = await deliverVoiceTraceEventsToSinks({
+      events: [event],
+      redact: options.redact,
+      sinks: options.sinks
+    });
+    await options.onDelivery?.(result);
+  };
+  return {
+    append: async (event) => {
+      const stored = await options.store.append(event);
+      if (options.deliveryQueue) {
+        const delivery2 = createVoiceTraceSinkDeliveryRecord({
+          events: [stored]
+        });
+        await options.deliveryQueue.set(delivery2.id, delivery2);
+        return stored;
+      }
+      const delivery = deliver(stored);
+      if (options.awaitDelivery) {
+        await delivery;
+      } else {
+        delivery.catch((error) => {
+          options.onError?.(error);
+        });
+      }
+      return stored;
+    },
+    get: (id) => options.store.get(id),
+    list: (filter) => options.store.list(filter),
+    remove: (id) => options.store.remove(id)
+  };
+};
+var createVoiceMemoryTraceSinkDeliveryStore = () => {
+  const deliveries = new Map;
+  return {
+    get: async (id) => deliveries.get(id),
+    list: async () => [...deliveries.values()].sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)),
+    remove: async (id) => {
+      deliveries.delete(id);
+    },
+    set: async (id, delivery) => {
+      deliveries.set(id, delivery);
+    }
+  };
+};
+var createVoiceMemoryTraceEventStore = () => {
+  const events = new Map;
+  const append = async (event) => {
+    const stored = createVoiceTraceEvent(event);
+    events.set(stored.id, stored);
+    return stored;
+  };
+  const get = async (id) => events.get(id);
+  const list = async (filter) => filterVoiceTraceEvents([...events.values()], filter);
+  const remove = async (id) => {
+    events.delete(id);
+  };
+  return { append, get, list, remove };
+};
+var exportVoiceTrace = async (input) => {
+  const events = await input.store.list(input.filter);
+  return {
+    exportedAt: Date.now(),
+    events: input.redact ? redactVoiceTraceEvents(events, input.redact) : events,
+    filter: input.filter,
+    redacted: Boolean(input.redact)
+  };
+};
+var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var escapeHtml2 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var formatTraceValue = (value) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var DEFAULT_REDACTION_KEYS = [
+  "apiKey",
+  "authorization",
+  "creditCard",
+  "email",
+  "externalId",
+  "password",
+  "phone",
+  "secret",
+  "ssn",
+  "token"
+];
+var DEFAULT_REDACTION_TEXT_KEYS = [
+  "assistantText",
+  "content",
+  "error",
+  "reason",
+  "summary",
+  "text"
+];
+var EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+var PHONE_PATTERN = /(?<!\d)(?:\+?1[\s.-]?)?(?:\(?\d{3}\)?[\s.-]?)\d{3}[\s.-]?\d{4}(?!\d)/g;
+var normalizeRedactionKey = (key) => key.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+var resolveVoiceTraceRedactionOptions = (options = {}) => ({
+  keys: typeof options === "boolean" ? DEFAULT_REDACTION_KEYS : options.keys ?? DEFAULT_REDACTION_KEYS,
+  redactEmails: typeof options === "boolean" ? true : options.redactEmails ?? true,
+  redactPhoneNumbers: typeof options === "boolean" ? true : options.redactPhoneNumbers ?? true,
+  redactText: typeof options === "boolean" ? true : options.redactText ?? true,
+  replacement: typeof options === "boolean" ? "[redacted]" : options.replacement ?? "[redacted]",
+  textKeys: typeof options === "boolean" ? DEFAULT_REDACTION_TEXT_KEYS : options.textKeys ?? DEFAULT_REDACTION_TEXT_KEYS
+});
+var resolveReplacement = (input) => typeof input.options.replacement === "function" ? input.options.replacement({
+  key: input.key,
+  path: input.path,
+  value: input.value
+}) : input.options.replacement;
+var redactVoiceTraceText = (value, options = {}, input = {}) => {
+  const resolved = resolveVoiceTraceRedactionOptions(options);
+  let redacted = value;
+  const replacement = resolveReplacement({
+    key: input.key,
+    options: resolved,
+    path: input.path ?? [],
+    value
+  });
+  if (resolved.redactEmails) {
+    redacted = redacted.replace(EMAIL_PATTERN, replacement);
+  }
+  if (resolved.redactPhoneNumbers) {
+    redacted = redacted.replace(PHONE_PATTERN, replacement);
+  }
+  return redacted;
+};
+var redactTraceValue = (value, options, path) => {
+  const key = path.at(-1);
+  const normalizedKey = key ? normalizeRedactionKey(key) : undefined;
+  const sensitiveKeys = new Set(options.keys.map(normalizeRedactionKey));
+  const textKeys = new Set(options.textKeys.map(normalizeRedactionKey));
+  if (normalizedKey && sensitiveKeys.has(normalizedKey) && (value === null || ["boolean", "number", "string", "undefined"].includes(typeof value))) {
+    return resolveReplacement({
+      key,
+      options,
+      path,
+      value: String(value ?? "")
+    });
+  }
+  if (typeof value === "string") {
+    const shouldRedactText = options.redactText && (!normalizedKey || textKeys.has(normalizedKey) || path.length === 0);
+    return shouldRedactText ? redactVoiceTraceText(value, options, {
+      key,
+      path
+    }) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactTraceValue(item, options, [...path, String(index)]));
+  }
+  if (typeof value === "object" && value) {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
+      entryKey,
+      redactTraceValue(entryValue, options, [...path, entryKey])
+    ]));
+  }
+  return value;
+};
+var redactVoiceTraceEvent = (event, options = {}) => {
+  const resolved = resolveVoiceTraceRedactionOptions(options);
+  return {
+    ...event,
+    metadata: redactTraceValue(event.metadata, resolved, ["metadata"]),
+    payload: redactTraceValue(event.payload, resolved, ["payload"])
+  };
+};
+var redactVoiceTraceEvents = (events, options = {}) => events.map((event) => redactVoiceTraceEvent(event, options));
+var summarizeVoiceTrace = (events) => {
+  const sorted = filterVoiceTraceEvents(events);
+  const firstEvent = sorted[0];
+  const lastEvent = sorted.at(-1);
+  const lifecycleEvents = sorted.filter((event) => event.type === "call.lifecycle");
+  const startEvent = lifecycleEvents.find((event) => event.payload.type === "start");
+  const endEvent = lifecycleEvents.toReversed().find((event) => event.payload.type === "end");
+  const costEvents = sorted.filter((event) => event.type === "turn.cost");
+  const toolEvents = sorted.filter((event) => event.type === "agent.tool");
+  const startedAt = startEvent?.at ?? firstEvent?.at;
+  const endedAt = endEvent?.at ?? lastEvent?.at;
+  const failed = sorted.some((event) => event.type === "session.error") || endEvent?.payload.disposition === "failed";
+  return {
+    assistantReplyCount: sorted.filter((event) => event.type === "turn.assistant").length,
+    callDurationMs: startedAt !== undefined && endedAt !== undefined ? Math.max(0, endedAt - startedAt) : undefined,
+    cost: {
+      estimatedRelativeCostUnits: costEvents.reduce((total, event) => total + toNumber(event.payload.estimatedRelativeCostUnits), 0),
+      totalBillableAudioMs: costEvents.reduce((total, event) => total + toNumber(event.payload.totalBillableAudioMs), 0)
+    },
+    endedAt,
+    errorCount: sorted.filter((event) => event.type === "session.error").length,
+    eventCount: sorted.length,
+    failed,
+    handoffCount: sorted.filter((event) => event.type === "agent.handoff").length,
+    modelCallCount: sorted.filter((event) => event.type === "agent.model").length,
+    sessionId: firstEvent?.sessionId,
+    startedAt,
+    toolCallCount: toolEvents.length,
+    toolErrorCount: toolEvents.filter((event) => event.payload.status === "error").length,
+    traceId: firstEvent?.traceId,
+    transcriptCount: sorted.filter((event) => event.type === "turn.transcript").length,
+    turnCount: sorted.filter((event) => event.type === "turn.committed").length
+  };
+};
+var evaluateVoiceTrace = (events, options = {}) => {
+  const summary = summarizeVoiceTrace(events);
+  const issues = [];
+  const maxHandoffs = options.maxHandoffs ?? 3;
+  const maxToolErrors = options.maxToolErrors ?? 0;
+  const maxModelCallsPerTurn = options.maxModelCallsPerTurn ?? 6;
+  const turnCountForRatio = Math.max(1, summary.turnCount);
+  if (options.requireCompletedCall !== false && !summary.endedAt) {
+    issues.push({
+      code: "call-not-ended",
+      message: "Trace does not include a call end lifecycle event.",
+      severity: "warning"
+    });
+  }
+  if (summary.failed) {
+    issues.push({
+      code: "session-error",
+      message: "Trace contains a session error or failed call disposition.",
+      severity: "error"
+    });
+  }
+  if (options.requireTranscript !== false && summary.transcriptCount === 0) {
+    issues.push({
+      code: "missing-transcript",
+      message: "Trace does not include any transcript events.",
+      severity: "error"
+    });
+  }
+  if (options.requireTurn !== false && summary.turnCount === 0) {
+    issues.push({
+      code: "missing-turn",
+      message: "Trace does not include any committed turns.",
+      severity: "error"
+    });
+  }
+  if (options.requireAssistantReply !== false && summary.turnCount > 0 && summary.assistantReplyCount === 0) {
+    issues.push({
+      code: "missing-assistant-reply",
+      message: "Trace has committed turns but no assistant replies.",
+      severity: "warning"
+    });
+  }
+  if (summary.toolErrorCount > maxToolErrors) {
+    issues.push({
+      code: "tool-errors",
+      message: `Trace has ${summary.toolErrorCount} tool error(s), above the allowed ${maxToolErrors}.`,
+      severity: "error"
+    });
+  }
+  if (summary.handoffCount > maxHandoffs) {
+    issues.push({
+      code: "too-many-handoffs",
+      message: `Trace has ${summary.handoffCount} handoff(s), above the allowed ${maxHandoffs}.`,
+      severity: "warning"
+    });
+  }
+  if (summary.modelCallCount / turnCountForRatio > maxModelCallsPerTurn) {
+    issues.push({
+      code: "too-many-model-calls",
+      message: `Trace averages more than ${maxModelCallsPerTurn} model calls per committed turn.`,
+      severity: "warning"
+    });
+  }
+  return {
+    issues,
+    pass: !issues.some((issue) => issue.severity === "error"),
+    summary
+  };
+};
+var renderTraceEventMarkdown = (event, startedAt) => {
+  const offset = startedAt === undefined ? `${event.at}` : `+${Math.max(0, event.at - startedAt)}ms`;
+  const label = `- ${offset} [${event.type}]`;
+  switch (event.type) {
+    case "turn.transcript":
+      return `${label} ${event.payload.isFinal ? "final" : "partial"} "${formatTraceValue(event.payload.text)}"`;
+    case "turn.committed":
+      return `${label} committed "${formatTraceValue(event.payload.text)}"`;
+    case "turn.assistant":
+      return event.payload.text ? `${label} assistant "${formatTraceValue(event.payload.text)}"` : `${label} ${formatTraceValue(event.payload.status)}`;
+    case "agent.tool":
+      return `${label} ${formatTraceValue(event.payload.toolName)} ${formatTraceValue(event.payload.status)}`;
+    case "agent.context":
+      return `${label} ${formatTraceValue(event.payload.fromAgentId)} -> ${formatTraceValue(event.payload.targetAgentId)} ${formatTraceValue(event.payload.status)}`;
+    case "agent.handoff":
+      return `${label} ${formatTraceValue(event.payload.fromAgentId)} -> ${formatTraceValue(event.payload.targetAgentId)}`;
+    case "session.error":
+      return `${label} ${formatTraceValue(event.payload.error)}`;
+    case "call.lifecycle":
+      return `${label} ${formatTraceValue(event.payload.type)} ${formatTraceValue(event.payload.disposition)}`.trim();
+    default:
+      return `${label} ${formatTraceValue(event.payload)}`;
+  }
+};
+var renderVoiceTraceMarkdown = (events, options = {}) => {
+  const sorted = filterVoiceTraceEvents(options.redact ? redactVoiceTraceEvents(events, options.redact) : events);
+  const summary = summarizeVoiceTrace(sorted);
+  const evaluation = evaluateVoiceTrace(sorted, options.evaluation);
+  const lines = [
+    `# ${options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim()}`,
+    "",
+    `Pass: ${evaluation.pass ? "yes" : "no"}`,
+    `Session: ${summary.sessionId ?? "unknown"}`,
+    `Events: ${summary.eventCount}`,
+    `Turns: ${summary.turnCount}`,
+    `Transcripts: ${summary.transcriptCount}`,
+    `Assistant replies: ${summary.assistantReplyCount}`,
+    `Model calls: ${summary.modelCallCount}`,
+    `Tool calls: ${summary.toolCallCount}`,
+    `Handoffs: ${summary.handoffCount}`,
+    `Errors: ${summary.errorCount}`,
+    `Estimated cost units: ${summary.cost.estimatedRelativeCostUnits}`,
+    ""
+  ];
+  if (evaluation.issues.length > 0) {
+    lines.push("## Issues", "");
+    for (const issue of evaluation.issues) {
+      lines.push(`- [${issue.severity}] ${issue.code}: ${issue.message}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Timeline", "");
+  for (const event of sorted) {
+    lines.push(renderTraceEventMarkdown(event, summary.startedAt));
+  }
+  return lines.join(`
+`);
+};
+var renderVoiceTraceHTML = (events, options = {}) => {
+  const markdown = renderVoiceTraceMarkdown(events, options);
+  const renderEvents = options.redact ? redactVoiceTraceEvents(events, options.redact) : events;
+  const summary = summarizeVoiceTrace(renderEvents);
+  const evaluation = evaluateVoiceTrace(renderEvents, options.evaluation);
+  const eventRows = filterVoiceTraceEvents(renderEvents).map((event) => {
+    const offset = summary.startedAt === undefined ? event.at : Math.max(0, event.at - summary.startedAt);
+    return [
+      "<tr>",
+      `<td>${escapeHtml2(String(offset))}</td>`,
+      `<td>${escapeHtml2(event.type)}</td>`,
+      `<td>${escapeHtml2(event.turnId ?? "")}</td>`,
+      `<td><code>${escapeHtml2(JSON.stringify(event.payload))}</code></td>`,
+      "</tr>"
+    ].join("");
+  }).join(`
+`);
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8" />',
+    '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    `<title>${escapeHtml2(options.title ?? "Voice Trace")}</title>`,
+    "<style>",
+    "body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;line-height:1.45;background:#f8f7f2;color:#181713}",
+    "main{max-width:1100px;margin:auto}",
+    ".summary{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:.75rem;margin:1rem 0}",
+    ".card{background:white;border:1px solid #ded9cc;border-radius:12px;padding:1rem}",
+    ".pass{color:#126b3a}.fail{color:#9d2222}",
+    "table{border-collapse:collapse;width:100%;background:white;border:1px solid #ded9cc}",
+    "th,td{border-bottom:1px solid #eee8dc;padding:.65rem;text-align:left;vertical-align:top}",
+    "code{white-space:pre-wrap;word-break:break-word}",
+    "pre{background:#181713;color:#f8f7f2;padding:1rem;border-radius:12px;overflow:auto}",
+    "</style>",
+    "</head>",
+    "<body><main>",
+    `<h1>${escapeHtml2(options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim())}</h1>`,
+    `<p class="${evaluation.pass ? "pass" : "fail"}">QA: ${evaluation.pass ? "pass" : "fail"}</p>`,
+    '<section class="summary">',
+    `<div class="card"><strong>Events</strong><br>${summary.eventCount}</div>`,
+    `<div class="card"><strong>Turns</strong><br>${summary.turnCount}</div>`,
+    `<div class="card"><strong>Transcripts</strong><br>${summary.transcriptCount}</div>`,
+    `<div class="card"><strong>Tool errors</strong><br>${summary.toolErrorCount}</div>`,
+    `<div class="card"><strong>Cost units</strong><br>${summary.cost.estimatedRelativeCostUnits}</div>`,
+    "</section>",
+    "<h2>Timeline</h2>",
+    "<table><thead><tr><th>Offset ms</th><th>Type</th><th>Turn</th><th>Payload</th></tr></thead><tbody>",
+    eventRows,
+    "</tbody></table>",
+    "<h2>Markdown Export</h2>",
+    `<pre>${escapeHtml2(markdown)}</pre>`,
+    "</main></body></html>"
+  ].join(`
+`);
+};
+var buildVoiceTraceReplay = (events, options = {}) => ({
+  evaluation: evaluateVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events, options.evaluation),
+  html: renderVoiceTraceHTML(events, options),
+  markdown: renderVoiceTraceMarkdown(events, options),
+  summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
+});
+
+// src/auditRoutes.ts
+import { Elysia } from "elysia";
+var escapeHtml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var getNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return;
+};
+var parseType = (value) => {
+  const text = getString(value);
+  return text && [
+    "handoff",
+    "operator.action",
+    "provider.call",
+    "retention.policy",
+    "tool.call"
+  ].includes(text) ? text : undefined;
+};
+var parseOutcome = (value) => {
+  const text = getString(value);
+  return text && ["error", "skipped", "success"].includes(text) ? text : undefined;
+};
+var parseBoolean = (value, fallback = false) => {
+  const text = getString(value)?.toLowerCase();
+  if (["1", "true", "yes"].includes(text ?? "")) {
+    return true;
+  }
+  if (["0", "false", "no"].includes(text ?? "")) {
+    return false;
+  }
+  return fallback;
+};
+var parseExportFormat = (value) => {
+  const text = getString(value)?.toLowerCase();
+  return text === "markdown" || text === "md" ? "markdown" : text === "html" ? "html" : "json";
+};
+var increment = (counts, key) => {
+  if (!key) {
+    return;
+  }
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+};
+var sortedCounts = (counts) => [...counts.entries()].sort(([leftKey, leftCount], [rightKey, rightCount]) => rightCount - leftCount || leftKey.localeCompare(rightKey));
+var resolveVoiceAuditTrailFilter = (query = {}, base = {}) => ({
+  ...base,
+  actorId: getString(query.actorId) ?? base.actorId,
+  after: getNumber(query.after) ?? base.after,
+  afterOrAt: getNumber(query.afterOrAt) ?? base.afterOrAt,
+  before: getNumber(query.before) ?? base.before,
+  beforeOrAt: getNumber(query.beforeOrAt) ?? base.beforeOrAt,
+  limit: getNumber(query.limit) ?? base.limit,
+  outcome: parseOutcome(query.outcome) ?? base.outcome,
+  resourceId: getString(query.resourceId) ?? base.resourceId,
+  resourceType: getString(query.resourceType) ?? base.resourceType,
+  sessionId: getString(query.sessionId) ?? base.sessionId,
+  traceId: getString(query.traceId) ?? base.traceId,
+  type: parseType(query.type) ?? base.type
+});
+var summarizeVoiceAuditTrail = (events) => {
+  const byActor = new Map;
+  const byOutcome = new Map;
+  const byResourceType = new Map;
+  const byType = new Map;
+  for (const event of events) {
+    increment(byActor, event.actor?.id);
+    increment(byOutcome, event.outcome);
+    increment(byResourceType, event.resource?.type);
+    increment(byType, event.type);
+  }
+  return {
+    byActor: sortedCounts(byActor),
+    byOutcome: sortedCounts(byOutcome),
+    byResourceType: sortedCounts(byResourceType),
+    byType: sortedCounts(byType),
+    errors: events.filter((event) => event.outcome === "error").length,
+    latestAt: events.at(-1)?.at,
+    total: events.length
+  };
+};
+var buildVoiceAuditTrailReport = async (options) => {
+  const filter = {
+    ...options.filter,
+    limit: options.filter?.limit ?? options.limit
+  };
+  const events = await options.store.list(filter);
+  return {
+    checkedAt: Date.now(),
+    events,
+    filter,
+    summary: summarizeVoiceAuditTrail(events)
+  };
+};
+var renderVoiceAuditTrailHTML = (report, options = {}) => {
+  const title = options.title ?? "AbsoluteJS Voice Audit Trail";
+  const chips = report.summary.byType.map(([type, count]) => `<span>${escapeHtml3(type)} <strong>${count}</strong></span>`).join("");
+  const rows = report.events.map((event) => {
+    const actor = event.actor ? `${event.actor.kind}:${event.actor.id}` : "unknown";
+    const resource = event.resource ? `${event.resource.type}${event.resource.id ? `:${event.resource.id}` : ""}` : "";
+    const payload = event.payload ? JSON.stringify(event.payload, null, 2) : "";
+    return `<article class="event ${escapeHtml3(event.outcome ?? "unknown")}"><div><span>${escapeHtml3(event.type)}</span><h2>${escapeHtml3(event.action)}</h2><p>${escapeHtml3(new Date(event.at).toLocaleString())}</p><p>Actor: ${escapeHtml3(actor)}${resource ? ` \xB7 Resource: ${escapeHtml3(resource)}` : ""}</p>${event.sessionId ? `<p>Session: ${escapeHtml3(event.sessionId)}</p>` : ""}</div><strong>${escapeHtml3(event.outcome ?? "recorded")}</strong>${payload ? `<pre>${escapeHtml3(payload)}</pre>` : ""}</article>`;
+  }).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml3(title)}</title><style>body{background:#11140f;color:#f7f1df;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1120px;padding:32px}.hero{background:linear-gradient(135deg,rgba(34,197,94,.18),rgba(245,158,11,.12));border:1px solid #2c3327;border-radius:28px;margin-bottom:18px;padding:28px}.eyebrow{color:#facc15;font-weight:900;letter-spacing:.12em;text-transform:uppercase}h1{font-size:clamp(2.3rem,6vw,4.8rem);line-height:.92;margin:.2rem 0 1rem}.chips{display:flex;flex-wrap:wrap;gap:10px}.chips span{border:1px solid #46513b;border-radius:999px;padding:8px 12px}.events{display:grid;gap:14px}.event{background:#181d15;border:1px solid #2c3327;border-radius:22px;display:grid;gap:16px;grid-template-columns:1fr auto;padding:18px}.event.error{border-color:rgba(239,68,68,.75)}.event.skipped{border-color:rgba(245,158,11,.7)}.event.success{border-color:rgba(34,197,94,.55)}.event span{color:#facc15;font-size:.78rem;font-weight:900;letter-spacing:.08em;text-transform:uppercase}.event h2{margin:.2rem 0}.event p{color:#c8ccb8;margin:.2rem 0}.event strong{text-transform:uppercase}pre{background:#0c0f0a;border-radius:14px;grid-column:1/-1;overflow:auto;padding:14px;white-space:pre-wrap}@media(max-width:760px){main{padding:20px}.event{grid-template-columns:1fr}}</style></head><body><main><section class="hero"><p class="eyebrow">Self-hosted evidence</p><h1>${escapeHtml3(title)}</h1><p>${report.summary.total} event(s), ${report.summary.errors} error(s). Latest ${report.summary.latestAt ? escapeHtml3(new Date(report.summary.latestAt).toLocaleString()) : "never"}.</p><div class="chips">${chips}</div></section><section class="events">${rows || "<p>No audit events match this filter.</p>"}</section></main></body></html>`;
+};
+var createVoiceAuditTrailRoutes = (options) => {
+  const path = options.path ?? "/api/voice-audit";
+  const htmlPath = options.htmlPath ?? "/audit";
+  const exportPath = options.exportPath ?? `${path}/export`;
+  const exportHtmlPath = options.exportHtmlPath ?? (htmlPath === false ? false : `${htmlPath}/export`);
+  const routes = new Elysia({
+    name: options.name ?? "absolutejs-voice-audit-trail"
+  });
+  routes.get(path, async ({ query }) => buildVoiceAuditTrailReport({
+    filter: resolveVoiceAuditTrailFilter(query, options.filter),
+    limit: options.limit,
+    store: options.store
+  }));
+  if (htmlPath !== false) {
+    routes.get(htmlPath, async ({ query }) => {
+      const report = await buildVoiceAuditTrailReport({
+        filter: resolveVoiceAuditTrailFilter(query, options.filter),
+        limit: options.limit,
+        store: options.store
+      });
+      const body = await (options.render ?? ((value) => renderVoiceAuditTrailHTML(value, { title: options.title })))(report);
+      return new Response(body, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          ...options.headers
+        }
+      });
+    });
+  }
+  if (exportPath !== false) {
+    routes.get(exportPath, async ({ query }) => {
+      const filter = resolveVoiceAuditTrailFilter(query, options.filter);
+      const redact = parseBoolean(query.redact, true);
+      const exported = await exportVoiceAuditTrail({
+        filter: {
+          ...filter,
+          limit: filter.limit ?? options.limit
+        },
+        redact,
+        store: options.store
+      });
+      const format = parseExportFormat(query.format);
+      if (format === "markdown") {
+        return new Response(renderVoiceAuditMarkdown(exported.events, {
+          title: options.title
+        }), {
+          headers: {
+            "Content-Type": "text/markdown; charset=utf-8",
+            ...options.headers
+          }
+        });
+      }
+      if (format === "html") {
+        return new Response(renderVoiceAuditHTML(exported.events, {
+          title: options.title
+        }), {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            ...options.headers
+          }
+        });
+      }
+      return exported;
+    });
+  }
+  if (exportHtmlPath !== false) {
+    routes.get(exportHtmlPath, async ({ query }) => {
+      const filter = resolveVoiceAuditTrailFilter(query, options.filter);
+      const exported = await exportVoiceAuditTrail({
+        filter: {
+          ...filter,
+          limit: filter.limit ?? options.limit
+        },
+        redact: parseBoolean(query.redact, true),
+        store: options.store
+      });
+      return new Response(renderVoiceAuditHTML(exported.events, {
+        title: options.title
+      }), {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          ...options.headers
+        }
+      });
+    });
+  }
+  return routes;
+};
+
+// src/auditExport.ts
+var escapeHtml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var normalizeRedactionKey2 = (key) => key.trim().toLowerCase().replace(/[^a-z0-9]/g, "");
+var resolveReplacement2 = (input) => typeof input.options.replacement === "function" ? input.options.replacement({
+  key: input.key,
+  path: input.path,
+  value: input.value
+}) : input.options.replacement;
+var redactAuditValue = (value, config, options, path) => {
+  const key = path.at(-1);
+  const normalizedKey = key ? normalizeRedactionKey2(key) : undefined;
+  const sensitiveKeys = new Set(options.keys.map(normalizeRedactionKey2));
+  const textKeys = new Set(options.textKeys.map(normalizeRedactionKey2));
+  if (normalizedKey && sensitiveKeys.has(normalizedKey) && (value === null || ["boolean", "number", "string", "undefined"].includes(typeof value))) {
+    return resolveReplacement2({
+      key,
+      options,
+      path,
+      value: String(value ?? "")
+    });
+  }
+  if (typeof value === "string") {
+    const shouldRedactText = options.redactText && (!normalizedKey || textKeys.has(normalizedKey) || path.length === 0 || path[0] === "payload" || path[0] === "metadata");
+    return shouldRedactText ? redactVoiceTraceText(value, config, {
+      key,
+      path
+    }) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactAuditValue(item, config, options, [...path, String(index)]));
+  }
+  if (typeof value === "object" && value) {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
+      entryKey,
+      redactAuditValue(entryValue, config, options, [...path, entryKey])
+    ]));
+  }
+  return value;
+};
+var redactVoiceAuditEvent = (event, options = {}) => {
+  const resolved = resolveVoiceTraceRedactionOptions(options);
+  return {
+    ...event,
+    actor: redactAuditValue(event.actor, options, resolved, [
+      "actor"
+    ]),
+    metadata: redactAuditValue(event.metadata, options, resolved, [
+      "metadata"
+    ]),
+    payload: redactAuditValue(event.payload, options, resolved, [
+      "payload"
+    ]),
+    resource: redactAuditValue(event.resource, options, resolved, [
+      "resource"
+    ])
+  };
+};
+var redactVoiceAuditEvents = (events, options = {}) => events.map((event) => redactVoiceAuditEvent(event, options));
+var exportVoiceAuditTrail = async (input) => {
+  const events = await input.store.list(input.filter);
+  const exportedEvents = input.redact ? redactVoiceAuditEvents(events, input.redact) : events;
+  return {
+    events: exportedEvents,
+    exportedAt: Date.now(),
+    filter: input.filter,
+    redacted: Boolean(input.redact),
+    summary: summarizeVoiceAuditTrail(exportedEvents)
+  };
+};
+var formatAuditValue = (value) => {
+  if (value === undefined || value === null || value === "") {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var renderAuditEventMarkdown = (event) => {
+  const actor = event.actor ? `${event.actor.kind}:${event.actor.id}` : "unknown";
+  const resource = event.resource ? `${event.resource.type}${event.resource.id ? `:${event.resource.id}` : ""}` : "";
+  const detail = [
+    `actor=${actor}`,
+    resource ? `resource=${resource}` : undefined,
+    event.sessionId ? `session=${event.sessionId}` : undefined,
+    event.traceId ? `trace=${event.traceId}` : undefined
+  ].filter(Boolean).join(" ");
+  return `- ${new Date(event.at).toISOString()} [${event.type}] ${event.action} ${event.outcome ?? "recorded"} ${detail} ${formatAuditValue(event.payload)}`.trim();
+};
+var renderVoiceAuditMarkdown = (events, options = {}) => {
+  const renderEvents = options.redact ? redactVoiceAuditEvents(events, options.redact) : events;
+  const summary = summarizeVoiceAuditTrail(renderEvents);
+  const lines = [
+    `# ${options.title ?? "Voice Audit Trail"}`,
+    "",
+    `Events: ${summary.total}`,
+    `Errors: ${summary.errors}`,
+    `Latest: ${summary.latestAt ? new Date(summary.latestAt).toISOString() : "never"}`,
+    "",
+    "## Event Types",
+    "",
+    ...summary.byType.map(([type, count]) => `- ${type}: ${count}`),
+    "",
+    "## Events",
+    "",
+    ...renderEvents.map(renderAuditEventMarkdown)
+  ];
+  return lines.join(`
+`);
+};
+var renderVoiceAuditHTML = (events, options = {}) => {
+  const title = options.title ?? "Voice Audit Trail";
+  const markdown = renderVoiceAuditMarkdown(events, options);
+  const renderEvents = options.redact ? redactVoiceAuditEvents(events, options.redact) : events;
+  const summary = summarizeVoiceAuditTrail(renderEvents);
+  const rows = renderEvents.map((event) => `<tr><td>${escapeHtml4(new Date(event.at).toISOString())}</td><td>${escapeHtml4(event.type)}</td><td>${escapeHtml4(event.action)}</td><td>${escapeHtml4(event.outcome ?? "")}</td><td><code>${escapeHtml4(JSON.stringify(event.payload ?? {}))}</code></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>${escapeHtml4(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;line-height:1.45;background:#f8f7f2;color:#181713}main{max-width:1100px;margin:auto}.summary{display:grid;grid-template-columns:repeat(auto-fit,minmax(160px,1fr));gap:.75rem;margin:1rem 0}.card{background:white;border:1px solid #ded9cc;border-radius:12px;padding:1rem}table{border-collapse:collapse;width:100%;background:white;border:1px solid #ded9cc}th,td{border-bottom:1px solid #eee8dc;padding:.65rem;text-align:left;vertical-align:top}code{white-space:pre-wrap;word-break:break-word}pre{background:#181713;color:#f8f7f2;padding:1rem;border-radius:12px;overflow:auto}</style></head><body><main><h1>${escapeHtml4(title)}</h1><section class="summary"><div class="card"><strong>Events</strong><br>${summary.total}</div><div class="card"><strong>Errors</strong><br>${summary.errors}</div><div class="card"><strong>Latest</strong><br>${summary.latestAt ? escapeHtml4(new Date(summary.latestAt).toLocaleString()) : "never"}</div></section><table><thead><tr><th>At</th><th>Type</th><th>Action</th><th>Outcome</th><th>Payload</th></tr></thead><tbody>${rows}</tbody></table><h2>Markdown Export</h2><pre>${escapeHtml4(markdown)}</pre></main></body></html>`;
+};
+var buildVoiceAuditExport = (events, options = {}) => {
+  const exportEvents = options.redact ? redactVoiceAuditEvents(events, options.redact) : events;
+  return {
+    events: exportEvents,
+    html: renderVoiceAuditHTML(events, options),
+    markdown: renderVoiceAuditMarkdown(events, options),
+    summary: summarizeVoiceAuditTrail(exportEvents)
+  };
+};
+
+// src/sessionReplay.ts
+import { Elysia as Elysia2 } from "elysia";
+var getString2 = (value) => typeof value === "string" ? value : undefined;
+var escapeHtml5 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var increment2 = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+var resolveSessionHref = (value, session) => {
+  if (value === false) {
+    return;
+  }
+  if (typeof value === "function") {
+    return value(session);
+  }
+  if (typeof value === "string") {
+    const encoded = encodeURIComponent(session.sessionId);
+    return value.includes(":sessionId") ? value.replace(":sessionId", encoded) : `${value.replace(/\/$/, "")}/${encoded}`;
+  }
+  return;
+};
+var isProviderErrorEvent = (event) => event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string");
+var isRecoveredProviderFallbackEvent = (event) => event.type === "session.error" && (event.payload.providerStatus === "fallback" || event.payload.status === "fallback") && event.payload.recovered === true;
+var turnRecoveryKey = (event) => event.turnId ?? `session:${event.sessionId}`;
+var summarizeVoiceProviderFallbackRecovery = (events) => {
+  const sorted = filterVoiceTraceEvents(events);
+  const recoveredEvents = sorted.filter(isRecoveredProviderFallbackEvent);
+  const recoveredKeys = new Set(recoveredEvents.map((event) => turnRecoveryKey(event)));
+  const recoveredSessions = new Set(recoveredEvents.map((event) => event.sessionId));
+  const unresolvedErrorEvents = sorted.filter((event) => isProviderErrorEvent(event) && !recoveredKeys.has(turnRecoveryKey(event)));
+  const unresolvedSessions = new Set(unresolvedErrorEvents.map((event) => event.sessionId));
+  return {
+    recovered: recoveredEvents.length,
+    recoveredSessions: recoveredSessions.size,
+    recoveredTurns: recoveredKeys.size,
+    status: unresolvedErrorEvents.length > 0 ? "fail" : "pass",
+    total: recoveredEvents.length + unresolvedErrorEvents.length,
+    unresolvedErrors: unresolvedErrorEvents.length,
+    unresolvedSessions: unresolvedSessions.size
+  };
+};
+var buildReplayTurns = (events) => {
+  const turns = new Map;
+  const getTurn = (turnId) => {
+    const existing = turns.get(turnId);
+    if (existing) {
+      return existing;
+    }
+    const turn = {
+      assistantReplies: [],
+      errors: [],
+      id: turnId,
+      modelCalls: [],
+      tools: [],
+      transcripts: []
+    };
+    turns.set(turnId, turn);
+    return turn;
+  };
+  for (const event of events) {
+    const turnId = event.turnId ?? "session";
+    const turn = getTurn(turnId);
+    switch (event.type) {
+      case "turn.transcript":
+        turn.transcripts.push({
+          isFinal: event.payload.isFinal === true,
+          text: getString2(event.payload.text)
+        });
+        break;
+      case "turn.committed":
+        turn.committedText = getString2(event.payload.text);
+        break;
+      case "turn.assistant": {
+        const text = getString2(event.payload.text);
+        if (text) {
+          turn.assistantReplies.push(text);
+        }
+        break;
+      }
+      case "agent.model":
+      case "assistant.run":
+        turn.modelCalls.push(event.payload);
+        break;
+      case "agent.tool":
+        turn.tools.push(event.payload);
+        break;
+      case "session.error":
+        turn.errors.push(event.payload);
+        break;
+    }
+  }
+  return [...turns.values()];
+};
+var summarizeVoiceSessionReplay = async (options) => {
+  const sourceEvents = options.events ?? await options.store?.list({ sessionId: options.sessionId }) ?? [];
+  const events = filterVoiceTraceEvents(sourceEvents, {
+    sessionId: options.sessionId
+  });
+  const replay = buildVoiceTraceReplay(events, {
+    evaluation: options.evaluation,
+    redact: options.redact,
+    title: options.title ?? `Voice Session ${options.sessionId}`
+  });
+  const startedAt = replay.summary.startedAt;
+  return {
+    evaluation: replay.evaluation,
+    events,
+    html: replay.html,
+    markdown: replay.markdown,
+    sessionId: options.sessionId,
+    summary: replay.summary,
+    timeline: events.map((event) => ({
+      at: event.at,
+      offsetMs: startedAt === undefined ? undefined : Math.max(0, event.at - startedAt),
+      payload: event.payload,
+      turnId: event.turnId,
+      type: event.type
+    })),
+    turns: buildReplayTurns(events)
+  };
+};
+var summarizeVoiceSessions = async (options = {}) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  const grouped = new Map;
+  for (const event of events) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const sessions = [...grouped.entries()].map(([sessionId, sessionEvents]) => {
+    const sorted = filterVoiceTraceEvents(sessionEvents);
+    const summary = buildVoiceTraceReplay(sorted, {
+      evaluation: {
+        requireAssistantReply: false,
+        requireCompletedCall: false,
+        requireTranscript: false,
+        requireTurn: false
+      }
+    }).summary;
+    const providerErrors = {};
+    const providers = new Set;
+    let latestOutcome;
+    let errorCount = 0;
+    const recoveredTurns = new Set(sorted.filter(isRecoveredProviderFallbackEvent).map((event) => turnRecoveryKey(event)));
+    for (const event of sorted) {
+      const provider = getString2(event.payload.provider);
+      if (provider) {
+        providers.add(provider);
+      }
+      if (isProviderErrorEvent(event) && !recoveredTurns.has(turnRecoveryKey(event))) {
+        errorCount += 1;
+        increment2(providerErrors, provider ?? "unknown");
+      }
+      const outcome = getString2(event.payload.outcome);
+      if (outcome) {
+        latestOutcome = outcome;
+      }
+    }
+    const item = {
+      endedAt: summary.endedAt,
+      errorCount,
+      eventCount: summary.eventCount,
+      latestOutcome,
+      providerErrors,
+      providers: [...providers].sort(),
+      sessionId,
+      startedAt: summary.startedAt,
+      status: errorCount > 0 ? "failed" : "healthy",
+      transcriptCount: summary.transcriptCount,
+      turnCount: summary.turnCount
+    };
+    const replayHref = options.replayHref === false ? "" : typeof options.replayHref === "function" ? options.replayHref(item) : `${options.replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(sessionId)}/replay/htmx`;
+    return {
+      ...item,
+      operationsRecordHref: resolveSessionHref(options.operationsRecordHref, item),
+      replayHref
+    };
+  });
+  const search = options.q?.trim().toLowerCase();
+  return sessions.filter((session) => {
+    if (options.status && options.status !== "all" && session.status !== options.status) {
+      return false;
+    }
+    if (options.provider && !session.providers.includes(options.provider)) {
+      return false;
+    }
+    if (!search) {
+      return true;
+    }
+    return [
+      session.sessionId,
+      session.latestOutcome,
+      session.status,
+      ...session.providers
+    ].some((value) => value?.toLowerCase().includes(search));
+  }).sort((left, right) => (right.endedAt ?? right.startedAt ?? 0) - (left.endedAt ?? left.startedAt ?? 0)).slice(0, options.limit ?? 50);
+};
+var renderVoiceSessionsHTML = (sessions) => sessions.length === 0 ? '<p class="voice-sessions-empty">No voice sessions found.</p>' : [
+  '<div class="voice-sessions-list">',
+  ...sessions.map((session) => [
+    `<article class="voice-session-card ${escapeHtml5(session.status)}">`,
+    '<div class="voice-session-card-header">',
+    `<strong>${escapeHtml5(session.sessionId)}</strong>`,
+    `<span>${escapeHtml5(session.status)}</span>`,
+    "</div>",
+    "<dl>",
+    `<div><dt>Events</dt><dd>${String(session.eventCount)}</dd></div>`,
+    `<div><dt>Turns</dt><dd>${String(session.turnCount)}</dd></div>`,
+    `<div><dt>Transcripts</dt><dd>${String(session.transcriptCount)}</dd></div>`,
+    `<div><dt>Errors</dt><dd>${String(session.errorCount)}</dd></div>`,
+    "</dl>",
+    session.latestOutcome ? `<p>Outcome: ${escapeHtml5(session.latestOutcome)}</p>` : "",
+    session.providers.length ? `<p>Providers: ${session.providers.map(escapeHtml5).join(", ")}</p>` : "",
+    session.replayHref ? `<p>${session.operationsRecordHref ? `<a href="${escapeHtml5(session.operationsRecordHref)}">Open operations record</a> \xB7 ` : ""}<a href="${escapeHtml5(session.replayHref)}">Open replay</a></p>` : "",
+    "</article>"
+  ].join("")),
+  "</div>"
+].join("");
+var createVoiceSessionsJSONHandler = (options = {}) => async ({ query }) => summarizeVoiceSessions({
+  ...options,
+  limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+  provider: query?.provider ?? options.provider,
+  q: query?.q ?? options.q,
+  status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+});
+var createVoiceSessionsHTMLHandler = (options = {}) => async ({ query }) => {
+  const sessions = await summarizeVoiceSessions({
+    ...options,
+    limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+    provider: query?.provider ?? options.provider,
+    q: query?.q ?? options.q,
+    status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+  });
+  const body = await (options.render?.(sessions) ?? renderVoiceSessionsHTML(sessions));
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionListRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-sessions";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia2({
+    name: options.name ?? "absolutejs-voice-session-list"
+  }).get(path, createVoiceSessionsJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionsHTMLHandler(options));
+  }
+  return routes;
+};
+var createVoiceSessionReplayJSONHandler = (options) => async ({ params }) => summarizeVoiceSessionReplay({
+  ...options,
+  sessionId: params.sessionId ?? ""
+});
+var createVoiceSessionReplayHTMLHandler = (options) => async ({ params }) => {
+  const replay = await summarizeVoiceSessionReplay({
+    ...options,
+    sessionId: params.sessionId ?? ""
+  });
+  const body = await (options.render?.(replay) ?? replay.html);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionReplayRoutes = (options) => {
+  const path = options.path ?? "/api/voice-sessions/:sessionId/replay";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia2({
+    name: options.name ?? "absolutejs-voice-session-replay"
+  }).get(path, createVoiceSessionReplayJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionReplayHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/traceTimeline.ts
+import { Elysia as Elysia3 } from "elysia";
+var escapeHtml6 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString3 = (value) => typeof value === "string" && value.trim() ? value : undefined;
+var getNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var firstString2 = (payload, keys) => {
+  for (const key of keys) {
+    const value = getString3(payload[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return;
+};
+var firstNumber2 = (payload, keys) => {
+  for (const key of keys) {
+    const value = getNumber2(payload[key]);
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return;
+};
+var eventProvider = (event) => firstString2(event.payload, [
+  "provider",
+  "selectedProvider",
+  "fallbackProvider",
+  "variantId"
+]);
+var eventStatus = (event) => firstString2(event.payload, [
+  "providerStatus",
+  "status",
+  "disposition",
+  "type",
+  "reason"
+]);
+var eventElapsedMs = (event) => firstNumber2(event.payload, ["elapsedMs", "latencyMs", "durationMs"]);
+var resolveSessionHref2 = (value, sessionId) => {
+  if (value === false) {
+    return;
+  }
+  if (typeof value === "function") {
+    return value(sessionId);
+  }
+  if (typeof value === "string") {
+    const encoded = encodeURIComponent(sessionId);
+    return value.includes(":sessionId") ? value.replace(":sessionId", encoded) : `${value.replace(/\/$/, "")}/${encoded}`;
+  }
+  return;
+};
+var timelineLabel = (event) => {
+  switch (event.type) {
+    case "call.lifecycle":
+      return `Call ${eventStatus(event) ?? "lifecycle"}`;
+    case "turn.transcript":
+      return event.payload.isFinal === true ? "Final transcript" : "Partial transcript";
+    case "turn.committed":
+      return `Committed turn${getString3(event.payload.reason) ? ` (${getString3(event.payload.reason)})` : ""}`;
+    case "turn.assistant":
+      return "Assistant reply";
+    case "agent.model":
+      return `Model call${eventProvider(event) ? ` via ${eventProvider(event)}` : ""}`;
+    case "agent.tool":
+      return `Tool ${getString3(event.payload.toolName) ?? "call"}`;
+    case "agent.handoff":
+      return `Agent handoff${getString3(event.payload.targetAgentId) ? ` to ${getString3(event.payload.targetAgentId)}` : ""}`;
+    case "assistant.run":
+      return `Assistant run${eventProvider(event) ? ` via ${eventProvider(event)}` : ""}`;
+    case "assistant.guardrail":
+      return `Guardrail ${eventStatus(event) ?? "check"}`;
+    case "call.handoff":
+      return `Call handoff ${eventStatus(event) ?? ""}`.trim();
+    case "client.live_latency":
+      return `Live latency${eventElapsedMs(event) !== undefined ? ` ${eventElapsedMs(event)}ms` : ""}`;
+    case "session.error":
+      return `Error${getString3(event.payload.error) ? `: ${getString3(event.payload.error)}` : ""}`;
+    case "turn.cost":
+      return "Cost telemetry";
+    case "turn_latency.stage":
+      return `Latency ${getString3(event.payload.stage) ?? "stage"}`;
+    case "workflow.contract":
+      return `Workflow contract ${eventStatus(event) ?? ""}`.trim();
+    default:
+      return event.type;
+  }
+};
+var summarizeProviders = (events) => {
+  const entries = new Map;
+  const getEntry = (provider) => {
+    const existing = entries.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      elapsed: [],
+      errorCount: 0,
+      eventCount: 0,
+      fallbackCount: 0,
+      successCount: 0,
+      timeoutCount: 0
+    };
+    entries.set(provider, entry);
+    return entry;
+  };
+  for (const event of events) {
+    const provider = eventProvider(event);
+    if (!provider) {
+      continue;
+    }
+    const entry = getEntry(provider);
+    const status = eventStatus(event);
+    const elapsedMs = eventElapsedMs(event);
+    entry.eventCount += 1;
+    if (elapsedMs !== undefined) {
+      entry.elapsed.push(elapsedMs);
+    }
+    if (status === "success") {
+      entry.successCount += 1;
+    }
+    if (status === "fallback") {
+      entry.fallbackCount += 1;
+    }
+    if (status === "error") {
+      entry.errorCount += 1;
+    }
+    if (status === "timeout") {
+      entry.timeoutCount += 1;
+    }
+  }
+  return [...entries.entries()].map(([provider, entry]) => ({
+    averageElapsedMs: entry.elapsed.length > 0 ? Math.round(entry.elapsed.reduce((total, value) => total + value, 0) / entry.elapsed.length) : undefined,
+    errorCount: entry.errorCount,
+    eventCount: entry.eventCount,
+    fallbackCount: entry.fallbackCount,
+    maxElapsedMs: entry.elapsed.length > 0 ? Math.max(...entry.elapsed) : undefined,
+    provider,
+    successCount: entry.successCount,
+    timeoutCount: entry.timeoutCount
+  })).sort((left, right) => right.eventCount - left.eventCount);
+};
+var summarizeVoiceTraceTimeline = (events, options = {}) => {
+  const source = options.redact ? redactVoiceTraceEvents(events, options.redact) : events;
+  const grouped = new Map;
+  for (const event of filterVoiceTraceEvents(source)) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const sessions = [...grouped.entries()].map(([sessionId, sessionEvents]) => {
+    const sorted = filterVoiceTraceEvents(sessionEvents);
+    const summary = summarizeVoiceTrace(sorted);
+    const evaluation = evaluateVoiceTrace(sorted, options.evaluation);
+    const startedAt = summary.startedAt ?? sorted[0]?.at ?? 0;
+    const status = summary.failed ? "failed" : evaluation.issues.length > 0 ? "warning" : "healthy";
+    return {
+      endedAt: summary.endedAt,
+      evaluation,
+      events: sorted.map((event) => ({
+        at: event.at,
+        elapsedMs: eventElapsedMs(event),
+        id: event.id,
+        label: timelineLabel(event),
+        offsetMs: Math.max(0, event.at - startedAt),
+        payload: event.payload,
+        provider: eventProvider(event),
+        status: eventStatus(event),
+        turnId: event.turnId,
+        type: event.type
+      })),
+      lastEventAt: sorted.at(-1)?.at,
+      operationsRecordHref: resolveSessionHref2(options.operationsRecordHref, sessionId),
+      providers: summarizeProviders(sorted),
+      sessionId,
+      startedAt: summary.startedAt,
+      status,
+      summary
+    };
+  }).sort((left, right) => (right.lastEventAt ?? 0) - (left.lastEventAt ?? 0)).slice(0, options.limit ?? 50);
+  return {
+    checkedAt: Date.now(),
+    failed: sessions.filter((session) => session.status === "failed").length,
+    sessions,
+    total: sessions.length,
+    warnings: sessions.filter((session) => session.status === "warning").length
+  };
+};
+var formatMs = (value) => value === undefined ? "n/a" : `${String(value)}ms`;
+var renderProviderCards = (session) => session.providers.length === 0 ? '<p class="muted">No provider events recorded for this session.</p>' : `<div class="providers">${session.providers.map((provider) => `<article><strong>${escapeHtml6(provider.provider)}</strong><dl><div><dt>Events</dt><dd>${String(provider.eventCount)}</dd></div><div><dt>Avg</dt><dd>${formatMs(provider.averageElapsedMs)}</dd></div><div><dt>Max</dt><dd>${formatMs(provider.maxElapsedMs)}</dd></div><div><dt>Errors</dt><dd>${String(provider.errorCount)}</dd></div><div><dt>Fallbacks</dt><dd>${String(provider.fallbackCount)}</dd></div><div><dt>Timeouts</dt><dd>${String(provider.timeoutCount)}</dd></div></dl></article>`).join("")}</div>`;
+var renderVoiceTraceTimelineSessionHTML = (session, options = {}) => {
+  const events = session.events.map((event) => `<tr class="${escapeHtml6(event.status ?? "")}"><td>+${String(event.offsetMs)}ms</td><td>${escapeHtml6(event.type)}</td><td>${escapeHtml6(event.label)}</td><td>${escapeHtml6(event.provider ?? "")}</td><td>${escapeHtml6(event.status ?? "")}</td><td>${formatMs(event.elapsedMs)}</td></tr>`).join("");
+  const issues = session.evaluation.issues.length ? session.evaluation.issues.map((issue) => `<li class="${escapeHtml6(issue.severity)}">${escapeHtml6(issue.code)}: ${escapeHtml6(issue.message)}</li>`).join("") : "<li>none</li>";
+  const supportLinks = session.operationsRecordHref ? `<p><a href="${escapeHtml6(session.operationsRecordHref)}">Open operations record</a></p>` : "";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml6(options.title ?? "Voice Trace Timeline")}</title><style>${timelineCSS}</style></head><body><main><a href="/traces">Back to traces</a><header><p class="eyebrow">Call timeline</p><h1>${escapeHtml6(session.sessionId)}</h1><p class="status ${escapeHtml6(session.status)}">${escapeHtml6(session.status)}</p>${supportLinks}</header><section class="metrics"><article><span>Events</span><strong>${String(session.summary.eventCount)}</strong></article><article><span>Turns</span><strong>${String(session.summary.turnCount)}</strong></article><article><span>Errors</span><strong>${String(session.summary.errorCount)}</strong></article><article><span>Duration</span><strong>${formatMs(session.summary.callDurationMs)}</strong></article></section><section><h2>Providers</h2>${renderProviderCards(session)}</section><section><h2>Issues</h2><ul>${issues}</ul></section><section><h2>Timeline</h2><table><thead><tr><th>Offset</th><th>Type</th><th>Event</th><th>Provider</th><th>Status</th><th>Latency</th></tr></thead><tbody>${events}</tbody></table></section></main></body></html>`;
+};
+var renderSessionRows = (report) => report.sessions.length === 0 ? '<tr><td colspan="7">No trace events recorded yet.</td></tr>' : report.sessions.map((session) => `<tr class="${escapeHtml6(session.status)}"><td>${session.operationsRecordHref ? `<a href="${escapeHtml6(session.operationsRecordHref)}">${escapeHtml6(session.sessionId)}</a>` : `<a href="/traces/${encodeURIComponent(session.sessionId)}">${escapeHtml6(session.sessionId)}</a>`}</td><td>${escapeHtml6(session.status)}</td><td>${String(session.summary.eventCount)}</td><td>${String(session.summary.turnCount)}</td><td>${String(session.summary.errorCount)}</td><td>${formatMs(session.summary.callDurationMs)}</td><td>${session.providers.map((provider) => escapeHtml6(provider.provider)).join(", ")}</td></tr>`).join("");
+var timelineCSS = "body{background:#0f1318;color:#f6f2e8;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1180px;padding:32px}a{color:#fbbf24}.eyebrow{color:#fbbf24;font-weight:900;letter-spacing:.12em;text-transform:uppercase}h1{font-size:clamp(2.4rem,6vw,4.5rem);line-height:.92;margin:.2rem 0 1rem}.status{border:1px solid #475569;border-radius:999px;display:inline-flex;padding:8px 12px}.healthy{color:#86efac}.warning{color:#fbbf24}.failed,.error{color:#fca5a5}.metrics,.providers{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(170px,1fr));margin:20px 0}.metrics article,.providers article{background:#181f27;border:1px solid #2b3642;border-radius:20px;padding:16px}.metrics span,dt,.muted{color:#a8b0b8}.metrics strong{display:block;font-size:2rem}dl{display:grid;gap:8px;grid-template-columns:repeat(2,minmax(0,1fr));margin:12px 0 0}dd{font-weight:800;margin:4px 0 0}table{background:#181f27;border-collapse:collapse;border-radius:18px;overflow:hidden;width:100%}td,th{border-bottom:1px solid #2b3642;padding:12px;text-align:left}section{margin-top:28px}@media(max-width:760px){main{padding:20px}table{font-size:.9rem}}";
+var renderVoiceTraceTimelineHTML = (report, options = {}) => {
+  const snippet = escapeHtml6(`const traceStore = createVoiceTraceSinkStore({
+	store: runtimeStorage.traces,
+	sinks: [
+		createVoiceTraceHTTPSink({
+			endpoint: process.env.VOICE_TRACE_WEBHOOK_URL
+		})
+	]
+});
+
+app.use(
+	createVoiceTraceTimelineRoutes({
+		htmlPath: '/traces',
+		path: '/api/voice-traces',
+		redact: {
+			keys: ['authorization', 'apiKey', 'token']
+		},
+		store: traceStore
+	})
+);
+
+app.use(
+	createVoiceProductionReadinessRoutes({
+		store: traceStore,
+		traceDeliveries: runtimeStorage.traceDeliveries
+	})
+);`);
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml6(options.title ?? "Voice Trace Timelines")}</title><style>${timelineCSS}.primitive{background:#181f27;border:1px solid #334155;border-radius:20px;margin:20px 0;padding:18px}.primitive p{line-height:1.55}.primitive pre{background:#0b1118;border:1px solid #2b3642;border-radius:16px;color:#dbeafe;overflow:auto;padding:14px}.primitive code{color:#bfdbfe}</style></head><body><main><header><p class="eyebrow">Self-hosted voice debugging</p><h1>${escapeHtml6(options.title ?? "Voice Trace Timelines")}</h1><p class="muted">Per-call event timelines with provider latency, fallback, timeout, handoff, and error context.</p></header><section class="metrics"><article><span>Sessions</span><strong>${String(report.total)}</strong></article><article><span>Failed</span><strong>${String(report.failed)}</strong></article><article><span>Warnings</span><strong>${String(report.warnings)}</strong></article></section><section class="primitive"><p class="eyebrow">Copy into your app</p><h2><code>createVoiceTraceTimelineRoutes(...)</code> makes traces the proof backbone</h2><p class="muted">Mount trace timelines from the same trace store used by readiness, simulations, provider recovery, delivery sinks, and phone-agent smoke proof.</p><pre><code>${snippet}</code></pre></section><table><thead><tr><th>Session</th><th>Status</th><th>Events</th><th>Turns</th><th>Errors</th><th>Duration</th><th>Providers</th></tr></thead><tbody>${renderSessionRows(report)}</tbody></table></main></body></html>`;
+};
+var createVoiceTraceTimelineRoutes = (options) => {
+  const path = options.path ?? "/api/voice-traces";
+  const htmlPath = options.htmlPath ?? "/traces";
+  const title = options.title ?? "AbsoluteJS Voice Trace Timelines";
+  const routes = new Elysia3({
+    name: options.name ?? "absolutejs-voice-trace-timelines"
+  });
+  const buildReport = async () => summarizeVoiceTraceTimeline(await options.store.list(), {
+    evaluation: options.evaluation,
+    limit: options.limit,
+    operationsRecordHref: options.operationsRecordHref,
+    redact: options.redact
+  });
+  const findSession = async (sessionId) => {
+    const report = summarizeVoiceTraceTimeline(await options.store.list({ sessionId }), {
+      evaluation: options.evaluation,
+      limit: 1,
+      operationsRecordHref: options.operationsRecordHref,
+      redact: options.redact
+    });
+    return report.sessions[0];
+  };
+  routes.get(path, async () => Response.json(await buildReport()));
+  routes.get(`${path}/:sessionId`, async ({ params }) => {
+    const session = await findSession(params.sessionId);
+    return session ? Response.json(session) : Response.json({ error: "Voice trace session not found." }, { status: 404 });
+  });
+  routes.get(htmlPath, async () => {
+    const report = await buildReport();
+    const body = await (options.render ?? ((input) => renderVoiceTraceTimelineHTML(input, { title })))(report);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${htmlPath}/:sessionId`, async ({ params }) => {
+    const session = await findSession(params.sessionId);
+    if (!session) {
+      return Response.json({ error: "Voice trace session not found." }, { status: 404 });
+    }
+    const body = await (options.renderSession ?? ((input) => renderVoiceTraceTimelineSessionHTML(input, { title })))(session);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
+
+// src/operationsRecord.ts
+var getString4 = (value) => typeof value === "string" ? value : undefined;
+var getNumber3 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getBoolean = (value) => typeof value === "boolean" ? value : undefined;
+var getRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var countOutcome = (events, outcome) => events.filter((event) => event.outcome === outcome).length;
+var matchesSessionScopedId = (id, sessionId) => id === sessionId || id.startsWith(`${sessionId}:`);
+var hasPayloadValue = (payload, key, values) => {
+  const value = payload[key];
+  return typeof value === "string" && values.has(value);
+};
+var countIntegrationDeliveryStatus = (events, status) => events.filter((event) => event.deliveryStatus === status).length;
+var uniqueSorted = (values) => [
+  ...new Set(values.filter((value) => typeof value === "string"))
+].sort();
+var pushMissingValuesIssue = (input) => {
+  const missing = (input.expected ?? []).filter((value) => !input.actual.includes(value));
+  if (missing.length > 0) {
+    input.issues.push(`Missing ${input.prefix ?? "guardrail"} ${input.label}: ${missing.join(", ")}`);
+  }
+};
+var resolveRoutePath = (path, sessionId) => path.replace(":sessionId", encodeURIComponent(sessionId));
+var toHandoff = (event) => ({
+  at: event.at,
+  fromAgentId: getString4(event.payload.fromAgentId),
+  metadata: event.payload.metadata && typeof event.payload.metadata === "object" && !Array.isArray(event.payload.metadata) ? event.payload.metadata : undefined,
+  reason: getString4(event.payload.reason),
+  status: getString4(event.payload.status),
+  summary: getString4(event.payload.summary),
+  targetAgentId: getString4(event.payload.targetAgentId),
+  turnId: event.turnId
+});
+var toTool = (event) => ({
+  at: event.at,
+  elapsedMs: getNumber3(event.payload.elapsedMs),
+  error: getString4(event.payload.error),
+  status: getString4(event.payload.status),
+  toolCallId: getString4(event.payload.toolCallId),
+  toolName: getString4(event.payload.toolName),
+  turnId: event.turnId
+});
+var toGuardrailFinding = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  return {
+    action: getString4(record.action),
+    label: getString4(record.label),
+    ruleId: getString4(record.ruleId)
+  };
+};
+var toGuardrailDecision = (event) => ({
+  allowed: getBoolean(event.payload.allowed),
+  at: event.at,
+  findings: Array.isArray(event.payload.findings) ? event.payload.findings.map(toGuardrailFinding).filter((finding) => finding !== undefined) : [],
+  metadata: event.metadata && typeof event.metadata === "object" && !Array.isArray(event.metadata) ? event.metadata : undefined,
+  proof: getString4(event.metadata?.proof),
+  stage: getString4(event.payload.stage),
+  status: getString4(event.payload.status),
+  toolName: getString4(event.payload.toolName),
+  turnId: event.turnId
+});
+var decodeBase64Bytes = (value) => {
+  if (typeof value !== "string") {
+    return 0;
+  }
+  try {
+    return Buffer.from(value, "base64").byteLength;
+  } catch {
+    return 0;
+  }
+};
+var toTelephonyMediaEvent = (event) => {
+  if (event.type !== "client.telephony_media") {
+    return;
+  }
+  const envelope = getRecord(event.payload.envelope);
+  const start = getRecord(envelope?.start);
+  const media = getRecord(envelope?.media);
+  const stop = getRecord(envelope?.stop);
+  const error = getRecord(envelope?.error);
+  const eventName = getString4(event.payload.event) ?? getString4(envelope?.event) ?? getString4(event.payload.kind) ?? "unknown";
+  const streamId = getString4(event.payload.streamId) ?? getString4(envelope?.streamSid) ?? getString4(start?.streamSid);
+  const callSid = getString4(event.payload.callSid) ?? getString4(start?.callSid) ?? getString4(stop?.callSid);
+  const sequenceNumber = getString4(media?.sequenceNumber) ?? getString4(envelope?.sequenceNumber);
+  const direction = getString4(media?.track) ?? getString4(media?.direction) ?? getString4(event.payload.direction);
+  return {
+    at: event.at,
+    audioBytes: getNumber3(event.payload.audioBytes) ?? getNumber3(media?.audioBytes) ?? decodeBase64Bytes(media?.payload),
+    callSid,
+    carrier: getString4(event.payload.carrier),
+    direction,
+    event: eventName,
+    sequenceNumber,
+    streamId
+  };
+};
+var summarizeTelephonyMedia = (events) => {
+  const mediaEvents = events.map(toTelephonyMediaEvent).filter((event) => event !== undefined);
+  const eventNames = mediaEvents.map((event) => event.event.toLowerCase());
+  return {
+    audioBytes: mediaEvents.reduce((total, event) => total + event.audioBytes, 0),
+    carriers: uniqueSorted(mediaEvents.map((event) => event.carrier)),
+    clears: eventNames.filter((event) => event === "clear").length,
+    errors: eventNames.filter((event) => event === "error").length,
+    events: mediaEvents,
+    inbound: mediaEvents.filter((event) => event.direction === "inbound").length,
+    marks: eventNames.filter((event) => event === "mark").length,
+    media: eventNames.filter((event) => event === "media").length,
+    outbound: mediaEvents.filter((event) => event.direction === "outbound").length,
+    starts: eventNames.filter((event) => event === "start").length,
+    stops: eventNames.filter((event) => event === "stop").length,
+    streamIds: uniqueSorted(mediaEvents.map((event) => event.streamId)),
+    total: mediaEvents.length
+  };
+};
+var summarizeGuardrails = (events) => {
+  const decisions = events.filter((event) => event.type === "assistant.guardrail").map(toGuardrailDecision);
+  const isBlocked = (decision) => decision.allowed === false || decision.status === "fail";
+  const isWarned = (decision) => decision.status === "warn" || decision.findings.some((finding) => finding.action === "warn");
+  const stages = [
+    ...new Set(decisions.map((decision) => decision.stage).filter((stage) => typeof stage === "string"))
+  ].sort();
+  return {
+    blocked: decisions.filter(isBlocked).length,
+    decisions,
+    passed: decisions.filter((decision) => !isBlocked(decision) && !isWarned(decision)).length,
+    stages,
+    total: decisions.length,
+    warned: decisions.filter(isWarned).length
+  };
+};
+var toProviderDecision = (event) => {
+  const provider = getString4(event.payload.provider) ?? getString4(event.payload.selectedProvider) ?? getString4(event.payload.fallbackProvider) ?? getString4(event.payload.variantId);
+  const status = getString4(event.payload.providerStatus) ?? getString4(event.payload.status);
+  const error = getString4(event.payload.error);
+  const elapsedMs = getNumber3(event.payload.elapsedMs) ?? getNumber3(event.payload.latencyMs) ?? getNumber3(event.payload.durationMs);
+  const hasProviderSignal = event.type === "provider.decision" || provider !== undefined || getString4(event.payload.selectedProvider) !== undefined || getString4(event.payload.fallbackProvider) !== undefined || getString4(event.payload.variantId) !== undefined;
+  if (!hasProviderSignal) {
+    return;
+  }
+  return {
+    at: event.at,
+    elapsedMs,
+    error,
+    fallbackProvider: getString4(event.payload.fallbackProvider),
+    kind: getString4(event.payload.kind),
+    provider,
+    reason: getString4(event.payload.reason),
+    selectedProvider: getString4(event.payload.selectedProvider),
+    status,
+    surface: getString4(event.payload.surface),
+    type: event.type,
+    turnId: event.turnId
+  };
+};
+var summarizeProviderDecisions = (decisions) => {
+  const providers = uniqueSorted(decisions.flatMap((decision) => [
+    decision.provider,
+    decision.selectedProvider,
+    decision.fallbackProvider
+  ]));
+  const surfaces = uniqueSorted(decisions.map((decision) => decision.surface));
+  const degraded = decisions.filter((decision) => decision.status === "degraded").length;
+  const errors = decisions.filter((decision) => decision.status === "error").length;
+  const fallbacks = decisions.filter((decision) => decision.status === "fallback").length;
+  const selected = decisions.filter((decision) => decision.status === "selected" || decision.status === "success").length;
+  const recoveryStatus = errors > 0 ? "failed" : degraded > 0 ? "degraded" : fallbacks > 0 ? "recovered" : selected > 0 ? "selected" : "none";
+  return {
+    degraded,
+    errors,
+    fallbacks,
+    providers,
+    recoveryStatus,
+    selected,
+    surfaces,
+    total: decisions.length
+  };
+};
+var buildTranscript = (replay) => replay.turns.map((turn) => ({
+  assistantReplies: turn.assistantReplies,
+  committedText: turn.committedText,
+  errors: turn.errors.map((error) => getString4(error.error) ?? JSON.stringify(error)).filter((error) => typeof error === "string"),
+  id: turn.id,
+  transcripts: turn.transcripts.map((transcript) => transcript.text).filter((text) => typeof text === "string" && text.length > 0)
+})).filter((turn) => turn.committedText || turn.assistantReplies.length > 0 || turn.transcripts.length > 0 || turn.errors.length > 0);
+var resolveOutcome = (events) => {
+  const agentResults = events.filter((event) => event.type === "agent.result");
+  return {
+    assistantReplies: events.filter((event) => event.type === "turn.assistant").length,
+    complete: agentResults.some((event) => event.payload.complete === true),
+    escalated: agentResults.some((event) => event.payload.escalated === true),
+    noAnswer: agentResults.some((event) => event.payload.noAnswer === true),
+    transferred: agentResults.some((event) => event.payload.transferred === true),
+    voicemail: agentResults.some((event) => event.payload.voicemail === true)
+  };
+};
+var buildVoiceOperationsRecord = async (options) => {
+  const sourceEvents = options.events ?? await options.store?.list({ sessionId: options.sessionId }) ?? [];
+  const rawTraceEvents = filterVoiceTraceEvents(sourceEvents, {
+    sessionId: options.sessionId
+  });
+  const traceEvents = options.redact ? redactVoiceTraceEvents(rawTraceEvents, options.redact) : rawTraceEvents;
+  const timelineReport = summarizeVoiceTraceTimeline(traceEvents, {
+    evaluation: options.evaluation,
+    limit: 1
+  });
+  const timelineSession = timelineReport.sessions[0];
+  const replay = await summarizeVoiceSessionReplay({
+    evaluation: options.evaluation,
+    events: traceEvents,
+    sessionId: options.sessionId
+  });
+  const rawAuditEvents = options.audit ? filterVoiceAuditEvents(await options.audit.list({ sessionId: options.sessionId })) : undefined;
+  const auditEvents = options.redact && rawAuditEvents ? redactVoiceAuditEvents(rawAuditEvents, options.redact) : rawAuditEvents;
+  const reviews = options.reviews ? (await options.reviews.list()).filter((review) => matchesSessionScopedId(review.id, options.sessionId)) : undefined;
+  const reviewIds = new Set(reviews?.map((review) => review.id) ?? []);
+  const tasks = options.tasks ? (await options.tasks.list()).filter((task) => matchesSessionScopedId(task.id, options.sessionId) || typeof task.reviewId === "string" && reviewIds.has(task.reviewId)) : undefined;
+  const taskIds = new Set(tasks?.map((task) => task.id) ?? []);
+  const integrationEvents = options.integrationEvents ? (await options.integrationEvents.list()).filter((event) => hasPayloadValue(event.payload, "sessionId", new Set([options.sessionId])) || hasPayloadValue(event.payload, "reviewId", reviewIds) || hasPayloadValue(event.payload, "taskId", taskIds)) : undefined;
+  const sinkDeliveries = integrationEvents?.reduce((total, event) => total + Object.keys(event.sinkDeliveries ?? {}).length, 0) ?? 0;
+  const providerDecisions = traceEvents.map(toProviderDecision).filter((decision) => decision !== undefined);
+  return {
+    audit: auditEvents ? {
+      error: countOutcome(auditEvents, "error"),
+      events: auditEvents,
+      skipped: countOutcome(auditEvents, "skipped"),
+      success: countOutcome(auditEvents, "success"),
+      total: auditEvents.length
+    } : undefined,
+    checkedAt: Date.now(),
+    guardrails: summarizeGuardrails(traceEvents),
+    handoffs: traceEvents.filter((event) => event.type === "agent.handoff").map(toHandoff),
+    integrationEvents: integrationEvents ? {
+      delivered: countIntegrationDeliveryStatus(integrationEvents, "delivered"),
+      events: integrationEvents,
+      failed: countIntegrationDeliveryStatus(integrationEvents, "failed"),
+      pending: countIntegrationDeliveryStatus(integrationEvents, "pending"),
+      sinkDeliveries,
+      skipped: countIntegrationDeliveryStatus(integrationEvents, "skipped"),
+      total: integrationEvents.length
+    } : undefined,
+    outcome: resolveOutcome(traceEvents),
+    providerDecisions,
+    providerDecisionSummary: summarizeProviderDecisions(providerDecisions),
+    providers: timelineSession?.providers ?? [],
+    replay,
+    reviews: reviews ? {
+      failed: reviews.filter((review) => !review.summary.pass).length,
+      reviews,
+      total: reviews.length
+    } : undefined,
+    sessionId: options.sessionId,
+    status: timelineSession?.status ?? "healthy",
+    summary: timelineSession?.summary ?? replay.summary,
+    tasks: tasks ? {
+      done: tasks.filter((task) => task.status === "done").length,
+      inProgress: tasks.filter((task) => task.status === "in-progress").length,
+      open: tasks.filter((task) => task.status === "open").length,
+      overdue: tasks.filter((task) => typeof task.dueAt === "number" && task.status !== "done" && task.dueAt <= Date.now()).length,
+      tasks,
+      total: tasks.length
+    } : undefined,
+    telephonyMedia: summarizeTelephonyMedia(traceEvents),
+    timeline: timelineSession?.events ?? [],
+    tools: traceEvents.filter((event) => event.type === "agent.tool").map(toTool),
+    traceEvents,
+    transcript: buildTranscript(replay)
+  };
+};
+var evaluateVoiceOperationsRecordGuardrails = (record, input = {}) => {
+  const issues = [];
+  const decisions = record.guardrails.decisions;
+  const proofs = uniqueSorted(decisions.map((decision) => decision.proof));
+  const ruleIds = uniqueSorted(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
+  const stages = uniqueSorted(decisions.map((decision) => decision.stage));
+  const statuses = uniqueSorted(decisions.map((decision) => decision.status));
+  const toolNames = uniqueSorted(decisions.map((decision) => decision.toolName));
+  const minDecisions = input.minDecisions ?? 1;
+  if (record.guardrails.total < minDecisions) {
+    issues.push(`Expected at least ${String(minDecisions)} guardrail decisions, found ${String(record.guardrails.total)}.`);
+  }
+  if (input.minBlocked !== undefined && record.guardrails.blocked < input.minBlocked) {
+    issues.push(`Expected at least ${String(input.minBlocked)} blocked guardrail decisions, found ${String(record.guardrails.blocked)}.`);
+  }
+  if (input.minWarned !== undefined && record.guardrails.warned < input.minWarned) {
+    issues.push(`Expected at least ${String(input.minWarned)} warned guardrail decisions, found ${String(record.guardrails.warned)}.`);
+  }
+  if (input.minPassed !== undefined && record.guardrails.passed < input.minPassed) {
+    issues.push(`Expected at least ${String(input.minPassed)} passed guardrail decisions, found ${String(record.guardrails.passed)}.`);
+  }
+  pushMissingValuesIssue({
+    actual: proofs,
+    expected: input.proofs,
+    issues,
+    label: "proofs"
+  });
+  pushMissingValuesIssue({
+    actual: ruleIds,
+    expected: input.ruleIds,
+    issues,
+    label: "rule IDs"
+  });
+  pushMissingValuesIssue({
+    actual: stages,
+    expected: input.stages,
+    issues,
+    label: "stages"
+  });
+  pushMissingValuesIssue({
+    actual: statuses,
+    expected: input.statuses,
+    issues,
+    label: "statuses"
+  });
+  pushMissingValuesIssue({
+    actual: toolNames,
+    expected: input.toolNames,
+    issues,
+    label: "tool names"
+  });
+  return {
+    blocked: record.guardrails.blocked,
+    decisions: record.guardrails.total,
+    issues,
+    ok: issues.length === 0,
+    passed: record.guardrails.passed,
+    proofs,
+    ruleIds,
+    stages,
+    statuses,
+    toolNames,
+    warned: record.guardrails.warned
+  };
+};
+var assertVoiceOperationsRecordGuardrails = (record, input = {}) => {
+  const report = evaluateVoiceOperationsRecordGuardrails(record, input);
+  if (!report.ok) {
+    throw new Error(`Voice operations record guardrail assertion failed for ${record.sessionId}: ${report.issues.join(" ")}`);
+  }
+  return report;
+};
+var evaluateVoiceOperationsRecordProviderRecovery = (record, input = {}) => {
+  const issues = [];
+  const summary = record.providerDecisionSummary;
+  const decisions = record.providerDecisions;
+  const providers = uniqueSorted(decisions.flatMap((decision) => [
+    decision.provider,
+    decision.selectedProvider,
+    decision.fallbackProvider
+  ]));
+  const selectedProviders = uniqueSorted(decisions.map((decision) => decision.selectedProvider));
+  const fallbackProviders = uniqueSorted(decisions.map((decision) => decision.fallbackProvider));
+  const statuses = uniqueSorted(decisions.map((decision) => decision.status));
+  const surfaces = uniqueSorted(decisions.map((decision) => decision.surface));
+  if (input.recoveryStatus && summary.recoveryStatus !== input.recoveryStatus) {
+    issues.push(`Expected provider recovery status ${input.recoveryStatus}, got ${summary.recoveryStatus}.`);
+  }
+  if (input.minTotal !== undefined && summary.total < input.minTotal) {
+    issues.push(`Expected at least ${String(input.minTotal)} provider decision(s), found ${String(summary.total)}.`);
+  }
+  if (input.minSelected !== undefined && summary.selected < input.minSelected) {
+    issues.push(`Expected at least ${String(input.minSelected)} selected provider decision(s), found ${String(summary.selected)}.`);
+  }
+  if (input.minFallbacks !== undefined && summary.fallbacks < input.minFallbacks) {
+    issues.push(`Expected at least ${String(input.minFallbacks)} provider fallback decision(s), found ${String(summary.fallbacks)}.`);
+  }
+  if (input.minDegraded !== undefined && summary.degraded < input.minDegraded) {
+    issues.push(`Expected at least ${String(input.minDegraded)} degraded provider decision(s), found ${String(summary.degraded)}.`);
+  }
+  if (input.minErrors !== undefined && summary.errors < input.minErrors) {
+    issues.push(`Expected at least ${String(input.minErrors)} provider error decision(s), found ${String(summary.errors)}.`);
+  }
+  pushMissingValuesIssue({
+    actual: providers,
+    expected: input.requiredProviders,
+    issues,
+    label: "providers",
+    prefix: "provider recovery"
+  });
+  pushMissingValuesIssue({
+    actual: selectedProviders,
+    expected: input.requiredSelectedProviders,
+    issues,
+    label: "selected providers",
+    prefix: "provider recovery"
+  });
+  pushMissingValuesIssue({
+    actual: fallbackProviders,
+    expected: input.requiredFallbackProviders,
+    issues,
+    label: "fallback providers",
+    prefix: "provider recovery"
+  });
+  pushMissingValuesIssue({
+    actual: statuses,
+    expected: input.requiredStatuses,
+    issues,
+    label: "statuses",
+    prefix: "provider recovery"
+  });
+  pushMissingValuesIssue({
+    actual: surfaces,
+    expected: input.requiredSurfaces,
+    issues,
+    label: "surfaces",
+    prefix: "provider recovery"
+  });
+  for (const phrase of input.requiredReasonIncludes ?? []) {
+    if (!decisions.some((decision) => decision.reason?.includes(phrase))) {
+      issues.push(`Missing provider recovery reason containing: ${phrase}.`);
+    }
+  }
+  return {
+    degraded: summary.degraded,
+    errors: summary.errors,
+    fallbacks: summary.fallbacks,
+    issues,
+    ok: issues.length === 0,
+    providers,
+    recoveryStatus: summary.recoveryStatus,
+    selected: summary.selected,
+    selectedProviders,
+    statuses,
+    surfaces,
+    total: summary.total
+  };
+};
+var assertVoiceOperationsRecordProviderRecovery = (record, input = {}) => {
+  const report = evaluateVoiceOperationsRecordProviderRecovery(record, input);
+  if (!report.ok) {
+    throw new Error(`Voice operations record provider recovery assertion failed for ${record.sessionId}: ${report.issues.join(" ")}`);
+  }
+  return report;
+};
+var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var formatMs2 = (value) => value === undefined ? "n/a" : `${String(value)}ms`;
+var outcomeLabels = (outcome) => [
+  outcome.complete ? "complete" : undefined,
+  outcome.escalated ? "escalated" : undefined,
+  outcome.transferred ? "transferred" : undefined,
+  outcome.voicemail ? "voicemail" : undefined,
+  outcome.noAnswer ? "no-answer" : undefined
+].filter((label) => label !== undefined);
+var renderVoiceOperationsRecordIncidentMarkdown = (record) => {
+  const outcomes = outcomeLabels(record.outcome);
+  const topErrors = record.traceEvents.filter((event) => event.type === "session.error").map((event) => getString4(event.payload.error)).filter((error) => typeof error === "string").slice(0, 3);
+  const openTasks = record.tasks?.tasks.filter((task) => task.status !== "done").map((task) => task.title).slice(0, 3) ?? [];
+  const providerDecisions = record.providerDecisions.filter((decision) => decision.provider || decision.selectedProvider || decision.fallbackProvider || decision.reason).slice(0, 5);
+  const providerDecisionLines = providerDecisions.length ? providerDecisions.map((decision) => {
+    const provider = decision.provider ?? decision.selectedProvider ?? decision.fallbackProvider ?? "provider";
+    const parts = [
+      decision.surface ? `surface=${decision.surface}` : undefined,
+      decision.status ? `status=${decision.status}` : undefined,
+      decision.selectedProvider ? `selected=${decision.selectedProvider}` : undefined,
+      decision.fallbackProvider ? `fallback=${decision.fallbackProvider}` : undefined,
+      decision.reason ? `reason=${decision.reason}` : undefined
+    ].filter((part) => typeof part === "string");
+    return `- ${provider}: ${parts.join("; ") || "decision recorded"}`;
+  }) : ["- none recorded"];
+  const providerDecisionSummary = record.providerDecisionSummary;
+  const providerRecoveryLine = [
+    `status=${providerDecisionSummary.recoveryStatus}`,
+    `selected=${String(providerDecisionSummary.selected)}`,
+    `fallbacks=${String(providerDecisionSummary.fallbacks)}`,
+    `degraded=${String(providerDecisionSummary.degraded)}`,
+    `errors=${String(providerDecisionSummary.errors)}`
+  ].join("; ");
+  const telephonyMediaLine = [
+    `events=${String(record.telephonyMedia.total)}`,
+    `starts=${String(record.telephonyMedia.starts)}`,
+    `media=${String(record.telephonyMedia.media)}`,
+    `inbound=${String(record.telephonyMedia.inbound)}`,
+    `outbound=${String(record.telephonyMedia.outbound)}`,
+    `marks=${String(record.telephonyMedia.marks)}`,
+    `clears=${String(record.telephonyMedia.clears)}`,
+    `stops=${String(record.telephonyMedia.stops)}`,
+    `errors=${String(record.telephonyMedia.errors)}`,
+    `audioBytes=${String(record.telephonyMedia.audioBytes)}`,
+    `carriers=${record.telephonyMedia.carriers.join(", ") || "none"}`,
+    `streams=${record.telephonyMedia.streamIds.join(", ") || "none"}`
+  ].join("; ");
+  const telephonyMediaLines = record.telephonyMedia.events.length ? record.telephonyMedia.events.slice(0, 12).map((event) => {
+    const parts = [
+      event.carrier ? `carrier=${event.carrier}` : undefined,
+      event.streamId ? `stream=${event.streamId}` : undefined,
+      event.callSid ? `call=${event.callSid}` : undefined,
+      event.direction ? `direction=${event.direction}` : undefined,
+      event.sequenceNumber ? `seq=${event.sequenceNumber}` : undefined,
+      `audioBytes=${String(event.audioBytes)}`
+    ].filter((part) => typeof part === "string");
+    return `- ${event.event}: ${parts.join("; ")}`;
+  }) : ["- none recorded"];
+  return [
+    `# Voice incident handoff: ${record.sessionId}`,
+    "",
+    `- Status: ${record.status}`,
+    `- Duration: ${formatMs2(record.summary.callDurationMs)}`,
+    `- Turns: ${String(record.summary.turnCount)}`,
+    `- Errors: ${String(record.summary.errorCount)}`,
+    `- Outcome: ${outcomes.join(", ") || "unknown"}`,
+    `- Providers: ${record.providers.map((provider) => provider.provider).join(", ") || "none recorded"}`,
+    `- Open tasks: ${openTasks.join("; ") || "none"}`,
+    `- Top errors: ${topErrors.join("; ") || "none"}`,
+    `- Guardrails: ${String(record.guardrails.blocked)} blocked / ${String(record.guardrails.warned)} warned / ${String(record.guardrails.total)} decisions`,
+    `- Provider recovery: ${providerRecoveryLine}`,
+    `- Telephony media: ${telephonyMediaLine}`,
+    "",
+    "## Provider decisions",
+    "",
+    ...providerDecisionLines,
+    "",
+    "## Telephony media",
+    "",
+    ...telephonyMediaLines,
+    "",
+    renderVoiceOperationsRecordGuardrailMarkdown(record),
+    "",
+    "## Next checks",
+    "- Review provider decisions and fallback status.",
+    "- Review transcript and assistant replies.",
+    "- Review handoffs, tools, audit, tasks, and integration delivery."
+  ].join(`
+`);
+};
+var renderVoiceOperationsRecordGuardrailMarkdown = (record) => {
+  if (record.guardrails.total === 0) {
+    return [
+      "## Guardrail evidence",
+      "",
+      "- No assistant.guardrail events were recorded for this session."
+    ].join(`
+`);
+  }
+  return [
+    "## Guardrail evidence",
+    "",
+    ...record.guardrails.decisions.map((decision) => {
+      const findings = decision.findings.map((finding) => [finding.action, finding.ruleId, finding.label].filter((value) => typeof value === "string").join(":")).filter(Boolean).join(", ");
+      return `- assistant.guardrail ${decision.stage ?? "unknown"}: ${decision.status ?? "unknown"}; allowed=${String(decision.allowed ?? "unknown")}; proof=${decision.proof ?? "runtime"}; findings=${findings || "none"}`;
+    })
+  ].join(`
+`);
+};
+var renderVoiceOperationsRecordHTML = (record, options = {}) => {
+  const providers = record.providers.length ? record.providers.map((provider) => `<article><strong>${escapeHtml7(provider.provider)}</strong><span>${String(provider.eventCount)} events</span><span>${formatMs2(provider.averageElapsedMs)} avg</span><span>${String(provider.errorCount)} errors</span></article>`).join("") : '<p class="muted">No provider events recorded.</p>';
+  const transcript = record.transcript.length ? record.transcript.map((turn) => `<li><strong>${escapeHtml7(turn.id)}</strong>${turn.committedText ? `<p><span class="label">Caller</span>${escapeHtml7(turn.committedText)}</p>` : ""}${turn.assistantReplies.map((reply) => `<p><span class="label">Assistant</span>${escapeHtml7(reply)}</p>`).join("")}${turn.errors.map((error) => `<p class="error"><span class="label">Error</span>${escapeHtml7(error)}</p>`).join("")}</li>`).join("") : "<li>No transcript turns recorded.</li>";
+  const providerDecisions = record.providerDecisions.length ? record.providerDecisions.map((decision) => `<li><strong>${escapeHtml7(decision.provider ?? decision.selectedProvider ?? decision.fallbackProvider ?? "provider")}</strong> <span>${escapeHtml7(decision.status ?? decision.type)}</span> ${formatMs2(decision.elapsedMs)}${decision.surface ? `<p><span class="label">Surface</span>${escapeHtml7(decision.surface)}</p>` : ""}${decision.kind ? `<p><span class="label">Kind</span>${escapeHtml7(decision.kind)}</p>` : ""}${decision.selectedProvider ? `<p>Selected: ${escapeHtml7(decision.selectedProvider)}</p>` : ""}${decision.fallbackProvider ? `<p>Fallback: ${escapeHtml7(decision.fallbackProvider)}</p>` : ""}${decision.error ? `<p class="error">${escapeHtml7(decision.error)}</p>` : ""}${decision.reason ? `<p>${escapeHtml7(decision.reason)}</p>` : ""}</li>`).join("") : "<li>No provider decisions recorded.</li>";
+  const providerDecisionSummary = record.providerDecisionSummary;
+  const handoffs = record.handoffs.length ? record.handoffs.map((handoff) => `<li><strong>${escapeHtml7(handoff.fromAgentId ?? "unknown")}</strong> to <strong>${escapeHtml7(handoff.targetAgentId ?? "unknown")}</strong> <span>${escapeHtml7(handoff.status ?? "")}</span><p>${escapeHtml7(handoff.summary ?? handoff.reason ?? "")}</p></li>`).join("") : "<li>No agent handoffs recorded.</li>";
+  const tools = record.tools.length ? record.tools.map((tool) => `<li><strong>${escapeHtml7(tool.toolName ?? "tool")}</strong> <span>${escapeHtml7(tool.status ?? "")}</span> ${formatMs2(tool.elapsedMs)} ${tool.error ? `<p>${escapeHtml7(tool.error)}</p>` : ""}</li>`).join("") : "<li>No tool calls recorded.</li>";
+  const reviews = record.reviews?.reviews.length ? record.reviews.reviews.map((review) => `<li><strong>${escapeHtml7(review.title)}</strong> <span>${escapeHtml7(review.summary.outcome ?? "")}</span><p>${escapeHtml7(review.postCall?.summary ?? review.transcript.actual)}</p></li>`).join("") : "<li>No call reviews recorded.</li>";
+  const tasks = record.tasks?.tasks.length ? record.tasks.tasks.map((task) => `<li><strong>${escapeHtml7(task.title)}</strong> <span>${escapeHtml7(task.status)}</span><p>${escapeHtml7(task.recommendedAction)}</p></li>`).join("") : "<li>No ops tasks recorded.</li>";
+  const integrationEvents = record.integrationEvents?.events.length ? record.integrationEvents.events.map((event) => `<li><strong>${escapeHtml7(event.type)}</strong> <span>${escapeHtml7(event.deliveryStatus ?? "local")}</span><p>${escapeHtml7(event.deliveryError ?? event.deliveredTo ?? "")}</p></li>`).join("") : "<li>No integration events recorded.</li>";
+  const guardrails = record.guardrails.total ? record.guardrails.decisions.map((decision) => {
+    const findings = decision.findings.map((finding) => finding.label ?? finding.ruleId ?? finding.action).filter((value) => typeof value === "string").join(", ") || "none";
+    return `<li><strong>assistant.guardrail ${escapeHtml7(decision.stage ?? "unknown")}</strong> <span>${escapeHtml7(decision.status ?? "")}</span><p>Allowed: ${escapeHtml7(String(decision.allowed ?? "unknown"))} \xB7 Proof: ${escapeHtml7(decision.proof ?? "runtime")}${decision.turnId ? ` \xB7 Turn: ${escapeHtml7(decision.turnId)}` : ""}</p><p>${escapeHtml7(findings)}</p></li>`;
+  }).join("") : "<li>No assistant.guardrail events recorded.</li>";
+  const telephonyMedia = record.telephonyMedia.events.length ? record.telephonyMedia.events.slice(0, 50).map((event) => {
+    const details = [
+      event.carrier ? `Carrier: ${event.carrier}` : undefined,
+      event.streamId ? `Stream: ${event.streamId}` : undefined,
+      event.callSid ? `Call: ${event.callSid}` : undefined,
+      event.direction ? `Direction: ${event.direction}` : undefined,
+      event.sequenceNumber ? `Seq: ${event.sequenceNumber}` : undefined,
+      `Audio bytes: ${String(event.audioBytes)}`
+    ].filter((detail) => typeof detail === "string");
+    return `<li><strong>${escapeHtml7(event.event)}</strong> <span>${escapeHtml7(new Date(event.at).toLocaleString())}</span><p>${escapeHtml7(details.join(" \xB7 "))}</p></li>`;
+  }).join("") : "<li>No telephony media trace events recorded.</li>";
+  const snippet = escapeHtml7(`app.use(
+	createVoiceOperationsRecordRoutes({
+		audit: auditStore,
+		integrationEvents: opsEvents,
+		htmlPath: '/voice-ops/:sessionId',
+		path: '/api/voice-ops/:sessionId',
+		redact: {
+			keys: ['authorization', 'apiKey', 'token']
+		},
+		reviews: callReviews,
+		store: traceStore,
+		tasks: opsTasks
+	})
+);`);
+  const incidentMarkdown = escapeHtml7(renderVoiceOperationsRecordIncidentMarkdown(record));
+  const incidentLink = options.incidentHref ? `<a href="${escapeHtml7(options.incidentHref)}">Download incident.md</a>` : "";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml7(options.title ?? "Voice Operations Record")}</title><style>body{background:#101417;color:#f9f4e8;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1120px;padding:32px}.eyebrow{color:#fbbf24;font-size:.8rem;font-weight:900;letter-spacing:.14em;text-transform:uppercase}h1{font-size:clamp(2.4rem,6vw,4.8rem);line-height:.9;margin:.2rem 0 1rem}.status{border:1px solid #475569;border-radius:999px;display:inline-flex;padding:8px 12px}.healthy{color:#86efac}.warning{color:#fbbf24}.failed,.error{color:#fca5a5}.grid{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));margin:20px 0}.card,.primitive{background:#182025;border:1px solid #2d3a43;border-radius:20px;padding:16px}.card span,.muted,.label{color:#a9b4bd}.label{display:block;font-size:.72rem;font-weight:900;letter-spacing:.12em;text-transform:uppercase}.card strong{display:block;font-size:2rem}section{margin-top:28px}article{display:grid;gap:8px}ul{display:grid;gap:10px;list-style:none;padding:0}li{background:#182025;border:1px solid #2d3a43;border-radius:16px;padding:14px}pre{background:#080d10;border:1px solid #2d3a43;border-radius:16px;color:#dbeafe;overflow:auto;padding:14px}.hero-actions{display:flex;flex-wrap:wrap;gap:10px;margin-top:16px}.hero-actions a{background:#fbbf24;border-radius:999px;color:#111827;font-weight:900;padding:10px 14px;text-decoration:none}.two-column{display:grid;gap:18px;grid-template-columns:minmax(0,1.15fr) minmax(280px,.85fr)}@media(max-width:860px){main{padding:20px}.two-column{grid-template-columns:1fr}}</style></head><body><main><p class="eyebrow">Call log replacement</p><h1>${escapeHtml7(options.title ?? "Voice Operations Record")}</h1><p class="status ${escapeHtml7(record.status)}">${escapeHtml7(record.status)}</p><div class="hero-actions"><a href="#transcript">Transcript</a><a href="#provider-decisions">Provider decisions</a><a href="#telephony-media">Telephony media</a><a href="#guardrails">Guardrails</a><a href="#incident-handoff">Incident handoff</a>${incidentLink}</div><section class="grid"><div class="card"><span>Events</span><strong>${String(record.summary.eventCount)}</strong></div><div class="card"><span>Turns</span><strong>${String(record.summary.turnCount)}</strong></div><div class="card"><span>Errors</span><strong>${String(record.summary.errorCount)}</strong></div><div class="card"><span>Duration</span><strong>${formatMs2(record.summary.callDurationMs)}</strong></div><div class="card"><span>Provider recovery</span><strong>${escapeHtml7(providerDecisionSummary.recoveryStatus)}</strong><span>${String(providerDecisionSummary.fallbacks)} fallback / ${String(providerDecisionSummary.degraded)} degraded / ${String(providerDecisionSummary.errors)} errors</span></div><div class="card"><span>Telephony media</span><strong>${String(record.telephonyMedia.media)}</strong><span>${String(record.telephonyMedia.inbound)} inbound / ${String(record.telephonyMedia.outbound)} outbound / ${String(record.telephonyMedia.clears)} clears</span></div><div class="card"><span>Guardrails</span><strong>${String(record.guardrails.blocked)}</strong></div><div class="card"><span>Audit</span><strong>${String(record.audit?.total ?? 0)}</strong></div><div class="card"><span>Reviews</span><strong>${String(record.reviews?.total ?? 0)}</strong></div><div class="card"><span>Tasks</span><strong>${String(record.tasks?.total ?? 0)}</strong></div><div class="card"><span>Integrations</span><strong>${String(record.integrationEvents?.total ?? 0)}</strong></div></section><section class="two-column"><div><h2 id="transcript">Transcript</h2><ul>${transcript}</ul></div><div><h2 id="provider-decisions">Provider Decisions</h2><ul>${providerDecisions}</ul></div></section><section id="telephony-media"><h2>Telephony Media</h2><p class="muted">Live <code>client.telephony_media</code> stream lifecycle evidence attached to this session. Carriers: ${escapeHtml7(record.telephonyMedia.carriers.join(", ") || "none")}. Streams: ${escapeHtml7(record.telephonyMedia.streamIds.join(", ") || "none")}. Inbound: ${String(record.telephonyMedia.inbound)}. Outbound: ${String(record.telephonyMedia.outbound)}. Marks: ${String(record.telephonyMedia.marks)}. Clears: ${String(record.telephonyMedia.clears)}.</p><ul>${telephonyMedia}</ul></section><section id="guardrails"><h2>Guardrail Evidence</h2><p class="muted">Live <code>assistant.guardrail</code> decisions attached to this session.</p><ul>${guardrails}</ul></section><section id="incident-handoff"><h2>Copyable Incident Handoff</h2><p class="muted">Paste this into Slack, Linear, Zendesk, or an incident review. ${incidentLink}</p><pre><code>${incidentMarkdown}</code></pre></section><section class="primitive"><p class="eyebrow">Copy into your app</p><h2><code>createVoiceOperationsRecordRoutes(...)</code> gives every call one debuggable object</h2><p class="muted">Use this as the support/debug payload across traces, provider routing, tools, handoffs, guardrails, audit, latency, replay, reviews, tasks, media streams, and webhook delivery.</p><pre><code>${snippet}</code></pre></section><section><h2>Provider Summary</h2><div class="grid">${providers}</div></section><section><h2>Handoffs</h2><ul>${handoffs}</ul></section><section><h2>Tools</h2><ul>${tools}</ul></section><section><h2>Reviews</h2><ul>${reviews}</ul></section><section><h2>Tasks</h2><ul>${tasks}</ul></section><section><h2>Integration Events</h2><ul>${integrationEvents}</ul></section></main></body></html>`;
+};
+var createVoiceOperationsRecordRoutes = (options) => {
+  const path = options.path ?? "/api/voice-operations/:sessionId";
+  const htmlPath = options.htmlPath === undefined ? "/voice-operations/:sessionId" : options.htmlPath;
+  const incidentPath = options.incidentPath === undefined ? `${path}/incident.md` : options.incidentPath;
+  const incidentHtmlPath = options.incidentHtmlPath === undefined && htmlPath ? `${htmlPath}/incident.md` : options.incidentHtmlPath;
+  const routes = new Elysia4({
+    name: options.name ?? "absolutejs-voice-operations-record"
+  });
+  const buildRecord = (sessionId) => buildVoiceOperationsRecord({
+    audit: options.audit,
+    evaluation: options.evaluation,
+    events: options.events,
+    integrationEvents: options.integrationEvents,
+    redact: options.redact,
+    reviews: options.reviews,
+    sessionId,
+    store: options.store,
+    tasks: options.tasks
+  });
+  const getSessionId = (params) => params.sessionId ?? "";
+  routes.get(path, async ({ params }) => Response.json(await buildRecord(getSessionId(params))));
+  const incidentHandler = async ({
+    params
+  }) => {
+    const record = await buildRecord(getSessionId(params));
+    const body = await (options.renderIncidentMarkdown ?? renderVoiceOperationsRecordIncidentMarkdown)(record);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  };
+  if (incidentPath) {
+    routes.get(incidentPath, incidentHandler);
+  }
+  if (htmlPath) {
+    routes.get(htmlPath, async ({ params }) => {
+      const record = await buildRecord(getSessionId(params));
+      const body = await (options.render ?? ((input) => renderVoiceOperationsRecordHTML(input, {
+        incidentHref: incidentHtmlPath ? resolveRoutePath(incidentHtmlPath, input.sessionId) : undefined,
+        title: options.title
+      })))(record);
+      return new Response(body, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          ...options.headers
+        }
+      });
+    });
+  }
+  if (incidentHtmlPath && incidentHtmlPath !== incidentPath) {
+    routes.get(incidentHtmlPath, incidentHandler);
+  }
+  return routes;
+};
+
 // src/telephony/twilio.ts
 import { Buffer as Buffer3 } from "buffer";
-import { Elysia as Elysia2 } from "elysia";
+import { Elysia as Elysia6 } from "elysia";
 
 // src/telephonyOutcome.ts
-import { Elysia } from "elysia";
+import { Elysia as Elysia5 } from "elysia";
 var DEFAULT_COMPLETED_STATUSES = [
   "answered",
   "completed",
@@ -9036,7 +11449,7 @@ var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
 ];
 var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var uniqueSorted2 = (values) => Array.from(new Set(values)).sort();
 var findMissing = (values, required) => {
   if (!required?.length) {
     return [];
@@ -9069,22 +11482,22 @@ var evaluateVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
   const issues = [];
   const decisions = input.decisions ?? [];
   const verificationAttempts = input.verificationAttempts ?? [];
-  const actions = uniqueSorted(decisions.map((decision) => decision.decision?.action ?? decision.action).filter(isTelephonyOutcomeAction));
-  const dispositions = uniqueSorted(decisions.map((decision) => decision.decision?.disposition ?? decision.disposition).filter(isCallDisposition));
-  const providers = uniqueSorted(decisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
-  const sources = uniqueSorted(decisions.map((decision) => decision.decision?.source ?? decision.source).filter((source) => typeof source === "string"));
+  const actions = uniqueSorted2(decisions.map((decision) => decision.decision?.action ?? decision.action).filter(isTelephonyOutcomeAction));
+  const dispositions = uniqueSorted2(decisions.map((decision) => decision.decision?.disposition ?? decision.disposition).filter(isCallDisposition));
+  const providers = uniqueSorted2(decisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const sources = uniqueSorted2(decisions.map((decision) => decision.decision?.source ?? decision.source).filter((source) => typeof source === "string"));
   const applied = decisions.filter((decision) => decision.applied === true).length;
   const duplicateDecisions = decisions.filter((decision) => decision.duplicate === true);
-  const duplicateProviders = uniqueSorted(duplicateDecisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const duplicateProviders = uniqueSorted2(duplicateDecisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
   const duplicateIdempotencyKeys = new Set(duplicateDecisions.map((decision) => decision.idempotencyKey).filter((key) => typeof key === "string" && key.length > 0)).size;
   const duplicateCampaignOutcomesApplied = duplicateDecisions.filter((decision) => isRecord(decision.campaignOutcome) && decision.campaignOutcome.applied === true).length;
-  const duplicateOutcomeReasons = uniqueSorted(duplicateDecisions.map((decision) => isRecord(decision.campaignOutcome) ? decision.campaignOutcome.reason : undefined).filter((reason) => typeof reason === "string"));
+  const duplicateOutcomeReasons = uniqueSorted2(duplicateDecisions.map((decision) => isRecord(decision.campaignOutcome) ? decision.campaignOutcome.reason : undefined).filter((reason) => typeof reason === "string"));
   const routeResults = decisions.filter((decision) => isRecord(decision.routeResult)).length;
   const missingSessionIds = decisions.filter((decision) => !decision.sessionId).length;
   const rejectedVerificationAttempts = verificationAttempts.filter((attempt) => attempt.rejected === true || attempt.status === 401 || attempt.verification?.ok === false && attempt.verification.reason === "invalid-signature");
-  const rejectedVerificationProviders = uniqueSorted(rejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
+  const rejectedVerificationProviders = uniqueSorted2(rejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
   const replayRejectedVerificationAttempts = rejectedVerificationAttempts.filter((attempt) => attempt.replayRejected === true);
-  const replayRejectedVerificationProviders = uniqueSorted(replayRejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
+  const replayRejectedVerificationProviders = uniqueSorted2(replayRejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
   const rejectedVerificationSideEffects = rejectedVerificationAttempts.reduce((total, attempt) => total + Math.max(0, attempt.sideEffects ?? 0), 0);
   if (input.minDecisions !== undefined && decisions.length < input.minDecisions) {
     issues.push(`Expected at least ${String(input.minDecisions)} telephony webhook decision(s), found ${String(decisions.length)}.`);
@@ -9166,7 +11579,7 @@ var assertVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
   return assertion;
 };
 var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
-var firstString2 = (source, keys) => {
+var firstString3 = (source, keys) => {
   for (const key of keys) {
     const value = source[key];
     if (typeof value === "string" && value.trim()) {
@@ -9177,7 +11590,7 @@ var firstString2 = (source, keys) => {
     }
   }
 };
-var firstNumber2 = (source, keys) => {
+var firstNumber3 = (source, keys) => {
   for (const key of keys) {
     const value = source[key];
     if (typeof value === "number" && Number.isFinite(value)) {
@@ -9538,8 +11951,8 @@ var verifyVoiceTelephonyWebhook = async (input) => {
 var durationMsFromSeconds = (value) => typeof value === "number" ? value * 1000 : undefined;
 var parseVoiceTelephonyWebhookEvent = (input) => {
   const payload = flattenPayload(input.body);
-  const provider = firstString2(payload, ["provider", "Provider"]) ?? input.provider;
-  const status = firstString2(payload, [
+  const provider = firstString3(payload, ["provider", "Provider"]) ?? input.provider;
+  const status = firstString3(payload, [
     "CallStatus",
     "call_status",
     "callStatus",
@@ -9549,7 +11962,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     "event_type",
     "type"
   ]);
-  const durationMs = firstNumber2(payload, ["durationMs", "duration_ms"]) ?? durationMsFromSeconds(firstNumber2(payload, [
+  const durationMs = firstNumber3(payload, ["durationMs", "duration_ms"]) ?? durationMsFromSeconds(firstNumber3(payload, [
     "CallDuration",
     "call_duration",
     "callDuration",
@@ -9557,16 +11970,16 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     "dial_call_duration",
     "duration"
   ]));
-  const sipCode = firstNumber2(payload, [
+  const sipCode = firstNumber3(payload, [
     "SipResponseCode",
     "sip_response_code",
     "sipCode",
     "sip_code",
     "hangupCauseCode"
   ]);
-  const from = firstString2(payload, ["From", "from", "caller_id", "callerId"]);
-  const to = firstString2(payload, ["To", "to", "called_number", "calledNumber"]);
-  const target = firstString2(payload, [
+  const from = firstString3(payload, ["From", "from", "caller_id", "callerId"]);
+  const to = firstString3(payload, ["To", "to", "called_number", "calledNumber"]);
+  const target = firstString3(payload, [
     "transferTarget",
     "TransferTarget",
     "target",
@@ -9574,7 +11987,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     "department"
   ]);
   return {
-    answeredBy: firstString2(payload, [
+    answeredBy: firstString3(payload, [
       "AnsweredBy",
       "answered_by",
       "answeredBy",
@@ -9588,7 +12001,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
       ...payload
     },
     provider,
-    reason: firstString2(payload, [
+    reason: firstString3(payload, [
       "Reason",
       "reason",
       "HangupCause",
@@ -9604,7 +12017,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
 var defaultSessionId = (input) => {
   const payload = flattenPayload(input.body);
   const metadataSessionId = input.event.metadata?.sessionId;
-  return firstString2(input.query, ["sessionId", "session_id"]) ?? firstString2(payload, [
+  return firstString3(input.query, ["sessionId", "session_id"]) ?? firstString3(payload, [
     "sessionId",
     "session_id",
     "SessionId",
@@ -9619,7 +12032,7 @@ var defaultSessionId = (input) => {
 };
 var defaultIdempotencyKey = (input) => {
   const payload = flattenPayload(input.body);
-  const eventId = firstString2(payload, [
+  const eventId = firstString3(payload, [
     "id",
     "event_id",
     "eventId",
@@ -9756,7 +12169,7 @@ var createVoiceTelephonyWebhookHandler = (options = {}) => async (input) => {
 var createVoiceTelephonyWebhookRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice/telephony/webhook";
   const handler = createVoiceTelephonyWebhookHandler(options);
-  return new Elysia({
+  return new Elysia5({
     name: options.name ?? "absolutejs-voice-telephony-webhooks"
   }).post(path, async ({ query, request }) => {
     try {
@@ -9807,7 +12220,7 @@ var resolveTwilioStreamParameters = async (parameters, input) => {
   return parameters;
 };
 var joinUrlPath = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
-var escapeHtml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var escapeHtml8 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var getWebhookVerificationUrl = (webhook, input) => {
   if (!webhook?.verificationUrl) {
     return;
@@ -9850,23 +12263,23 @@ var buildTwilioVoiceSetupStatus = async (options, input) => {
 };
 var renderTwilioVoiceSetupHTML = (status, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
 <p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Twilio setup</p>
-<h1>${escapeHtml2(title)}</h1>
+<h1>${escapeHtml8(title)}</h1>
 <p><strong>Status:</strong> ${status.ready ? "Ready" : "Needs attention"}</p>
 <section>
 <h2>URLs</h2>
 <ul>
-<li><strong>TwiML:</strong> <code>${escapeHtml2(status.urls.twiml)}</code></li>
-<li><strong>Media stream:</strong> <code>${escapeHtml2(status.urls.stream)}</code></li>
-<li><strong>Status webhook:</strong> <code>${escapeHtml2(status.urls.webhook)}</code></li>
+<li><strong>TwiML:</strong> <code>${escapeHtml8(status.urls.twiml)}</code></li>
+<li><strong>Media stream:</strong> <code>${escapeHtml8(status.urls.stream)}</code></li>
+<li><strong>Status webhook:</strong> <code>${escapeHtml8(status.urls.webhook)}</code></li>
 </ul>
 </section>
 <section>
 <h2>Signing</h2>
 <p>Mode: <code>${status.signing.mode}</code></p>
-${status.signing.verificationUrl ? `<p>Verification URL: <code>${escapeHtml2(status.signing.verificationUrl)}</code></p>` : ""}
+${status.signing.verificationUrl ? `<p>Verification URL: <code>${escapeHtml8(status.signing.verificationUrl)}</code></p>` : ""}
 </section>
-${status.missing.length ? `<section><h2>Missing env</h2><ul>${status.missing.map((name) => `<li><code>${escapeHtml2(name)}</code></li>`).join("")}</ul></section>` : ""}
-${status.warnings.length ? `<section><h2>Warnings</h2><ul>${status.warnings.map((warning) => `<li>${escapeHtml2(warning)}</li>`).join("")}</ul></section>` : ""}
+${status.missing.length ? `<section><h2>Missing env</h2><ul>${status.missing.map((name) => `<li><code>${escapeHtml8(name)}</code></li>`).join("")}</ul></section>` : ""}
+${status.warnings.length ? `<section><h2>Warnings</h2><ul>${status.warnings.map((warning) => `<li>${escapeHtml8(warning)}</li>`).join("")}</ul></section>` : ""}
 </main>`;
 var extractTwilioStreamUrl = (twiml) => twiml.match(/<Stream\b[^>]*\surl="([^"]+)"/i)?.[1]?.replaceAll("&amp;", "&");
 var createSmokeCheck = (name, status, message, details) => ({
@@ -9877,20 +12290,20 @@ var createSmokeCheck = (name, status, message, details) => ({
 });
 var renderTwilioVoiceSmokeHTML = (report, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
 <p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Twilio smoke test</p>
-<h1>${escapeHtml2(title)}</h1>
+<h1>${escapeHtml8(title)}</h1>
 <p><strong>Status:</strong> ${report.pass ? "Pass" : "Fail"}</p>
 <section>
 <h2>Checks</h2>
 <ul>
-${report.checks.map((check) => `<li><strong>${escapeHtml2(check.name)}</strong>: ${escapeHtml2(check.status)}${check.message ? ` - ${escapeHtml2(check.message)}` : ""}</li>`).join("")}
+${report.checks.map((check) => `<li><strong>${escapeHtml8(check.name)}</strong>: ${escapeHtml8(check.status)}${check.message ? ` - ${escapeHtml8(check.message)}` : ""}</li>`).join("")}
 </ul>
 </section>
 <section>
 <h2>Observed URLs</h2>
 <ul>
-<li><strong>TwiML:</strong> <code>${escapeHtml2(report.setup.urls.twiml)}</code></li>
-<li><strong>Stream:</strong> <code>${escapeHtml2(report.twiml?.streamUrl ?? report.setup.urls.stream)}</code></li>
-<li><strong>Webhook:</strong> <code>${escapeHtml2(report.setup.urls.webhook)}</code></li>
+<li><strong>TwiML:</strong> <code>${escapeHtml8(report.setup.urls.twiml)}</code></li>
+<li><strong>Stream:</strong> <code>${escapeHtml8(report.twiml?.streamUrl ?? report.setup.urls.stream)}</code></li>
+<li><strong>Webhook:</strong> <code>${escapeHtml8(report.setup.urls.webhook)}</code></li>
 </ul>
 </section>
 </main>`;
@@ -10436,7 +12849,7 @@ var createTwilioVoiceRoutes = (options) => {
   const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/twilio/smoke";
   const bridges = new WeakMap;
   const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
-  const app = new Elysia2({
+  const app = new Elysia6({
     name: options.name ?? "absolutejs-voice-twilio"
   }).get(twimlPath, async ({ query, request }) => {
     const streamUrl = await resolveTwilioStreamUrl(options, {
@@ -10714,6 +13127,104 @@ var createFakeTTSAdapter = (chunkCount, chunkDelayMs) => ({
     };
   }
 });
+var defaultOperationsRecordHref = ({
+  sessionId
+}) => `/voice-operations/${encodeURIComponent(sessionId)}`;
+var resolveOperationsRecordHref = (href, input) => typeof href === "function" ? href(input) : href === undefined ? defaultOperationsRecordHref(input) : href;
+var runVoiceTelephonyMediaOperationsSmoke = async (options = {}) => {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const sessionId = options.sessionId ?? `telephony-media-ops-${Date.now()}`;
+  const streamSid = options.streamSid ?? "telephony-media-ops-stream";
+  const callSid = options.callSid ?? "telephony-media-ops-call";
+  const scenarioId = options.scenarioId ?? "telephony-media-operations-smoke";
+  const trace = options.store ?? createVoiceMemoryTraceEventStore();
+  const sentEvents = [];
+  const receivedAudio = [];
+  const bridge = createTwilioMediaStreamBridge({
+    close: () => {},
+    send: (data) => {
+      sentEvents.push(JSON.parse(data));
+    }
+  }, {
+    context: {},
+    onComplete: async () => {},
+    onTurn: async () => ({
+      assistantText: "Confirmed. Two way carrier media is visible."
+    }),
+    session: createVoiceMemoryStore(),
+    stt: createFakeSTTAdapter(receivedAudio, 0),
+    trace,
+    tts: createFakeTTSAdapter(1, 0),
+    turnDetection: {
+      transcriptStabilityMs: 0
+    }
+  });
+  const payload = encodeTwilioMulawBase64(new Int16Array([500, -500, 1500, -1500, 2500, -2500]));
+  await bridge.handleMessage({
+    event: "start",
+    start: {
+      callSid,
+      customParameters: {
+        scenarioId,
+        sessionId
+      },
+      streamSid
+    },
+    streamSid
+  });
+  await bridge.handleMessage({
+    event: "media",
+    media: {
+      payload,
+      track: "inbound"
+    },
+    streamSid
+  });
+  await waitFor(() => sentEvents.some((message) => message.event === "media"), timeoutMs);
+  await bridge.handleMessage({
+    event: "media",
+    media: {
+      payload,
+      track: "inbound"
+    },
+    streamSid
+  });
+  await waitFor(() => sentEvents.some((message) => message.event === "clear"), timeoutMs);
+  await bridge.handleMessage({
+    event: "stop",
+    stop: {
+      callSid
+    },
+    streamSid
+  });
+  await bridge.close("telephony-media-operations-smoke-complete");
+  const operationsRecord = await buildVoiceOperationsRecord({
+    sessionId,
+    store: trace
+  });
+  const media = operationsRecord.telephonyMedia;
+  const issues = [
+    media.starts < 1 ? "Missing telephony media start event." : undefined,
+    media.stops < 1 ? "Missing telephony media stop event." : undefined,
+    media.inbound < 2 ? "Expected at least two inbound telephony media events." : undefined,
+    media.outbound < 2 ? "Expected outbound assistant media/control evidence." : undefined,
+    media.media < 3 ? "Expected inbound and outbound telephony media packet evidence." : undefined,
+    media.clears < 1 ? "Missing outbound clear evidence." : undefined,
+    media.audioBytes <= 0 ? "Missing telephony media audio bytes." : undefined,
+    media.carriers.includes("twilio") ? undefined : "Missing Twilio carrier evidence.",
+    media.streamIds.includes(streamSid) ? undefined : "Missing telephony media stream ID evidence."
+  ].filter((issue) => typeof issue === "string");
+  return {
+    issues,
+    ok: issues.length === 0,
+    operationsRecord,
+    operationsRecordHref: resolveOperationsRecordHref(options.operationsRecordHref, { sessionId, streamSid }),
+    sentEvents: sentEvents.map((message) => message.event).filter((event) => typeof event === "string"),
+    sessionId,
+    streamSid,
+    telephonyMedia: media
+  };
+};
 var getDefaultVoiceTelephonyBenchmarkScenarios = () => DEFAULT_SCENARIOS2.map((scenario) => ({ ...scenario }));
 var runVoiceTelephonyBenchmarkScenario = async (scenario, options = {}) => {
   const timeoutMs = options.timeoutMs ?? 1000;
@@ -11035,6 +13546,7 @@ export {
   summarizeSTTBenchmark,
   scoreTranscriptAccuracy,
   scoreCorrectedExpectedTerms,
+  runVoiceTelephonyMediaOperationsSmoke,
   runVoiceTelephonyBenchmarkScenario,
   runVoiceTelephonyBenchmark,
   runVoiceSessionBenchmarkSeries,