@absolutejs/voice 0.0.22-beta.56 → 0.0.22-beta.560

package/dist/core/simulationSuite.d.ts

@@ -0,0 +1,144 @@
+import { Elysia } from "elysia";
+import { type VoiceEvalReport, type VoiceEvalRoutesOptions, type VoiceScenarioEvalDefinition, type VoiceScenarioEvalReport, type VoiceScenarioFixture, type VoiceScenarioFixtureEvalReport, type VoiceScenarioFixtureStore } from "./evalRoutes";
+import { type VoiceOutcomeContractDefinition, type VoiceOutcomeContractOptions, type VoiceOutcomeContractSuiteReport } from "./outcomeContract";
+import { type VoiceToolContractDefinition, type VoiceToolContractSuiteReport } from "./toolContract";
+import type { VoiceQualityThresholds } from "./qualityRoutes";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceSessionRecord } from "./types";
+export type VoiceSimulationSuiteStatus = "pass" | "fail";
+export type VoiceSimulationSuiteReport = {
+    actions: VoiceSimulationSuiteAction[];
+    checkedAt: number;
+    failed: number;
+    fixtures?: VoiceScenarioFixtureEvalReport;
+    outcomes?: VoiceOutcomeContractSuiteReport;
+    passed: number;
+    scenarios?: VoiceScenarioEvalReport;
+    sessions?: VoiceEvalReport;
+    status: VoiceSimulationSuiteStatus;
+    summary: {
+        fixtures?: VoiceSimulationSuiteSectionSummary;
+        outcomes?: VoiceSimulationSuiteSectionSummary;
+        scenarios?: VoiceSimulationSuiteSectionSummary;
+        sessions?: VoiceSimulationSuiteSectionSummary;
+        tools?: VoiceSimulationSuiteSectionSummary;
+    };
+    tools?: VoiceToolContractSuiteReport;
+    total: number;
+};
+type VoiceSimulationSuiteAction = {
+    description: string;
+    href?: string;
+    label: string;
+    section: "fixtures" | "outcomes" | "scenarios" | "sessions" | "tools";
+    severity: "error" | "warning";
+};
+export type VoiceSimulationSuiteSectionSummary = {
+    failed: number;
+    passed: number;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteSection = "fixtures" | "outcomes" | "scenarios" | "sessions" | "tools";
+export type VoiceSimulationSuiteAssertionInput = {
+    maxActions?: number;
+    maxFailed?: number;
+    minPassed?: number;
+    minSections?: number;
+    requiredSections?: VoiceSimulationSuiteSection[];
+    sectionMinimums?: Partial<Record<VoiceSimulationSuiteSection, number>>;
+};
+export type VoiceSimulationSuiteAssertionReport = {
+    actions: number;
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    sections: VoiceSimulationSuiteSection[];
+    sectionTotals: Partial<Record<VoiceSimulationSuiteSection, number>>;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    actionLinks?: {
+        fixtures?: string;
+        outcomes?: string;
+        scenarios?: string;
+        sessions?: string;
+        tools?: string;
+    };
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    include?: {
+        fixtures?: boolean;
+        outcomes?: boolean;
+        scenarios?: boolean;
+        sessions?: boolean;
+        tools?: boolean;
+    };
+    limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    outcomes?: Omit<VoiceOutcomeContractOptions<TSession>, "contracts"> & {
+        contracts: VoiceOutcomeContractDefinition[];
+    };
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    tools?: VoiceToolContractDefinition[];
+};
+export type VoiceSimulationSuiteRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceSimulationSuiteOptions<TSession> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceSimulationSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const runVoiceSimulationSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteOptions<TSession>) => Promise<VoiceSimulationSuiteReport>;
+export declare const assertVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const evaluateVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const createVoiceSimulationSuiteRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteRoutesOptions<TSession>) => 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: VoiceSimulationSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceSimulationSuiteHTML: (report: VoiceSimulationSuiteReport, options?: {
+    title?: string;
+}) => string;
+export type VoiceSimulationSuiteEvalRoutesOptions = VoiceEvalRoutesOptions;
+export {};

package/dist/core/sloCalibration.d.ts

