@absolutejs/voice 0.0.22-beta.31 → 0.0.22-beta.310

package/dist/angular/index.js

@@ -69,902 +69,2320 @@ 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 "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 "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 = {
-  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 "error":
-    case "final":
-    case "partial":
-    case "pong":
-    case "session":
-    case "turn":
-      return true;
-    default:
-      return false;
-  }
-};
-var parseServerMessage = (event) => {
-  if (typeof event.data !== "string") {
-    return null;
+// 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())
+    };
   }
-  try {
-    const parsed = JSON.parse(event.data);
-    return isVoiceServerMessage(parsed) ? parsed : null;
-  } catch {
-    return null;
+}
+VoiceOpsStatusService = __decorateElement(_init, 0, "VoiceOpsStatusService", _dec, VoiceOpsStatusService);
+__runInitializers(_init, 1, VoiceOpsStatusService);
+__decoratorMetadata(_init, VoiceOpsStatusService);
+let _VoiceOpsStatusService = VoiceOpsStatusService;
+// src/angular/voice-platform-coverage.service.ts
+import { computed as computed2, Injectable as Injectable2, signal as signal2 } from "@angular/core";
+
+// src/client/platformCoverage.ts
+var fetchVoicePlatformCoverage = async (path = "/api/voice/platform-coverage", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice platform coverage failed: HTTP ${response.status}`);
   }
+  return await response.json();
 };
-var createVoiceConnection = (path, options = {}) => {
-  if (typeof window === "undefined") {
-    return NOOP_CONNECTION;
-  }
+var createVoicePlatformCoverageStore = (path = "/api/voice/platform-coverage", 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 = {
+    error: null,
+    isLoading: 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 refresh = async () => {
+    if (closed) {
+      return snapshot.report;
     }
-    while (state.pendingMessages.length > 0) {
-      const next = state.pendingMessages.shift();
-      if (next !== undefined) {
-        state.ws.send(next);
-      }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoicePlatformCoverage(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 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 (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/angular/voice-platform-coverage.service.ts
+var _dec = [
+  Injectable2({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoicePlatformCoverageService {
+  connect(path = "/api/voice/platform-coverage", options = {}) {
+    const store = createVoicePlatformCoverageStore(path, options);
+    const errorSignal = signal2(null);
+    const isLoadingSignal = signal2(false);
+    const reportSignal = signal2(undefined);
+    const updatedAtSignal = signal2(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
     };
-    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();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed2(() => errorSignal()),
+      isLoading: computed2(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed2(() => reportSignal()),
+      updatedAt: computed2(() => updatedAtSignal())
     };
-    state.ws = ws;
+  }
+}
+VoicePlatformCoverageService = __decorateElement(_init, 0, "VoicePlatformCoverageService", _dec, VoicePlatformCoverageService);
+__runInitializers(_init, 1, VoicePlatformCoverageService);
+__decoratorMetadata(_init, VoicePlatformCoverageService);
+let _VoicePlatformCoverageService = VoicePlatformCoverageService;
+// src/angular/voice-proof-trends.service.ts
+import { computed as computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
+
+// src/client/proofTrends.ts
+var fetchVoiceProofTrends = async (path = "/api/voice/proof-trends", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice proof trends failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProofTrendsStore = (path = "/api/voice/proof-trends", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
   };
-  const sendSerialized = (value) => {
-    if (state.ws?.readyState === WS_OPEN) {
-      state.ws.send(value);
-      return;
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-    state.pendingMessages.push(value);
-  };
-  const send = (message) => {
-    sendSerialized(JSON.stringify(message));
   };
-  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 fetchVoiceProofTrends(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;
     }
-    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;
+    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 {
-    callControl,
     close,
-    endTurn,
-    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
-    getScenarioId: () => state.scenarioId ?? "",
-    getSessionId: () => state.sessionId,
-    send,
-    sendAudio,
-    start,
-    subscribe
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
   };
 };
 
-// src/client/store.ts
-var createInitialState = () => ({
-  assistantAudio: [],
-  assistantTexts: [],
-  call: null,
-  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 "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
-        };
-        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;
+// src/angular/voice-proof-trends.service.ts
+var _dec = [
+  Injectable3({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProofTrendsService {
+  connect(path = "/api/voice/proof-trends", options = {}) {
+    const store = createVoiceProofTrendsStore(path, options);
+    const errorSignal = signal3(null);
+    const isLoadingSignal = signal3(false);
+    const reportSignal = signal3(undefined);
+    const updatedAtSignal = signal3(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(() => {});
     }
-    notify();
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed3(() => errorSignal()),
+      isLoading: computed3(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed3(() => reportSignal()),
+      updatedAt: computed3(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProofTrendsService = __decorateElement(_init, 0, "VoiceProofTrendsService", _dec, VoiceProofTrendsService);
+__runInitializers(_init, 1, VoiceProofTrendsService);
+__decoratorMetadata(_init, VoiceProofTrendsService);
+let _VoiceProofTrendsService = VoiceProofTrendsService;
+// src/angular/voice-readiness-failures.service.ts
+import { computed as computed4, Injectable as Injectable4, signal as signal4 } from "@angular/core";
+
+// src/client/readinessFailures.ts
+var fetchVoiceReadinessFailures = async (path = "/api/production-readiness", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice readiness failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceReadinessFailuresStore = (path = "/api/production-readiness", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
   };
-  return {
-    dispatch,
-    getServerSnapshot: () => state,
-    getSnapshot: () => state,
-    subscribe: (subscriber) => {
-      subscribers.add(subscriber);
-      return () => {
-        subscribers.delete(subscriber);
-      };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
   };
-};
-
-// 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;
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await fetchVoiceReadinessFailures(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;
     }
-    connection.start(input);
-  });
-  const notify = () => {
-    subscribers.forEach((subscriber) => subscriber());
   };
-  const unsubscribeConnection = connection.subscribe((message) => {
-    const action = serverMessageToAction(message);
-    if (action) {
-      store.dispatch(action);
-      notify();
+  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 {
-    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 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);
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
       return () => {
-        subscribers.delete(subscriber);
+        listeners.delete(listener);
       };
     }
   };
 };
 
-// src/angular/voice-stream.service.ts
+// src/angular/voice-readiness-failures.service.ts
 var _dec = [
-  Injectable({ providedIn: "root" })
+  Injectable4({ providedIn: "root" })
 ];
 var _init = __decoratorStart(undefined);
 
-class VoiceStreamService {
-  connect(path, options = {}) {
-    const stream = createVoiceStream(path, options);
-    const assistantAudioSignal = signal([]);
-    const assistantTextsSignal = signal([]);
-    const callSignal = signal(null);
-    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 VoiceReadinessFailuresService {
+  connect(path = "/api/production-readiness", options = {}) {
+    const store = createVoiceReadinessFailuresStore(path, options);
+    const errorSignal = signal4(null);
+    const isLoadingSignal = signal4(false);
+    const reportSignal = signal4(undefined);
+    const updatedAtSignal = signal4(undefined);
     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);
-      sessionIdSignal.set(stream.sessionId);
-      statusSignal.set(stream.status);
-      turnsSignal.set([...stream.turns]);
+      const snapshot = store.getSnapshot();
+      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()),
-      call: computed(() => callSignal()),
-      callControl: (message) => stream.callControl(message),
       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: computed4(() => errorSignal()),
+      explanations: computed4(() => reportSignal()?.checks.filter((check) => check.status !== "pass" && !!check.gateExplanation) ?? []),
+      isLoading: computed4(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed4(() => reportSignal()),
+      updatedAt: computed4(() => 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";
+VoiceReadinessFailuresService = __decorateElement(_init, 0, "VoiceReadinessFailuresService", _dec, VoiceReadinessFailuresService);
+__runInitializers(_init, 1, VoiceReadinessFailuresService);
+__decoratorMetadata(_init, VoiceReadinessFailuresService);
+let _VoiceReadinessFailuresService = VoiceReadinessFailuresService;
+// src/angular/voice-ops-action-center.service.ts
+import { computed as computed5, Injectable as Injectable5, signal as signal5 } 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 "";
+// src/client/opsActionCenter.ts
+var recordVoiceOpsActionResult = async (result, options = {}) => {
+  if (options.auditPath === false) {
+    return;
   }
-  const url = new URL(baseRoute, window.location.origin);
-  if (sessionId) {
-    url.searchParams.set(queryParam, sessionId);
-  } else {
-    url.searchParams.delete(queryParam);
+  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}`);
   }
