@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

package/dist/core/realtimeProviderContracts.d.ts

@@ -0,0 +1,133 @@
+import { Elysia } from "elysia";
+import type { VoiceRealtimeChannelReport } from "./realtimeChannel";
+export type VoiceRealtimeProviderContractStatus = "fail" | "pass" | "warn";
+export type VoiceRealtimeProviderContractCapability = "barge-in" | "browser-format-negotiation" | "duplex-audio" | "first-audio-latency" | "raw-pcm" | "reconnect" | "trace-evidence" | "turn-commit";
+export type VoiceRealtimeProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    implementationStatus?: "available" | "planned";
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    readinessHref?: string;
+    realtimeChannel?: VoiceRealtimeChannelReport;
+    requiredCapabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    requiredEnv?: readonly string[];
+    selected?: boolean;
+    traceHref?: string;
+};
+export type VoiceRealtimeProviderPresetProvider = "gemini-live" | "openai-realtime" | (string & {});
+export type VoiceRealtimeProviderContractMatrixPresetOptions<TProvider extends string = VoiceRealtimeProviderPresetProvider> = {
+    capabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    configured?: Record<string, boolean>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Record<string, readonly TProvider[]>;
+    implementationStatus?: Record<string, "available" | "planned">;
+    latencyBudgets?: Record<string, number>;
+    providers?: readonly TProvider[];
+    readinessHref?: string | Record<string, string | undefined>;
+    realtimeChannels?: Record<string, VoiceRealtimeChannelReport | undefined>;
+    requiredCapabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    requiredEnv?: Record<string, readonly string[]>;
+    selected?: TProvider;
+    traceHref?: string | Record<string, string | undefined>;
+};
+export type VoiceRealtimeProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    status: VoiceRealtimeProviderContractStatus;
+};
+export type VoiceRealtimeProviderContractRow<TProvider extends string = string> = {
+    checks: VoiceRealtimeProviderContractCheck[];
+    configured: boolean;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceRealtimeProviderContractStatus;
+};
+export type VoiceRealtimeProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceRealtimeProviderContractDefinition<TProvider>[];
+};
+export type VoiceRealtimeProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceRealtimeProviderContractRow<TProvider>[];
+    status: VoiceRealtimeProviderContractStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceRealtimeProviderContractAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceRealtimeProviderContractStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireSelected?: boolean;
+    requiredCapabilities?: readonly VoiceRealtimeProviderContractCapability[];
+    requiredCheckKeys?: readonly string[];
+    requiredProviders?: readonly TProvider[];
+};
+export type VoiceRealtimeProviderContractAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedProviders: TProvider[];
+    status: VoiceRealtimeProviderContractStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceRealtimeProviderContractRoutesOptions<TProvider extends string = string> = {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    matrix: (() => Promise<VoiceRealtimeProviderContractMatrixInput<TProvider>> | VoiceRealtimeProviderContractMatrixInput<TProvider>) | VoiceRealtimeProviderContractMatrixInput<TProvider>;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceRealtimeProviderContractMatrixReport<TProvider>) => Promise<string> | string;
+    title?: string;
+};
+export declare const assertVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;
+export declare const buildVoiceRealtimeProviderContractMatrix: <TProvider extends string = string>(input: VoiceRealtimeProviderContractMatrixInput<TProvider>) => VoiceRealtimeProviderContractMatrixReport<TProvider>;
+export declare const createVoiceRealtimeProviderContractMatrixPreset: <TProvider extends string = VoiceRealtimeProviderPresetProvider>(options?: VoiceRealtimeProviderContractMatrixPresetOptions<TProvider>) => VoiceRealtimeProviderContractMatrixInput<TProvider>;
+export declare const evaluateVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;
+export declare const createVoiceRealtimeProviderContractRoutes: <TProvider extends string = string>(options: VoiceRealtimeProviderContractRoutesOptions<TProvider>) => 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: {};
+}>;
+export declare const renderVoiceRealtimeProviderContractHTML: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, title?: string) => string;

