@absolutejs/voice 0.0.22-beta.16 → 0.0.22-beta.160

package/dist/angular/index.js

@@ -69,741 +69,1627 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
-// src/angular/voice-stream.service.ts
+// src/angular/voice-ops-status.service.ts
 import { computed, Injectable, signal } from "@angular/core";
 
-// src/client/actions.ts
-var normalizeErrorMessage = (value) => {
-  if (typeof value === "string" && value.trim()) {
-    return value;
-  }
-  if (value instanceof Error && value.message.trim()) {
-    return value.message;
+// src/client/opsStatus.ts
+var fetchVoiceOpsStatus = async (path = "/api/voice/ops-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice ops status failed: HTTP ${response.status}`);
   }
-  if (value && typeof value === "object") {
-    const record = value;
-    for (const key of ["message", "reason", "description"]) {
-      const candidate = record[key];
-      if (typeof candidate === "string" && candidate.trim()) {
-        return candidate;
-      }
-    }
-    if ("error" in record) {
-      return normalizeErrorMessage(record.error);
+  return await response.json();
+};
+var createVoiceOpsStatusStore = (path = "/api/voice/ops-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-    if ("cause" in record) {
-      return normalizeErrorMessage(record.cause);
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
     }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
     try {
-      return JSON.stringify(value);
-    } catch {}
-  }
-  return "Unexpected error";
-};
-var serverMessageToAction = (message) => {
-  switch (message.type) {
-    case "audio":
-      return {
-        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
-        format: message.format,
-        receivedAt: message.receivedAt,
-        turnId: message.turnId,
-        type: "audio"
-      };
-    case "assistant":
-      return {
-        text: message.text,
-        type: "assistant"
-      };
-    case "complete":
-      return {
-        sessionId: message.sessionId,
-        type: "complete"
-      };
-    case "error":
-      return {
-        message: normalizeErrorMessage(message.message),
-        type: "error"
-      };
-    case "final":
-      return {
-        transcript: message.transcript,
-        type: "final"
-      };
-    case "partial":
-      return {
-        transcript: message.transcript,
-        type: "partial"
-      };
-    case "session":
-      return {
-        sessionId: message.sessionId,
-        scenarioId: message.scenarioId,
-        status: message.status,
-        type: "session"
+      const report = await fetchVoiceOpsStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
       };
-    case "turn":
-      return {
-        turn: message.turn,
-        type: "turn"
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
       };
-    default:
-      return null;
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
   }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
 };
 
-// src/client/connection.ts
-var WS_OPEN = 1;
-var WS_CLOSED = 3;
-var WS_NORMAL_CLOSURE = 1000;
-var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
-var DEFAULT_PING_INTERVAL = 30000;
-var RECONNECT_DELAY_MS = 500;
-var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
-var noop = () => {};
-var noopUnsubscribe = () => noop;
-var NOOP_CONNECTION = {
-  start: () => {},
-  close: noop,
-  endTurn: noop,
-  getReadyState: () => WS_CLOSED,
-  getScenarioId: () => "",
-  getSessionId: () => "",
-  send: noop,
-  sendAudio: noop,
-  subscribe: noopUnsubscribe
-};
-var createSessionId = () => crypto.randomUUID();
-var buildWsUrl = (path, sessionId, scenarioId) => {
-  const { hostname, port, protocol } = window.location;
-  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
-  const portSuffix = port ? `:${port}` : "";
-  const url = new URL(`${wsProtocol}//${hostname}${portSuffix}${path}`);
-  url.searchParams.set("sessionId", sessionId);
-  if (scenarioId) {
-    url.searchParams.set(DEFAULT_SCENARIO_QUERY_PARAM, scenarioId);
+// src/angular/voice-ops-status.service.ts
+var _dec = [
+  Injectable({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceOpsStatusService {
+  connect(path = "/api/voice/ops-status", options = {}) {
+    const store = createVoiceOpsStatusStore(path, options);
+    const errorSignal = signal(null);
+    const isLoadingSignal = signal(false);
+    const reportSignal = signal(undefined);
+    const updatedAtSignal = signal(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed(() => errorSignal()),
+      isLoading: computed(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed(() => reportSignal()),
+      updatedAt: computed(() => updatedAtSignal())
+    };
   }
-  return url.toString();
-};
-var isVoiceServerMessage = (value) => {
-  if (!value || typeof value !== "object" || !("type" in value)) {
-    return false;
+}
+VoiceOpsStatusService = __decorateElement(_init, 0, "VoiceOpsStatusService", _dec, VoiceOpsStatusService);
+__runInitializers(_init, 1, VoiceOpsStatusService);
+__decoratorMetadata(_init, VoiceOpsStatusService);
+let _VoiceOpsStatusService = VoiceOpsStatusService;
+// src/angular/voice-ops-action-center.service.ts
+import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+
+// src/client/opsActionCenter.ts
+var recordVoiceOpsActionResult = async (result, options = {}) => {
+  if (options.auditPath === false) {
+    return;
   }
-  switch (value.type) {
-    case "audio":
-    case "assistant":
-    case "complete":
-    case "error":
-    case "final":
-    case "partial":
-    case "pong":
-    case "session":
-    case "turn":
-      return true;
-    default:
-      return false;
+  const path = options.auditPath ?? "/api/voice/ops-actions/audit";
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, {
+    body: JSON.stringify(result),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`Voice ops action audit failed: HTTP ${response.status}`);
   }
 };
-var parseServerMessage = (event) => {
-  if (typeof event.data !== "string") {
-    return null;
+var createVoiceOpsActionCenterActions = (options = {}) => {
+  const deliveryRuntimePath = options.deliveryRuntimePath ?? "/api/voice-delivery-runtime";
+  const actions = [];
+  if (options.includeProductionReadiness !== false) {
+    actions.push({
+      description: "Refresh the production readiness report.",
+      id: "production-readiness",
+      label: "Refresh readiness",
+      method: "GET",
+      path: options.productionReadinessPath ?? "/api/production-readiness"
+    });
   }
-  try {
-    const parsed = JSON.parse(event.data);
-    return isVoiceServerMessage(parsed) ? parsed : null;
-  } catch {
-    return null;
+  if (options.includeDeliveryRuntime !== false) {
+    actions.push({
+      description: "Drain pending and failed audit/trace deliveries.",
+      id: "delivery-runtime.tick",
+      label: "Tick delivery workers",
+      method: "POST",
+      path: `${deliveryRuntimePath.replace(/\/$/, "")}/tick`
+    }, {
+      description: "Move reviewed dead letters back to live delivery queues.",
+      id: "delivery-runtime.requeue-dead-letters",
+      label: "Requeue dead letters",
+      method: "POST",
+      path: `${deliveryRuntimePath.replace(/\/$/, "")}/requeue-dead-letters`
+    });
+  }
+  if (options.includeTurnLatencyProof !== false) {
+    actions.push({
+      description: "Run the synthetic turn latency proof.",
+      id: "turn-latency.proof",
+      label: "Run latency proof",
+      method: "POST",
+      path: options.turnLatencyProofPath ?? "/api/turn-latency/proof"
+    });
+  }
+  if (options.includeProviderSimulation !== false) {
+    const pathPrefix = options.providerSimulationPathPrefix ?? "/api/stt-simulate";
+    for (const provider of options.providers ?? []) {
+      actions.push({
+        description: `Simulate ${provider} provider failure.`,
+        id: `provider.${provider}.failure`,
+        label: `Simulate ${provider} failure`,
+        method: "POST",
+        path: `${pathPrefix}/failure?provider=${encodeURIComponent(provider)}`
+      }, {
+        description: `Mark ${provider} provider recovered.`,
+        id: `provider.${provider}.recovery`,
+        label: `Recover ${provider}`,
+        method: "POST",
+        path: `${pathPrefix}/recovery?provider=${encodeURIComponent(provider)}`
+      });
+    }
   }
+  return actions;
 };
-var createVoiceConnection = (path, options = {}) => {
-  if (typeof window === "undefined") {
-    return NOOP_CONNECTION;
+var runVoiceOpsAction = async (action, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(action.path, {
+    method: action.method ?? "POST"
+  });
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = body && typeof body === "object" && "error" in body ? String(body.error) : `Voice ops action "${action.id}" failed: HTTP ${response.status}`;
+    throw new Error(message);
   }
+  return {
+    actionId: action.id,
+    body,
+    ok: response.ok,
+    ranAt: Date.now(),
+    status: response.status
+  };
+};
+var createVoiceOpsActionCenterStore = (options = {}) => {
   const listeners = new Set;
-  const shouldReconnect = options.reconnect !== false;
-  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
-  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
-  const state = {
-    isConnected: false,
-    pendingMessages: [],
-    scenarioId: options.scenarioId ?? null,
-    pingInterval: null,
-    reconnectAttempts: 0,
-    reconnectTimeout: null,
-    sessionId: options.sessionId ?? createSessionId(),
-    ws: null
+  let closed = false;
+  let timer;
+  let snapshot = {
+    actions: options.actions ?? createVoiceOpsActionCenterActions(),
+    error: null,
+    isRunning: false
   };
-  const clearTimers = () => {
-    if (state.pingInterval) {
-      clearInterval(state.pingInterval);
-      state.pingInterval = null;
-    }
-    if (state.reconnectTimeout) {
-      clearTimeout(state.reconnectTimeout);
-      state.reconnectTimeout = null;
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
   };
-  const flushPendingMessages = () => {
-    if (state.ws?.readyState !== WS_OPEN) {
-      return;
+  const setActions = (actions) => {
+    snapshot = { ...snapshot, actions, updatedAt: Date.now() };
+    emit();
+  };
+  const run = async (actionId) => {
+    if (closed) {
+      return snapshot.lastResult;
     }
-    while (state.pendingMessages.length > 0) {
-      const next = state.pendingMessages.shift();
-      if (next !== undefined) {
-        state.ws.send(next);
-      }
+    const action = snapshot.actions.find((item) => item.id === actionId);
+    if (!action) {
+      throw new Error(`Voice ops action "${actionId}" is not configured.`);
+    }
+    if (action.disabled) {
+      throw new Error(`Voice ops action "${actionId}" is disabled.`);
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isRunning: true,
+      runningActionId: action.id
+    };
+    emit();
+    try {
+      const result = await runVoiceOpsAction(action, options);
+      await options.onActionResult?.(result);
+      await recordVoiceOpsActionResult(result, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isRunning: false,
+        lastResult: result,
+        runningActionId: undefined,
+        updatedAt: Date.now()
+      };
+      emit();
+      return result;
+    } catch (error) {
+      const result = {
+        actionId: action.id,
+        body: null,
+        error: error instanceof Error ? error.message : String(error),
+        ok: false,
+        ranAt: Date.now(),
+        status: 0
+      };
+      await options.onActionResult?.(result);
+      await recordVoiceOpsActionResult(result, options).catch(() => {});
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isRunning: false,
+        runningActionId: undefined
+      };
+      emit();
+      throw error;
     }
   };
-  const scheduleReconnect = () => {
-    state.reconnectAttempts += 1;
-    state.reconnectTimeout = setTimeout(() => {
-      if (state.reconnectAttempts > maxReconnectAttempts) {
-        return;
-      }
-      connect();
-    }, RECONNECT_DELAY_MS);
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
   };
-  const connect = () => {
-    const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
-    ws.binaryType = "arraybuffer";
-    ws.onopen = () => {
-      state.isConnected = true;
-      state.reconnectAttempts = 0;
-      flushPendingMessages();
-      listeners.forEach((listener) => listener({
-        scenarioId: state.scenarioId ?? undefined,
-        sessionId: state.sessionId,
-        status: "active",
-        type: "session"
-      }));
-      state.pingInterval = setInterval(() => {
-        if (ws.readyState === WS_OPEN) {
-          ws.send(JSON.stringify({ type: "ping" }));
-        }
-      }, pingInterval);
-    };
-    ws.onmessage = (event) => {
-      const parsed = parseServerMessage(event);
-      if (!parsed) {
-        return;
-      }
-      if (parsed.type === "session") {
-        state.sessionId = parsed.sessionId;
-        state.scenarioId = parsed.scenarioId ?? state.scenarioId;
-      }
-      listeners.forEach((listener) => listener(parsed));
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      emit();
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    run,
+    setActions,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-ops-action-center.service.ts
+var _dec = [
+  Injectable2({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceOpsActionCenterService {
+  connect(options = {}) {
+    const store = createVoiceOpsActionCenterStore(options);
+    const actionsSignal = signal2([]);
+    const errorSignal = signal2(null);
+    const isRunningSignal = signal2(false);
+    const lastResultSignal = signal2(undefined);
+    const runningActionIdSignal = signal2(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      actionsSignal.set(snapshot.actions);
+      errorSignal.set(snapshot.error);
+      isRunningSignal.set(snapshot.isRunning);
+      lastResultSignal.set(snapshot.lastResult);
+      runningActionIdSignal.set(snapshot.runningActionId);
     };
-    ws.onclose = (event) => {
-      state.isConnected = false;
-      clearTimers();
-      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
-      if (reconnectable) {
-        scheduleReconnect();
-      }
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    return {
+      actions: computed2(() => actionsSignal()),
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed2(() => errorSignal()),
+      isRunning: computed2(() => isRunningSignal()),
+      lastResult: computed2(() => lastResultSignal()),
+      run: store.run,
+      runningActionId: computed2(() => runningActionIdSignal()),
+      setActions: store.setActions
     };
-    state.ws = ws;
+  }
+}
+VoiceOpsActionCenterService = __decorateElement(_init, 0, "VoiceOpsActionCenterService", _dec, VoiceOpsActionCenterService);
+__runInitializers(_init, 1, VoiceOpsActionCenterService);
+__decoratorMetadata(_init, VoiceOpsActionCenterService);
+let _VoiceOpsActionCenterService = VoiceOpsActionCenterService;
+// src/angular/voice-delivery-runtime.service.ts
+import { computed as computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
+
+// src/client/deliveryRuntime.ts
+var getDefaultActionPath = (path, action, options) => {
+  if (action === "tick") {
+    return options.tickPath ?? `${path.replace(/\/$/, "")}/tick`;
+  }
+  return options.requeueDeadLettersPath ?? `${path.replace(/\/$/, "")}/requeue-dead-letters`;
+};
+var fetchVoiceDeliveryRuntime = async (path = "/api/voice-delivery-runtime", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice delivery runtime failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var runVoiceDeliveryRuntimeAction = async (action, path = "/api/voice-delivery-runtime", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(getDefaultActionPath(path, action, options), {
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(`Voice delivery runtime ${action} failed: HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  return {
+    action,
+    result: body.result,
+    summary: body.summary,
+    updatedAt: Date.now()
   };
-  const sendSerialized = (value) => {
-    if (state.ws?.readyState === WS_OPEN) {
-      state.ws.send(value);
-      return;
-    }
-    state.pendingMessages.push(value);
+};
+var createVoiceDeliveryRuntimeStore = (path = "/api/voice-delivery-runtime", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    actionError: null,
+    actionStatus: "idle",
+    error: null,
+    isLoading: false
   };
-  const send = (message) => {
-    sendSerialized(JSON.stringify(message));
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
   };
-  const start = (input = {}) => {
-    if (input.sessionId) {
-      state.sessionId = input.sessionId;
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
     }
-    if (input.scenarioId) {
-      state.scenarioId = input.scenarioId;
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceDeliveryRuntime(path, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
     }
-    send({
-      type: "start",
-      sessionId: state.sessionId,
-      scenarioId: state.scenarioId ?? undefined
-    });
-  };
-  const sendAudio = (audio) => {
-    sendSerialized(audio);
   };
-  const endTurn = () => {
-    send({ type: "end_turn" });
+  const runAction = async (action) => {
+    if (closed) {
+      return snapshot.lastAction;
+    }
+    snapshot = {
+      ...snapshot,
+      actionError: null,
+      actionStatus: "running"
+    };
+    emit();
+    try {
+      const result = await runVoiceDeliveryRuntimeAction(action, path, options);
+      snapshot = {
+        ...snapshot,
+        actionError: null,
+        actionStatus: "completed",
+        lastAction: result
+      };
+      emit();
+      await refresh();
+      return result;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        actionError: error instanceof Error ? error.message : String(error),
+        actionStatus: "failed"
+      };
+      emit();
+      throw error;
+    }
   };
   const close = () => {
-    clearTimers();
-    if (state.ws) {
-      state.ws.close(WS_NORMAL_CLOSURE);
-      state.ws = null;
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
     }
-    state.isConnected = false;
     listeners.clear();
   };
-  const subscribe = (callback) => {
-    listeners.add(callback);
-    return () => {
-      listeners.delete(callback);
-    };
-  };
-  connect();
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
   return {
-    start,
     close,
-    endTurn,
-    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
-    getScenarioId: () => state.scenarioId ?? "",
-    getSessionId: () => state.sessionId,
-    send,
-    sendAudio,
-    subscribe
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    requeueDeadLetters: () => runAction("requeue-dead-letters"),
+    refresh,
+    tick: () => runAction("tick"),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
   };
 };
 
-// src/client/store.ts
-var createInitialState = () => ({
-  assistantAudio: [],
-  assistantTexts: [],
-  error: null,
-  isConnected: false,
-  scenarioId: null,
-  partial: "",
-  sessionId: null,
-  status: "idle",
-  turns: []
-});
-var createVoiceStreamStore = () => {
-  let state = createInitialState();
-  const subscribers = new Set;
-  const notify = () => {
-    subscribers.forEach((subscriber) => subscriber());
-  };
-  const dispatch = (action) => {
-    switch (action.type) {
-      case "audio":
-        state = {
-          ...state,
-          assistantAudio: [
-            ...state.assistantAudio,
-            {
-              chunk: action.chunk,
-              format: action.format,
-              receivedAt: action.receivedAt,
-              turnId: action.turnId
-            }
-          ]
-        };
-        break;
-      case "assistant":
-        state = {
-          ...state,
-          assistantTexts: [...state.assistantTexts, action.text]
-        };
-        break;
-      case "complete":
-        state = {
-          ...state,
-          sessionId: action.sessionId,
-          status: "completed"
-        };
-        break;
-      case "connected":
-        state = {
-          ...state,
-          isConnected: true
-        };
-        break;
-      case "disconnected":
-        state = {
-          ...state,
-          isConnected: false
-        };
-        break;
-      case "error":
-        state = {
-          ...state,
-          error: action.message
-        };
-        break;
-      case "final":
-        state = {
-          ...state,
-          partial: action.transcript.text,
-          turns: state.turns.map((turn) => turn)
-        };
-        break;
-      case "partial":
-        state = {
-          ...state,
-          partial: action.transcript.text
-        };
-        break;
-      case "session":
-        state = {
-          ...state,
-          error: null,
-          scenarioId: action.scenarioId ?? state.scenarioId,
-          isConnected: action.status === "active",
-          sessionId: action.sessionId,
-          status: action.status
-        };
-        break;
-      case "turn":
-        state = {
-          ...state,
-          partial: "",
-          turns: [...state.turns, action.turn]
-        };
-        break;
-    }
-    notify();
-  };
-  return {
-    dispatch,
-    getServerSnapshot: () => state,
-    getSnapshot: () => state,
-    subscribe: (subscriber) => {
-      subscribers.add(subscriber);
-      return () => {
-        subscribers.delete(subscriber);
-      };
-    }
-  };
-};
-
-// src/client/createVoiceStream.ts
-var createVoiceStream = (path, options = {}) => {
-  const connection = createVoiceConnection(path, options);
-  const store = createVoiceStreamStore();
-  const subscribers = new Set;
-  const start = (input) => Promise.resolve().then(() => {
-    if (!input?.sessionId && !input?.scenarioId) {
-      return;
-    }
-    connection.start(input);
-  });
-  const notify = () => {
-    subscribers.forEach((subscriber) => subscriber());
-  };
-  const unsubscribeConnection = connection.subscribe((message) => {
-    const action = serverMessageToAction(message);
-    if (action) {
-      store.dispatch(action);
-      notify();
-    }
-  });
-  return {
-    close() {
-      unsubscribeConnection();
-      connection.close();
-      store.dispatch({ type: "disconnected" });
-      notify();
-    },
-    endTurn() {
-      connection.endTurn();
-    },
-    get error() {
-      return store.getSnapshot().error;
-    },
-    getServerSnapshot() {
-      return store.getServerSnapshot();
-    },
-    getSnapshot() {
-      return store.getSnapshot();
-    },
-    get isConnected() {
-      return store.getSnapshot().isConnected;
-    },
-    get scenarioId() {
-      return store.getSnapshot().scenarioId;
-    },
-    start,
-    get partial() {
-      return store.getSnapshot().partial;
-    },
-    get sessionId() {
-      return connection.getSessionId();
-    },
-    get status() {
-      return store.getSnapshot().status;
-    },
-    get turns() {
-      return store.getSnapshot().turns;
-    },
-    get assistantTexts() {
-      return store.getSnapshot().assistantTexts;
-    },
-    get assistantAudio() {
-      return store.getSnapshot().assistantAudio;
-    },
-    sendAudio(audio) {
-      connection.sendAudio(audio);
-    },
-    subscribe(subscriber) {
-      subscribers.add(subscriber);
-      return () => {
-        subscribers.delete(subscriber);
-      };
-    }
-  };
-};
-
-// src/angular/voice-stream.service.ts
+// src/angular/voice-delivery-runtime.service.ts
 var _dec = [
-  Injectable({ providedIn: "root" })
+  Injectable3({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
-class VoiceStreamService {
-  connect(path, options = {}) {
-    const stream = createVoiceStream(path, options);
-    const assistantAudioSignal = signal([]);
-    const assistantTextsSignal = signal([]);
-    const errorSignal = signal(null);
-    const isConnectedSignal = signal(false);
-    const partialSignal = signal("");
-    const sessionIdSignal = signal(stream.sessionId);
-    const statusSignal = signal(stream.status);
-    const turnsSignal = signal([]);
+class VoiceDeliveryRuntimeService {
+  connect(path = "/api/voice-delivery-runtime", options = {}) {
+    const store = createVoiceDeliveryRuntimeStore(path, options);
+    const actionErrorSignal = signal3(null);
+    const actionStatusSignal = signal3("idle");
+    const errorSignal = signal3(null);
+    const isLoadingSignal = signal3(false);
+    const reportSignal = signal3(undefined);
+    const updatedAtSignal = signal3(undefined);
     const sync = () => {
-      assistantAudioSignal.set([...stream.assistantAudio]);
-      assistantTextsSignal.set([...stream.assistantTexts]);
-      errorSignal.set(stream.error);
-      isConnectedSignal.set(stream.isConnected);
-      partialSignal.set(stream.partial);
-      sessionIdSignal.set(stream.sessionId);
-      statusSignal.set(stream.status);
-      turnsSignal.set([...stream.turns]);
+      const snapshot = store.getSnapshot();
+      actionErrorSignal.set(snapshot.actionError);
+      actionStatusSignal.set(snapshot.actionStatus);
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
     };
-    const unsubscribe = stream.subscribe(sync);
+    const unsubscribe = store.subscribe(sync);
     sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
     return {
-      assistantAudio: computed(() => assistantAudioSignal()),
-      assistantTexts: computed(() => assistantTextsSignal()),
       close: () => {
         unsubscribe();
-        stream.close();
+        store.close();
       },
-      endTurn: () => stream.endTurn(),
-      error: computed(() => errorSignal()),
-      isConnected: computed(() => isConnectedSignal()),
-      partial: computed(() => partialSignal()),
-      sendAudio: (audio) => stream.sendAudio(audio),
-      sessionId: computed(() => sessionIdSignal()),
-      status: computed(() => statusSignal()),
-      turns: computed(() => turnsSignal())
+      error: computed3(() => errorSignal()),
+      actionError: computed3(() => actionErrorSignal()),
+      actionStatus: computed3(() => actionStatusSignal()),
+      isLoading: computed3(() => isLoadingSignal()),
+      requeueDeadLetters: store.requeueDeadLetters,
+      refresh: store.refresh,
+      report: computed3(() => reportSignal()),
+      tick: store.tick,
+      updatedAt: computed3(() => updatedAtSignal())
     };
   }
 }
-VoiceStreamService = __decorateElement(_init, 0, "VoiceStreamService", _dec, VoiceStreamService);
-__runInitializers(_init, 1, VoiceStreamService);
-__decoratorMetadata(_init, VoiceStreamService);
-let _VoiceStreamService = VoiceStreamService;
-// src/angular/voice-controller.service.ts
-import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+VoiceDeliveryRuntimeService = __decorateElement(_init, 0, "VoiceDeliveryRuntimeService", _dec, VoiceDeliveryRuntimeService);
+__runInitializers(_init, 1, VoiceDeliveryRuntimeService);
+__decoratorMetadata(_init, VoiceDeliveryRuntimeService);
+let _VoiceDeliveryRuntimeService = VoiceDeliveryRuntimeService;
+// src/angular/voice-campaign-dialer-proof.service.ts
+import { computed as computed4, Injectable as Injectable4, signal as signal4 } from "@angular/core";
 
-// src/client/htmx.ts
-var DEFAULT_EVENT_NAME = "voice-refresh";
-var DEFAULT_QUERY_PARAM = "sessionId";
-var resolveElement = (input) => {
-  if (typeof input !== "string") {
-    return input;
+// src/client/campaignDialerProof.ts
+var fetchVoiceCampaignDialerProofStatus = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof status failed: HTTP ${response.status}`);
   }
-  return document.querySelector(input);
+  return await response.json();
 };
-var buildRoute = (element, route, queryParam, sessionId) => {
-  const baseRoute = route ?? element.getAttribute("hx-get") ?? "";
-  if (!baseRoute) {
-    return "";
-  }
-  const url = new URL(baseRoute, window.location.origin);
-  if (sessionId) {
-    url.searchParams.set(queryParam, sessionId);
-  } else {
-    url.searchParams.delete(queryParam);
+var runVoiceCampaignDialerProofAction = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof failed: HTTP ${response.status}`);
   }
-  return `${url.pathname}${url.search}${url.hash}`;
+  return await response.json();
 };
-var bindVoiceHTMX = (stream, options) => {
-  if (typeof window === "undefined" || typeof document === "undefined") {
-    return () => {};
-  }
-  const element = resolveElement(options.element);
-  if (!element) {
-    return () => {};
-  }
-  const eventName = options.eventName ?? DEFAULT_EVENT_NAME;
-  const queryParam = options.sessionQueryParam ?? DEFAULT_QUERY_PARAM;
-  const sync = () => {
-    const htmxWindow = window;
-    const nextRoute = buildRoute(element, options.route, queryParam, stream.sessionId);
-    if (nextRoute) {
-      element.setAttribute("hx-get", nextRoute);
-    }
-    htmxWindow.htmx?.process?.(element);
-    htmxWindow.htmx?.trigger?.(element, eventName);
+var createVoiceCampaignDialerProofStore = (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
   };
-  const unsubscribe = stream.subscribe(sync);
-  sync();
-  return () => {
-    unsubscribe();
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
   };
-};
-
-// src/client/microphone.ts
-var clampSample = (value) => Math.max(-1, Math.min(1, value));
-var floatTo16BitPCM = (input) => {
-  const output = new Int16Array(input.length);
-  for (let index = 0;index < input.length; index += 1) {
-    const sample = clampSample(input[index] ?? 0);
-    output[index] = sample < 0 ? sample * 32768 : sample * 32767;
-  }
-  return new Uint8Array(output.buffer);
-};
-var getPcmLevel = (audio) => {
-  const bytes = audio instanceof Uint8Array ? audio : new Uint8Array(audio);
-  if (bytes.byteLength < 2) {
-    return 0;
-  }
-  const samples = new Int16Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 2));
-  if (samples.length === 0) {
-    return 0;
-  }
-  let sumSquares = 0;
-  for (const sample of samples) {
-    const normalized = sample / 32768;
-    sumSquares += normalized * normalized;
-  }
-  return Math.min(1, Math.max(0, Math.sqrt(sumSquares / samples.length) * 5.5));
-};
-var downsampleBuffer = (input, sourceRate, targetRate) => {
-  if (sourceRate === targetRate) {
-    return input;
-  }
-  const ratio = sourceRate / targetRate;
-  const length = Math.round(input.length / ratio);
-  const output = new Float32Array(length);
-  let offsetResult = 0;
-  let offsetBuffer = 0;
-  while (offsetResult < output.length) {
-    const nextOffsetBuffer = Math.round((offsetResult + 1) * ratio);
-    let accum = 0;
-    let count = 0;
-    for (let index = offsetBuffer;index < nextOffsetBuffer && index < input.length; index += 1) {
-      accum += input[index] ?? 0;
-      count += 1;
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.status;
     }
-    output[offsetResult] = count > 0 ? accum / count : 0;
-    offsetResult += 1;
-    offsetBuffer = nextOffsetBuffer;
-  }
-  return output;
-};
-var createMicrophoneCapture = (options) => {
-  let audioContext = null;
-  let sourceNode = null;
-  let processorNode = null;
-  let mediaStream = null;
-  const start = async () => {
-    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
-      throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const status = await fetchVoiceCampaignDialerProofStatus(path, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        status,
+        updatedAt: Date.now()
+      };
+      emit();
+      return status;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
     }
-    const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
-    if (!AudioContextCtor) {
-      throw new Error("Browser microphone capture requires AudioContext support.");
+  };
+  const runProof = async () => {
+    const runPath = options.runPath ?? snapshot.status?.runPath ?? path;
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await runVoiceCampaignDialerProofAction(runPath, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        report,
+        status: {
+          generatedAt: Date.now(),
+          mode: report.mode,
+          ok: report.ok,
+          providers: report.providers.map((provider) => provider.provider),
+          runPath,
+          safe: true
+        },
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
     }
-    mediaStream = await navigator.mediaDevices.getUserMedia({
-      audio: {
-        channelCount: options.channelCount ?? 1
-      }
-    });
-    audioContext = new AudioContextCtor;
-    sourceNode = audioContext.createMediaStreamSource(mediaStream);
-    processorNode = audioContext.createScriptProcessor(4096, 1, 1);
-    processorNode.onaudioprocess = (event) => {
-      const channel = event.inputBuffer.getChannelData(0);
-      const downsampled = downsampleBuffer(channel, audioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
-      const pcm = floatTo16BitPCM(downsampled);
-      options.onLevel?.(getPcmLevel(pcm));
-      options.onAudio(pcm);
-    };
-    sourceNode.connect(processorNode);
-    processorNode.connect(audioContext.destination);
   };
-  const stop = () => {
-    processorNode?.disconnect();
-    sourceNode?.disconnect();
-    mediaStream?.getTracks().forEach((track) => track.stop());
-    audioContext?.close();
-    options.onLevel?.(0);
-    audioContext = null;
-    mediaStream = null;
-    processorNode = null;
-    sourceNode = null;
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
   };
-  return { start, stop };
-};
-
-// src/audioConditioning.ts
-var DEFAULT_TARGET_LEVEL = 0.08;
-var DEFAULT_MAX_GAIN = 3;
-var DEFAULT_NOISE_GATE_THRESHOLD = 0.006;
-var DEFAULT_NOISE_GATE_ATTENUATION = 0.15;
-var toInt16Array = (audio) => {
-  if (audio instanceof ArrayBuffer) {
-    return new Int16Array(audio, 0, Math.floor(audio.byteLength / 2));
-  }
-  return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
-};
-var computeRms = (samples) => {
-  if (samples.length === 0) {
-    return 0;
-  }
-  let sumSquares = 0;
-  for (const sample of samples) {
-    const normalized = sample / 32768;
-    sumSquares += normalized * normalized;
-  }
-  return Math.sqrt(sumSquares / samples.length);
-};
-var resolveAudioConditioningConfig = (config) => {
-  if (!config || config.enabled === false) {
-    return;
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
   }
   return {
-    enabled: true,
-    maxGain: config.maxGain ?? DEFAULT_MAX_GAIN,
-    noiseGateAttenuation: config.noiseGateAttenuation ?? DEFAULT_NOISE_GATE_ATTENUATION,
-    noiseGateThreshold: config.noiseGateThreshold ?? DEFAULT_NOISE_GATE_THRESHOLD,
-    targetLevel: config.targetLevel ?? DEFAULT_TARGET_LEVEL
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    runProof,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
   };
 };
-var conditionAudioChunk = (audio, config) => {
-  if (!config) {
-    return audio;
+
+// src/angular/voice-campaign-dialer-proof.service.ts
+var _dec = [
+  Injectable4({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceCampaignDialerProofService {
+  connect(path = "/api/voice/campaigns/dialer-proof", options = {}) {
+    const store = createVoiceCampaignDialerProofStore(path, options);
+    const errorSignal = signal4(null);
+    const isLoadingSignal = signal4(false);
+    const reportSignal = signal4(undefined);
+    const statusSignal = signal4(undefined);
+    const updatedAtSignal = signal4(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      statusSignal.set(snapshot.status);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed4(() => errorSignal()),
+      isLoading: computed4(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed4(() => reportSignal()),
+      runProof: store.runProof,
+      status: computed4(() => statusSignal()),
+      updatedAt: computed4(() => updatedAtSignal())
+    };
   }
-  const source = toInt16Array(audio);
-  if (source.length === 0) {
-    return audio;
+}
+VoiceCampaignDialerProofService = __decorateElement(_init, 0, "VoiceCampaignDialerProofService", _dec, VoiceCampaignDialerProofService);
+__runInitializers(_init, 1, VoiceCampaignDialerProofService);
+__decoratorMetadata(_init, VoiceCampaignDialerProofService);
+let _VoiceCampaignDialerProofService = VoiceCampaignDialerProofService;
+// src/angular/voice-stream.service.ts
+import { computed as computed5, Injectable as Injectable5, signal as signal5 } from "@angular/core";
+
+// src/client/actions.ts
+var normalizeErrorMessage = (value) => {
+  if (typeof value === "string" && value.trim()) {
+    return value;
   }
-  const rms = computeRms(source);
-  const output = new Int16Array(source.length);
-  const gateFactor = rms < config.noiseGateThreshold ? config.noiseGateAttenuation : 1;
-  const baseLevel = Math.max(rms * gateFactor, 0.000001);
-  const gain = Math.min(config.maxGain, config.targetLevel / baseLevel);
-  const appliedGain = Math.max(0.25, gain) * gateFactor;
-  for (let index = 0;index < source.length; index += 1) {
-    const next = Math.round(source[index] * appliedGain);
-    output[index] = Math.max(-32768, Math.min(32767, next));
+  if (value instanceof Error && value.message.trim()) {
+    return value.message;
   }
-  return new Uint8Array(output.buffer);
-};
-
-// src/turnProfiles.ts
-var TURN_PROFILE_DEFAULTS = {
-  balanced: {
-    qualityProfile: "general",
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const key of ["message", "reason", "description"]) {
+      const candidate = record[key];
+      if (typeof candidate === "string" && candidate.trim()) {
+        return candidate;
+      }
+    }
+    if ("error" in record) {
+      return normalizeErrorMessage(record.error);
+    }
+    if ("cause" in record) {
+      return normalizeErrorMessage(record.cause);
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {}
+  }
+  return "Unexpected error";
+};
+var serverMessageToAction = (message) => {
+  switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
+    case "assistant":
+      return {
+        text: message.text,
+        type: "assistant"
+      };
+    case "complete":
+      return {
+        sessionId: message.sessionId,
+        type: "complete"
+      };
+    case "connection":
+      return {
+        reconnect: message.reconnect,
+        type: "connection"
+      };
+    case "call_lifecycle":
+      return {
+        event: message.event,
+        sessionId: message.sessionId,
+        type: "call_lifecycle"
+      };
+    case "error":
+      return {
+        message: normalizeErrorMessage(message.message),
+        type: "error"
+      };
+    case "final":
+      return {
+        transcript: message.transcript,
+        type: "final"
+      };
+    case "partial":
+      return {
+        transcript: message.transcript,
+        type: "partial"
+      };
+    case "replay":
+      return {
+        assistantTexts: message.assistantTexts,
+        call: message.call,
+        partial: message.partial,
+        scenarioId: message.scenarioId,
+        sessionId: message.sessionId,
+        status: message.status,
+        turns: message.turns,
+        type: "replay"
+      };
+    case "session":
+      return {
+        sessionId: message.sessionId,
+        scenarioId: message.scenarioId,
+        status: message.status,
+        type: "session"
+      };
+    case "turn":
+      return {
+        turn: message.turn,
+        type: "turn"
+      };
+    default:
+      return null;
+  }
+};
+
+// src/client/connection.ts
+var WS_OPEN = 1;
+var WS_CLOSED = 3;
+var WS_NORMAL_CLOSURE = 1000;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_PING_INTERVAL = 30000;
+var RECONNECT_DELAY_MS = 500;
+var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
+var noop = () => {};
+var noopUnsubscribe = () => noop;
+var NOOP_CONNECTION = {
+  callControl: noop,
+  close: noop,
+  endTurn: noop,
+  getReadyState: () => WS_CLOSED,
+  getScenarioId: () => "",
+  getSessionId: () => "",
+  send: noop,
+  sendAudio: noop,
+  start: () => {},
+  subscribe: noopUnsubscribe
+};
+var createSessionId = () => crypto.randomUUID();
+var buildWsUrl = (path, sessionId, scenarioId) => {
+  const { hostname, port, protocol } = window.location;
+  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+  const portSuffix = port ? `:${port}` : "";
+  const url = new URL(`${wsProtocol}//${hostname}${portSuffix}${path}`);
+  url.searchParams.set("sessionId", sessionId);
+  if (scenarioId) {
+    url.searchParams.set(DEFAULT_SCENARIO_QUERY_PARAM, scenarioId);
+  }
+  return url.toString();
+};
+var isVoiceServerMessage = (value) => {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  switch (value.type) {
+    case "audio":
+    case "assistant":
+    case "call_lifecycle":
+    case "complete":
+    case "connection":
+    case "error":
+    case "final":
+    case "partial":
+    case "pong":
+    case "replay":
+    case "session":
+    case "turn":
+      return true;
+    default:
+      return false;
+  }
+};
+var parseServerMessage = (event) => {
+  if (typeof event.data !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(event.data);
+    return isVoiceServerMessage(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var createVoiceConnection = (path, options = {}) => {
+  if (typeof window === "undefined") {
+    return NOOP_CONNECTION;
+  }
+  const listeners = new Set;
+  const shouldReconnect = options.reconnect !== false;
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const state = {
+    isConnected: false,
+    pendingMessages: [],
+    scenarioId: options.scenarioId ?? null,
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    sessionId: options.sessionId ?? createSessionId(),
+    ws: null
+  };
+  const emitConnection = (reconnect) => {
+    listeners.forEach((listener) => listener(reconnect));
+  };
+  const clearTimers = () => {
+    if (state.pingInterval) {
+      clearInterval(state.pingInterval);
+      state.pingInterval = null;
+    }
+    if (state.reconnectTimeout) {
+      clearTimeout(state.reconnectTimeout);
+      state.reconnectTimeout = null;
+    }
+  };
+  const flushPendingMessages = () => {
+    if (state.ws?.readyState !== WS_OPEN) {
+      return;
+    }
+    while (state.pendingMessages.length > 0) {
+      const next = state.pendingMessages.shift();
+      if (next !== undefined) {
+        state.ws.send(next);
+      }
+    }
+  };
+  const scheduleReconnect = () => {
+    const nextAttemptAt = Date.now() + RECONNECT_DELAY_MS;
+    state.reconnectAttempts += 1;
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        lastDisconnectAt: Date.now(),
+        maxAttempts: maxReconnectAttempts,
+        nextAttemptAt,
+        status: "reconnecting"
+      },
+      type: "connection"
+    });
+    state.reconnectTimeout = setTimeout(() => {
+      if (state.reconnectAttempts > maxReconnectAttempts) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
+        return;
+      }
+      connect();
+    }, RECONNECT_DELAY_MS);
+  };
+  const connect = () => {
+    const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      const wasReconnecting = state.reconnectAttempts > 0;
+      state.isConnected = true;
+      flushPendingMessages();
+      if (wasReconnecting) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastResumedAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "resumed"
+          },
+          type: "connection"
+        });
+        state.reconnectAttempts = 0;
+      }
+      listeners.forEach((listener) => listener({
+        scenarioId: state.scenarioId ?? undefined,
+        sessionId: state.sessionId,
+        status: "active",
+        type: "session"
+      }));
+      state.pingInterval = setInterval(() => {
+        if (ws.readyState === WS_OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    };
+    ws.onmessage = (event) => {
+      const parsed = parseServerMessage(event);
+      if (!parsed) {
+        return;
+      }
+      if (parsed.type === "session") {
+        state.sessionId = parsed.sessionId;
+        state.scenarioId = parsed.scenarioId ?? state.scenarioId;
+      }
+      listeners.forEach((listener) => listener(parsed));
+    };
+    ws.onclose = (event) => {
+      state.isConnected = false;
+      clearTimers();
+      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
+      if (reconnectable) {
+        scheduleReconnect();
+      } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastDisconnectAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
+      }
+    };
+    state.ws = ws;
+  };
+  const sendSerialized = (value) => {
+    if (state.ws?.readyState === WS_OPEN) {
+      state.ws.send(value);
+      return;
+    }
+    state.pendingMessages.push(value);
+  };
+  const send = (message) => {
+    sendSerialized(JSON.stringify(message));
+  };
+  const start = (input = {}) => {
+    if (input.sessionId) {
+      state.sessionId = input.sessionId;
+    }
+    if (input.scenarioId) {
+      state.scenarioId = input.scenarioId;
+    }
+    send({
+      type: "start",
+      sessionId: state.sessionId,
+      scenarioId: state.scenarioId ?? undefined
+    });
+  };
+  const sendAudio = (audio) => {
+    sendSerialized(audio);
+  };
+  const endTurn = () => {
+    send({ type: "end_turn" });
+  };
+  const callControl = (message) => {
+    send({
+      ...message,
+      type: "call_control"
+    });
+  };
+  const close = () => {
+    clearTimers();
+    if (state.ws) {
+      state.ws.close(WS_NORMAL_CLOSURE);
+      state.ws = null;
+    }
+    state.isConnected = false;
+    listeners.clear();
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  connect();
+  return {
+    callControl,
+    close,
+    endTurn,
+    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
+    getScenarioId: () => state.scenarioId ?? "",
+    getSessionId: () => state.sessionId,
+    send,
+    sendAudio,
+    start,
+    subscribe
+  };
+};
+
+// src/client/store.ts
+var createInitialReconnectState = () => ({
+  attempts: 0,
+  maxAttempts: 0,
+  status: "idle"
+});
+var createInitialState = () => ({
+  assistantAudio: [],
+  assistantTexts: [],
+  call: null,
+  error: null,
+  isConnected: false,
+  scenarioId: null,
+  partial: "",
+  reconnect: createInitialReconnectState(),
+  sessionId: null,
+  status: "idle",
+  turns: []
+});
+var createVoiceStreamStore = () => {
+  let state = createInitialState();
+  const subscribers = new Set;
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const dispatch = (action) => {
+    switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
+      case "assistant":
+        state = {
+          ...state,
+          assistantTexts: [...state.assistantTexts, action.text]
+        };
+        break;
+      case "complete":
+        state = {
+          ...state,
+          sessionId: action.sessionId,
+          status: "completed"
+        };
+        break;
+      case "call_lifecycle":
+        state = {
+          ...state,
+          call: {
+            ...state.call,
+            disposition: action.event.type === "end" ? action.event.disposition : state.call?.disposition,
+            endedAt: action.event.type === "end" ? action.event.at : state.call?.endedAt,
+            events: [...state.call?.events ?? [], action.event],
+            lastEventAt: action.event.at,
+            startedAt: state.call?.startedAt ?? action.event.at
+          },
+          sessionId: action.sessionId
+        };
+        break;
+      case "connected":
+        state = {
+          ...state,
+          isConnected: true,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect
+        };
+        break;
+      case "connection":
+        state = {
+          ...state,
+          reconnect: action.reconnect
+        };
+        break;
+      case "disconnected":
+        state = {
+          ...state,
+          isConnected: false
+        };
+        break;
+      case "error":
+        state = {
+          ...state,
+          error: action.message
+        };
+        break;
+      case "final":
+        state = {
+          ...state,
+          partial: action.transcript.text,
+          turns: state.turns.map((turn) => turn)
+        };
+        break;
+      case "partial":
+        state = {
+          ...state,
+          partial: action.transcript.text
+        };
+        break;
+      case "replay":
+        state = {
+          ...state,
+          assistantTexts: [...action.assistantTexts],
+          call: action.call ?? null,
+          error: null,
+          isConnected: action.status === "active",
+          partial: action.partial,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          sessionId: action.sessionId,
+          status: action.status,
+          turns: [...action.turns]
+        };
+        break;
+      case "session":
+        state = {
+          ...state,
+          error: null,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          isConnected: action.status === "active",
+          sessionId: action.sessionId,
+          status: action.status
+        };
+        break;
+      case "turn":
+        state = {
+          ...state,
+          partial: "",
+          turns: [...state.turns, action.turn]
+        };
+        break;
+    }
+    notify();
+  };
+  return {
+    dispatch,
+    getServerSnapshot: () => state,
+    getSnapshot: () => state,
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/client/createVoiceStream.ts
+var createVoiceStream = (path, options = {}) => {
+  const connection = createVoiceConnection(path, options);
+  const store = createVoiceStreamStore();
+  const subscribers = new Set;
+  const start = (input) => Promise.resolve().then(() => {
+    if (!input?.sessionId && !input?.scenarioId) {
+      return;
+    }
+    connection.start(input);
+  });
+  const notify = () => {
+    subscribers.forEach((subscriber) => subscriber());
+  };
+  const reportReconnect = () => {
+    if (!options.reconnectReportPath || typeof fetch === "undefined") {
+      return;
+    }
+    const snapshot = store.getSnapshot();
+    const body = JSON.stringify({
+      at: Date.now(),
+      reconnect: snapshot.reconnect,
+      scenarioId: snapshot.scenarioId,
+      sessionId: connection.getSessionId(),
+      turnIds: snapshot.turns.map((turn) => turn.id)
+    });
+    fetch(options.reconnectReportPath, {
+      body,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      keepalive: true,
+      method: "POST"
+    }).catch(() => {});
+  };
+  const unsubscribeConnection = connection.subscribe((message) => {
+    const action = serverMessageToAction(message);
+    if (action) {
+      store.dispatch(action);
+      if (message.type === "connection") {
+        reportReconnect();
+      }
+      notify();
+    }
+  });
+  return {
+    callControl(message) {
+      connection.callControl(message);
+    },
+    close() {
+      unsubscribeConnection();
+      connection.close();
+      store.dispatch({ type: "disconnected" });
+      notify();
+    },
+    endTurn() {
+      connection.endTurn();
+    },
+    get error() {
+      return store.getSnapshot().error;
+    },
+    getServerSnapshot() {
+      return store.getServerSnapshot();
+    },
+    getSnapshot() {
+      return store.getSnapshot();
+    },
+    get isConnected() {
+      return store.getSnapshot().isConnected;
+    },
+    get scenarioId() {
+      return store.getSnapshot().scenarioId;
+    },
+    start,
+    get partial() {
+      return store.getSnapshot().partial;
+    },
+    get reconnect() {
+      return store.getSnapshot().reconnect;
+    },
+    get sessionId() {
+      return connection.getSessionId();
+    },
+    get status() {
+      return store.getSnapshot().status;
+    },
+    get turns() {
+      return store.getSnapshot().turns;
+    },
+    get assistantTexts() {
+      return store.getSnapshot().assistantTexts;
+    },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
+    get call() {
+      return store.getSnapshot().call;
+    },
+    sendAudio(audio) {
+      connection.sendAudio(audio);
+    },
+    subscribe(subscriber) {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/angular/voice-stream.service.ts
+var _dec = [
+  Injectable5({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceStreamService {
+  connect(path, options = {}) {
+    const stream = createVoiceStream(path, options);
+    const assistantAudioSignal = signal5([]);
+    const assistantTextsSignal = signal5([]);
+    const callSignal = signal5(null);
+    const errorSignal = signal5(null);
+    const isConnectedSignal = signal5(false);
+    const partialSignal = signal5("");
+    const reconnectSignal = signal5(stream.reconnect);
+    const sessionIdSignal = signal5(stream.sessionId);
+    const statusSignal = signal5(stream.status);
+    const turnsSignal = signal5([]);
+    const sync = () => {
+      assistantAudioSignal.set([...stream.assistantAudio]);
+      assistantTextsSignal.set([...stream.assistantTexts]);
+      callSignal.set(stream.call);
+      errorSignal.set(stream.error);
+      isConnectedSignal.set(stream.isConnected);
+      partialSignal.set(stream.partial);
+      reconnectSignal.set(stream.reconnect);
+      sessionIdSignal.set(stream.sessionId);
+      statusSignal.set(stream.status);
+      turnsSignal.set([...stream.turns]);
+    };
+    const unsubscribe = stream.subscribe(sync);
+    sync();
+    return {
+      assistantAudio: computed5(() => assistantAudioSignal()),
+      assistantTexts: computed5(() => assistantTextsSignal()),
+      call: computed5(() => callSignal()),
+      callControl: (message) => stream.callControl(message),
+      close: () => {
+        unsubscribe();
+        stream.close();
+      },
+      endTurn: () => stream.endTurn(),
+      error: computed5(() => errorSignal()),
+      isConnected: computed5(() => isConnectedSignal()),
+      partial: computed5(() => partialSignal()),
+      reconnect: computed5(() => reconnectSignal()),
+      sendAudio: (audio) => stream.sendAudio(audio),
+      sessionId: computed5(() => sessionIdSignal()),
+      status: computed5(() => statusSignal()),
+      turns: computed5(() => turnsSignal())
+    };
+  }
+}
+VoiceStreamService = __decorateElement(_init, 0, "VoiceStreamService", _dec, VoiceStreamService);
+__runInitializers(_init, 1, VoiceStreamService);
+__decoratorMetadata(_init, VoiceStreamService);
+let _VoiceStreamService = VoiceStreamService;
+// src/angular/voice-controller.service.ts
+import { computed as computed6, Injectable as Injectable6, signal as signal6 } from "@angular/core";
+
+// src/client/htmx.ts
+var DEFAULT_EVENT_NAME = "voice-refresh";
+var DEFAULT_QUERY_PARAM = "sessionId";
+var resolveElement = (input) => {
+  if (typeof input !== "string") {
+    return input;
+  }
+  return document.querySelector(input);
+};
+var buildRoute = (element, route, queryParam, sessionId) => {
+  const baseRoute = route ?? element.getAttribute("hx-get") ?? "";
+  if (!baseRoute) {
+    return "";
+  }
+  const url = new URL(baseRoute, window.location.origin);
+  if (sessionId) {
+    url.searchParams.set(queryParam, sessionId);
+  } else {
+    url.searchParams.delete(queryParam);
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+};
+var bindVoiceHTMX = (stream, options) => {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {};
+  }
+  const element = resolveElement(options.element);
+  if (!element) {
+    return () => {};
+  }
+  const eventName = options.eventName ?? DEFAULT_EVENT_NAME;
+  const queryParam = options.sessionQueryParam ?? DEFAULT_QUERY_PARAM;
+  const sync = () => {
+    const htmxWindow = window;
+    const nextRoute = buildRoute(element, options.route, queryParam, stream.sessionId);
+    if (nextRoute) {
+      element.setAttribute("hx-get", nextRoute);
+    }
+    htmxWindow.htmx?.process?.(element);
+    htmxWindow.htmx?.trigger?.(element, eventName);
+  };
+  const unsubscribe = stream.subscribe(sync);
+  sync();
+  return () => {
+    unsubscribe();
+  };
+};
+
+// src/client/microphone.ts
+var clampSample = (value) => Math.max(-1, Math.min(1, value));
+var floatTo16BitPCM = (input) => {
+  const output = new Int16Array(input.length);
+  for (let index = 0;index < input.length; index += 1) {
+    const sample = clampSample(input[index] ?? 0);
+    output[index] = sample < 0 ? sample * 32768 : sample * 32767;
+  }
+  return new Uint8Array(output.buffer);
+};
+var getPcmLevel = (audio) => {
+  const bytes = audio instanceof Uint8Array ? audio : new Uint8Array(audio);
+  if (bytes.byteLength < 2) {
+    return 0;
+  }
+  const samples = new Int16Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 2));
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sumSquares = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sumSquares += normalized * normalized;
+  }
+  return Math.min(1, Math.max(0, Math.sqrt(sumSquares / samples.length) * 5.5));
+};
+var downsampleBuffer = (input, sourceRate, targetRate) => {
+  if (sourceRate === targetRate) {
+    return input;
+  }
+  const ratio = sourceRate / targetRate;
+  const length = Math.round(input.length / ratio);
+  const output = new Float32Array(length);
+  let offsetResult = 0;
+  let offsetBuffer = 0;
+  while (offsetResult < output.length) {
+    const nextOffsetBuffer = Math.round((offsetResult + 1) * ratio);
+    let accum = 0;
+    let count = 0;
+    for (let index = offsetBuffer;index < nextOffsetBuffer && index < input.length; index += 1) {
+      accum += input[index] ?? 0;
+      count += 1;
+    }
+    output[offsetResult] = count > 0 ? accum / count : 0;
+    offsetResult += 1;
+    offsetBuffer = nextOffsetBuffer;
+  }
+  return output;
+};
+var createMicrophoneCapture = (options) => {
+  let audioContext = null;
+  let sourceNode = null;
+  let processorNode = null;
+  let mediaStream = null;
+  const start = async () => {
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+      throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
+    }
+    const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
+    if (!AudioContextCtor) {
+      throw new Error("Browser microphone capture requires AudioContext support.");
+    }
+    mediaStream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        channelCount: options.channelCount ?? 1
+      }
+    });
+    audioContext = new AudioContextCtor;
+    sourceNode = audioContext.createMediaStreamSource(mediaStream);
+    processorNode = audioContext.createScriptProcessor(4096, 1, 1);
+    processorNode.onaudioprocess = (event) => {
+      const channel = event.inputBuffer.getChannelData(0);
+      const downsampled = downsampleBuffer(channel, audioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
+      const pcm = floatTo16BitPCM(downsampled);
+      options.onLevel?.(getPcmLevel(pcm));
+      options.onAudio(pcm);
+    };
+    sourceNode.connect(processorNode);
+    processorNode.connect(audioContext.destination);
+  };
+  const stop = () => {
+    processorNode?.disconnect();
+    sourceNode?.disconnect();
+    mediaStream?.getTracks().forEach((track) => track.stop());
+    audioContext?.close();
+    options.onLevel?.(0);
+    audioContext = null;
+    mediaStream = null;
+    processorNode = null;
+    sourceNode = null;
+  };
+  return { start, stop };
+};
+
+// src/audioConditioning.ts
+var DEFAULT_TARGET_LEVEL = 0.08;
+var DEFAULT_MAX_GAIN = 3;
+var DEFAULT_NOISE_GATE_THRESHOLD = 0.006;
+var DEFAULT_NOISE_GATE_ATTENUATION = 0.15;
+var toInt16Array = (audio) => {
+  if (audio instanceof ArrayBuffer) {
+    return new Int16Array(audio, 0, Math.floor(audio.byteLength / 2));
+  }
+  return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
+};
+var computeRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sumSquares = 0;
+  for (const sample of samples) {
+    const normalized = sample / 32768;
+    sumSquares += normalized * normalized;
+  }
+  return Math.sqrt(sumSquares / samples.length);
+};
+var resolveAudioConditioningConfig = (config) => {
+  if (!config || config.enabled === false) {
+    return;
+  }
+  return {
+    enabled: true,
+    maxGain: config.maxGain ?? DEFAULT_MAX_GAIN,
+    noiseGateAttenuation: config.noiseGateAttenuation ?? DEFAULT_NOISE_GATE_ATTENUATION,
+    noiseGateThreshold: config.noiseGateThreshold ?? DEFAULT_NOISE_GATE_THRESHOLD,
+    targetLevel: config.targetLevel ?? DEFAULT_TARGET_LEVEL
+  };
+};
+var conditionAudioChunk = (audio, config) => {
+  if (!config) {
+    return audio;
+  }
+  const source = toInt16Array(audio);
+  if (source.length === 0) {
+    return audio;
+  }
+  const rms = computeRms(source);
+  const output = new Int16Array(source.length);
+  const gateFactor = rms < config.noiseGateThreshold ? config.noiseGateAttenuation : 1;
+  const baseLevel = Math.max(rms * gateFactor, 0.000001);
+  const gain = Math.min(config.maxGain, config.targetLevel / baseLevel);
+  const appliedGain = Math.max(0.25, gain) * gateFactor;
+  for (let index = 0;index < source.length; index += 1) {
+    const next = Math.round(source[index] * appliedGain);
+    output[index] = Math.max(-32768, Math.min(32767, next));
+  }
+  return new Uint8Array(output.buffer);
+};
+
+// src/turnProfiles.ts
+var TURN_PROFILE_DEFAULTS = {
+  balanced: {
+    qualityProfile: "general",
     silenceMs: 1400,
     speechThreshold: 0.012,
     transcriptStabilityMs: 1000
@@ -814,500 +1700,1279 @@ var TURN_PROFILE_DEFAULTS = {
     speechThreshold: 0.015,
     transcriptStabilityMs: 450
   },
-  "long-form": {
-    qualityProfile: "general",
-    silenceMs: 2200,
-    speechThreshold: 0.01,
-    transcriptStabilityMs: 1500
+  "long-form": {
+    qualityProfile: "general",
+    silenceMs: 2200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1500
+  }
+};
+var QUALITY_PROFILE_DEFAULTS = {
+  general: {},
+  "accent-heavy": {
+    silenceMs: 1200,
+    speechThreshold: 0.01,
+    transcriptStabilityMs: 1200
+  },
+  "noisy-room": {
+    silenceMs: 2000,
+    speechThreshold: 0.02,
+    transcriptStabilityMs: 1600
+  },
+  "short-command": {
+    silenceMs: 500,
+    speechThreshold: 0.016,
+    transcriptStabilityMs: 420
+  }
+};
+var DEFAULT_TURN_PROFILE = "fast";
+var DEFAULT_QUALITY_PROFILE = "general";
+var resolveTurnDetectionConfig = (config) => {
+  const profile = config?.profile ?? DEFAULT_TURN_PROFILE;
+  const qualityProfile = config?.qualityProfile ?? DEFAULT_QUALITY_PROFILE;
+  const preset = TURN_PROFILE_DEFAULTS[profile];
+  const quality = QUALITY_PROFILE_DEFAULTS[qualityProfile];
+  return {
+    profile,
+    qualityProfile,
+    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
+    speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
+    transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
+  };
+};
+
+// src/presets.ts
+var PRESET_INPUTS = {
+  chat: {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.5,
+      noiseGateAttenuation: 0,
+      noiseGateThreshold: 0.004,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 10,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "short-command",
+      profile: "balanced"
+    }
+  },
+  default: {
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 10,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "general",
+      profile: "fast"
+    }
+  },
+  dictation: {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.25,
+      noiseGateAttenuation: 0.05,
+      noiseGateThreshold: 0.003,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 12,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "accent-heavy",
+      profile: "long-form"
+    }
+  },
+  "guided-intake": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.5,
+      noiseGateAttenuation: 0,
+      noiseGateThreshold: 0.004,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 12,
+      pingInterval: 30000,
+      reconnect: true
+    },
+    sttLifecycle: "turn-scoped",
+    turnDetection: {
+      qualityProfile: "accent-heavy",
+      profile: "long-form"
+    }
+  },
+  "noisy-room": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 3,
+      noiseGateAttenuation: 0.12,
+      noiseGateThreshold: 0.006,
+      targetLevel: 0.085
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 2100,
+      speechThreshold: 0.02,
+      transcriptStabilityMs: 1650
+    }
+  },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
+  reliability: {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.9,
+      noiseGateAttenuation: 0.08,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form"
+    }
+  }
+};
+var resolveVoiceRuntimePreset = (name = "default") => {
+  const preset = PRESET_INPUTS[name];
+  return {
+    audioConditioning: resolveAudioConditioningConfig(preset.audioConditioning),
+    capture: {
+      channelCount: preset.capture?.channelCount ?? 1,
+      sampleRateHz: preset.capture?.sampleRateHz ?? 16000
+    },
+    connection: {
+      ...preset.connection
+    },
+    name,
+    sttLifecycle: preset.sttLifecycle ?? "continuous",
+    turnDetection: resolveTurnDetectionConfig(preset.turnDetection)
+  };
+};
+
+// src/client/controller.ts
+var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
+  assistantTexts: [...stream.assistantTexts],
+  call: stream.call,
+  error: stream.error,
+  isConnected: stream.isConnected,
+  isRecording: false,
+  partial: stream.partial,
+  reconnect: stream.reconnect,
+  recordingError: null,
+  sessionId: stream.sessionId,
+  scenarioId: stream.scenarioId,
+  status: stream.status,
+  turns: [...stream.turns]
+});
+var createVoiceController = (path, options = {}) => {
+  const preset = resolveVoiceRuntimePreset(options.preset);
+  const stream = createVoiceStream(path, {
+    ...preset.connection,
+    ...options.connection
+  });
+  let capture = null;
+  let state = createInitialState2(stream);
+  const subscribers = new Set;
+  const notify = () => {
+    for (const subscriber of subscribers) {
+      subscriber();
+    }
+  };
+  const sync = () => {
+    state = {
+      ...state,
+      assistantAudio: [...stream.assistantAudio],
+      assistantTexts: [...stream.assistantTexts],
+      call: stream.call,
+      error: stream.error,
+      isConnected: stream.isConnected,
+      partial: stream.partial,
+      reconnect: stream.reconnect,
+      sessionId: stream.sessionId,
+      scenarioId: stream.scenarioId,
+      status: stream.status,
+      turns: [...stream.turns]
+    };
+    if (options.autoStopOnComplete !== false && state.status === "completed" && state.isRecording) {
+      capture?.stop();
+      capture = null;
+      state = {
+        ...state,
+        isRecording: false
+      };
+    }
+    notify();
+  };
+  const unsubscribeStream = stream.subscribe(sync);
+  sync();
+  const ensureCapture = () => {
+    if (capture) {
+      return capture;
+    }
+    capture = createMicrophoneCapture({
+      channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
+      onLevel: options.capture?.onLevel,
+      onAudio: (audio) => {
+        if (options.capture?.onAudio) {
+          options.capture.onAudio(audio, stream.sendAudio);
+          return;
+        }
+        stream.sendAudio(audio);
+      },
+      sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
+    });
+    return capture;
+  };
+  const stopRecording = () => {
+    capture?.stop();
+    capture = null;
+    state = {
+      ...state,
+      isRecording: false
+    };
+    notify();
+  };
+  const startRecording = async () => {
+    if (state.isRecording) {
+      return;
+    }
+    try {
+      state = {
+        ...state,
+        recordingError: null
+      };
+      notify();
+      await ensureCapture().start();
+      state = {
+        ...state,
+        isRecording: true
+      };
+      notify();
+    } catch (error) {
+      capture = null;
+      state = {
+        ...state,
+        isRecording: false,
+        recordingError: error instanceof Error ? error.message : String(error)
+      };
+      notify();
+      throw error;
+    }
+  };
+  const close = () => {
+    unsubscribeStream();
+    stopRecording();
+    stream.close();
+  };
+  return {
+    bindHTMX(bindingOptions) {
+      return bindVoiceHTMX(stream, bindingOptions);
+    },
+    callControl: (message) => stream.callControl(message),
+    close,
+    endTurn: () => stream.endTurn(),
+    get error() {
+      return state.error;
+    },
+    getServerSnapshot: () => state,
+    getSnapshot: () => state,
+    get isConnected() {
+      return state.isConnected;
+    },
+    get isRecording() {
+      return state.isRecording;
+    },
+    get partial() {
+      return state.partial;
+    },
+    get recordingError() {
+      return state.recordingError;
+    },
+    get reconnect() {
+      return state.reconnect;
+    },
+    sendAudio: (audio) => stream.sendAudio(audio),
+    get sessionId() {
+      return state.sessionId;
+    },
+    get scenarioId() {
+      return state.scenarioId;
+    },
+    startRecording,
+    get status() {
+      return state.status;
+    },
+    stopRecording,
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    toggleRecording: async () => {
+      if (state.isRecording) {
+        stopRecording();
+        return;
+      }
+      await startRecording();
+    },
+    get turns() {
+      return state.turns;
+    },
+    get assistantTexts() {
+      return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
+    },
+    get call() {
+      return state.call;
+    }
+  };
+};
+
+// src/angular/voice-controller.service.ts
+var _dec = [
+  Injectable6({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceControllerService {
+  connect(path, options = {}) {
+    const controller = createVoiceController(path, options);
+    const assistantAudioSignal = signal6([]);
+    const assistantTextsSignal = signal6([]);
+    const errorSignal = signal6(null);
+    const isConnectedSignal = signal6(false);
+    const isRecordingSignal = signal6(false);
+    const partialSignal = signal6("");
+    const reconnectSignal = signal6(controller.reconnect);
+    const recordingErrorSignal = signal6(null);
+    const sessionIdSignal = signal6(controller.sessionId);
+    const statusSignal = signal6(controller.status);
+    const turnsSignal = signal6([]);
+    const sync = () => {
+      assistantAudioSignal.set([...controller.assistantAudio]);
+      assistantTextsSignal.set([...controller.assistantTexts]);
+      errorSignal.set(controller.error);
+      isConnectedSignal.set(controller.isConnected);
+      isRecordingSignal.set(controller.isRecording);
+      partialSignal.set(controller.partial);
+      reconnectSignal.set(controller.reconnect);
+      recordingErrorSignal.set(controller.recordingError);
+      sessionIdSignal.set(controller.sessionId);
+      statusSignal.set(controller.status);
+      turnsSignal.set([...controller.turns]);
+    };
+    const unsubscribe = controller.subscribe(sync);
+    sync();
+    return {
+      assistantAudio: computed6(() => assistantAudioSignal()),
+      assistantTexts: computed6(() => assistantTextsSignal()),
+      bindHTMX: controller.bindHTMX,
+      close: () => {
+        unsubscribe();
+        controller.close();
+      },
+      endTurn: () => controller.endTurn(),
+      error: computed6(() => errorSignal()),
+      isConnected: computed6(() => isConnectedSignal()),
+      isRecording: computed6(() => isRecordingSignal()),
+      partial: computed6(() => partialSignal()),
+      reconnect: computed6(() => reconnectSignal()),
+      recordingError: computed6(() => recordingErrorSignal()),
+      sendAudio: (audio) => controller.sendAudio(audio),
+      sessionId: computed6(() => sessionIdSignal()),
+      startRecording: () => controller.startRecording(),
+      status: computed6(() => statusSignal()),
+      stopRecording: () => controller.stopRecording(),
+      toggleRecording: () => controller.toggleRecording(),
+      turns: computed6(() => turnsSignal())
+    };
+  }
+}
+VoiceControllerService = __decorateElement(_init, 0, "VoiceControllerService", _dec, VoiceControllerService);
+__runInitializers(_init, 1, VoiceControllerService);
+__decoratorMetadata(_init, VoiceControllerService);
+let _VoiceControllerService = VoiceControllerService;
+// src/angular/voice-provider-capabilities.service.ts
+import { computed as computed7, Injectable as Injectable7, signal as signal7 } from "@angular/core";
+
+// src/client/providerCapabilities.ts
+var fetchVoiceProviderCapabilities = async (path = "/api/provider-capabilities", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider capabilities failed: HTTP ${response.status}`);
   }
+  return await response.json();
 };
-var QUALITY_PROFILE_DEFAULTS = {
-  general: {},
-  "accent-heavy": {
-    silenceMs: 1200,
-    speechThreshold: 0.01,
-    transcriptStabilityMs: 1200
-  },
-  "noisy-room": {
-    silenceMs: 2000,
-    speechThreshold: 0.02,
-    transcriptStabilityMs: 1600
-  },
-  "short-command": {
-    silenceMs: 500,
-    speechThreshold: 0.016,
-    transcriptStabilityMs: 420
+var createVoiceProviderCapabilitiesStore = (path = "/api/provider-capabilities", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceProviderCapabilities(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
   }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
 };
-var DEFAULT_TURN_PROFILE = "fast";
-var DEFAULT_QUALITY_PROFILE = "general";
-var resolveTurnDetectionConfig = (config) => {
-  const profile = config?.profile ?? DEFAULT_TURN_PROFILE;
-  const qualityProfile = config?.qualityProfile ?? DEFAULT_QUALITY_PROFILE;
-  const preset = TURN_PROFILE_DEFAULTS[profile];
-  const quality = QUALITY_PROFILE_DEFAULTS[qualityProfile];
+
+// src/angular/voice-provider-capabilities.service.ts
+var _dec = [
+  Injectable7({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderCapabilitiesService {
+  connect(path = "/api/provider-capabilities", options = {}) {
+    const store = createVoiceProviderCapabilitiesStore(path, options);
+    const errorSignal = signal7(null);
+    const isLoadingSignal = signal7(false);
+    const reportSignal = signal7(undefined);
+    const updatedAtSignal = signal7(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed7(() => errorSignal()),
+      isLoading: computed7(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed7(() => reportSignal()),
+      updatedAt: computed7(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderCapabilitiesService = __decorateElement(_init, 0, "VoiceProviderCapabilitiesService", _dec, VoiceProviderCapabilitiesService);
+__runInitializers(_init, 1, VoiceProviderCapabilitiesService);
+__decoratorMetadata(_init, VoiceProviderCapabilitiesService);
+let _VoiceProviderCapabilitiesService = VoiceProviderCapabilitiesService;
+// src/angular/voice-provider-status.service.ts
+import { computed as computed8, Injectable as Injectable8, signal as signal8 } from "@angular/core";
+
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
   return {
-    profile,
-    qualityProfile,
-    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
-    speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
-    transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-status.service.ts
+var _dec = [
+  Injectable8({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderStatusService {
+  connect(path = "/api/provider-status", options = {}) {
+    const store = createVoiceProviderStatusStore(path, options);
+    const errorSignal = signal8(null);
+    const isLoadingSignal = signal8(false);
+    const providersSignal = signal8([]);
+    const updatedAtSignal = signal8(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      providersSignal.set([...snapshot.providers]);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed8(() => errorSignal()),
+      isLoading: computed8(() => isLoadingSignal()),
+      providers: computed8(() => providersSignal()),
+      refresh: store.refresh,
+      updatedAt: computed8(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderStatusService = __decorateElement(_init, 0, "VoiceProviderStatusService", _dec, VoiceProviderStatusService);
+__runInitializers(_init, 1, VoiceProviderStatusService);
+__decoratorMetadata(_init, VoiceProviderStatusService);
+let _VoiceProviderStatusService = VoiceProviderStatusService;
+// src/angular/voice-routing-status.service.ts
+import { Injectable as Injectable9, signal as signal9 } from "@angular/core";
+
+// src/client/routingStatus.ts
+var fetchVoiceRoutingStatus = async (path = "/api/routing/latest", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice routing status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceRoutingStatusStore = (path = "/api/routing/latest", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    decision: null,
+    error: null,
+    isLoading: false
   };
-};
-
-// src/presets.ts
-var PRESET_INPUTS = {
-  chat: {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.5,
-      noiseGateAttenuation: 0,
-      noiseGateThreshold: 0.004,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 10,
-      pingInterval: 30000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "short-command",
-      profile: "balanced"
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-  },
-  default: {
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 10,
-      pingInterval: 30000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "general",
-      profile: "fast"
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.decision;
     }
-  },
-  dictation: {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.25,
-      noiseGateAttenuation: 0.05,
-      noiseGateThreshold: 0.003,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 12,
-      pingInterval: 30000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "accent-heavy",
-      profile: "long-form"
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const decision = await fetchVoiceRoutingStatus(path, options);
+      snapshot = {
+        decision,
+        error: null,
+        isLoading: false,
+        updatedAt: Date.now()
+      };
+      emit();
+      return decision;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
     }
-  },
-  "guided-intake": {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.5,
-      noiseGateAttenuation: 0,
-      noiseGateThreshold: 0.004,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 12,
-      pingInterval: 30000,
-      reconnect: true
-    },
-    sttLifecycle: "turn-scoped",
-    turnDetection: {
-      qualityProfile: "accent-heavy",
-      profile: "long-form"
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
     }
-  },
-  "noisy-room": {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 3,
-      noiseGateAttenuation: 0.12,
-      noiseGateThreshold: 0.006,
-      targetLevel: 0.085
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 14,
-      pingInterval: 45000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "noisy-room",
-      profile: "long-form",
-      silenceMs: 2100,
-      speechThreshold: 0.02,
-      transcriptStabilityMs: 1650
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     }
-  },
-  "pstn-balanced": {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.8,
-      noiseGateAttenuation: 0.07,
-      noiseGateThreshold: 0.005,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 14,
-      pingInterval: 45000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "noisy-room",
-      profile: "long-form",
-      silenceMs: 660,
-      speechThreshold: 0.012,
-      transcriptStabilityMs: 300
+  };
+};
+
+// src/angular/voice-routing-status.service.ts
+var _dec = [
+  Injectable9({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceRoutingStatusService {
+  connect(path = "/api/routing/latest", options = {}) {
+    const store = createVoiceRoutingStatusStore(path, options);
+    const decisionSignal = signal9(null);
+    const errorSignal = signal9(null);
+    const isLoadingSignal = signal9(false);
+    const updatedAtSignal = signal9(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      decisionSignal.set(snapshot.decision);
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      decision: decisionSignal.asReadonly(),
+      error: errorSignal.asReadonly(),
+      isLoading: isLoadingSignal.asReadonly(),
+      refresh: store.refresh,
+      updatedAt: updatedAtSignal.asReadonly()
+    };
+  }
+}
+VoiceRoutingStatusService = __decorateElement(_init, 0, "VoiceRoutingStatusService", _dec, VoiceRoutingStatusService);
+__runInitializers(_init, 1, VoiceRoutingStatusService);
+__decoratorMetadata(_init, VoiceRoutingStatusService);
+let _VoiceRoutingStatusService = VoiceRoutingStatusService;
+// src/angular/voice-trace-timeline.service.ts
+import { computed as computed9, Injectable as Injectable10, signal as signal10 } from "@angular/core";
+
+// src/client/traceTimeline.ts
+var fetchVoiceTraceTimeline = async (path = "/api/voice-traces", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice trace timeline failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceTraceTimelineStore = (path = "/api/voice-traces", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    report: null
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-  },
-  "pstn-fast": {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.75,
-      noiseGateAttenuation: 0.06,
-      noiseGateThreshold: 0.005,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 14,
-      pingInterval: 45000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "noisy-room",
-      profile: "long-form",
-      silenceMs: 620,
-      speechThreshold: 0.012,
-      transcriptStabilityMs: 280
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
     }
-  },
-  reliability: {
-    audioConditioning: {
-      enabled: true,
-      maxGain: 2.9,
-      noiseGateAttenuation: 0.08,
-      noiseGateThreshold: 0.005,
-      targetLevel: 0.08
-    },
-    capture: {
-      channelCount: 1,
-      sampleRateHz: 16000
-    },
-    connection: {
-      maxReconnectAttempts: 14,
-      pingInterval: 45000,
-      reconnect: true
-    },
-    sttLifecycle: "continuous",
-    turnDetection: {
-      qualityProfile: "noisy-room",
-      profile: "long-form"
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceTraceTimeline(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
     }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
   }
-};
-var resolveVoiceRuntimePreset = (name = "default") => {
-  const preset = PRESET_INPUTS[name];
   return {
-    audioConditioning: resolveAudioConditioningConfig(preset.audioConditioning),
-    capture: {
-      channelCount: preset.capture?.channelCount ?? 1,
-      sampleRateHz: preset.capture?.sampleRateHz ?? 16000
-    },
-    connection: {
-      ...preset.connection
-    },
-    name,
-    sttLifecycle: preset.sttLifecycle ?? "continuous",
-    turnDetection: resolveTurnDetectionConfig(preset.turnDetection)
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
   };
 };
 
-// src/client/controller.ts
-var createInitialState2 = (stream) => ({
-  assistantAudio: [...stream.assistantAudio],
-  assistantTexts: [...stream.assistantTexts],
-  error: stream.error,
-  isConnected: stream.isConnected,
-  isRecording: false,
-  partial: stream.partial,
-  recordingError: null,
-  sessionId: stream.sessionId,
-  scenarioId: stream.scenarioId,
-  status: stream.status,
-  turns: [...stream.turns]
-});
-var createVoiceController = (path, options = {}) => {
-  const preset = resolveVoiceRuntimePreset(options.preset);
-  const stream = createVoiceStream(path, {
-    ...preset.connection,
-    ...options.connection
-  });
-  let capture = null;
-  let state = createInitialState2(stream);
-  const subscribers = new Set;
-  const notify = () => {
-    for (const subscriber of subscribers) {
-      subscriber();
+// src/angular/voice-trace-timeline.service.ts
+var _dec = [
+  Injectable10({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTraceTimelineService {
+  connect(path = "/api/voice-traces", options = {}) {
+    const store = createVoiceTraceTimelineStore(path, options);
+    const errorSignal = signal10(null);
+    const isLoadingSignal = signal10(false);
+    const reportSignal = signal10(null);
+    const updatedAtSignal = signal10(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed9(() => errorSignal()),
+      isLoading: computed9(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed9(() => reportSignal()),
+      updatedAt: computed9(() => updatedAtSignal())
+    };
+  }
+}
+VoiceTraceTimelineService = __decorateElement(_init, 0, "VoiceTraceTimelineService", _dec, VoiceTraceTimelineService);
+__runInitializers(_init, 1, VoiceTraceTimelineService);
+__decoratorMetadata(_init, VoiceTraceTimelineService);
+let _VoiceTraceTimelineService = VoiceTraceTimelineService;
+// src/angular/voice-turn-latency.service.ts
+import { computed as computed10, Injectable as Injectable11, signal as signal11 } from "@angular/core";
+
+// src/client/turnLatency.ts
+var fetchVoiceTurnLatency = async (path = "/api/turn-latency", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice turn latency failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var runVoiceTurnLatencyProof = async (path, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Voice turn latency proof failed: HTTP ${response.status}`);
+  }
+  return response.json();
+};
+var createVoiceTurnLatencyStore = (path = "/api/turn-latency", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
   };
-  const sync = () => {
-    state = {
-      ...state,
-      assistantAudio: [...stream.assistantAudio],
-      assistantTexts: [...stream.assistantTexts],
-      error: stream.error,
-      isConnected: stream.isConnected,
-      partial: stream.partial,
-      sessionId: stream.sessionId,
-      scenarioId: stream.scenarioId,
-      status: stream.status,
-      turns: [...stream.turns]
-    };
-    if (options.autoStopOnComplete !== false && state.status === "completed" && state.isRecording) {
-      capture?.stop();
-      capture = null;
-      state = {
-        ...state,
-        isRecording: false
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await fetchVoiceTurnLatency(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
       };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
     }
-    notify();
   };
-  const unsubscribeStream = stream.subscribe(sync);
-  sync();
-  const ensureCapture = () => {
-    if (capture) {
-      return capture;
+  const runProof = async () => {
+    if (!options.proofPath) {
+      throw new Error("Voice turn latency proof path is not configured.");
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      await runVoiceTurnLatencyProof(options.proofPath, options);
+      return await refresh();
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    runProof,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-turn-latency.service.ts
+var _dec = [
+  Injectable11({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTurnLatencyService {
+  connect(path = "/api/turn-latency", options = {}) {
+    const store = createVoiceTurnLatencyStore(path, options);
+    const errorSignal = signal11(null);
+    const isLoadingSignal = signal11(false);
+    const reportSignal = signal11(undefined);
+    const updatedAtSignal = signal11(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed10(() => errorSignal()),
+      isLoading: computed10(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed10(() => reportSignal()),
+      runProof: store.runProof,
+      updatedAt: computed10(() => updatedAtSignal())
+    };
+  }
+}
+VoiceTurnLatencyService = __decorateElement(_init, 0, "VoiceTurnLatencyService", _dec, VoiceTurnLatencyService);
+__runInitializers(_init, 1, VoiceTurnLatencyService);
+__decoratorMetadata(_init, VoiceTurnLatencyService);
+let _VoiceTurnLatencyService = VoiceTurnLatencyService;
+// src/angular/voice-turn-quality.service.ts
+import { computed as computed11, Injectable as Injectable12, signal as signal12 } from "@angular/core";
+
+// src/client/turnQuality.ts
+var fetchVoiceTurnQuality = async (path = "/api/turn-quality", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice turn quality failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceTurnQualityStore = (path = "/api/turn-quality", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-    capture = createMicrophoneCapture({
-      channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
-      onLevel: options.capture?.onLevel,
-      onAudio: (audio) => stream.sendAudio(audio),
-      sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
-    });
-    return capture;
-  };
-  const stopRecording = () => {
-    capture?.stop();
-    capture = null;
-    state = {
-      ...state,
-      isRecording: false
-    };
-    notify();
   };
-  const startRecording = async () => {
-    if (state.isRecording) {
-      return;
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
     }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
     try {
-      state = {
-        ...state,
-        recordingError: null
-      };
-      notify();
-      await ensureCapture().start();
-      state = {
-        ...state,
-        isRecording: true
+      const report = await fetchVoiceTurnQuality(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
       };
-      notify();
+      emit();
+      return report;
     } catch (error) {
-      capture = null;
-      state = {
-        ...state,
-        isRecording: false,
-        recordingError: error instanceof Error ? error.message : String(error)
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
       };
-      notify();
+      emit();
       throw error;
     }
   };
   const close = () => {
-    unsubscribeStream();
-    stopRecording();
-    stream.close();
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
   };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
   return {
-    bindHTMX(bindingOptions) {
-      return bindVoiceHTMX(stream, bindingOptions);
-    },
     close,
-    endTurn: () => stream.endTurn(),
-    get error() {
-      return state.error;
-    },
-    getServerSnapshot: () => state,
-    getSnapshot: () => state,
-    get isConnected() {
-      return state.isConnected;
-    },
-    get isRecording() {
-      return state.isRecording;
-    },
-    get partial() {
-      return state.partial;
-    },
-    get recordingError() {
-      return state.recordingError;
-    },
-    sendAudio: (audio) => stream.sendAudio(audio),
-    get sessionId() {
-      return state.sessionId;
-    },
-    get scenarioId() {
-      return state.scenarioId;
-    },
-    startRecording,
-    get status() {
-      return state.status;
-    },
-    stopRecording,
-    subscribe: (subscriber) => {
-      subscribers.add(subscriber);
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
       return () => {
-        subscribers.delete(subscriber);
+        listeners.delete(listener);
       };
-    },
-    toggleRecording: async () => {
-      if (state.isRecording) {
-        stopRecording();
-        return;
-      }
-      await startRecording();
-    },
-    get turns() {
-      return state.turns;
-    },
-    get assistantTexts() {
-      return state.assistantTexts;
-    },
-    get assistantAudio() {
-      return state.assistantAudio;
     }
   };
 };
 
-// src/angular/voice-controller.service.ts
+// src/angular/voice-turn-quality.service.ts
 var _dec = [
-  Injectable2({ providedIn: "root" })
+  Injectable12({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
-class VoiceControllerService {
-  connect(path, options = {}) {
-    const controller = createVoiceController(path, options);
-    const assistantAudioSignal = signal2([]);
-    const assistantTextsSignal = signal2([]);
-    const errorSignal = signal2(null);
-    const isConnectedSignal = signal2(false);
-    const isRecordingSignal = signal2(false);
-    const partialSignal = signal2("");
-    const recordingErrorSignal = signal2(null);
-    const sessionIdSignal = signal2(controller.sessionId);
-    const statusSignal = signal2(controller.status);
-    const turnsSignal = signal2([]);
+class VoiceTurnQualityService {
+  connect(path = "/api/turn-quality", options = {}) {
+    const store = createVoiceTurnQualityStore(path, options);
+    const errorSignal = signal12(null);
+    const isLoadingSignal = signal12(false);
+    const reportSignal = signal12(undefined);
+    const updatedAtSignal = signal12(undefined);
     const sync = () => {
-      assistantAudioSignal.set([...controller.assistantAudio]);
-      assistantTextsSignal.set([...controller.assistantTexts]);
-      errorSignal.set(controller.error);
-      isConnectedSignal.set(controller.isConnected);
-      isRecordingSignal.set(controller.isRecording);
-      partialSignal.set(controller.partial);
-      recordingErrorSignal.set(controller.recordingError);
-      sessionIdSignal.set(controller.sessionId);
-      statusSignal.set(controller.status);
-      turnsSignal.set([...controller.turns]);
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
     };
-    const unsubscribe = controller.subscribe(sync);
+    const unsubscribe = store.subscribe(sync);
     sync();
+    store.refresh().catch(() => {});
     return {
-      assistantAudio: computed2(() => assistantAudioSignal()),
-      assistantTexts: computed2(() => assistantTextsSignal()),
-      bindHTMX: controller.bindHTMX,
       close: () => {
         unsubscribe();
-        controller.close();
+        store.close();
       },
-      endTurn: () => controller.endTurn(),
-      error: computed2(() => errorSignal()),
-      isConnected: computed2(() => isConnectedSignal()),
-      isRecording: computed2(() => isRecordingSignal()),
-      partial: computed2(() => partialSignal()),
-      recordingError: computed2(() => recordingErrorSignal()),
-      sendAudio: (audio) => controller.sendAudio(audio),
-      sessionId: computed2(() => sessionIdSignal()),
-      startRecording: () => controller.startRecording(),
-      status: computed2(() => statusSignal()),
-      stopRecording: () => controller.stopRecording(),
-      toggleRecording: () => controller.toggleRecording(),
-      turns: computed2(() => turnsSignal())
+      error: computed11(() => errorSignal()),
+      isLoading: computed11(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed11(() => reportSignal()),
+      updatedAt: computed11(() => updatedAtSignal())
     };
   }
 }
-VoiceControllerService = __decorateElement(_init, 0, "VoiceControllerService", _dec, VoiceControllerService);
-__runInitializers(_init, 1, VoiceControllerService);
-__decoratorMetadata(_init, VoiceControllerService);
-let _VoiceControllerService = VoiceControllerService;
-// src/angular/voice-provider-status.service.ts
-import { computed as computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
+VoiceTurnQualityService = __decorateElement(_init, 0, "VoiceTurnQualityService", _dec, VoiceTurnQualityService);
+__runInitializers(_init, 1, VoiceTurnQualityService);
+__decoratorMetadata(_init, VoiceTurnQualityService);
+let _VoiceTurnQualityService = VoiceTurnQualityService;
+// src/angular/voice-workflow-status.service.ts
+import { computed as computed12, Injectable as Injectable13, signal as signal13 } from "@angular/core";
 
-// src/client/providerStatus.ts
-var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const response = await fetchImpl(path);
   if (!response.ok) {
-    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
   }
   return await response.json();
 };
-var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
   const listeners = new Set;
   let closed = false;
   let timer;
   let snapshot = {
     error: null,
-    isLoading: false,
-    providers: []
+    isLoading: false
   };
   const emit = () => {
     for (const listener of listeners) {
@@ -1316,7 +2981,7 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
   };
   const refresh = async () => {
     if (closed) {
-      return snapshot.providers;
+      return snapshot.report;
     }
     snapshot = {
       ...snapshot,
@@ -1325,15 +2990,15 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
     };
     emit();
     try {
-      const providers = await fetchVoiceProviderStatus(path, options);
+      const report = await fetchVoiceWorkflowStatus(path, options);
       snapshot = {
         error: null,
         isLoading: false,
-        providers,
+        report,
         updatedAt: Date.now()
       };
       emit();
-      return providers;
+      return report;
     } catch (error) {
       snapshot = {
         ...snapshot,
@@ -1352,7 +3017,7 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
     }
     listeners.clear();
   };
-  if (options.intervalMs && options.intervalMs > 0) {
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
     timer = setInterval(() => {
       refresh().catch(() => {});
     }, options.intervalMs);
@@ -1371,48 +3036,349 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
   };
 };
 
-// src/angular/voice-provider-status.service.ts
+// src/angular/voice-workflow-status.service.ts
 var _dec = [
-  Injectable3({ providedIn: "root" })
+  Injectable13({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
-class VoiceProviderStatusService {
-  connect(path = "/api/provider-status", options = {}) {
-    const store = createVoiceProviderStatusStore(path, options);
-    const errorSignal = signal3(null);
-    const isLoadingSignal = signal3(false);
-    const providersSignal = signal3([]);
-    const updatedAtSignal = signal3(undefined);
+class VoiceWorkflowStatusService {
+  connect(path = "/evals/scenarios/json", options = {}) {
+    const store = createVoiceWorkflowStatusStore(path, options);
+    const errorSignal = signal13(null);
+    const isLoadingSignal = signal13(false);
+    const reportSignal = signal13(undefined);
+    const updatedAtSignal = signal13(undefined);
     const sync = () => {
       const snapshot = store.getSnapshot();
       errorSignal.set(snapshot.error);
       isLoadingSignal.set(snapshot.isLoading);
-      providersSignal.set([...snapshot.providers]);
+      reportSignal.set(snapshot.report);
       updatedAtSignal.set(snapshot.updatedAt);
     };
     const unsubscribe = store.subscribe(sync);
     sync();
-    store.refresh().catch(() => {});
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
     return {
       close: () => {
         unsubscribe();
         store.close();
       },
-      error: computed3(() => errorSignal()),
-      isLoading: computed3(() => isLoadingSignal()),
-      providers: computed3(() => providersSignal()),
+      error: computed12(() => errorSignal()),
+      isLoading: computed12(() => isLoadingSignal()),
       refresh: store.refresh,
-      updatedAt: computed3(() => updatedAtSignal())
+      report: computed12(() => reportSignal()),
+      updatedAt: computed12(() => updatedAtSignal())
     };
   }
 }
-VoiceProviderStatusService = __decorateElement(_init, 0, "VoiceProviderStatusService", _dec, VoiceProviderStatusService);
-__runInitializers(_init, 1, VoiceProviderStatusService);
-__decoratorMetadata(_init, VoiceProviderStatusService);
-let _VoiceProviderStatusService = VoiceProviderStatusService;
+VoiceWorkflowStatusService = __decorateElement(_init, 0, "VoiceWorkflowStatusService", _dec, VoiceWorkflowStatusService);
+__runInitializers(_init, 1, VoiceWorkflowStatusService);
+__decoratorMetadata(_init, VoiceWorkflowStatusService);
+let _VoiceWorkflowStatusService = VoiceWorkflowStatusService;
+// src/angular/voice-delivery-runtime.component.ts
+import { Component, Input, signal as signal14 } from "@angular/core";
+
+// src/client/deliveryRuntimeWidget.ts
+var DEFAULT_TITLE = "Voice Delivery Runtime";
+var DEFAULT_DESCRIPTION = "Audit and trace delivery worker health from your AbsoluteJS voice app.";
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var createSurface = (id, summary) => {
+  if (!summary) {
+    return {
+      deadLettered: 0,
+      detail: "Worker disabled",
+      failed: 0,
+      id,
+      label: id === "audit" ? "Audit delivery" : "Trace delivery",
+      pending: 0,
+      status: "disabled",
+      total: 0
+    };
+  }
+  const blocked = summary.failed + summary.deadLettered;
+  return {
+    deadLettered: summary.deadLettered,
+    detail: `${summary.delivered}/${summary.total} delivered, ${summary.pending} pending`,
+    failed: summary.failed,
+    id,
+    label: id === "audit" ? "Audit delivery" : "Trace delivery",
+    pending: summary.pending,
+    status: blocked > 0 ? "warn" : "pass",
+    total: summary.total
+  };
+};
+var createVoiceDeliveryRuntimeViewModel = (snapshot, options = {}) => {
+  const report = snapshot.report;
+  const surfaces = [
+    createSurface("audit", report?.summary.audit),
+    createSurface("trace", report?.summary.trace)
+  ];
+  const hasWarnings = surfaces.some((surface) => surface.status === "warn");
+  return {
+    description: options.description ?? DEFAULT_DESCRIPTION,
+    error: snapshot.error,
+    actionError: snapshot.actionError,
+    actionStatus: snapshot.actionStatus,
+    isLoading: snapshot.isLoading,
+    isRunning: Boolean(report?.isRunning),
+    label: snapshot.error ? "Unavailable" : report ? report.isRunning ? "Running" : "Stopped" : "Checking",
+    status: snapshot.error ? "error" : report ? hasWarnings ? "warn" : "pass" : "loading",
+    surfaces,
+    title: options.title ?? DEFAULT_TITLE,
+    updatedAt: snapshot.updatedAt
+  };
+};
+var renderVoiceDeliveryRuntimeHTML = (snapshot, options = {}) => {
+  const model = createVoiceDeliveryRuntimeViewModel(snapshot, options);
+  const surfaces = model.surfaces.map((surface) => `<li class="absolute-voice-delivery-runtime__surface absolute-voice-delivery-runtime__surface--${escapeHtml(surface.status)}">
+  <span>${escapeHtml(surface.label)}</span>
+  <strong>${escapeHtml(surface.detail)}</strong>
+  <small>${String(surface.failed)} failed &middot; ${String(surface.deadLettered)} dead-lettered</small>
+</li>`).join("");
+  const actions = options.includeActions === false ? "" : `<div class="absolute-voice-delivery-runtime__actions">
+  <button type="button" data-absolute-voice-delivery-runtime-action="tick">${model.actionStatus === "running" ? "Working..." : "Tick workers"}</button>
+  <button type="button" data-absolute-voice-delivery-runtime-action="requeue-dead-letters"${model.surfaces.some((surface) => surface.deadLettered > 0) ? "" : " disabled"}>Requeue dead letters</button>
+</div>`;
+  const actionError = model.actionError ? `<p class="absolute-voice-delivery-runtime__error">${escapeHtml(model.actionError)}</p>` : "";
+  return `<section class="absolute-voice-delivery-runtime absolute-voice-delivery-runtime--${escapeHtml(model.status)}">
+  <header class="absolute-voice-delivery-runtime__header">
+    <span class="absolute-voice-delivery-runtime__eyebrow">${escapeHtml(model.title)}</span>
+    <strong class="absolute-voice-delivery-runtime__label">${escapeHtml(model.label)}</strong>
+  </header>
+  <p class="absolute-voice-delivery-runtime__description">${escapeHtml(model.description)}</p>
+  <ul class="absolute-voice-delivery-runtime__surfaces">${surfaces}</ul>
+  ${actions}
+  ${actionError}
+  ${model.error ? `<p class="absolute-voice-delivery-runtime__error">${escapeHtml(model.error)}</p>` : ""}
+</section>`;
+};
+var getVoiceDeliveryRuntimeCSS = () => `.absolute-voice-delivery-runtime{border:1px solid #c9d8cf;border-radius:20px;background:#f6fff9;color:#0d1b12;padding:18px;box-shadow:0 18px 40px rgba(19,55,35,.12);font-family:inherit}.absolute-voice-delivery-runtime--warn,.absolute-voice-delivery-runtime--error{border-color:#f2b56b;background:#fff9ed}.absolute-voice-delivery-runtime__header{align-items:start;display:flex;gap:12px;justify-content:space-between}.absolute-voice-delivery-runtime__eyebrow{color:#4e6b59;font-size:12px;font-weight:800;letter-spacing:.08em;text-transform:uppercase}.absolute-voice-delivery-runtime__label{font-size:28px;line-height:1}.absolute-voice-delivery-runtime__description{color:#33483b;margin:12px 0 0}.absolute-voice-delivery-runtime__surfaces{display:grid;gap:8px;list-style:none;margin:16px 0 0;padding:0}.absolute-voice-delivery-runtime__surface{background:#fff;border:1px solid #d9eadf;border-radius:14px;display:grid;gap:4px;padding:10px 12px}.absolute-voice-delivery-runtime__surface--warn{border-color:#f2b56b}.absolute-voice-delivery-runtime__surface--disabled{opacity:.72}.absolute-voice-delivery-runtime__surface span,.absolute-voice-delivery-runtime__surface small{color:#587063}.absolute-voice-delivery-runtime__actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:14px}.absolute-voice-delivery-runtime__actions button{background:#134e2d;border:0;border-radius:999px;color:#f6fff9;cursor:pointer;font:inherit;font-weight:800;padding:8px 12px}.absolute-voice-delivery-runtime__actions button:disabled{cursor:not-allowed;opacity:.48}.absolute-voice-delivery-runtime__error{color:#9f1239;font-weight:700}`;
+var mountVoiceDeliveryRuntime = (element, path = "/api/voice-delivery-runtime", options = {}) => {
+  const store = createVoiceDeliveryRuntimeStore(path, options);
+  const render = () => {
+    element.innerHTML = renderVoiceDeliveryRuntimeHTML(store.getSnapshot(), options);
+  };
+  const unsubscribe = store.subscribe(render);
+  const handleClick = (event) => {
+    const target = event.target;
+    if (!(target instanceof Element)) {
+      return;
+    }
+    const action = target.closest("[data-absolute-voice-delivery-runtime-action]");
+    const actionName = action?.getAttribute("data-absolute-voice-delivery-runtime-action");
+    if (actionName === "tick") {
+      store.tick().catch(() => {});
+    }
+    if (actionName === "requeue-dead-letters") {
+      store.requeueDeadLetters().catch(() => {});
+    }
+  };
+  element.addEventListener?.("click", handleClick);
+  render();
+  store.refresh().catch(() => {});
+  return {
+    close: () => {
+      element.removeEventListener?.("click", handleClick);
+      unsubscribe();
+      store.close();
+    },
+    refresh: store.refresh
+  };
+};
+var defineVoiceDeliveryRuntimeElement = (tagName = "absolute-voice-delivery-runtime") => {
+  if (typeof window === "undefined" || typeof customElements === "undefined" || customElements.get(tagName)) {
+    return;
+  }
+  customElements.define(tagName, class AbsoluteVoiceDeliveryRuntimeElement extends HTMLElement {
+    mounted;
+    connectedCallback() {
+      const intervalMs = Number(this.getAttribute("interval-ms") ?? 5000);
+      this.mounted = mountVoiceDeliveryRuntime(this, this.getAttribute("path") ?? "/api/voice-delivery-runtime", {
+        description: this.getAttribute("description") ?? undefined,
+        intervalMs: Number.isFinite(intervalMs) ? intervalMs : 5000,
+        title: this.getAttribute("title") ?? undefined
+      });
+    }
+    disconnectedCallback() {
+      this.mounted?.close();
+      this.mounted = undefined;
+    }
+  });
+};
+
+// src/angular/voice-delivery-runtime.component.ts
+var _dec = [
+  Component({
+    selector: "absolute-voice-delivery-runtime",
+    standalone: true,
+    template: `
+		<section
+			class="absolute-voice-delivery-runtime"
+			[class.absolute-voice-delivery-runtime--pass]="model().status === 'pass'"
+			[class.absolute-voice-delivery-runtime--warn]="model().status === 'warn'"
+			[class.absolute-voice-delivery-runtime--loading]="
+				model().status === 'loading'
+			"
+			[class.absolute-voice-delivery-runtime--error]="
+				model().status === 'error'
+			"
+		>
+			<header class="absolute-voice-delivery-runtime__header">
+				<span class="absolute-voice-delivery-runtime__eyebrow">{{
+					model().title
+				}}</span>
+				<strong class="absolute-voice-delivery-runtime__label">{{
+					model().label
+				}}</strong>
+			</header>
+			<p class="absolute-voice-delivery-runtime__description">
+				{{ model().description }}
+			</p>
+			<ul class="absolute-voice-delivery-runtime__surfaces">
+				@for (surface of model().surfaces; track surface.id) {
+					<li
+						class="absolute-voice-delivery-runtime__surface"
+						[class.absolute-voice-delivery-runtime__surface--pass]="
+							surface.status === 'pass'
+						"
+						[class.absolute-voice-delivery-runtime__surface--warn]="
+							surface.status === 'warn'
+						"
+						[class.absolute-voice-delivery-runtime__surface--disabled]="
+							surface.status === 'disabled'
+						"
+					>
+						<span>{{ surface.label }}</span>
+						<strong>{{ surface.detail }}</strong>
+						<small
+							>{{ surface.failed }} failed /
+							{{ surface.deadLettered }} dead-lettered</small
+						>
+					</li>
+				}
+			</ul>
+			<div class="absolute-voice-delivery-runtime__actions">
+				<button
+					type="button"
+					[disabled]="model().actionStatus === 'running'"
+					(click)="tick()"
+				>
+					{{ model().actionStatus === "running" ? "Working..." : "Tick workers" }}
+				</button>
+				<button
+					type="button"
+					[disabled]="
+						model().actionStatus === 'running' || deadLettered() === 0
+					"
+					(click)="requeueDeadLetters()"
+				>
+					Requeue dead letters
+				</button>
+			</div>
+			@if (model().actionError) {
+				<p class="absolute-voice-delivery-runtime__error">
+					{{ model().actionError }}
+				</p>
+			}
+			@if (model().error) {
+				<p class="absolute-voice-delivery-runtime__error">
+					{{ model().error }}
+				</p>
+			}
+		</section>
+	`
+  })
+];
+var _dec2 = [
+  Input()
+];
+var _dec3 = [
+  Input()
+];
+var _dec4 = [
+  Input()
+];
+var _dec5 = [
+  Input()
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceDeliveryRuntimeComponent {
+  constructor() {
+    this.description = __runInitializers(_init, 8, this);
+    __runInitializers(_init, 11, this);
+    this.intervalMs = __runInitializers(_init, 12, this);
+    __runInitializers(_init, 15, this);
+    this.path = __runInitializers(_init, 16, this, "/api/voice-delivery-runtime");
+    __runInitializers(_init, 19, this);
+    this.title = __runInitializers(_init, 20, this);
+    __runInitializers(_init, 23, this);
+  }
+  cleanup = () => {};
+  store;
+  model = signal14(createVoiceDeliveryRuntimeViewModel({
+    actionError: null,
+    actionStatus: "idle",
+    error: null,
+    isLoading: true
+  }));
+  ngOnInit() {
+    const options = this.options();
+    this.store = createVoiceDeliveryRuntimeStore(this.path, options);
+    const sync = () => {
+      this.model.set(createVoiceDeliveryRuntimeViewModel(this.store.getSnapshot(), options));
+    };
+    this.cleanup = this.store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      this.store.refresh().catch(() => {});
+    }
+  }
+  ngOnDestroy() {
+    this.cleanup();
+    this.store?.close();
+  }
+  deadLettered() {
+    return this.model().surfaces.reduce((total, surface) => total + surface.deadLettered, 0);
+  }
+  tick() {
+    this.store?.tick().catch(() => {});
+  }
+  requeueDeadLetters() {
+    this.store?.requeueDeadLetters().catch(() => {});
+  }
+  options() {
+    return {
+      description: this.description,
+      intervalMs: this.intervalMs,
+      title: this.title
+    };
+  }
+}
+__decorateElement(_init, 5, "description", _dec2, VoiceDeliveryRuntimeComponent);
+__decorateElement(_init, 5, "intervalMs", _dec3, VoiceDeliveryRuntimeComponent);
+__decorateElement(_init, 5, "path", _dec4, VoiceDeliveryRuntimeComponent);
+__decorateElement(_init, 5, "title", _dec5, VoiceDeliveryRuntimeComponent);
+VoiceDeliveryRuntimeComponent = __decorateElement(_init, 0, "VoiceDeliveryRuntimeComponent", _dec, VoiceDeliveryRuntimeComponent);
+__runInitializers(_init, 1, VoiceDeliveryRuntimeComponent);
+__decoratorMetadata(_init, VoiceDeliveryRuntimeComponent);
+let _VoiceDeliveryRuntimeComponent = VoiceDeliveryRuntimeComponent;
 export {
+  VoiceWorkflowStatusService,
+  VoiceTurnQualityService,
+  VoiceTurnLatencyService,
+  VoiceTraceTimelineService,
   VoiceStreamService,
+  VoiceRoutingStatusService,
   VoiceProviderStatusService,
-  VoiceControllerService
+  VoiceProviderCapabilitiesService,
+  VoiceOpsStatusService,
+  VoiceOpsActionCenterService,
+  VoiceDeliveryRuntimeService,
+  VoiceDeliveryRuntimeComponent,
+  VoiceControllerService,
+  VoiceCampaignDialerProofService
 };