@absolutejs/voice 0.0.22-beta.52 → 0.0.22-beta.520

package/dist/reconnectContract.d.ts

@@ -0,0 +1,176 @@
+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[];
+};
+export 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 runVoiceReconnectContract: (options: VoiceReconnectContractOptions) => VoiceReconnectContractReport;
+export declare const buildVoiceReconnectProofReport: (options?: VoiceReconnectProofOptions) => VoiceReconnectProofReport;
+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 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: {};
+}>;

package/dist/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/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 encodeStereoWav: ({ format, left, right, }: EncodeStereoWavInput) => Uint8Array;
+export declare const createVoiceWavRecordingEncoder: () => VoiceRecordingEncoder;
+export declare const computePcmDurationMs: (pcmByteLength: number, format: AudioFormat) => number;
+export declare const createVoiceMemoryRecordingStore: () => VoiceRecordingStore;

package/dist/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/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[];
+    list: (appointmentId?: string) => VoiceReminderJob[];
+    markFailed: (jobId: string, error: string) => boolean;
+    markInFlight: (jobId: string) => boolean;
+    markSent: (jobId: string) => boolean;
+    schedule: (input: ScheduleVoiceRemindersInput) => VoiceReminderJob[];
+    subscribe(listener: (job: VoiceReminderJob) => void): () => void;
+};
+export type VoiceReminderScheduler = ReturnType<typeof createVoiceReminderScheduler>;