package/dist/core/reconnectContract.d.ts

@@ -0,0 +1,177 @@
+import { Elysia } from "elysia";
+import type { VoiceReconnectClientState, VoiceSessionRecord, VoiceSessionStore } from "./types";
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceReconnectContractSnapshot = {
+    at: number;
+    reconnect: VoiceReconnectClientState;
+    turnIds?: readonly string[];
+};
+type VoiceReconnectContractIssue = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+};
+export type VoiceReconnectContractReport = {
+    checkedAt: number;
+    issues: VoiceReconnectContractIssue[];
+    pass: boolean;
+    resumeLatencyP95Ms?: number;
+    snapshotCount: number;
+    statuses: VoiceReconnectClientState["status"][];
+    summary: {
+        attempts: number;
+        maxAttempts: number;
+        reconnected: boolean;
+        resumed: boolean;
+        exhausted: boolean;
+        duplicateTurnIds: string[];
+    };
+};
+export type VoiceReconnectContractOptions = {
+    allowNoSnapshots?: boolean;
+    requireReconnect?: boolean;
+    requireResume?: boolean;
+    requireReplayProtection?: boolean;
+    snapshots: readonly VoiceReconnectContractSnapshot[];
+};
+export type VoiceReconnectProofStatus = "fail" | "pass" | "warn";
+export type VoiceReconnectProofReport = {
+    checkedAt: number;
+    contract: VoiceReconnectContractReport;
+    generatedAt: string;
+    ok: boolean;
+    reconnectAware: true;
+    sessionCount: number;
+    snapshotCount: number;
+    status: VoiceReconnectProofStatus;
+    summary: string;
+};
+export type VoiceReconnectProofOptions = {
+    completedSessionCount?: number;
+    maxAttempts?: number;
+    requireObservedReconnect?: boolean;
+    requireReplayProtection?: boolean;
+    requireResumeAfterReconnect?: boolean;
+    sessions?: readonly VoiceSessionRecord[];
+    snapshots?: readonly VoiceReconnectContractSnapshot[];
+};
+export type VoiceReconnectProofRoutesOptions = Omit<VoiceReconnectProofOptions, "completedSessionCount" | "sessions" | "snapshots"> & {
+    getCompletedSessionCount?: () => number | Promise<number>;
+    getSessions?: () => readonly VoiceSessionRecord[] | Promise<readonly VoiceSessionRecord[]>;
+    getSnapshots?: () => readonly VoiceReconnectContractSnapshot[] | Promise<readonly VoiceReconnectContractSnapshot[]>;
+    headers?: HeadersInit;
+    maxCollectedSnapshots?: number;
+    name?: string;
+    path?: string;
+    store?: VoiceSessionStore;
+};
+export type VoiceReconnectContractRoutesOptions = Omit<VoiceReconnectContractOptions, "snapshots"> & {
+    getSnapshots: () => readonly VoiceReconnectContractSnapshot[] | Promise<readonly VoiceReconnectContractSnapshot[]>;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceReconnectContractReport) => string | Promise<string>;
+};
+export declare const summarizeVoiceReconnectContractSnapshots: (events: readonly StoredVoiceTraceEvent[], options?: {
+    sessionId?: string;
+}) => VoiceReconnectContractSnapshot[];
+export declare const summarizeVoiceReconnectProofSessions: (sessions: readonly VoiceSessionRecord[], options?: {
+    maxAttempts?: number;
+}) => VoiceReconnectContractSnapshot[];
+export declare const buildVoiceReconnectProofReport: (options?: VoiceReconnectProofOptions) => VoiceReconnectProofReport;
+export declare const runVoiceReconnectContract: (options: VoiceReconnectContractOptions) => VoiceReconnectContractReport;
+export declare const createVoiceReconnectContractRoutes: (options: VoiceReconnectContractRoutesOptions) => 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: {};
+}>;
+export declare const createVoiceReconnectProofRoutes: (options?: VoiceReconnectProofRoutesOptions) => 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;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceReconnectContractHTML: (report: VoiceReconnectContractReport) => string;
+export {};