-  return `${url.pathname}${url.search}${url.hash}`;
 };
-var bindVoiceHTMX = (stream, options) => {
-  if (typeof window === "undefined" || typeof document === "undefined") {
-    return () => {};
+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"
+    });
   }
-  const element = resolveElement(options.element);
-  if (!element) {
-    return () => {};
+  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`
+    });
   }
-  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);
+  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)}`
+      });
     }
-    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);
+  return actions;
 };
-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;
+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 Math.min(1, Math.max(0, Math.sqrt(sumSquares / samples.length) * 5.5));
+  return {
+    actionId: action.id,
+    body,
+    ok: response.ok,
+    ranAt: Date.now(),
+    status: response.status
+  };
 };
-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;
+var createVoiceOpsActionCenterStore = (options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    actions: options.actions ?? createVoiceOpsActionCenterActions(),
+    error: null,
+    isRunning: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
     }
-    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 setActions = (actions) => {
+    snapshot = { ...snapshot, actions, updatedAt: Date.now() };
+    emit();
+  };
+  const run = async (actionId) => {
+    if (closed) {
+      return snapshot.lastResult;
     }
-    const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
-    if (!AudioContextCtor) {
-      throw new Error("Browser microphone capture requires AudioContext support.");
+    const action = snapshot.actions.find((item) => item.id === actionId);
+    if (!action) {
+      throw new Error(`Voice ops action "${actionId}" is not configured.`);
     }
-    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);
+    if (action.disabled) {
+      throw new Error(`Voice ops action "${actionId}" is disabled.`);
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isRunning: true,
+      runningActionId: action.id
     };
-    sourceNode.connect(processorNode);
-    processorNode.connect(audioContext.destination);
+    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 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();
+  };
+  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);
+      };
+    }
   };