package/dist/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 summarizeVoiceRoutingSessions: (events: StoredVoiceTraceEvent[] | VoiceRoutingEvent[], options?: VoiceRoutingSessionSummaryOptions) => VoiceRoutingSessionSummary[];
+export declare const createVoiceRoutingDecisionSummary: (options: VoiceRoutingDecisionSummaryOptions) => Promise<VoiceRoutingDecisionSummary | null>;
 export declare const renderVoiceResilienceHTML: (input: VoiceResiliencePageData) => string;
 export declare const createVoiceResilienceRoutes: (options: VoiceResilienceRoutesOptions) => Elysia<"", {
     decorator: {};

package/dist/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/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>;

package/dist/routeAuth.d.ts

@@ -0,0 +1,58 @@
+import { Elysia } from "elysia";
+export type VoiceRouteAuthDecision = {
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+    status?: number;
+};
+export type VoiceRouteAuthInput = {
+    body?: string;
+    headers: Headers;
+    method: string;
+    url: string;
+};
+export type VoiceRouteAuthVerifier = (input: VoiceRouteAuthInput) => Promise<VoiceRouteAuthDecision> | VoiceRouteAuthDecision;
+export type VoiceRouteAuthOptions = {
+    bypassPaths?: ReadonlyArray<string>;
+    name?: string;
+    verify: VoiceRouteAuthVerifier;
+};
+export declare const createVoiceBearerAuthVerifier: (input: {
+    expectedToken: string;
+    headerName?: string;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceHMACAuthVerifier: (input: {
+    secret: string;
+    toleranceMs?: number;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceRouteAuth: (options: VoiceRouteAuthOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

package/dist/routing.d.ts

@@ -1,3 +1,3 @@
-import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from './types';
+import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from "./types";
 export declare const resolveVoiceSTTRoutingStrategy: (goal?: VoiceSTTRoutingGoal) => VoiceSTTRoutingStrategy;
 export declare const createVoiceSTTRoutingCorrectionHandler: (mode?: VoiceSTTRoutingCorrectionMode) => VoiceTurnCorrectionHandler | undefined;

package/dist/runtimeOps.d.ts

@@ -1,6 +1,6 @@
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from './testing/review';
-import type { VoiceOpsTask } from './ops';
-import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from "./testing/review";
+import type { VoiceOpsTask } from "./ops";
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from "./types";
 export declare const createVoiceCallReviewFromSession: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(input: {
     disposition: VoiceCallDisposition;
     generatedAt?: number;

package/dist/s3Store.d.ts

@@ -1,14 +1,29 @@
-import type { S3Client, S3Options } from 'bun';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { S3Client, S3Options } from "bun";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { VoiceRecordingStore } from "./recordingStore";
 export type VoiceS3ReviewStoreFile = {
     delete: () => Promise<void>;
     exists: () => Promise<boolean>;
     text: () => Promise<string>;
     write: (data: string) => Promise<number>;
 };
-export type VoiceS3ReviewStoreClient = Pick<S3Client, 'file' | 'list'>;
+export type VoiceS3ReviewStoreClient = Pick<S3Client, "file" | "list">;
 export type VoiceS3ReviewStoreOptions = S3Options & {
     client?: VoiceS3ReviewStoreClient;
     keyPrefix?: string;
 };
 export declare const createVoiceS3ReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceS3ReviewStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export type VoiceS3RecordingStoreFile = {
+    delete: () => Promise<void>;
+    exists: () => Promise<boolean>;
+    text: () => Promise<string>;
+    bytes: () => Promise<Uint8Array>;
+    write: (data: string | Uint8Array) => Promise<number>;
+};
+export type VoiceS3RecordingStoreClient = Pick<S3Client, "file" | "list">;
+export type VoiceS3RecordingStoreOptions = S3Options & {
+    client?: VoiceS3RecordingStoreClient;
+    keyPrefix?: string;
+    publicUrlBase?: string;
+};
+export declare const createVoiceS3RecordingStore: (options: VoiceS3RecordingStoreOptions) => VoiceRecordingStore;

package/dist/scorecardCalibration.d.ts

@@ -0,0 +1,31 @@
+import type { VoiceScorecard } from "./callScorecard";
+export type VoiceScorecardCalibrationPair = {
+    sessionId: string;
+    human: VoiceScorecard;
+    llm: VoiceScorecard;
+};
+export type VoiceScorecardCalibrationDivergence = {
+    sessionId: string;
+    criterionId: string;
+    humanScore: number;
+    llmScore: number;
+    normalizedGap: number;
+};
+export type VoiceScorecardCalibrationReport = {
+    pairsCompared: number;
+    meanAbsoluteError: number;
+    rootMeanSquareError: number;
+    weightedScoreCorrelation: number;
+    gradeAgreementRate: number;
+    perCriterion: {
+        criterionId: string;
+        meanAbsoluteError: number;
+        averageHumanScore: number;
+        averageLLMScore: number;
+        bias: number;
+    }[];
+    worstDivergences: VoiceScorecardCalibrationDivergence[];
+};
+export declare const computeVoiceScorecardCalibration: (pairs: VoiceScorecardCalibrationPair[], options?: {
+    topDivergences?: number;
+}) => VoiceScorecardCalibrationReport;

package/dist/semanticTurn.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript } from "./types";
+export type VoiceSemanticTurnInput = {
+    audioLevel?: number;
+    lastFinalTranscript?: Transcript;
+    partialText: string;
+    silenceMs: number;
+    transcripts: Transcript[];
+};
+export type VoiceSemanticTurnVerdict = {
+    confidence?: number;
+    endOfTurn: boolean;
+    reason?: string;
+};
+export type VoiceSemanticTurnDetector = {
+    evaluate: (input: VoiceSemanticTurnInput) => Promise<VoiceSemanticTurnVerdict> | VoiceSemanticTurnVerdict;
+};
+export type CreatePunctuationSemanticTurnDetectorOptions = {
+    endPunctuation?: ReadonlyArray<string>;
+    fillerWords?: ReadonlyArray<string>;
+    minPartialWords?: number;
+};
+export declare const createPunctuationSemanticTurnDetector: (options?: CreatePunctuationSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;
+export type CreateRegexSemanticTurnDetectorOptions = {
+    endPattern: RegExp;
+    minPartialWords?: number;
+};
+export declare const createRegexSemanticTurnDetector: (options: CreateRegexSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;

package/dist/session.d.ts

@@ -1,2 +1,2 @@
-import type { CreateVoiceSessionOptions, VoiceSessionHandle, VoiceSessionRecord } from './types';
+import type { CreateVoiceSessionOptions, VoiceSessionHandle, VoiceSessionRecord } from "./types";
 export declare const createVoiceSession: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: CreateVoiceSessionOptions<TContext, TSession, TResult>) => VoiceSessionHandle<TContext, TSession, TResult>;