package/dist/core/recordingRedaction.d.ts

@@ -0,0 +1,47 @@
+import { type AudioRedactionFill } from "@absolutejs/media";
+import type { AudioFormat, Transcript } from "./types";
+import { type VoiceRedactionPattern } from "./redaction";
+export type VoiceRecordingRedactionRange = {
+    endMs: number;
+    label?: string;
+    startMs: number;
+};
+export type DeriveVoiceRecordingRedactionRangesInput = {
+    /** When the recording starts in epoch ms; used to convert absolute timestamps if transcripts use them. */
+    recordingStartedAtEpochMs?: number;
+    /** Optional padding around redaction ranges, in ms (default 100). */
+    paddingMs?: number;
+    /** Patterns to test against transcripts. Defaults to DEFAULT_VOICE_REDACTION_PATTERNS. */
+    patterns?: ReadonlyArray<VoiceRedactionPattern>;
+    /** Transcripts to scan. */
+    transcripts: ReadonlyArray<Transcript>;
+};
+export declare const deriveVoiceRecordingRedactionRanges: (input: DeriveVoiceRecordingRedactionRangesInput) => VoiceRecordingRedactionRange[];
+export type RedactVoiceRecordingInput = {
+    /** Raw pcm_s16le bytes of the recorded artifact. */
+    pcm: ArrayBuffer | ArrayBufferView;
+    /** Format of the recording (must be raw pcm_s16le). */
+    format: AudioFormat;
+    /** Final transcripts with timing, scanned for sensitive content. */
+    transcripts: ReadonlyArray<Transcript>;
+    recordingStartedAtEpochMs?: number;
+    paddingMs?: number;
+    patterns?: ReadonlyArray<VoiceRedactionPattern>;
+    /** Bleep style — silence (default) or a tone. */
+    fill?: AudioRedactionFill;
+};
+export type RedactVoiceRecordingResult = {
+    /** The redacted pcm_s16le bytes. */
+    bytes: Uint8Array;
+    /** The merged ranges that were bleeped. */
+    ranges: VoiceRecordingRedactionRange[];
+    /** How many ranges were redacted. */
+    redactedCount: number;
+};
+/**
+ * End-to-end recording redaction: derives sensitive ranges from final
+ * transcripts, merges overlaps, and applies the audio bleep via
+ * `@absolutejs/media`'s `applyAudioRedaction`. Returns the redacted bytes
+ * ready to re-store in place of the original artifact.
+ */
+export declare const redactVoiceRecording: (input: RedactVoiceRecordingInput) => RedactVoiceRecordingResult;

package/dist/core/recordingStore.d.ts