-  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));
+// src/angular/voice-ops-action-center.service.ts
+var _dec = [
+  Injectable5({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceOpsActionCenterService {
+  connect(options = {}) {
+    const store = createVoiceOpsActionCenterStore(options);
+    const actionsSignal = signal5([]);
+    const errorSignal = signal5(null);
+    const isRunningSignal = signal5(false);
+    const lastResultSignal = signal5(undefined);
+    const runningActionIdSignal = signal5(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);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    return {
+      actions: computed5(() => actionsSignal()),
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed5(() => errorSignal()),
+      isRunning: computed5(() => isRunningSignal()),
+      lastResult: computed5(() => lastResultSignal()),
+      run: store.run,
+      runningActionId: computed5(() => runningActionIdSignal()),
+      setActions: store.setActions
+    };
   }
-  return new Int16Array(audio.buffer, audio.byteOffset, Math.floor(audio.byteLength / 2));
-};
-var computeRms = (samples) => {
-  if (samples.length === 0) {
-    return 0;
+}
+VoiceOpsActionCenterService = __decorateElement(_init, 0, "VoiceOpsActionCenterService", _dec, VoiceOpsActionCenterService);
+__runInitializers(_init, 1, VoiceOpsActionCenterService);
+__decoratorMetadata(_init, VoiceOpsActionCenterService);
+let _VoiceOpsActionCenterService = VoiceOpsActionCenterService;
+// src/angular/voice-live-ops.service.ts
+import { computed as computed6, Injectable as Injectable6, signal as signal6 } from "@angular/core";
+
+// src/client/liveOps.ts
+var postVoiceLiveOpsAction = async (input, options = {}) => {
+  if (!input.sessionId) {
+    throw new Error("Start a voice session before running live ops actions.");
   }
-  let sumSquares = 0;
-  for (const sample of samples) {
-    const normalized = sample / 32768;
-    sumSquares += normalized * normalized;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(options.actionPath ?? "/api/voice/live-ops/action", {
+    body: JSON.stringify(input),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || !payload?.ok) {
+    const message = payload && typeof payload === "object" && "error" in payload ? String(payload.error) : `Voice live ops action failed: HTTP ${response.status}`;
+    throw new Error(message);
   }
-  return Math.sqrt(sumSquares / samples.length);
+  return payload;
 };
-var resolveAudioConditioningConfig = (config) => {
-  if (!config || config.enabled === false) {
-    return;
-  }
+var createVoiceLiveOpsStore = (options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let snapshot = {
+    error: null,
+    isRunning: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const run = async (input) => {
+    if (closed) {
+      return snapshot.lastResult;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isRunning: true,
+      runningAction: input.action
+    };
+    emit();
+    try {
+      const result = await postVoiceLiveOpsAction(input, options);
+      await options.onControl?.(result);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isRunning: false,
+        lastResult: result,
+        runningAction: undefined,
+        updatedAt: Date.now()
+      };
+      emit();
+      return result;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isRunning: false,
+        runningAction: undefined,
+        updatedAt: Date.now()
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    listeners.clear();
+  };
   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,
+    run,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
   };
 };
-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));
+
+// src/angular/voice-live-ops.service.ts
+var _dec = [
+  Injectable6({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceLiveOpsService {
+  connect(options = {}) {
+    const store = createVoiceLiveOpsStore(options);
+    const errorSignal = signal6(null);
+    const isRunningSignal = signal6(false);
+    const lastResultSignal = signal6(undefined);
+    const runningActionSignal = signal6(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isRunningSignal.set(snapshot.isRunning);
+      lastResultSignal.set(snapshot.lastResult);
+      runningActionSignal.set(snapshot.runningAction);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed6(() => errorSignal()),
+      isRunning: computed6(() => isRunningSignal()),
+      lastResult: computed6(() => lastResultSignal()),
+      run: store.run,
+      runningAction: computed6(() => runningActionSignal())
+    };
   }
-  return new Uint8Array(output.buffer);
-};
+}
+VoiceLiveOpsService = __decorateElement(_init, 0, "VoiceLiveOpsService", _dec, VoiceLiveOpsService);
+__runInitializers(_init, 1, VoiceLiveOpsService);
+__decoratorMetadata(_init, VoiceLiveOpsService);
+let _VoiceLiveOpsService = VoiceLiveOpsService;
+// src/angular/voice-delivery-runtime.service.ts
+import { computed as computed7, Injectable as Injectable7, signal as signal7 } from "@angular/core";
 
-// src/turnProfiles.ts
-var TURN_PROFILE_DEFAULTS = {
-  balanced: {
-    qualityProfile: "general",
-    silenceMs: 1400,
-    speechThreshold: 0.012,
-    transcriptStabilityMs: 1000
-  },
-  fast: {
-    qualityProfile: "general",
-    silenceMs: 700,
-    speechThreshold: 0.015,
-    transcriptStabilityMs: 450
-  },
-  "long-form": {
-    qualityProfile: "general",
-    silenceMs: 2200,
-    speechThreshold: 0.01,
-    transcriptStabilityMs: 1500
+// 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 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 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 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];
+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 {
-    profile,
-    qualityProfile,
-    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
-    speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
-    transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
+    action,
+    result: body.result,
+    summary: body.summary,
+    updatedAt: Date.now()
   };
 };
-
-// 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"
+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 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.report;
     }
-  },
-  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 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;
     }
-  },
-  "guided-intake": {
+  };
+  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 = () => {
+    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,
+    requeueDeadLetters: () => runAction("requeue-dead-letters"),
+    refresh,
+    tick: () => runAction("tick"),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-delivery-runtime.service.ts
+var _dec = [
+  Injectable7({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceDeliveryRuntimeService {
+  connect(path = "/api/voice-delivery-runtime", options = {}) {
+    const store = createVoiceDeliveryRuntimeStore(path, options);
+    const actionErrorSignal = signal7(null);
+    const actionStatusSignal = signal7("idle");
+    const errorSignal = signal7(null);
+    const isLoadingSignal = signal7(false);
+    const reportSignal = signal7(undefined);
+    const updatedAtSignal = signal7(undefined);
+    const sync = () => {
+      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 = store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed7(() => errorSignal()),
+      actionError: computed7(() => actionErrorSignal()),
+      actionStatus: computed7(() => actionStatusSignal()),
+      isLoading: computed7(() => isLoadingSignal()),
+      requeueDeadLetters: store.requeueDeadLetters,
+      refresh: store.refresh,
+      report: computed7(() => reportSignal()),
+      tick: store.tick,
+      updatedAt: computed7(() => updatedAtSignal())
+    };
+  }
+}
+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 computed8, Injectable as Injectable8, signal as signal8 } from "@angular/core";
+
+// 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 await response.json();
+};
+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 await response.json();
+};
+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 emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.status;
+    }
+    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 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;
+    }
+  };
+  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-campaign-dialer-proof.service.ts
+var _dec = [
+  Injectable8({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceCampaignDialerProofService {
+  connect(path = "/api/voice/campaigns/dialer-proof", options = {}) {
+    const store = createVoiceCampaignDialerProofStore(path, options);
+    const errorSignal = signal8(null);
+    const isLoadingSignal = signal8(false);
+    const reportSignal = signal8(undefined);
+    const statusSignal = signal8(undefined);
+    const updatedAtSignal = signal8(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: computed8(() => errorSignal()),
+      isLoading: computed8(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed8(() => reportSignal()),
+      runProof: store.runProof,
+      status: computed8(() => statusSignal()),
+      updatedAt: computed8(() => updatedAtSignal())
+    };
+  }
+}
+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 computed9, Injectable as Injectable9, signal as signal9 } 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;
+  }
+  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 = [
+  Injectable9({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceStreamService {
+  connect(path, options = {}) {
+    const stream = createVoiceStream(path, options);
+    const assistantAudioSignal = signal9([]);
+    const assistantTextsSignal = signal9([]);
+    const callSignal = signal9(null);
+    const errorSignal = signal9(null);
+    const isConnectedSignal = signal9(false);
+    const partialSignal = signal9("");
+    const reconnectSignal = signal9(stream.reconnect);
+    const sessionIdSignal = signal9(stream.sessionId);
+    const statusSignal = signal9(stream.status);
+    const turnsSignal = signal9([]);
+    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: computed9(() => assistantAudioSignal()),
+      assistantTexts: computed9(() => assistantTextsSignal()),
+      call: computed9(() => callSignal()),
+      callControl: (message) => stream.callControl(message),
+      close: () => {
+        unsubscribe();
+        stream.close();
+      },
+      endTurn: () => stream.endTurn(),
+      error: computed9(() => errorSignal()),
+      isConnected: computed9(() => isConnectedSignal()),
+      partial: computed9(() => partialSignal()),
+      reconnect: computed9(() => reconnectSignal()),
+      sendAudio: (audio) => stream.sendAudio(audio),
+      sessionId: computed9(() => sessionIdSignal()),
+      status: computed9(() => statusSignal()),
+      turns: computed9(() => 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 computed10, Injectable as Injectable10, signal as signal10 } 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
+  },
+  fast: {
+    qualityProfile: "general",
+    silenceMs: 700,
+    speechThreshold: 0.015,
+    transcriptStabilityMs: 450
+  },
+  "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.5,
-      noiseGateAttenuation: 0,
-      noiseGateThreshold: 0.004,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
       targetLevel: 0.08
     },
     capture: {
@@ -972,388 +2390,1322 @@ var PRESET_INPUTS = {
       sampleRateHz: 16000
     },
     connection: {
-      maxReconnectAttempts: 12,
-      pingInterval: 30000,
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
       reconnect: true
     },
-    sttLifecycle: "turn-scoped",
+    sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "accent-heavy",
+      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"
     }
-  },
-  "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
+  }
+};
+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 = [
+  Injectable10({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceControllerService {
+  connect(path, options = {}) {
+    const controller = createVoiceController(path, options);
+    const assistantAudioSignal = signal10([]);
+    const assistantTextsSignal = signal10([]);
+    const errorSignal = signal10(null);
+    const isConnectedSignal = signal10(false);
+    const isRecordingSignal = signal10(false);
+    const partialSignal = signal10("");
+    const reconnectSignal = signal10(controller.reconnect);
+    const recordingErrorSignal = signal10(null);
+    const sessionIdSignal = signal10(controller.sessionId);
+    const statusSignal = signal10(controller.status);
+    const turnsSignal = signal10([]);
+    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: computed10(() => assistantAudioSignal()),
+      assistantTexts: computed10(() => assistantTextsSignal()),
+      bindHTMX: controller.bindHTMX,
+      close: () => {
+        unsubscribe();
+        controller.close();
+      },
+      endTurn: () => controller.endTurn(),
+      error: computed10(() => errorSignal()),
+      isConnected: computed10(() => isConnectedSignal()),
+      isRecording: computed10(() => isRecordingSignal()),
+      partial: computed10(() => partialSignal()),
+      reconnect: computed10(() => reconnectSignal()),
+      recordingError: computed10(() => recordingErrorSignal()),
+      sendAudio: (audio) => controller.sendAudio(audio),
+      sessionId: computed10(() => sessionIdSignal()),
+      startRecording: () => controller.startRecording(),
+      status: computed10(() => statusSignal()),
+      stopRecording: () => controller.stopRecording(),
+      toggleRecording: () => controller.toggleRecording(),
+      turns: computed10(() => 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 computed11, Injectable as Injectable11, signal as signal11 } 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 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);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-capabilities.service.ts
+var _dec = [
+  Injectable11({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderCapabilitiesService {
+  connect(path = "/api/provider-capabilities", options = {}) {
+    const store = createVoiceProviderCapabilitiesStore(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: computed11(() => errorSignal()),
+      isLoading: computed11(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed11(() => reportSignal()),
+      updatedAt: computed11(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderCapabilitiesService = __decorateElement(_init, 0, "VoiceProviderCapabilitiesService", _dec, VoiceProviderCapabilitiesService);
+__runInitializers(_init, 1, VoiceProviderCapabilitiesService);
+__decoratorMetadata(_init, VoiceProviderCapabilitiesService);
+let _VoiceProviderCapabilitiesService = VoiceProviderCapabilitiesService;
+// src/angular/voice-provider-contracts.service.ts
+import { computed as computed12, Injectable as Injectable12, signal as signal12 } from "@angular/core";
+
+// src/client/providerContracts.ts
+var fetchVoiceProviderContracts = async (path = "/api/provider-contracts", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider contracts failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderContractsStore = (path = "/api/provider-contracts", 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 fetchVoiceProviderContracts(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);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-contracts.service.ts
+var _dec = [
+  Injectable12({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderContractsService {
+  connect(path = "/api/provider-contracts", options = {}) {
+    const store = createVoiceProviderContractsStore(path, options);
+    const errorSignal = signal12(null);
+    const isLoadingSignal = signal12(false);
+    const reportSignal = signal12(undefined);
+    const updatedAtSignal = signal12(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: computed12(() => errorSignal()),
+      isLoading: computed12(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed12(() => reportSignal()),
+      updatedAt: computed12(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderContractsService = __decorateElement(_init, 0, "VoiceProviderContractsService", _dec, VoiceProviderContractsService);
+__runInitializers(_init, 1, VoiceProviderContractsService);
+__decoratorMetadata(_init, VoiceProviderContractsService);
+let _VoiceProviderContractsService = VoiceProviderContractsService;
+// src/angular/voice-provider-status.service.ts
+import { computed as computed13, Injectable as Injectable13, signal as signal13 } 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;
     }
-  },
-  "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
+    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);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-status.service.ts
+var _dec = [
+  Injectable13({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderStatusService {
+  connect(path = "/api/provider-status", options = {}) {
+    const store = createVoiceProviderStatusStore(path, options);
+    const errorSignal = signal13(null);
+    const isLoadingSignal = signal13(false);
+    const providersSignal = signal13([]);
+    const updatedAtSignal = signal13(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: computed13(() => errorSignal()),
+      isLoading: computed13(() => isLoadingSignal()),
+      providers: computed13(() => providersSignal()),
+      refresh: store.refresh,
+      updatedAt: computed13(() => 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 Injectable14, signal as signal14 } 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
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.decision;
+    }
+    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;
+    }
+  };
+  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);
+      };
+    }
+  };
+};
+
+// src/angular/voice-routing-status.service.ts
+var _dec = [
+  Injectable14({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceRoutingStatusService {
+  connect(path = "/api/routing/latest", options = {}) {
+    const store = createVoiceRoutingStatusStore(path, options);
+    const decisionSignal = signal14(null);
+    const errorSignal = signal14(null);
+    const isLoadingSignal = signal14(false);
+    const updatedAtSignal = signal14(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 computed14, Injectable as Injectable15, signal as signal15 } 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();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    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;
     }
-  },
-  "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 close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
     }
-  },
-  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"
+    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);
+      };
     }
+  };
+};
+
+// src/angular/voice-trace-timeline.service.ts
+var _dec = [
+  Injectable15({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTraceTimelineService {
+  connect(path = "/api/voice-traces", options = {}) {
+    const store = createVoiceTraceTimelineStore(path, options);
+    const errorSignal = signal15(null);
+    const isLoadingSignal = signal15(false);
+    const reportSignal = signal15(null);
+    const updatedAtSignal = signal15(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: computed14(() => errorSignal()),
+      isLoading: computed14(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed14(() => reportSignal()),
+      updatedAt: computed14(() => updatedAtSignal())
+    };
   }
+}
+VoiceTraceTimelineService = __decorateElement(_init, 0, "VoiceTraceTimelineService", _dec, VoiceTraceTimelineService);
+__runInitializers(_init, 1, VoiceTraceTimelineService);
+__decoratorMetadata(_init, VoiceTraceTimelineService);
+let _VoiceTraceTimelineService = VoiceTraceTimelineService;
+// src/angular/voice-agent-squad-status.service.ts
+import { computed as computed15, Injectable as Injectable16, signal as signal16 } from "@angular/core";
+
+// src/client/agentSquadStatus.ts
+var getString = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var getPayloadString = (event, key) => getString(event.payload?.[key]);
+var eventStatus = (event) => {
+  const status = getPayloadString(event, "status");
+  if (status === "blocked")
+    return "blocked";
+  if (status === "unknown-target")
+    return "unknown-target";
+  if (status === "allowed")
+    return "handoff";
+  return event.type === "agent.result" ? "active" : "handoff";
 };
-var resolveVoiceRuntimePreset = (name = "default") => {
-  const preset = PRESET_INPUTS[name];
+var deriveSessionSpecialist = (session) => {
+  const events = [...session.events].sort((left, right) => left.at - right.at);
+  const agentEvents = events.filter((event) => event.type === "agent.handoff" || event.type === "agent.context" || event.type === "agent.result" || event.type === "agent.model");
+  const latest = agentEvents.at(-1);
+  if (!latest) {
+    return {
+      lastEventAt: session.lastEventAt,
+      sessionId: session.sessionId,
+      status: "idle"
+    };
+  }
+  const handoffEvents = events.filter((event) => event.type === "agent.handoff");
+  const lastHandoff = handoffEvents.at(-1);
+  const latestAgentId = getPayloadString(latest, "agentId");
+  const handoffStatus = lastHandoff ? eventStatus(lastHandoff) : undefined;
+  const currentTarget = handoffStatus === "blocked" || handoffStatus === "unknown-target" ? getPayloadString(lastHandoff, "fromAgentId") ?? latestAgentId : getPayloadString(lastHandoff ?? latest, "targetAgentId") ?? latestAgentId;
   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)
+    fromAgentId: getPayloadString(lastHandoff ?? latest, "fromAgentId"),
+    lastEventAt: latest.at,
+    reason: getPayloadString(lastHandoff ?? latest, "reason") ?? getPayloadString(latest, "handoffTarget"),
+    sessionId: session.sessionId,
+    status: lastHandoff ? eventStatus(lastHandoff) : "active",
+    summary: getPayloadString(lastHandoff ?? latest, "summary"),
+    targetAgentId: currentTarget,
+    turnId: latest.turnId
   };
 };
-
-// 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,
-  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
+var buildVoiceAgentSquadStatusReport = (timeline, options = {}) => {
+  const sessions = (timeline?.sessions ?? []).filter((session) => !options.sessionId || session.sessionId === options.sessionId).map(deriveSessionSpecialist).sort((left, right) => (right.lastEventAt ?? 0) - (left.lastEventAt ?? 0));
+  const active = sessions.filter((session) => session.status !== "idle");
+  return {
+    active,
+    checkedAt: timeline?.checkedAt,
+    current: active[0] ?? sessions[0],
+    sessionCount: sessions.length,
+    sessions
+  };
+};
+var createVoiceAgentSquadStatusStore = (path = "/api/voice-traces", options = {}) => {
+  const timelineStore = createVoiceTraceTimelineStore(path, options);
+  const getReport = () => buildVoiceAgentSquadStatusReport(timelineStore.getSnapshot().report, {
+    sessionId: options.sessionId
   });
-  let capture = null;
-  let state = createInitialState2(stream);
-  const subscribers = new Set;
-  const notify = () => {
-    for (const subscriber of subscribers) {
-      subscriber();
-    }
+  const getSnapshot = () => {
+    const snapshot = timelineStore.getSnapshot();
+    return {
+      error: snapshot.error,
+      isLoading: snapshot.isLoading,
+      report: getReport(),
+      updatedAt: snapshot.updatedAt
+    };
   };
-  const sync = () => {
-    state = {
-      ...state,
-      assistantAudio: [...stream.assistantAudio],
-      assistantTexts: [...stream.assistantTexts],
-      call: stream.call,
-      error: stream.error,
-      isConnected: stream.isConnected,
-      partial: stream.partial,
-      sessionId: stream.sessionId,
-      scenarioId: stream.scenarioId,
-      status: stream.status,
-      turns: [...stream.turns]
+  return {
+    close: timelineStore.close,
+    getServerSnapshot: getSnapshot,
+    getSnapshot,
+    refresh: timelineStore.refresh,
+    subscribe: timelineStore.subscribe
+  };
+};
+
+// src/angular/voice-agent-squad-status.service.ts
+var _dec = [
+  Injectable16({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceAgentSquadStatusService {
+  connect(path = "/api/voice-traces", options = {}) {
+    const store = createVoiceAgentSquadStatusStore(path, options);
+    const errorSignal = signal16(null);
+    const isLoadingSignal = signal16(false);
+    const reportSignal = signal16(undefined);
+    const updatedAtSignal = signal16(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
     };
-    if (options.autoStopOnComplete !== false && state.status === "completed" && state.isRecording) {
-      capture?.stop();
-      capture = null;
-      state = {
-        ...state,
-        isRecording: false
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      current: computed15(() => reportSignal()?.current),
+      error: computed15(() => errorSignal()),
+      isLoading: computed15(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed15(() => reportSignal()),
+      updatedAt: computed15(() => updatedAtSignal())
+    };
+  }
+}
+VoiceAgentSquadStatusService = __decorateElement(_init, 0, "VoiceAgentSquadStatusService", _dec, VoiceAgentSquadStatusService);
+__runInitializers(_init, 1, VoiceAgentSquadStatusService);
+__decoratorMetadata(_init, VoiceAgentSquadStatusService);
+let _VoiceAgentSquadStatusService = VoiceAgentSquadStatusService;
+// src/angular/voice-turn-latency.service.ts
+import { computed as computed16, Injectable as Injectable17, signal as signal17 } 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 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;
+    }
+  };
+  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;
     }
-    notify();
+    listeners.clear();
   };
-  const unsubscribeStream = stream.subscribe(sync);
-  sync();
-  const ensureCapture = () => {
-    if (capture) {
-      return capture;
+  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);
+      };
     }
-    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
+};
+
+// src/angular/voice-turn-latency.service.ts
+var _dec = [
+  Injectable17({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceTurnLatencyService {
+  connect(path = "/api/turn-latency", options = {}) {
+    const store = createVoiceTurnLatencyStore(path, options);
+    const errorSignal = signal17(null);
+    const isLoadingSignal = signal17(false);
+    const reportSignal = signal17(undefined);
+    const updatedAtSignal = signal17(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
     };
-    notify();
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed16(() => errorSignal()),
+      isLoading: computed16(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed16(() => reportSignal()),
+      runProof: store.runProof,
+      updatedAt: computed16(() => 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 computed17, Injectable as Injectable18, signal as signal18 } 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 startRecording = async () => {
-    if (state.isRecording) {
-      return;
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  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);
-    },
-    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;
-    },
-    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;
-    },
-    get call() {
-      return state.call;
     }
   };
 };
 
-// src/angular/voice-controller.service.ts
+// src/angular/voice-turn-quality.service.ts
 var _dec = [
-  Injectable2({ providedIn: "root" })
+  Injectable18({ 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 = signal18(null);
+    const isLoadingSignal = signal18(false);
+    const reportSignal = signal18(undefined);
+    const updatedAtSignal = signal18(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: computed17(() => errorSignal()),
+      isLoading: computed17(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed17(() => reportSignal()),
+      updatedAt: computed17(() => 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 computed18, Injectable as Injectable19, signal as signal19 } 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) {
@@ -1362,7 +3714,7 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
   };
   const refresh = async () => {
     if (closed) {
-      return snapshot.providers;
+      return snapshot.report;
     }
     snapshot = {
       ...snapshot,
@@ -1371,15 +3723,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,
@@ -1398,7 +3750,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);
@@ -1417,48 +3769,66 @@ 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" })
+  Injectable19({ 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 = signal19(null);
+    const isLoadingSignal = signal19(false);
+    const reportSignal = signal19(undefined);
+    const updatedAtSignal = signal19(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: computed18(() => errorSignal()),
+      isLoading: computed18(() => isLoadingSignal()),
       refresh: store.refresh,
-      updatedAt: computed3(() => updatedAtSignal())
+      report: computed18(() => reportSignal()),
+      updatedAt: computed18(() => 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;
 export {
+  VoiceWorkflowStatusService,
+  VoiceTurnQualityService,
+  VoiceTurnLatencyService,
+  VoiceTraceTimelineService,
   VoiceStreamService,
+  VoiceRoutingStatusService,
+  VoiceReadinessFailuresService,
   VoiceProviderStatusService,
-  VoiceControllerService
+  VoiceProviderContractsService,
+  VoiceProviderCapabilitiesService,
+  VoiceProofTrendsService,
+  VoicePlatformCoverageService,
+  VoiceOpsStatusService,
+  VoiceOpsActionCenterService,
+  VoiceLiveOpsService,
+  VoiceDeliveryRuntimeService,
+  VoiceControllerService,
+  VoiceCampaignDialerProofService,
+  VoiceAgentSquadStatusService
 };