@absolutejs/voice 0.0.22-beta.397 → 0.0.22-beta.399

package/dist/react/index.d.ts

@@ -18,6 +18,7 @@ export { VoiceTurnQuality } from './VoiceTurnQuality';
 export { useVoiceOpsStatus } from './useVoiceOpsStatus';
 export { useVoicePlatformCoverage } from './useVoicePlatformCoverage';
 export { useVoiceProofTrends } from './useVoiceProofTrends';
+export { useVoiceSessionSnapshot } from './useVoiceSessionSnapshot';
 export { useVoiceProfileComparison } from './useVoiceProfileComparison';
 export { useVoiceProfileSwitchRecommendation } from './useVoiceProfileSwitchRecommendation';
 export { useVoiceReadinessFailures } from './useVoiceReadinessFailures';

package/dist/react/index.js

@@ -8871,9 +8871,122 @@ var VoiceTurnQuality = ({
     ]
   }, undefined, true, undefined, this);
 };
-// src/react/useVoiceLiveOps.tsx
+// src/react/useVoiceSessionSnapshot.tsx
 import { useEffect as useEffect18, useRef as useRef18, useSyncExternalStore as useSyncExternalStore18 } from "react";
 
+// src/client/sessionSnapshot.ts
+var withTurnId = (path, turnId) => {
+  if (!turnId) {
+    return path;
+  }
+  const url = new URL(path, "http://absolutejs.local");
+  url.searchParams.set("turnId", turnId);
+  return `${url.pathname}${url.search}`;
+};
+var fetchVoiceSessionSnapshot = async (path, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(withTurnId(path, options.turnId));
+  if (!response.ok) {
+    throw new Error(`Voice session snapshot failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceSessionSnapshotStore = (path, 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.snapshot;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const next = await fetchVoiceSessionSnapshot(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        snapshot: next,
+        updatedAt: Date.now()
+      };
+      emit();
+      return next;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const download = () => {
+    const current = snapshot.snapshot;
+    if (current === undefined) {
+      throw new Error("Voice session snapshot has not been loaded.");
+    }
+    return new Blob([JSON.stringify(current, null, 2)], {
+      type: "application/json"
+    });
+  };
+  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,
+    download,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/react/useVoiceSessionSnapshot.tsx
+var useVoiceSessionSnapshot = (path, options = {}) => {
+  const storeRef = useRef18(null);
+  if (!storeRef.current) {
+    storeRef.current = createVoiceSessionSnapshotStore(path, options);
+  }
+  const store = storeRef.current;
+  useEffect18(() => {
+    store.refresh().catch(() => {});
+    return () => store.close();
+  }, [store]);
+  return {
+    ...useSyncExternalStore18(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    download: store.download,
+    refresh: store.refresh
+  };
+};
+// src/react/useVoiceLiveOps.tsx
+import { useEffect as useEffect19, useRef as useRef19, useSyncExternalStore as useSyncExternalStore19 } from "react";
+
 // src/client/liveOps.ts
 var postVoiceLiveOpsAction = async (input, options = {}) => {
   if (!input.sessionId) {
@@ -8962,19 +9075,19 @@ var createVoiceLiveOpsStore = (options = {}) => {
 
 // src/react/useVoiceLiveOps.tsx
 var useVoiceLiveOps = (options = {}) => {
-  const storeRef = useRef18(null);
+  const storeRef = useRef19(null);
   if (!storeRef.current) {
     storeRef.current = createVoiceLiveOpsStore(options);
   }
   const store = storeRef.current;
-  useEffect18(() => () => store.close(), [store]);
+  useEffect19(() => () => store.close(), [store]);
   return {
-    ...useSyncExternalStore18(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    ...useSyncExternalStore19(store.subscribe, store.getSnapshot, store.getServerSnapshot),
     run: store.run
   };
 };
 // src/react/useVoiceCampaignDialerProof.tsx
-import { useEffect as useEffect19, useRef as useRef19, useSyncExternalStore as useSyncExternalStore19 } from "react";
+import { useEffect as useEffect20, useRef as useRef20, useSyncExternalStore as useSyncExternalStore20 } from "react";
 
 // src/client/campaignDialerProof.ts
 var fetchVoiceCampaignDialerProofStatus = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
@@ -9096,23 +9209,23 @@ var createVoiceCampaignDialerProofStore = (path = "/api/voice/campaigns/dialer-p
 
 // src/react/useVoiceCampaignDialerProof.tsx
 var useVoiceCampaignDialerProof = (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
-  const storeRef = useRef19(null);
+  const storeRef = useRef20(null);
   if (!storeRef.current) {
     storeRef.current = createVoiceCampaignDialerProofStore(path, options);
   }
   const store = storeRef.current;
-  useEffect19(() => {
+  useEffect20(() => {
     store.refresh().catch(() => {});
     return () => store.close();
   }, [store]);
   return {
-    ...useSyncExternalStore19(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    ...useSyncExternalStore20(store.subscribe, store.getSnapshot, store.getServerSnapshot),
     refresh: store.refresh,
     runProof: store.runProof
   };
 };
 // src/react/useVoiceStream.tsx
-import { useEffect as useEffect20, useRef as useRef20, useSyncExternalStore as useSyncExternalStore20 } from "react";
+import { useEffect as useEffect21, useRef as useRef21, useSyncExternalStore as useSyncExternalStore21 } from "react";
 
 // src/client/actions.ts
 var normalizeErrorMessage = (value) => {
@@ -10523,13 +10636,13 @@ var EMPTY_SNAPSHOT = {
   turns: []
 };
 var useVoiceStream = (path, options = {}) => {
-  const streamRef = useRef20(null);
+  const streamRef = useRef21(null);
   if (!streamRef.current) {
     streamRef.current = createVoiceStream(path, options);
   }
   const stream = streamRef.current;
-  useEffect20(() => () => stream.close(), [stream]);
-  const snapshot = useSyncExternalStore20(stream.subscribe, stream.getSnapshot, stream.getServerSnapshot) ?? EMPTY_SNAPSHOT;
+  useEffect21(() => () => stream.close(), [stream]);
+  const snapshot = useSyncExternalStore21(stream.subscribe, stream.getSnapshot, stream.getServerSnapshot) ?? EMPTY_SNAPSHOT;
   return {
     ...snapshot,
     callControl: (message) => stream.callControl(message),
@@ -10539,7 +10652,7 @@ var useVoiceStream = (path, options = {}) => {
   };
 };
 // src/react/useVoiceController.tsx
-import { useEffect as useEffect21, useRef as useRef21, useSyncExternalStore as useSyncExternalStore21 } from "react";
+import { useEffect as useEffect22, useRef as useRef22, useSyncExternalStore as useSyncExternalStore22 } from "react";
 
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
@@ -11207,13 +11320,13 @@ var EMPTY_SNAPSHOT2 = {
   turns: []
 };
 var useVoiceController = (path, options = {}) => {
-  const controllerRef = useRef21(null);
+  const controllerRef = useRef22(null);
   if (!controllerRef.current) {
     controllerRef.current = createVoiceController(path, options);
   }
   const controller = controllerRef.current;
-  useEffect21(() => () => controller.close(), [controller]);
-  const snapshot = useSyncExternalStore21(controller.subscribe, controller.getSnapshot, controller.getServerSnapshot) ?? EMPTY_SNAPSHOT2;
+  useEffect22(() => () => controller.close(), [controller]);
+  const snapshot = useSyncExternalStore22(controller.subscribe, controller.getSnapshot, controller.getServerSnapshot) ?? EMPTY_SNAPSHOT2;
   return {
     ...snapshot,
     bindHTMX: controller.bindHTMX,
@@ -11227,7 +11340,7 @@ var useVoiceController = (path, options = {}) => {
   };
 };
 // src/react/useVoiceWorkflowStatus.tsx
-import { useEffect as useEffect22, useRef as useRef22, useSyncExternalStore as useSyncExternalStore22 } from "react";
+import { useEffect as useEffect23, useRef as useRef23, useSyncExternalStore as useSyncExternalStore23 } from "react";
 
 // src/client/workflowStatus.ts
 var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
@@ -11310,17 +11423,17 @@ var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options =
 
 // src/react/useVoiceWorkflowStatus.tsx
 var useVoiceWorkflowStatus = (path = "/evals/scenarios/json", options = {}) => {
-  const storeRef = useRef22(null);
+  const storeRef = useRef23(null);
   if (!storeRef.current) {
     storeRef.current = createVoiceWorkflowStatusStore(path, options);
   }
   const store = storeRef.current;
-  useEffect22(() => {
+  useEffect23(() => {
     store.refresh().catch(() => {});
     return () => store.close();
   }, [store]);
   return {
-    ...useSyncExternalStore22(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    ...useSyncExternalStore23(store.subscribe, store.getSnapshot, store.getServerSnapshot),
     refresh: store.refresh
   };
 };
@@ -11330,6 +11443,7 @@ export {
   useVoiceTurnLatency,
   useVoiceTraceTimeline,
   useVoiceStream,
+  useVoiceSessionSnapshot,
   useVoiceRoutingStatus,
   useVoiceReadinessFailures,
   useVoiceProviderStatus,

package/dist/react/useVoiceSessionSnapshot.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceSessionSnapshotClientOptions } from '../client/sessionSnapshot';
+export declare const useVoiceSessionSnapshot: (path: string, options?: VoiceSessionSnapshotClientOptions) => {
+    download: () => Blob;
+    refresh: () => Promise<import("..").VoiceSessionSnapshot | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    snapshot?: import("..").VoiceSessionSnapshot;
+    updatedAt?: number;
+};

package/dist/sessionSnapshot.d.ts

@@ -1,3 +1,4 @@
+import { Elysia } from 'elysia';
 import type { MediaProcessorGraphSnapshot } from '@absolutejs/media';
 import type { VoiceProofAssertionResult, VoiceProofAssertionSummary } from './proofAssertions';
 import type { VoiceCampaignTelephonyOutcomeSnapshot } from './campaign';
@@ -34,6 +35,19 @@ export type VoiceSessionSnapshotInput = {
     telephonyOutcomes?: readonly VoiceCampaignTelephonyOutcomeSnapshot[];
     turnId?: string;
 };
+export type VoiceSessionSnapshotRouteSourceInput = {
+    request: Request;
+    sessionId: string;
+    turnId?: string;
+};
+export type VoiceSessionSnapshotRouteSource = VoiceSessionSnapshot | VoiceSessionSnapshotInput | ((input: VoiceSessionSnapshotRouteSourceInput) => Promise<VoiceSessionSnapshot | VoiceSessionSnapshotInput> | VoiceSessionSnapshot | VoiceSessionSnapshotInput);
+export type VoiceSessionSnapshotRoutesOptions = Partial<VoiceSessionSnapshotInput> & {
+    downloadPath?: false | string;
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source?: VoiceSessionSnapshotRouteSource;
+};
 export declare const buildVoiceSessionSnapshotStatus: (input: {
     media?: readonly Pick<MediaProcessorGraphSnapshot, "report">[];
     proofSummary?: Pick<VoiceProofAssertionSummary, "ok">;
@@ -42,3 +56,43 @@ export declare const buildVoiceSessionSnapshotStatus: (input: {
 }) => VoiceSessionSnapshotStatus;
 export declare const buildVoiceSessionSnapshot: (input: VoiceSessionSnapshotInput) => VoiceSessionSnapshot;
 export declare const parseVoiceSessionSnapshot: (snapshot: VoiceSessionSnapshot) => VoiceSessionSnapshot;
+export declare const createVoiceSessionSnapshotRoutes: (options?: VoiceSessionSnapshotRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/svelte/createVoiceSessionSnapshot.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceSessionSnapshotClientOptions } from '../client/sessionSnapshot';
+export declare const createVoiceSessionSnapshot: (path: string, options?: VoiceSessionSnapshotClientOptions) => {
+    close: () => void;
+    download: () => Blob;
+    getServerSnapshot: () => import("../client").VoiceSessionSnapshotClientState;
+    getSnapshot: () => import("../client").VoiceSessionSnapshotClientState;
+    refresh: () => Promise<import("..").VoiceSessionSnapshot | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/index.d.ts

@@ -5,6 +5,7 @@ export { createVoiceLiveOps } from './createVoiceLiveOps';
 export { createVoiceOpsStatus } from './createVoiceOpsStatus';
 export { createVoicePlatformCoverage } from './createVoicePlatformCoverage';
 export { createVoiceProofTrends } from './createVoiceProofTrends';
+export { createVoiceSessionSnapshot } from './createVoiceSessionSnapshot';
 export { createVoiceProfileComparison } from './createVoiceProfileComparison';
 export { createVoiceReadinessFailures } from './createVoiceReadinessFailures';
 export { createVoiceProviderSimulationControls } from './createVoiceProviderSimulationControls';

package/dist/svelte/index.js

@@ -2629,6 +2629,101 @@ var createVoiceProofTrends = (path = "/api/voice/proof-trends", options = {}) =>
     subscribe: store.subscribe
   };
 };
+// src/client/sessionSnapshot.ts
+var withTurnId = (path, turnId) => {
+  if (!turnId) {
+    return path;
+  }
+  const url = new URL(path, "http://absolutejs.local");
+  url.searchParams.set("turnId", turnId);
+  return `${url.pathname}${url.search}`;
+};
+var fetchVoiceSessionSnapshot = async (path, options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(withTurnId(path, options.turnId));
+  if (!response.ok) {
+    throw new Error(`Voice session snapshot failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceSessionSnapshotStore = (path, 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.snapshot;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const next = await fetchVoiceSessionSnapshot(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        snapshot: next,
+        updatedAt: Date.now()
+      };
+      emit();
+      return next;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const download = () => {
+    const current = snapshot.snapshot;
+    if (current === undefined) {
+      throw new Error("Voice session snapshot has not been loaded.");
+    }
+    return new Blob([JSON.stringify(current, null, 2)], {
+      type: "application/json"
+    });
+  };
+  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,
+    download,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/svelte/createVoiceSessionSnapshot.ts
+var createVoiceSessionSnapshot = (path, options = {}) => createVoiceSessionSnapshotStore(path, options);
 // src/client/profileComparison.ts
 var fetchVoiceProfileComparison = async (path = "/api/voice/real-call-profile-history", options = {}) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -6719,6 +6814,7 @@ export {
   createVoiceTurnLatency,
   createVoiceTraceTimeline,
   createVoiceStream2 as createVoiceStream,
+  createVoiceSessionSnapshot,
   createVoiceRoutingStatus,
   createVoiceReadinessFailures,
   createVoiceProviderStatus,

package/dist/vue/index.d.ts

@@ -15,6 +15,7 @@ export { VoiceTurnQuality } from './VoiceTurnQuality';
 export { useVoiceOpsStatus } from './useVoiceOpsStatus';
 export { useVoicePlatformCoverage } from './useVoicePlatformCoverage';
 export { useVoiceProofTrends } from './useVoiceProofTrends';
+export { useVoiceSessionSnapshot } from './useVoiceSessionSnapshot';
 export { useVoiceProfileComparison } from './useVoiceProfileComparison';
 export { useVoiceReadinessFailures } from './useVoiceReadinessFailures';
 export { useVoiceOpsActionCenter } from './useVoiceOpsActionCenter';