@@ -0,0 +1,60 @@
+import type { AudioFormat } from "./types";
+export type VoiceRecordingChannel = "assistant" | "user";
+export type VoiceRecordingArtifact = {
+    audioBytes: Uint8Array;
+    capturedAt: number;
+    channel: VoiceRecordingChannel;
+    durationMs: number;
+    format: AudioFormat;
+    sessionId: string;
+};
+export type StoredVoiceRecordingArtifact = VoiceRecordingArtifact & {
+    recordingUrl?: string;
+};
+export type VoiceRecordingEncoderInput = {
+    channel: VoiceRecordingChannel;
+    format: AudioFormat;
+    pcm: Uint8Array;
+    sessionId: string;
+};
+export type VoiceRecordingEncoderResult = {
+    bytes: Uint8Array;
+    contentType: string;
+    extension: string;
+};
+export type VoiceRecordingEncoder = {
+    encode: (input: VoiceRecordingEncoderInput) => Promise<VoiceRecordingEncoderResult> | VoiceRecordingEncoderResult;
+    kind: string;
+};
+export type VoiceRecordingStore = {
+    get: (sessionId: string, channel: VoiceRecordingChannel) => Promise<StoredVoiceRecordingArtifact | undefined>;
+    list: (sessionId: string) => Promise<StoredVoiceRecordingArtifact[]>;
+    put: (artifact: VoiceRecordingArtifact) => Promise<StoredVoiceRecordingArtifact>;
+};
+export declare const encodePcmAsWav: (pcm: Uint8Array, format: AudioFormat) => Uint8Array;
+export type InterleavePcmInput = {
+    /** Mono PCM bytes for the left channel. */
+    left: Uint8Array;
+    /** Mono PCM bytes for the right channel. */
+    right: Uint8Array;
+};
+/**
+ * Interleaves two mono pcm_s16le buffers into a single stereo pcm_s16le
+ * buffer at the same sample rate. Output length is max(left, right) * 2.
+ * The shorter buffer is right-padded with silence to align frame counts.
+ */
+export declare const interleaveStereoPcm: (input: InterleavePcmInput) => Uint8Array;
+export type EncodeStereoWavInput = {
+    format: AudioFormat;
+    left: Uint8Array;
+    right: Uint8Array;
+};
+/**
+ * Builds a stereo WAV file from two mono pcm_s16le channels. Convention:
+ * left = user track, right = assistant track. Review tools can split them
+ * back out with any DAW.
+ */
+export declare const computePcmDurationMs: (pcmByteLength: number, format: AudioFormat) => number;
+export declare const createVoiceMemoryRecordingStore: () => VoiceRecordingStore;
+export declare const createVoiceWavRecordingEncoder: () => VoiceRecordingEncoder;
+export declare const encodeStereoWav: ({ format, left, right, }: EncodeStereoWavInput) => Uint8Array;

package/dist/core/redaction.d.ts

@@ -0,0 +1,13 @@
+import type { Transcript } from "./types";
+export type VoiceRedactionPattern = {
+    label: string;
+    replacement?: string;
+    regex: RegExp;
+};
+export declare const DEFAULT_VOICE_REDACTION_PATTERNS: VoiceRedactionPattern[];
+export type VoiceTranscriptRedactor = (transcript: Transcript) => Transcript;
+export type CreateVoiceTranscriptRedactorOptions = {
+    patterns?: VoiceRedactionPattern[];
+};
+export declare const createVoiceTranscriptRedactor: (options?: CreateVoiceTranscriptRedactorOptions) => VoiceTranscriptRedactor;
+export declare const redactVoiceTranscript: (transcript: Transcript, patterns?: VoiceRedactionPattern[]) => Transcript;

package/dist/core/reminderScheduler.d.ts

@@ -0,0 +1,43 @@
+export type VoiceReminderChannel = "call" | "sms" | "email";
+export type VoiceReminderTrigger = {
+    id: string;
+    channel: VoiceReminderChannel;
+    offsetMinutesBeforeStart: number;
+    templateId?: string;
+    retryOnFailure?: boolean;
+};
+export type VoiceReminderJob = {
+    id: string;
+    appointmentId: string;
+    triggerId: string;
+    channel: VoiceReminderChannel;
+    scheduledAtMs: number;
+    status: "pending" | "in-flight" | "sent" | "skipped" | "failed" | "cancelled";
+    attempts: number;
+    lastError?: string;
+    metadata?: Record<string, string>;
+};
+export type ScheduleVoiceRemindersInput = {
+    appointmentId: string;
+    appointmentStartMs: number;
+    triggers: VoiceReminderTrigger[];
+    metadata?: Record<string, string>;
+};
+export type CreateVoiceReminderSchedulerOptions = {
+    generateJobId?: () => string;
+    now?: () => number;
+    defaultTriggers?: VoiceReminderTrigger[];
+    maxAttempts?: number;
+};
+export declare const DEFAULT_VOICE_REMINDER_TRIGGERS: VoiceReminderTrigger[];
+export declare const createVoiceReminderScheduler: (options?: CreateVoiceReminderSchedulerOptions) => {
+    cancelForAppointment: (appointmentId: string) => number;
+    due: (at?: number) => VoiceReminderJob[];
+    markFailed: (jobId: string, error: string) => boolean;
+    markInFlight: (jobId: string) => boolean;
+    markSent: (jobId: string) => boolean;
+    schedule: (input: ScheduleVoiceRemindersInput) => VoiceReminderJob[];
+    list: (appointmentId?: string) => VoiceReminderJob[];
+    subscribe(listener: (job: VoiceReminderJob) => void): () => void;
+};
+export type VoiceReminderScheduler = ReturnType<typeof createVoiceReminderScheduler>;

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