@@ -0,0 +1,185 @@
+import { Elysia } from "elysia";
+import type { VoiceProviderSloThresholdConfig } from "./providerSlo";
+import type { VoiceProductionReadinessRoutesOptions } from "./productionReadiness";
+import type { VoiceProofTrendReport } from "./proofTrends";
+export type VoiceSloCalibrationStatus = "fail" | "pass" | "warn";
+export type VoiceSloCalibrationMetricKey = "interruption" | "liveLatency" | "monitorRun" | "notifierDelivery" | "provider" | "reconnect" | "turnLatency";
+export type VoiceSloCalibrationSample = {
+    generatedAt?: string;
+    interruptionP95Ms?: number;
+    liveP95Ms?: number;
+    monitorRunP95Ms?: number;
+    notifierDeliveryP95Ms?: number;
+    ok?: boolean;
+    providerP95Ms?: number;
+    reconnectP95Ms?: number;
+    runId?: string;
+    source?: string;
+    turnP95Ms?: number;
+};
+export type VoiceSloCalibrationThreshold = {
+    baselineP95Ms?: number;
+    failAfterMs?: number;
+    headroomMultiplier: number;
+    maxObservedMs?: number;
+    metric: VoiceSloCalibrationMetricKey;
+    minimumMs: number;
+    recommendedMs?: number;
+    samples: number;
+    status: VoiceSloCalibrationStatus;
+    warnAfterMs?: number;
+};
+export type VoiceSloCalibrationThresholds = {
+    interruption: VoiceSloCalibrationThreshold;
+    liveLatency: VoiceSloCalibrationThreshold;
+    monitorRun: VoiceSloCalibrationThreshold;
+    notifierDelivery: VoiceSloCalibrationThreshold;
+    provider: VoiceSloCalibrationThreshold;
+    reconnect: VoiceSloCalibrationThreshold;
+    turnLatency: VoiceSloCalibrationThreshold;
+};
+export type VoiceSloCalibrationReport = {
+    generatedAt: string;
+    issues: string[];
+    minPassingRuns: number;
+    ok: boolean;
+    passingRuns: number;
+    recommendedProviderSloThresholds: VoiceProviderSloThresholdConfig;
+    runs: number;
+    sources: string[];
+    status: VoiceSloCalibrationStatus;
+    thresholds: VoiceSloCalibrationThresholds;
+};
+export type VoiceSloThresholdProfile = {
+    bargeIn: {
+        thresholdMs?: number;
+    };
+    issues: string[];
+    liveLatency: {
+        failAfterMs?: number;
+        warnAfterMs?: number;
+    };
+    monitoring: {
+        monitorRunFailAfterMs?: number;
+        notifierDeliveryFailAfterMs?: number;
+    };
+    providerSlo: VoiceProviderSloThresholdConfig;
+    reconnect: {
+        failAfterMs?: number;
+    };
+    status: VoiceSloCalibrationStatus;
+};
+export type VoiceSloReadinessThresholdOptions = Pick<VoiceProductionReadinessRoutesOptions, "liveLatencyFailAfterMs" | "liveLatencyWarnAfterMs" | "monitoringNotifierDeliveryFailAfterMs" | "monitoringRunFailAfterMs" | "reconnectResumeFailAfterMs">;
+export type VoiceSloReadinessThresholdReport = {
+    bargeIn: VoiceSloThresholdProfile["bargeIn"];
+    generatedAt: string;
+    issues: string[];
+    liveLatencyMaxAgeMs?: number;
+    ok: boolean;
+    providerSlo: VoiceProviderSloThresholdConfig;
+    readinessOptions: VoiceSloReadinessThresholdOptions;
+    sources: string[];
+    status: VoiceSloCalibrationStatus;
+};
+export type VoiceSloCalibrationOptions = {
+    headroomMultiplier?: number;
+    liveLatencyMinimumMs?: number;
+    minPassingRuns?: number;
+    monitorRunMinimumMs?: number;
+    notifierDeliveryMinimumMs?: number;
+    providerMinimumMs?: number;
+    reconnectMinimumMs?: number;
+    interruptionMinimumMs?: number;
+    turnLatencyMinimumMs?: number;
+    warnRatio?: number;
+};
+export type VoiceSloCalibrationRoutesOptions = VoiceSloCalibrationOptions & {
+    headers?: HeadersInit;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    source: (() => Promise<Array<VoiceProofTrendReport | VoiceSloCalibrationSample>> | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>) | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>;
+    title?: string;
+};
+export type VoiceSloReadinessThresholdReportOptions = VoiceSloCalibrationOptions & {
+    liveLatencyMaxAgeMs?: number;
+};
+export type VoiceSloReadinessThresholdRoutesOptions = VoiceSloReadinessThresholdReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    source: (() => Promise<VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>> | VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>) | VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>;
+    title?: string;
+};
+export declare const assertVoiceSloCalibration: (input: Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloCalibrationReport;
+export declare const buildVoiceSloCalibrationReport: (input: Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloCalibrationReport;
+export declare const buildVoiceSloReadinessThresholdReport: (input: VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloReadinessThresholdReportOptions) => VoiceSloReadinessThresholdReport;
+export declare const createVoiceSloReadinessThresholdOptions: (input: VoiceSloCalibrationReport | VoiceSloThresholdProfile | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloReadinessThresholdOptions;
+export declare const createVoiceSloThresholdProfile: (input: VoiceSloCalibrationReport | Array<VoiceProofTrendReport | VoiceSloCalibrationSample>, options?: VoiceSloCalibrationOptions) => VoiceSloThresholdProfile;
+export declare const createVoiceSloCalibrationRoutes: (options: VoiceSloCalibrationRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceSloReadinessThresholdRoutes: (options: VoiceSloReadinessThresholdRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceSloCalibrationMarkdown: (report: VoiceSloCalibrationReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceSloReadinessThresholdHTML: (report: VoiceSloReadinessThresholdReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceSloReadinessThresholdMarkdown: (report: VoiceSloReadinessThresholdReport, options?: {
+    title?: string;
+}) => string;

package/dist/{sqliteStore.d.ts → core/sqliteStore.d.ts}

@@ -1,13 +1,20 @@
-import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from './trace';
-import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import { type StoredVoiceTraceEvent, type VoiceTraceSinkDeliveryRecord, type VoiceTraceSinkDeliveryStore, type VoiceTraceEventStore } from "./trace";
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from "./audit";
+import type { VoiceAuditSinkDeliveryRecord, VoiceAuditSinkDeliveryStore } from "./auditSinks";
+import type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMapStore, VoiceIntegrationEventStore, VoiceOpsTaskStore } from "./ops";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "../testing/review";
+import type { VoiceTelephonyWebhookIdempotencyStore } from "./telephonyOutcome";
+import type { VoiceCampaignStore } from "./campaign";
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
 export type VoiceSQLiteStoreOptions = {
     path: string;
     tableName?: string;
     tablePrefix?: string;
 };
-export type VoiceSQLiteRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord> = {
+export type VoiceSQLiteRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = {
+    audit: VoiceAuditEventStore<TAudit>;
+    auditDeliveries: VoiceAuditSinkDeliveryStore<TAuditDelivery>;
+    campaigns: VoiceCampaignStore;
     events: VoiceIntegrationEventStore<TEvent>;
     externalObjects: VoiceExternalObjectMapStore<TMapping>;
     reviews: VoiceCallReviewStore<TReview>;
@@ -16,11 +23,15 @@ export type VoiceSQLiteRuntimeStorage<TSession extends VoiceSessionRecord = Voic
     traceDeliveries: VoiceTraceSinkDeliveryStore<TTraceDelivery>;
     traces: VoiceTraceEventStore<TTrace>;
 };
-export declare const createVoiceSQLiteSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSQLiteStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoiceSQLiteAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceSQLiteStoreOptions) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceSQLiteAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const createVoiceSQLiteCampaignStore: (options: VoiceSQLiteStoreOptions) => VoiceCampaignStore;
+export declare const createVoiceSQLiteExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceSQLiteStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoiceSQLiteIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceSQLiteStoreOptions) => VoiceIntegrationEventStore<TEvent>;
 export declare const createVoiceSQLiteReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceSQLiteStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoiceSQLiteRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord, TAudit extends StoredVoiceAuditEvent = StoredVoiceAuditEvent, TAuditDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceSQLiteRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery, TAudit, TAuditDelivery>;
+export declare const createVoiceSQLiteSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSQLiteStoreOptions) => VoiceSessionStore<TSession>;
 export declare const createVoiceSQLiteTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceSQLiteStoreOptions) => VoiceOpsTaskStore<TTask>;
-export declare const createVoiceSQLiteIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceSQLiteStoreOptions) => VoiceIntegrationEventStore<TEvent>;
-export declare const createVoiceSQLiteExternalObjectMapStore: <TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap>(options: VoiceSQLiteStoreOptions) => VoiceExternalObjectMapStore<TMapping>;
+export declare const createVoiceSQLiteTelephonyWebhookIdempotencyStore: <TResult = unknown>(options: VoiceSQLiteStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
 export declare const createVoiceSQLiteTraceEventStore: <TEvent extends StoredVoiceTraceEvent = StoredVoiceTraceEvent>(options: VoiceSQLiteStoreOptions) => VoiceTraceEventStore<TEvent>;
 export declare const createVoiceSQLiteTraceSinkDeliveryStore: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceTraceSinkDeliveryStore<TDelivery>;
-export declare const createVoiceSQLiteRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent, TMapping extends StoredVoiceExternalObjectMap = StoredVoiceExternalObjectMap, TTrace extends StoredVoiceTraceEvent = StoredVoiceTraceEvent, TTraceDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceSQLiteStoreOptions) => VoiceSQLiteRuntimeStorage<TSession, TReview, TTask, TEvent, TMapping, TTrace, TTraceDelivery>;

package/dist/{store.d.ts → core/store.d.ts}

@@ -1,4 +1,4 @@
-import type { Transcript, VoiceSessionRecord, VoiceSessionSummary } from './types';
+import type { Transcript, VoiceSessionRecord, VoiceSessionSummary } from "./types";
 export declare const createId: () => `${string}-${string}-${string}-${string}-${string}`;
 export declare const createTranscript: (text: string, input?: Partial<Transcript>) => Transcript;
 export declare const createVoiceSessionRecord: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(id: string, scenarioId?: string) => TSession;

package/dist/core/supervisorPermissions.d.ts

@@ -0,0 +1,33 @@
+export type VoiceSupervisorCapability = "monitor" | "annotate" | "coach" | "whisper" | "barge" | "takeover" | "release" | "end-call" | "view-pii" | "export-recording";
+export type VoiceSupervisorTier = "monitor-only" | "annotate" | "coach" | "whisper" | "full-control";
+export type VoiceSupervisorPermission = {
+    supervisorId: string;
+    tier: VoiceSupervisorTier;
+    extraCapabilities?: VoiceSupervisorCapability[];
+    deniedCapabilities?: VoiceSupervisorCapability[];
+    expiresAt?: number;
+};
+export type VoiceSupervisorPermissionCheck = {
+    allowed: boolean;
+    reason?: "no-permission" | "expired" | "denied" | "tier-too-low";
+};
+export type CreateVoiceSupervisorPermissionsOptions = {
+    defaultTier?: VoiceSupervisorTier;
+    permissions?: VoiceSupervisorPermission[];
+    now?: () => number;
+};
+export declare const createVoiceSupervisorPermissions: (options?: CreateVoiceSupervisorPermissionsOptions) => {
+    can: (supervisorId: string, capability: VoiceSupervisorCapability) => VoiceSupervisorPermissionCheck;
+    capabilitiesFor: (supervisorId: string) => VoiceSupervisorCapability[];
+    enforce: (supervisorId: string, capability: VoiceSupervisorCapability) => void;
+    get: (supervisorId: string) => VoiceSupervisorPermission | null;
+    grant: (supervisorId: string, tier: VoiceSupervisorTier, options?: {
+        extraCapabilities?: VoiceSupervisorCapability[];
+        deniedCapabilities?: VoiceSupervisorCapability[];
+        expiresAt?: number;
+    }) => VoiceSupervisorPermission;
+    revoke: (supervisorId: string) => boolean;
+    tiers: () => VoiceSupervisorTier[];
+};
+export type VoiceSupervisorPermissions = ReturnType<typeof createVoiceSupervisorPermissions>;
+export declare const VOICE_SUPERVISOR_TIER_CAPABILITIES: Record<VoiceSupervisorTier, VoiceSupervisorCapability[]>;

package/dist/core/supervisorPresence.d.ts

@@ -0,0 +1,49 @@
+export type VoiceSupervisorRole = "viewer" | "coach" | "whisperer" | "owner";
+export type VoiceSupervisorWatcher = {
+    supervisorId: string;
+    sessionId: string;
+    joinedAt: number;
+    lastSeenAt: number;
+    role: VoiceSupervisorRole;
+    displayName?: string;
+};
+export type VoiceSupervisorPresenceEvent = {
+    type: "join";
+    watcher: VoiceSupervisorWatcher;
+} | {
+    type: "leave";
+    supervisorId: string;
+    sessionId: string;
+    at: number;
+} | {
+    type: "role-change";
+    supervisorId: string;
+    sessionId: string;
+    from: VoiceSupervisorRole;
+    to: VoiceSupervisorRole;
+    at: number;
+} | {
+    type: "heartbeat";
+    supervisorId: string;
+    sessionId: string;
+    at: number;
+};
+export type CreateVoiceSupervisorPresenceOptions = {
+    staleAfterMs?: number;
+    now?: () => number;
+};
+export declare const createVoiceSupervisorPresence: (options?: CreateVoiceSupervisorPresenceOptions) => {
+    heartbeat: (sessionId: string, supervisorId: string) => boolean;
+    join: (input: {
+        supervisorId: string;
+        sessionId: string;
+        role?: VoiceSupervisorRole;
+        displayName?: string;
+    }) => VoiceSupervisorWatcher;
+    leave: (sessionId: string, supervisorId: string) => boolean;
+    list: (sessionId: string) => VoiceSupervisorWatcher[];
+    setRole: (sessionId: string, supervisorId: string, role: VoiceSupervisorRole) => boolean;
+    sessionsWatchedBy(supervisorId: string): string[];
+    subscribe(listener: (event: VoiceSupervisorPresenceEvent) => void): () => void;
+};
+export type VoiceSupervisorPresence = ReturnType<typeof createVoiceSupervisorPresence>;

package/dist/core/telephonyMediaRoutes.d.ts

@@ -0,0 +1,72 @@
+import { Elysia } from "elysia";
+import type { MediaFrame, MediaTelephonyCarrier, MediaTelephonyEnvelope, MediaTelephonyStreamLifecycleReport } from "@absolutejs/media";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceTelephonyMediaStatus = "fail" | "pass";
+export type VoiceTelephonyMediaCarrierInput = {
+    carrier: MediaTelephonyCarrier;
+    envelope?: MediaTelephonyEnvelope;
+    lifecycleEnvelopes?: readonly MediaTelephonyEnvelope[];
+};
+export type VoiceTelephonyMediaCarrierReport = {
+    audioBytes: number;
+    carrier: MediaTelephonyCarrier;
+    frame?: MediaFrame;
+    issues: string[];
+    lifecycle: MediaTelephonyStreamLifecycleReport;
+    serialized?: MediaTelephonyEnvelope;
+    status: VoiceTelephonyMediaStatus;
+};
+export type VoiceTelephonyMediaReport = {
+    carriers: readonly VoiceTelephonyMediaCarrierReport[];
+    checkedAt: number;
+    issues: string[];
+    status: VoiceTelephonyMediaStatus;
+};
+export type VoiceTelephonyMediaRoutesOptions = {
+    carriers?: readonly VoiceTelephonyMediaCarrierInput[];
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    store?: VoiceTraceEventStore;
+    title?: string;
+};
+export type VoiceTelephonyMediaTraceReportOptions = {
+    carriers?: readonly MediaTelephonyCarrier[];
+    store: VoiceTraceEventStore;
+};
+export declare const buildVoiceTelephonyMediaReport: (input?: {
+    carriers?: readonly VoiceTelephonyMediaCarrierInput[];
+}) => VoiceTelephonyMediaReport;
+export declare const createVoiceTelephonyMediaRoutes: (options?: VoiceTelephonyMediaRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const getLatestVoiceTelephonyMediaReport: (options: VoiceTelephonyMediaTraceReportOptions) => Promise<VoiceTelephonyMediaReport | undefined>;
+export declare const renderVoiceTelephonyMediaHTML: (report: VoiceTelephonyMediaReport, options?: {
+    title?: string;
+}) => string;