@@ -1,8 +1,8 @@
-import { Elysia } from 'elysia';
-import { type VoiceProviderHealthSummary } from './providerHealth';
-import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
-import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from './testing/ioProviderSimulator';
-export type VoiceRoutingEventKind = 'llm' | 'stt' | 'tts';
+import { Elysia } from "elysia";
+import { type VoiceProviderHealthSummary } from "./providerHealth";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from "../testing/ioProviderSimulator";
+export type VoiceRoutingEventKind = "llm" | "stt" | "tts";
 export type VoiceRoutingEvent = {
     at: number;
     attempt?: number;
@@ -12,13 +12,49 @@ export type VoiceRoutingEvent = {
     kind: VoiceRoutingEventKind;
     latencyBudgetMs?: number;
     operation?: string;
+    profileId?: string;
+    profileLabel?: string;
     provider?: string;
+    providerRoutes?: Record<string, string>;
+    routing?: string;
+    scenarioId?: string;
     selectedProvider?: string;
     sessionId: string;
     status?: string;
+    suppressionRemainingMs?: number;
     timedOut: boolean;
     turnId?: string;
 };
+export type VoiceRoutingDecisionSummary = VoiceRoutingEvent;
+export type VoiceRoutingDecisionSummaryOptions = {
+    kind?: VoiceRoutingEventKind;
+    limit?: number;
+    sessionId?: string;
+    store: VoiceTraceEventStore;
+};
+export type VoiceRoutingKindSummary = {
+    errorCount: number;
+    fallbackCount: number;
+    latest?: VoiceRoutingEvent;
+    providers: string[];
+    runCount: number;
+    timeoutCount: number;
+};
+export type VoiceRoutingSessionSummary = {
+    errorCount: number;
+    eventCount: number;
+    fallbackCount: number;
+    kinds: Record<VoiceRoutingEventKind, VoiceRoutingKindSummary>;
+    lastEventAt: number;
+    sessionId: string;
+    startedAt: number;
+    status: "healthy" | "fallback" | "degraded";
+    timeoutCount: number;
+};
+export type VoiceRoutingSessionSummaryOptions = {
+    limit?: number;
+    sessionId?: string;
+};
 export type VoiceResilienceLink = {
     href: string;
     label: string;
@@ -42,6 +78,7 @@ export type VoiceResiliencePageData = {
     links?: readonly VoiceResilienceLink[];
     llmProviderHealth: VoiceProviderHealthSummary<string>[];
     routingEvents: VoiceRoutingEvent[];
+    routingSessions: VoiceRoutingSessionSummary[];
     sttProviderHealth: VoiceProviderHealthSummary<string>[];
     sttSimulation?: VoiceResilienceIOSimulator<string>;
     title?: string;
@@ -63,6 +100,9 @@ export type VoiceResilienceRoutesOptions = {
     ttsSimulation?: VoiceResilienceIOSimulator<string>;
 };
 export declare const listVoiceRoutingEvents: (events: StoredVoiceTraceEvent[]) => VoiceRoutingEvent[];
+export declare const summarizeVoiceRoutingDecision: (events: StoredVoiceTraceEvent[], options?: Omit<VoiceRoutingDecisionSummaryOptions, "store">) => VoiceRoutingDecisionSummary | null;
+export declare const createVoiceRoutingDecisionSummary: (options: VoiceRoutingDecisionSummaryOptions) => Promise<VoiceRoutingDecisionSummary | null>;
+export declare const summarizeVoiceRoutingSessions: (events: StoredVoiceTraceEvent[] | VoiceRoutingEvent[], options?: VoiceRoutingSessionSummaryOptions) => VoiceRoutingSessionSummary[];
 export declare const renderVoiceResilienceHTML: (input: VoiceResiliencePageData) => string;
 export declare const createVoiceResilienceRoutes: (options: VoiceResilienceRoutesOptions) => Elysia<"", {
     decorator: {};

package/dist/core/retention.d.ts

@@ -0,0 +1,37 @@
+export type VoiceRetentionPolicyOptions = {
+    /** Maximum age in milliseconds; events older than this are eligible for purge. */
+    maxAgeMs: number;
+    /** Optional override that returns the timestamp for an event. Defaults to event.at. */
+    resolveAt?: (event: unknown) => number | undefined;
+};
+export type VoiceRetentionStore<TRecord extends {
+    id: string;
+}> = {
+    list: (filter?: Record<string, unknown>) => Promise<TRecord[]> | TRecord[];
+    remove: (id: string) => Promise<void> | void;
+};
+export type VoicePurgeReport = {
+    attempted: number;
+    failed: number;
+    purgedIds: string[];
+    reason: "expired" | "manual";
+    removed: number;
+};
+export declare const purgeVoiceRetentionStore: <TRecord extends {
+    id: string;
+}>(store: VoiceRetentionStore<TRecord>, options: VoiceRetentionPolicyOptions, now?: number) => Promise<VoicePurgeReport>;
+export type VoiceRetentionScheduler = {
+    start: () => void;
+    stop: () => void;
+};
+export type CreateVoiceRetentionSchedulerOptions<TRecord extends {
+    id: string;
+}> = {
+    intervalMs?: number;
+    onReport?: (report: VoicePurgeReport) => void;
+    policy: VoiceRetentionPolicyOptions;
+    store: VoiceRetentionStore<TRecord>;
+};
+export declare const createVoiceRetentionScheduler: <TRecord extends {
+    id: string;
+}>(options: CreateVoiceRetentionSchedulerOptions<TRecord>) => VoiceRetentionScheduler;

package/dist/core/retryPolicy.d.ts

@@ -0,0 +1,38 @@
+export type VoiceRetryDispositionAction = "retry" | "abandon" | "escalate";
+export type VoiceRetryDispositionRule = {
+    disposition: string;
+    action: VoiceRetryDispositionAction;
+    cooldownMs?: number;
+    maxAttemptsOverride?: number;
+};
+export type VoiceRetryAttempt = {
+    disposition: string;
+    at: number;
+};
+export type VoiceRetryDecision = {
+    action: "retry";
+    attemptNumber: number;
+    retryAt: number;
+} | {
+    action: "abandon";
+    reason: "max-attempts" | "non-retryable" | "explicit";
+} | {
+    action: "escalate";
+    reason: string;
+};
+export type CreateVoiceRetryPolicyOptions = {
+    maxAttempts?: number;
+    defaultCooldownMs?: number;
+    jitterMs?: number;
+    backoffMultiplier?: number;
+    rules?: VoiceRetryDispositionRule[];
+    escalateAfterAttempts?: number;
+    now?: () => number;
+};
+export declare const createVoiceRetryPolicy: (options?: CreateVoiceRetryPolicyOptions) => {
+    decide: (history: VoiceRetryAttempt[], lastDisposition: string) => VoiceRetryDecision;
+    maxAttempts: number;
+    rules: () => VoiceRetryDispositionRule[];
+    updateRule(rule: VoiceRetryDispositionRule): void;
+};
+export type VoiceRetryPolicy = ReturnType<typeof createVoiceRetryPolicy>;