@absolutejs/voice 0.0.22-beta.497 → 0.0.22-beta.498

package/dist/assistant.d.ts

@@ -59,7 +59,7 @@ export type VoiceAssistantExperimentOptions<TContext = unknown, TSession extends
     }) => VoiceAssistantVariant<TContext, TSession, TResult> | string | void;
     variants: Array<VoiceAssistantVariant<TContext, TSession, TResult>>;
 };
-type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
+export type VoiceAssistantAgentSource<TContext, TSession extends VoiceSessionRecord, TResult> = {
     agent: VoiceAgent<TContext, TSession, TResult>;
     agents?: never;
     defaultAgentId?: never;
@@ -140,4 +140,3 @@ export declare const summarizeVoiceAssistantRuns: (input: StoredVoiceTraceEvent[
     events?: StoredVoiceTraceEvent[];
     store?: VoiceTraceEventStore;
 }) => Promise<VoiceAssistantRunsSummary>;
-export {};

package/dist/callQuota.d.ts

@@ -0,0 +1,54 @@
+export type VoiceCallQuotaTier = {
+    burstAllowance?: number;
+    customerId: string;
+    monthlyMinutes?: number;
+    reservedConcurrent: number;
+};
+export type VoiceCallReservation = {
+    callId: string;
+    customerId: string;
+    release: () => Promise<void> | void;
+    reservedAt: number;
+};
+export type VoiceCallQuotaRejection = {
+    customerId: string;
+    reason: "concurrency-exceeded" | "customer-not-found" | "monthly-minutes-exceeded";
+    retryAfterMs?: number;
+};
+export type VoiceCallQuotaResult = {
+    ok: false;
+    rejection: VoiceCallQuotaRejection;
+} | {
+    ok: true;
+    reservation: VoiceCallReservation;
+};
+export type VoiceCallQuota = {
+    describe: (customerId: string) => Promise<undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    }> | (undefined | {
+        activeCalls: number;
+        burstAllowance: number;
+        monthlyMinutesUsed: number;
+        reservedConcurrent: number;
+        tier: VoiceCallQuotaTier;
+    });
+    recordMinutes: (input: {
+        callId?: string;
+        customerId: string;
+        minutes: number;
+    }) => Promise<void> | void;
+    reserve: (input: {
+        callId: string;
+        customerId: string;
+    }) => Promise<VoiceCallQuotaResult> | VoiceCallQuotaResult;
+};
+export type CreateInMemoryVoiceCallQuotaOptions = {
+    /** When provided, treat any customer not in the map as denied with 'customer-not-found'. */
+    strict?: boolean;
+    tiers: VoiceCallQuotaTier[];
+};
+export declare const createInMemoryVoiceCallQuota: (options: CreateInMemoryVoiceCallQuotaOptions) => VoiceCallQuota;

package/dist/client/costDashboard.d.ts

@@ -0,0 +1,27 @@
+import type { StoredVoiceTraceEvent } from "../trace";
+export type VoiceCostDashboardBucket = {
+    bucketKey: string;
+    callCount: number;
+    llmUsd: number;
+    sttUsd: number;
+    telephonyMinutes: number;
+    telephonyUsd: number;
+    totalUsd: number;
+    ttsUsd: number;
+};
+export type VoiceCostDashboardReport = {
+    buckets: VoiceCostDashboardBucket[];
+    generatedAt: number;
+    grandTotal: VoiceCostDashboardBucket;
+    windowEndMs: number;
+    windowStartMs: number;
+};
+export type VoiceCostDashboardOptions = {
+    bucketBy?: "day" | "hour" | "month";
+    events: ReadonlyArray<StoredVoiceTraceEvent>;
+    /** Inclusive bucket start filter, epoch ms. */
+    fromMs?: number;
+    /** Inclusive bucket end filter, epoch ms. */
+    toMs?: number;
+};
+export declare const buildVoiceCostDashboardReport: (options: VoiceCostDashboardOptions) => VoiceCostDashboardReport;

package/dist/client/liveCallViewer.d.ts

@@ -0,0 +1,42 @@
+import type { VoiceAgentUIState } from "../agentState";
+export type LiveCallEventKind = "agent_audio" | "agent_text" | "lifecycle" | "transcript" | "tool";
+export type LiveCallTimelineEvent = {
+    at: number;
+    detail?: string;
+    kind: LiveCallEventKind;
+    title: string;
+};
+export type LiveCallViewState = {
+    agentState: VoiceAgentUIState;
+    callDurationMs: number;
+    events: LiveCallTimelineEvent[];
+    isConnected: boolean;
+    isLiveListening: boolean;
+    lastAssistantAt?: number;
+    lastTranscriptAt?: number;
+    partialTranscript: string;
+    sessionId: string;
+};
+export type CreateLiveCallViewerOptions = {
+    bufferLimit?: number;
+    sessionId: string;
+    startedAt?: number;
+};
+export type LiveCallViewer = {
+    applyControl: (control: {
+        reason?: string;
+        type: string;
+    }) => void;
+    applyEvent: (event: LiveCallTimelineEvent) => void;
+    applyMonitorEvent: (event: {
+        payload: Record<string, unknown>;
+        type: string;
+    }) => void;
+    getState: () => LiveCallViewState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    reset: (sessionId: string, startedAt?: number) => void;
+    subscribe: (subscriber: () => void) => () => void;
+};
+export declare const createLiveCallViewer: (options: CreateLiveCallViewerOptions) => LiveCallViewer;

package/dist/client/replayTimeline.d.ts

@@ -0,0 +1,26 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+export type ReplayTimelineEvent = {
+    at: number;
+    category: "agent" | "lifecycle" | "tool" | "user";
+    detail?: string;
+    durationMs?: number;
+    label: string;
+};
+export type ReplayTimelineReport = {
+    duration: number;
+    events: ReplayTimelineEvent[];
+    metadata: {
+        artifactId: string;
+        title: string;
+    };
+    startedAt: number;
+    summary: {
+        agentTurns: number;
+        toolCalls: number;
+        userTurns: number;
+    };
+};
+export type ReplayTimelineInput = {
+    artifact: VoiceCallReviewArtifact;
+};
+export declare const buildReplayTimelineReport: (input: ReplayTimelineInput) => ReplayTimelineReport;

package/dist/defineVoiceAssistant.d.ts

@@ -0,0 +1,68 @@
+import { type VoiceAssistant, type VoiceAssistantAgentSource, type VoiceAssistantGuardrails, type VoiceAssistantMemoryLifecycle } from "./assistant";
+import type { AudioFormat, CreateVoiceSessionOptions, RealtimeAdapter, STTAdapter, TTSAdapter, VoiceLanguageStrategy, VoiceLexiconEntry, VoicePhraseHint, VoiceReconnectConfig, VoiceResolvedSTTFallbackConfig, VoiceResolvedAudioConditioningConfig, VoiceRouteConfig, VoiceSessionRecord, VoiceSessionRecordingConfig, VoiceSessionStore, VoiceSocket, VoiceSTTLifecycle, VoiceTTSProsody, VoiceTurnDetectionConfig } from "./types";
+import type { VoiceAssistantMemoryOptions } from "./assistantMemory";
+import type { VoiceAgentTool } from "./agent";
+import type { VoiceAMDDetector } from "./amdDetector";
+import type { VoiceCostAccountant } from "./costAccounting";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceTranscriptRedactor } from "./redaction";
+import type { VoiceSemanticTurnDetector } from "./semanticTurn";
+import type { VoiceAssistantMode } from "./assistantMode";
+import type { VoiceRuntimeOpsConfig } from "./types";
+export type VoiceAssistantVoiceConfig = {
+    prosody?: VoiceTTSProsody;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
+    stt?: STTAdapter;
+    sttFallback?: VoiceResolvedSTTFallbackConfig;
+    tts?: TTSAdapter;
+};
+export type VoiceAssistantObservabilityConfig = {
+    costAccountant?: VoiceCostAccountant;
+    costTelephony?: {
+        provider?: string;
+    };
+    recording?: VoiceSessionRecordingConfig;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceAssistantDefinition<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    agent: VoiceAssistantAgentSource<TContext, TSession, TResult>;
+    amd?: VoiceAMDDetector<TContext, TSession, TResult>;
+    assistantMode?: VoiceAssistantMode;
+    audioConditioning?: VoiceResolvedAudioConditioningConfig;
+    callSilenceTimeoutMs?: number;
+    guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
+    id: string;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
+    metadata?: Record<string, unknown>;
+    modalities?: ReadonlyArray<"audio" | "text">;
+    ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    observability?: VoiceAssistantObservabilityConfig;
+    phraseHints?: VoicePhraseHint[];
+    redact?: VoiceTranscriptRedactor;
+    route?: Partial<VoiceRouteConfig<TContext, TSession, TResult>>;
+    semanticTurnDetector?: VoiceSemanticTurnDetector;
+    tools?: ReadonlyArray<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
+    turnDetection?: VoiceTurnDetectionConfig;
+    voice: VoiceAssistantVoiceConfig;
+};
+export type VoiceAssistantSessionInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    context: TContext;
+    id: string;
+    reconnect?: Partial<VoiceReconnectConfig>;
+    scenarioId?: string;
+    sessionMetadata?: Record<string, unknown>;
+    socket: VoiceSocket;
+    sttLifecycle?: VoiceSTTLifecycle;
+    store: VoiceSessionStore<TSession>;
+};
+export type DefinedVoiceAssistant<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    assistant: VoiceAssistant<TContext, TSession, TResult>;
+    definition: VoiceAssistantDefinition<TContext, TSession, TResult>;
+    id: string;
+    toSessionOptions: (input: VoiceAssistantSessionInput<TContext, TSession>) => CreateVoiceSessionOptions<TContext, TSession, TResult>;
+};
+export declare const defineVoiceAssistant: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(definition: VoiceAssistantDefinition<TContext, TSession, TResult>) => DefinedVoiceAssistant<TContext, TSession, TResult>;

package/dist/index.d.ts

@@ -75,6 +75,8 @@ export { createVoiceAIJudgeCompletion, createVoiceLLMJudge, } from "./llmJudge";
 export type { CreateVoiceAIJudgeCompletionOptions, CreateVoiceLLMJudgeOptions, VoiceLLMJudge, VoiceLLMJudgeCompletion, VoiceLLMJudgeCriterionVerdict, VoiceLLMJudgeInput, VoiceLLMJudgeRubric, VoiceLLMJudgeRubricCriterion, VoiceLLMJudgeVerdict, } from "./llmJudge";
 export { DEFAULT_VOICE_REDACTION_PATTERNS, createVoiceTranscriptRedactor, redactVoiceTranscript, } from "./redaction";
 export type { CreateVoiceTranscriptRedactorOptions, VoiceRedactionPattern, VoiceTranscriptRedactor, } from "./redaction";
+export { deriveVoiceRecordingRedactionRanges } from "./recordingRedaction";
+export type { DeriveVoiceRecordingRedactionRangesInput, VoiceRecordingRedactionRange, } from "./recordingRedaction";
 export { DEFAULT_VOICE_PRICE_BOOK, createVoiceCostAccountant, } from "./costAccounting";
 export type { CreateVoiceCostAccountantOptions, VoiceCostAccountant, VoiceCostBreakdown, VoiceCostLLMRecord, VoiceCostSTTRecord, VoiceCostTTSRecord, VoiceCostTelephonyRecord, VoicePriceBook, VoiceProviderRates, } from "./costAccounting";
 export { describeVoiceAssistantMode, resolveVoiceAssistantMode, } from "./assistantMode";
@@ -102,6 +104,20 @@ export type { MonologueAMDDetectorOptions, VoiceAMDDetector, VoiceAMDDetectorInp
 export { createVoiceRAGTool, extractVoiceRAGCitations } from "./ragTool";
 export type { VoiceRAGCitationSummary, VoiceRAGCollectionLike, VoiceRAGQueryResult, VoiceRAGSearchInput, VoiceRAGToolArgs, VoiceRAGToolOptions, VoiceRAGToolResult, } from "./ragTool";
 export { createVoiceApiRequestTool, createVoiceDTMFTool, createVoiceEndCallTool, createVoiceTransferCallTool, createVoiceVoicemailDetectionTool, } from "./agentTools";
+export { defineVoiceAssistant } from "./defineVoiceAssistant";
+export type { DefinedVoiceAssistant, VoiceAssistantDefinition, VoiceAssistantObservabilityConfig, VoiceAssistantSessionInput, VoiceAssistantVoiceConfig, } from "./defineVoiceAssistant";
+export { createInMemoryVoiceCallQuota } from "./callQuota";
+export type { CreateInMemoryVoiceCallQuotaOptions, VoiceCallQuota, VoiceCallQuotaRejection, VoiceCallQuotaResult, VoiceCallQuotaTier, VoiceCallReservation, } from "./callQuota";
+export { createVoiceBearerAuthVerifier, createVoiceHMACAuthVerifier, createVoiceRouteAuth, } from "./routeAuth";
+export type { VoiceRouteAuthDecision, VoiceRouteAuthInput, VoiceRouteAuthOptions, VoiceRouteAuthVerifier, } from "./routeAuth";
+export { buildVoiceCostDashboardReport } from "./client/costDashboard";
+export type { VoiceCostDashboardBucket, VoiceCostDashboardOptions, VoiceCostDashboardReport, } from "./client/costDashboard";
+export { createLiveCallViewer } from "./client/liveCallViewer";
+export type { CreateLiveCallViewerOptions, LiveCallEventKind, LiveCallTimelineEvent, LiveCallViewState, LiveCallViewer, } from "./client/liveCallViewer";
+export { buildReplayTimelineReport } from "./client/replayTimeline";
+export type { ReplayTimelineEvent, ReplayTimelineInput, ReplayTimelineReport, } from "./client/replayTimeline";
+export { createVoiceRetentionScheduler, purgeVoiceRetentionStore, } from "./retention";
+export type { CreateVoiceRetentionSchedulerOptions, VoicePurgeReport, VoiceRetentionPolicyOptions, VoiceRetentionScheduler, VoiceRetentionStore, } from "./retention";
 export { fromVapiAssistantConfig } from "./vapiAdapter";
 export type { VapiAssistantConfig, VapiAssistantConfigModel, VapiAssistantConfigTool, VapiAssistantConfigTranscriber, VapiAssistantConfigTransferDestination, VapiAssistantConfigVoice, VapiAssistantMessage, VoiceFromVapiAssistantOptions, VoiceFromVapiAssistantResult, VoiceFromVapiCustomToolFactory, VoiceFromVapiCustomToolInput, VoiceFromVapiDTMFFactory, VoiceFromVapiKnowledgeBase, VoiceFromVapiModelFactory, VoiceFromVapiModelFactoryInput, VoiceFromVapiRouteHints, VoiceFromVapiUnsupportedReason, } from "./vapiAdapter";
 export type { VoiceApiRequestToolArgs, VoiceApiRequestToolFetch, VoiceApiRequestToolHttpMethod, VoiceApiRequestToolOptions, VoiceApiRequestToolResult, VoiceDTMFToolArgs, VoiceDTMFToolOptions, VoiceDTMFToolResult, VoiceEndCallToolArgs, VoiceEndCallToolOptions, VoiceEndCallToolResult, VoiceTransferCallToolArgs, VoiceTransferCallToolDestination, VoiceTransferCallToolOptions, VoiceTransferCallToolResult, VoiceVoicemailDetectionToolArgs, VoiceVoicemailDetectionToolOptions, VoiceVoicemailDetectionToolResult, } from "./agentTools";

package/dist/index.js

@@ -35232,6 +35232,44 @@ var createVoiceTranscriptRedactor = (options = {}) => {
   };
 };
 var redactVoiceTranscript = (transcript, patterns = DEFAULT_VOICE_REDACTION_PATTERNS) => createVoiceTranscriptRedactor({ patterns })(transcript);
+// src/recordingRedaction.ts
+var matchesAnyPattern = (text, patterns) => {
+  for (const pattern of patterns) {
+    pattern.regex.lastIndex = 0;
+    if (pattern.regex.test(text)) {
+      pattern.regex.lastIndex = 0;
+      return pattern;
+    }
+  }
+  return;
+};
+var deriveVoiceRecordingRedactionRanges = (input) => {
+  const patterns = input.patterns ?? DEFAULT_VOICE_REDACTION_PATTERNS;
+  const padding = Math.max(0, input.paddingMs ?? 100);
+  const baseEpoch = input.recordingStartedAtEpochMs;
+  const out = [];
+  for (const transcript of input.transcripts) {
+    if (!transcript.isFinal)
+      continue;
+    if (typeof transcript.startedAtMs !== "number")
+      continue;
+    if (typeof transcript.endedAtMs !== "number")
+      continue;
+    const matched = matchesAnyPattern(transcript.text, patterns);
+    if (!matched)
+      continue;
+    const absStart = transcript.startedAtMs;
+    const absEnd = transcript.endedAtMs;
+    const start = typeof baseEpoch === "number" && absStart >= baseEpoch ? absStart - baseEpoch : absStart;
+    const end = typeof baseEpoch === "number" && absEnd >= baseEpoch ? absEnd - baseEpoch : absEnd;
+    out.push({
+      endMs: end + padding,
+      label: matched.label,
+      startMs: Math.max(0, start - padding)
+    });
+  }
+  return out;
+};
 // src/costAccounting.ts
 var DEFAULT_VOICE_PRICE_BOOK = {
   "anthropic:claude-opus-4-5": {
@@ -36481,6 +36519,524 @@ var createVoiceApiRequestTool = (options) => {
     resultToMessage: options.formatResult ?? ((result) => result.ok ? `API request ${options.name} succeeded (${String(result.status)}).` : `API request ${options.name} failed with status ${String(result.status)}.`)
   });
 };
+// src/defineVoiceAssistant.ts
+var DEFAULT_SPEECH_THRESHOLD2 = 0.015;
+var DEFAULT_SILENCE_MS2 = 700;
+var DEFAULT_TRANSCRIPT_STABILITY_MS2 = 200;
+var resolveTurnDetection = (input) => ({
+  profile: input?.profile ?? "balanced",
+  qualityProfile: input?.qualityProfile ?? "general",
+  silenceMs: input?.silenceMs ?? DEFAULT_SILENCE_MS2,
+  speechThreshold: input?.speechThreshold ?? DEFAULT_SPEECH_THRESHOLD2,
+  transcriptStabilityMs: input?.transcriptStabilityMs ?? DEFAULT_TRANSCRIPT_STABILITY_MS2
+});
+var resolveReconnect = (input) => ({
+  maxAttempts: input?.maxAttempts ?? 3,
+  strategy: input?.strategy ?? "resume-last-turn",
+  timeout: input?.timeout ?? 30000
+});
+var buildAssistantOptions = (def) => ({
+  ...def.agent,
+  guardrails: def.guardrails,
+  id: def.id,
+  memory: def.memory,
+  memoryLifecycle: def.memoryLifecycle,
+  ops: def.ops
+});
+var defineVoiceAssistant = (definition) => {
+  const assistantOptions = buildAssistantOptions(definition);
+  const assistant = createVoiceAssistant(assistantOptions);
+  return {
+    assistant,
+    definition,
+    id: definition.id,
+    toSessionOptions: (input) => {
+      const route = assistant.route(definition.route ?? {});
+      const observability = definition.observability ?? {};
+      return {
+        amd: definition.amd,
+        assistantMode: definition.assistantMode,
+        audioConditioning: definition.audioConditioning,
+        callSilenceTimeoutMs: definition.callSilenceTimeoutMs,
+        context: input.context,
+        costAccountant: observability.costAccountant,
+        costTelephony: observability.costTelephony,
+        id: input.id,
+        languageStrategy: definition.languageStrategy,
+        lexicon: definition.lexicon,
+        modalities: definition.modalities,
+        phraseHints: definition.phraseHints,
+        prosody: definition.voice.prosody,
+        realtime: definition.voice.realtime,
+        realtimeInputFormat: definition.voice.realtimeInputFormat,
+        reconnect: resolveReconnect(input.reconnect),
+        recording: observability.recording,
+        redact: definition.redact,
+        route,
+        scenarioId: input.scenarioId,
+        semanticTurnDetector: definition.semanticTurnDetector,
+        sessionMetadata: { ...definition.metadata, ...input.sessionMetadata },
+        socket: input.socket,
+        store: input.store,
+        stt: definition.voice.stt,
+        sttFallback: definition.voice.sttFallback,
+        sttLifecycle: input.sttLifecycle ?? "continuous",
+        trace: observability.trace,
+        tts: definition.voice.tts,
+        turnDetection: resolveTurnDetection(definition.turnDetection)
+      };
+    }
+  };
+};
+// src/callQuota.ts
+var monthBucketKey = (epochMs) => {
+  const date = new Date(epochMs);
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}`;
+};
+var createInMemoryVoiceCallQuota = (options) => {
+  const tiers = new Map(options.tiers.map((tier) => [tier.customerId, tier]));
+  const activeCalls = new Map;
+  const monthlyUsage = new Map;
+  const usageFor = (customerId) => {
+    const key = monthBucketKey(Date.now());
+    let bucket = monthlyUsage.get(customerId);
+    if (!bucket) {
+      bucket = new Map;
+      monthlyUsage.set(customerId, bucket);
+    }
+    return { bucket, key };
+  };
+  return {
+    describe: (customerId) => {
+      const tier = tiers.get(customerId);
+      if (!tier)
+        return;
+      const active = activeCalls.get(customerId)?.size ?? 0;
+      const { bucket, key } = usageFor(customerId);
+      return {
+        activeCalls: active,
+        burstAllowance: tier.burstAllowance ?? 0,
+        monthlyMinutesUsed: bucket.get(key) ?? 0,
+        reservedConcurrent: tier.reservedConcurrent,
+        tier
+      };
+    },
+    recordMinutes: ({ customerId, minutes }) => {
+      const { bucket, key } = usageFor(customerId);
+      bucket.set(key, (bucket.get(key) ?? 0) + Math.max(0, minutes));
+    },
+    reserve: ({ callId, customerId }) => {
+      const tier = tiers.get(customerId);
+      if (!tier) {
+        if (options.strict) {
+          return {
+            ok: false,
+            rejection: { customerId, reason: "customer-not-found" }
+          };
+        }
+        return {
+          ok: true,
+          reservation: {
+            callId,
+            customerId,
+            release: () => {},
+            reservedAt: Date.now()
+          }
+        };
+      }
+      const limit = tier.reservedConcurrent + (tier.burstAllowance ?? 0);
+      const set = activeCalls.get(customerId) ?? new Set;
+      if (set.size >= limit) {
+        return {
+          ok: false,
+          rejection: {
+            customerId,
+            reason: "concurrency-exceeded",
+            retryAfterMs: 30000
+          }
+        };
+      }
+      if (typeof tier.monthlyMinutes === "number") {
+        const { bucket, key } = usageFor(customerId);
+        if ((bucket.get(key) ?? 0) >= tier.monthlyMinutes) {
+          return {
+            ok: false,
+            rejection: {
+              customerId,
+              reason: "monthly-minutes-exceeded"
+            }
+          };
+        }
+      }
+      set.add(callId);
+      activeCalls.set(customerId, set);
+      return {
+        ok: true,
+        reservation: {
+          callId,
+          customerId,
+          release: () => {
+            set.delete(callId);
+            if (set.size === 0)
+              activeCalls.delete(customerId);
+          },
+          reservedAt: Date.now()
+        }
+      };
+    }
+  };
+};
+// src/routeAuth.ts
+import { Elysia as Elysia53 } from "elysia";
+var createVoiceBearerAuthVerifier = (input) => {
+  const headerName = (input.headerName ?? "authorization").toLowerCase();
+  const expected = `Bearer ${input.expectedToken}`;
+  return ({ headers }) => {
+    const value = headers.get(headerName);
+    if (!value) {
+      return { allow: false, reason: "missing-bearer", status: 401 };
+    }
+    if (value !== expected) {
+      return { allow: false, reason: "bearer-mismatch", status: 401 };
+    }
+    return { allow: true };
+  };
+};
+var createVoiceHMACAuthVerifier = (input) => {
+  return async ({ body, headers }) => {
+    const { signature, timestamp } = extractVoiceWebhookSignatureFromHeaders(headers);
+    const result = await verifyVoiceWebhookSignature({
+      body: body ?? "",
+      secret: input.secret,
+      signature,
+      timestamp,
+      toleranceMs: input.toleranceMs
+    });
+    if (!result.ok) {
+      return { allow: false, reason: result.reason, status: 401 };
+    }
+    return { allow: true };
+  };
+};
+var isBypassed = (bypassPaths, url) => {
+  for (const path of bypassPaths) {
+    if (url.includes(path))
+      return true;
+  }
+  return false;
+};
+var createVoiceRouteAuth = (options) => {
+  const bypassPaths = options.bypassPaths ?? [];
+  return new Elysia53({ name: options.name ?? "voice-route-auth" }).onRequest(async ({ request, set }) => {
+    const url = request.url;
+    if (isBypassed(bypassPaths, url))
+      return;
+    const cloned = request.clone();
+    const body = request.method === "GET" || request.method === "HEAD" ? "" : await cloned.text().catch(() => "");
+    const decision = await Promise.resolve(options.verify({
+      body,
+      headers: request.headers,
+      method: request.method,
+      url
+    }));
+    if (!decision.allow) {
+      set.status = decision.status ?? 401;
+      return new Response(JSON.stringify({ error: decision.reason, ok: false }), {
+        headers: { "content-type": "application/json" },
+        status: decision.status ?? 401
+      });
+    }
+  });
+};
+// src/client/costDashboard.ts
+var padTwo = (value) => String(value).padStart(2, "0");
+var formatBucketKey = (epochMs, bucketBy) => {
+  const date = new Date(epochMs);
+  const y = date.getUTCFullYear();
+  const m = padTwo(date.getUTCMonth() + 1);
+  const d = padTwo(date.getUTCDate());
+  const h = padTwo(date.getUTCHours());
+  if (bucketBy === "month")
+    return `${y}-${m}`;
+  if (bucketBy === "day")
+    return `${y}-${m}-${d}`;
+  return `${y}-${m}-${d}T${h}`;
+};
+var isCostBreakdown = (value) => Boolean(value) && typeof value === "object" && typeof value.totalUsd === "number";
+var emptyBucket = (bucketKey2) => ({
+  bucketKey: bucketKey2,
+  callCount: 0,
+  llmUsd: 0,
+  sttUsd: 0,
+  telephonyMinutes: 0,
+  telephonyUsd: 0,
+  totalUsd: 0,
+  ttsUsd: 0
+});
+var accumulate = (bucket, payload) => {
+  bucket.callCount += 1;
+  bucket.llmUsd += payload.llm.usd;
+  bucket.sttUsd += payload.stt.usd;
+  bucket.ttsUsd += payload.tts.usd;
+  bucket.telephonyUsd += payload.telephony.usd;
+  bucket.telephonyMinutes += payload.telephony.minutes;
+  bucket.totalUsd += payload.totalUsd;
+};
+var roundCurrency = (bucket) => {
+  bucket.llmUsd = Math.round(bucket.llmUsd * 1e6) / 1e6;
+  bucket.sttUsd = Math.round(bucket.sttUsd * 1e6) / 1e6;
+  bucket.ttsUsd = Math.round(bucket.ttsUsd * 1e6) / 1e6;
+  bucket.telephonyUsd = Math.round(bucket.telephonyUsd * 1e6) / 1e6;
+  bucket.totalUsd = Math.round(bucket.totalUsd * 1e6) / 1e6;
+};
+var buildVoiceCostDashboardReport = (options) => {
+  const bucketBy = options.bucketBy ?? "day";
+  const fromMs = options.fromMs ?? Number.NEGATIVE_INFINITY;
+  const toMs = options.toMs ?? Number.POSITIVE_INFINITY;
+  const buckets = new Map;
+  const grandTotal = emptyBucket("total");
+  let minMs = Number.POSITIVE_INFINITY;
+  let maxMs = Number.NEGATIVE_INFINITY;
+  for (const event of options.events) {
+    if (event.type !== "cost.ready")
+      continue;
+    if (event.at < fromMs || event.at > toMs)
+      continue;
+    if (!isCostBreakdown(event.payload))
+      continue;
+    minMs = Math.min(minMs, event.at);
+    maxMs = Math.max(maxMs, event.at);
+    const bucketKey2 = formatBucketKey(event.at, bucketBy);
+    let bucket = buckets.get(bucketKey2);
+    if (!bucket) {
+      bucket = emptyBucket(bucketKey2);
+      buckets.set(bucketKey2, bucket);
+    }
+    accumulate(bucket, event.payload);
+    accumulate(grandTotal, event.payload);
+  }
+  for (const bucket of buckets.values()) {
+    roundCurrency(bucket);
+  }
+  roundCurrency(grandTotal);
+  return {
+    buckets: Array.from(buckets.values()).sort((a, b) => a.bucketKey.localeCompare(b.bucketKey)),
+    generatedAt: Date.now(),
+    grandTotal,
+    windowEndMs: Number.isFinite(maxMs) ? maxMs : 0,
+    windowStartMs: Number.isFinite(minMs) ? minMs : 0
+  };
+};
+// src/client/liveCallViewer.ts
+var EVENT_BUFFER_LIMIT = 200;
+var createLiveCallViewer = (options) => {
+  const bufferLimit = options.bufferLimit ?? EVENT_BUFFER_LIMIT;
+  const subscribers = new Set;
+  let state = {
+    agentState: "idle",
+    callDurationMs: 0,
+    events: [],
+    isConnected: true,
+    isLiveListening: true,
+    partialTranscript: "",
+    sessionId: options.sessionId
+  };
+  const startedAt = options.startedAt ?? Date.now();
+  const notify = () => {
+    for (const subscriber of subscribers)
+      subscriber();
+  };
+  const update = (next) => {
+    state = { ...state, ...next };
+    state.callDurationMs = Math.max(0, Date.now() - startedAt);
+    state.agentState = deriveVoiceAgentUIState({
+      hasActivePartial: state.partialTranscript.length > 0,
+      isConnected: state.isConnected,
+      isPlaying: false,
+      isRecording: state.isLiveListening,
+      lastAssistantAt: state.lastAssistantAt,
+      lastTranscriptAt: state.lastTranscriptAt
+    });
+    notify();
+  };
+  const pushEvent = (event) => {
+    const next = state.events.concat(event);
+    if (next.length > bufferLimit) {
+      next.splice(0, next.length - bufferLimit);
+    }
+    update({ events: next });
+  };
+  return {
+    applyControl: (control) => {
+      pushEvent({
+        at: Date.now(),
+        detail: control.reason,
+        kind: "lifecycle",
+        title: `control:${control.type}`
+      });
+    },
+    applyEvent: pushEvent,
+    applyMonitorEvent: ({ payload, type }) => {
+      pushEvent({
+        at: Date.now(),
+        detail: JSON.stringify(payload).slice(0, 240),
+        kind: type === "call.lifecycle" ? "lifecycle" : "lifecycle",
+        title: type
+      });
+    },
+    getState: () => state,
+    noteAgentAudio: (at) => {
+      const ts = at ?? Date.now();
+      update({ lastAssistantAt: ts });
+      pushEvent({
+        at: ts,
+        kind: "agent_audio",
+        title: "Agent audio frame"
+      });
+    },
+    notePartial: (text, at) => {
+      update({ partialTranscript: text });
+      if (text) {
+        pushEvent({
+          at: at ?? Date.now(),
+          detail: text,
+          kind: "transcript",
+          title: "Partial"
+        });
+      }
+    },
+    noteTranscript: (text, at) => {
+      const ts = at ?? Date.now();
+      update({ lastTranscriptAt: ts, partialTranscript: "" });
+      pushEvent({
+        at: ts,
+        detail: text,
+        kind: "transcript",
+        title: "Final transcript"
+      });
+    },
+    reset: (sessionId, startedAtOverride) => {
+      state = {
+        agentState: "idle",
+        callDurationMs: 0,
+        events: [],
+        isConnected: true,
+        isLiveListening: true,
+        partialTranscript: "",
+        sessionId
+      };
+      if (typeof startedAtOverride === "number") {}
+      notify();
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => subscribers.delete(subscriber);
+    }
+  };
+};
+// src/client/replayTimeline.ts
+var categorize = (entry) => {
+  const event = entry.event.toLowerCase();
+  if (event.startsWith("stt.") || event.includes("user"))
+    return "user";
+  if (event.startsWith("tts.") || event.includes("assistant") || event.includes("agent"))
+    return "agent";
+  if (event.startsWith("tool.") || event.includes("tool"))
+    return "tool";
+  return "lifecycle";
+};
+var buildReplayTimelineReport = (input) => {
+  const events = [];
+  let summaryAgentTurns = 0;
+  let summaryUserTurns = 0;
+  let summaryToolCalls = 0;
+  for (const entry of input.artifact.timeline ?? []) {
+    const category = categorize(entry);
+    if (category === "user")
+      summaryUserTurns += 1;
+    if (category === "agent")
+      summaryAgentTurns += 1;
+    if (category === "tool")
+      summaryToolCalls += 1;
+    events.push({
+      at: entry.atMs,
+      category,
+      detail: entry.text ?? entry.reason,
+      durationMs: entry.chunkDurationMs,
+      label: entry.event
+    });
+  }
+  events.sort((a, b) => a.at - b.at);
+  const first = events[0]?.at ?? 0;
+  const last = events.at(-1)?.at ?? first;
+  return {
+    duration: last - first,
+    events,
+    metadata: {
+      artifactId: input.artifact.id ?? "",
+      title: input.artifact.title
+    },
+    startedAt: first,
+    summary: {
+      agentTurns: summaryAgentTurns,
+      toolCalls: summaryToolCalls,
+      userTurns: summaryUserTurns
+    }
+  };
+};
+// src/retention.ts
+var defaultResolveAt = (event) => {
+  if (!event || typeof event !== "object")
+    return;
+  const value = event.at;
+  return typeof value === "number" ? value : undefined;
+};
+var purgeVoiceRetentionStore = async (store, options, now = Date.now()) => {
+  const resolveAt = options.resolveAt ?? defaultResolveAt;
+  const cutoff = now - Math.max(0, options.maxAgeMs);
+  const records = await Promise.resolve(store.list());
+  const purgedIds = [];
+  let attempted = 0;
+  let removed = 0;
+  let failed = 0;
+  for (const record of records) {
+    const at = resolveAt(record);
+    if (typeof at !== "number" || at >= cutoff)
+      continue;
+    attempted += 1;
+    try {
+      await Promise.resolve(store.remove(record.id));
+      purgedIds.push(record.id);
+      removed += 1;
+    } catch {
+      failed += 1;
+    }
+  }
+  return { attempted, failed, purgedIds, reason: "expired", removed };
+};
+var createVoiceRetentionScheduler = (options) => {
+  const intervalMs = Math.max(60000, options.intervalMs ?? 6 * 60 * 60000);
+  let timer;
+  const run = async () => {
+    const report = await purgeVoiceRetentionStore(options.store, options.policy);
+    options.onReport?.(report);
+  };
+  return {
+    start: () => {
+      if (timer)
+        return;
+      timer = setInterval(() => {
+        run();
+      }, intervalMs);
+    },
+    stop: () => {
+      if (!timer)
+        return;
+      clearInterval(timer);
+      timer = undefined;
+    }
+  };
+};
 // src/vapiAdapter.ts
 var VAPI_BUILT_IN_VARIABLES = {
   date: () => new Date().toISOString().slice(0, 10),
@@ -37064,7 +37620,7 @@ var assertVoiceAgentSquadContractEvidence = (reports, input = {}) => {
   return report;
 };
 // src/turnLatency.ts
-import { Elysia as Elysia53 } from "elysia";
+import { Elysia as Elysia54 } from "elysia";
 var DEFAULT_WARN_AFTER_MS2 = 1800;
 var DEFAULT_FAIL_AFTER_MS2 = 3200;
 var escapeHtml50 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
@@ -37224,7 +37780,7 @@ var createVoiceTurnLatencyHTMLHandler = (options) => async () => {
 var createVoiceTurnLatencyRoutes = (options) => {
   const path = options.path ?? "/api/turn-latency";
   const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
-  const routes = new Elysia53({
+  const routes = new Elysia54({
     name: options.name ?? "absolutejs-voice-turn-latency"
   }).get(path, createVoiceTurnLatencyJSONHandler(options));
   if (htmlPath) {
@@ -37233,7 +37789,7 @@ var createVoiceTurnLatencyRoutes = (options) => {
   return routes;
 };
 // src/liveLatency.ts
-import { Elysia as Elysia54 } from "elysia";
+import { Elysia as Elysia55 } from "elysia";
 var escapeHtml51 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var percentile6 = (values, percentileValue) => {
   if (values.length === 0) {
@@ -37307,7 +37863,7 @@ await traceStore.append({
 var createVoiceLiveLatencyRoutes = (options) => {
   const path = options.path ?? "/api/live-latency";
   const htmlPath = options.htmlPath === undefined ? "/live-latency" : options.htmlPath;
-  const routes = new Elysia54({
+  const routes = new Elysia55({
     name: options.name ?? "absolutejs-voice-live-latency"
   }).get(path, () => summarizeVoiceLiveLatency(options));
   if (htmlPath) {
@@ -37324,7 +37880,7 @@ var createVoiceLiveLatencyRoutes = (options) => {
   return routes;
 };
 // src/turnQuality.ts
-import { Elysia as Elysia55 } from "elysia";
+import { Elysia as Elysia56 } from "elysia";
 var DEFAULT_CONFIDENCE_WARN_THRESHOLD = 0.72;
 var escapeHtml52 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var getTurnLatencyMs = (turn) => {
@@ -37430,7 +37986,7 @@ var createVoiceTurnQualityHTMLHandler = (options) => async () => {
 var createVoiceTurnQualityRoutes = (options) => {
   const path = options.path ?? "/api/turn-quality";
   const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
-  const routes = new Elysia55({
+  const routes = new Elysia56({
     name: options.name ?? "absolutejs-voice-turn-quality"
   }).get(path, createVoiceTurnQualityJSONHandler(options));
   if (htmlPath) {
@@ -37439,10 +37995,10 @@ var createVoiceTurnQualityRoutes = (options) => {
   return routes;
 };
 // src/phoneAgent.ts
-import { Elysia as Elysia57 } from "elysia";
+import { Elysia as Elysia58 } from "elysia";
 
 // src/phoneAgentProductionSmoke.ts
-import { Elysia as Elysia56 } from "elysia";
+import { Elysia as Elysia57 } from "elysia";
 var defaultRequirements = [
   "media-started",
   "transcript",
@@ -37585,7 +38141,7 @@ var createVoicePhoneAgentProductionSmokeHTMLHandler = (options) => async ({
 var createVoicePhoneAgentProductionSmokeRoutes = (options) => {
   const path = options.path ?? "/api/voice/phone/smoke-contract";
   const htmlPath = options.htmlPath === undefined ? "/voice/phone/smoke-contract" : options.htmlPath;
-  const routes = new Elysia56({
+  const routes = new Elysia57({
     name: options.name ?? "absolutejs-voice-phone-smoke-contract"
   }).get(path, createVoicePhoneAgentProductionSmokeJSONHandler(options));
   if (htmlPath) {
@@ -37916,7 +38472,7 @@ var createVoicePhoneAgent = (options) => {
     setupPath: resolveSetupPath(carrier),
     smokePath: resolveSmokePath(carrier)
   }));
-  const app = new Elysia57({
+  const app = new Elysia58({
     name: options.name ?? "absolutejs-voice-phone-agent"
   });
   for (const carrier of options.carriers) {
@@ -39725,7 +40281,7 @@ var createOpenAIVoiceTTS = (options) => {
   };
 };
 // src/providerCapabilities.ts
-import { Elysia as Elysia58 } from "elysia";
+import { Elysia as Elysia59 } from "elysia";
 var escapeHtml55 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var fromProviderList = (kind, providers, options) => (providers ?? []).map((provider) => ({
   configured: true,
@@ -39828,7 +40384,7 @@ var createVoiceProviderCapabilityHTMLHandler = (options) => async () => {
 var createVoiceProviderCapabilityRoutes = (options) => {
   const path = options.path ?? "/api/provider-capabilities";
   const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
-  const routes = new Elysia58({
+  const routes = new Elysia59({
     name: options.name ?? "absolutejs-voice-provider-capabilities"
   }).get(path, createVoiceProviderCapabilityJSONHandler(options));
   if (htmlPath) {
@@ -39837,7 +40393,7 @@ var createVoiceProviderCapabilityRoutes = (options) => {
   return routes;
 };
 // src/providerOrchestration.ts
-import { Elysia as Elysia59 } from "elysia";
+import { Elysia as Elysia60 } from "elysia";
 var defaultRequirement = {
   minProviders: 1,
   requireBudgetPolicy: false,
@@ -40013,7 +40569,7 @@ var createVoiceProviderOrchestrationRoutes = (options) => {
   const path = options.path ?? "/api/voice/provider-orchestration";
   const htmlPath = options.htmlPath === undefined ? "/voice/provider-orchestration" : options.htmlPath;
   const markdownPath = options.markdownPath === undefined ? "/voice/provider-orchestration.md" : options.markdownPath;
-  const routes = new Elysia59({
+  const routes = new Elysia60({
     name: options.name ?? "absolutejs-voice-provider-orchestration"
   }).get(path, () => buildVoiceProviderOrchestrationReport(options));
   if (htmlPath) {
@@ -40186,7 +40742,7 @@ var assertVoiceProviderRoutingContractEvidence = (reports, input = {}) => {
   return report;
 };
 // src/voiceMonitoring.ts
-import { Elysia as Elysia60 } from "elysia";
+import { Elysia as Elysia61 } from "elysia";
 var escapeHtml57 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var issueIdForRun = (run) => `voice-monitor:${run.id}:${run.impactedSessions?.[0] ?? "global"}`;
 var rollupStatus5 = (runs) => runs.some((run) => run.status === "fail") ? "fail" : runs.some((run) => run.status === "warn") ? "warn" : "pass";
@@ -40471,7 +41027,7 @@ var createVoiceMonitorRoutes = (options) => {
     monitors: options.monitors,
     now: options.now
   });
-  const routes = new Elysia60({
+  const routes = new Elysia61({
     name: options.name ?? "absolutejs-voice-monitoring"
   }).get(path, report).get(`${path}.md`, async () => {
     return new Response(renderVoiceMonitorMarkdown(await report()), {
@@ -40518,7 +41074,7 @@ var createVoiceMonitorRoutes = (options) => {
 };
 var createVoiceMonitorRunnerRoutes = (options) => {
   const path = options.path ?? "/api/voice/monitor-runner";
-  return new Elysia60({
+  return new Elysia61({
     name: options.name ?? "absolutejs-voice-monitor-runner"
   }).get(path, () => ({
     isRunning: options.runner.isRunning()
@@ -40906,7 +41462,7 @@ var recommendVoiceReadinessProfile = (options) => {
   };
 };
 // src/providerStackRecommendations.ts
-import { Elysia as Elysia61 } from "elysia";
+import { Elysia as Elysia62 } from "elysia";
 var escapeHtml58 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var profileProviderPriorities = {
   "meeting-recorder": {
@@ -41268,7 +41824,7 @@ var createVoiceProviderContractMatrixHTMLHandler = (options) => async () => {
 var createVoiceProviderContractMatrixRoutes = (options) => {
   const path = options.path ?? "/api/provider-contracts";
   const htmlPath = options.htmlPath ?? "/provider-contracts";
-  const routes = new Elysia61({
+  const routes = new Elysia62({
     name: options.name ?? "absolutejs-voice-provider-contract-matrix"
   });
   const jsonHandler = createVoiceProviderContractMatrixJSONHandler(options.matrix);
@@ -41386,7 +41942,7 @@ var assertVoiceProviderStackEvidence = (report, input = {}) => {
   return assertion;
 };
 // src/opsConsoleRoutes.ts
-import { Elysia as Elysia62 } from "elysia";
+import { Elysia as Elysia63 } from "elysia";
 var DEFAULT_LINKS = [
   {
     description: "Quality gates for CI, deploy checks, and production readiness.",
@@ -41503,7 +42059,7 @@ var renderVoiceOpsConsoleHTML = (report, options = {}) => {
 };
 var createVoiceOpsConsoleRoutes = (options) => {
   const path = options.path ?? "/ops-console";
-  const routes = new Elysia62({
+  const routes = new Elysia63({
     name: options.name ?? "absolutejs-voice-ops-console"
   });
   const getReport = () => buildVoiceOpsConsoleReport(options);
@@ -41520,7 +42076,7 @@ var createVoiceOpsConsoleRoutes = (options) => {
   return routes;
 };
 // src/incidentBundle.ts
-import { Elysia as Elysia63 } from "elysia";
+import { Elysia as Elysia64 } from "elysia";
 var filterIncidentBundleArtifacts = (artifacts, filter = {}) => artifacts.filter((artifact) => {
   if (filter.sessionId && artifact.sessionId !== filter.sessionId) {
     return false;
@@ -41737,7 +42293,7 @@ var buildVoiceIncidentBundle = async (options) => {
 var createVoiceIncidentBundleRoutes = (options) => {
   const path = options.path ?? "/api/voice-incidents/:sessionId";
   const markdownPath = options.markdownPath === undefined ? "/voice-incidents/:sessionId/markdown" : options.markdownPath;
-  const routes = new Elysia63({
+  const routes = new Elysia64({
     name: options.name ?? "absolutejs-voice-incident-bundle"
   });
   const getSessionId = (params) => params.sessionId ?? "";
@@ -41938,7 +42494,7 @@ var summarizeVoiceOpsStatus = async (options) => {
   };
 };
 // src/opsStatusRoutes.ts
-import { Elysia as Elysia64 } from "elysia";
+import { Elysia as Elysia65 } from "elysia";
 var escapeHtml60 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var renderVoiceOpsStatusHTML = (report, options = {}) => {
   const title = options.title ?? "AbsoluteJS Voice Ops Status";
@@ -41950,7 +42506,7 @@ var renderVoiceOpsStatusHTML = (report, options = {}) => {
 };
 var createVoiceOpsStatusRoutes = (options) => {
   const path = options.path ?? "/api/voice/ops-status";
-  const routes = new Elysia64({
+  const routes = new Elysia65({
     name: options.name ?? "absolutejs-voice-ops-status"
   });
   routes.get(path, async () => summarizeVoiceOpsStatus(options));
@@ -42383,7 +42939,7 @@ var createVoiceTTSProviderRouter = (options) => {
   };
 };
 // src/traceDeliveryRoutes.ts
-import { Elysia as Elysia65 } from "elysia";
+import { Elysia as Elysia66 } from "elysia";
 var escapeHtml61 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var getString20 = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
 var getNumber12 = (value) => {
@@ -42492,7 +43048,7 @@ var createVoiceTraceDeliveryRoutes = (options) => {
   const path = options.path ?? "/api/voice-trace-deliveries";
   const htmlPath = options.htmlPath === undefined ? "/traces/deliveries" : options.htmlPath;
   const workerPath = options.workerPath === undefined ? `${path}/drain` : options.workerPath;
-  const routes = new Elysia65({
+  const routes = new Elysia66({
     name: options.name ?? "absolutejs-voice-trace-deliveries"
   }).get(path, createVoiceTraceDeliveryJSONHandler(options));
   if (htmlPath !== false) {
@@ -42645,7 +43201,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia66 } from "elysia";
+import { Elysia as Elysia67 } from "elysia";
 var toHex7 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
   const encoder2 = new TextEncoder;
@@ -42775,7 +43331,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia66().post(path, async ({ body, request, set }) => {
+  return new Elysia67().post(path, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -43230,7 +43786,7 @@ var resolveVoiceOpsPreset = (name, overrides = {}) => {
   };
 };
 // src/postCallAnalysis.ts
-import { Elysia as Elysia67 } from "elysia";
+import { Elysia as Elysia68 } from "elysia";
 var isStore = (value) => Boolean(value) && typeof value === "object" && value !== null && ("list" in value);
 var asArray = async (value) => Array.isArray(value) ? value : isStore(value) ? await value.list() : [];
 var getPathValue3 = (source, path) => {
@@ -43409,7 +43965,7 @@ var resolvePostCallAnalysisReport = async (options, input) => {
 };
 var createVoicePostCallAnalysisRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice/post-call-analysis";
-  const routes = new Elysia67({
+  const routes = new Elysia68({
     name: options.name ?? "absolutejs-voice-post-call-analysis"
   });
   routes.get(path, async ({ query }) => {
@@ -43434,7 +43990,7 @@ var createVoicePostCallAnalysisRoutes = (options = {}) => {
   return routes;
 };
 // src/guardrails.ts
-import { Elysia as Elysia68 } from "elysia";
+import { Elysia as Elysia69 } from "elysia";
 var stringifyContent = (value) => typeof value === "string" ? value : JSON.stringify(value) ?? "";
 var appliesToStage = (rule, stage) => !rule.stages || rule.stages.length === 0 || rule.stages.includes(stage);
 var matchesRule = async (rule, input) => {
@@ -43736,7 +44292,7 @@ var resolveGuardrailReport = async (options, input) => {
 };
 var createVoiceGuardrailRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice/guardrails";
-  const routes = new Elysia68({
+  const routes = new Elysia69({
     name: options.name ?? "absolutejs-voice-guardrails"
   });
   routes.all(path, async ({ request }) => {
@@ -44515,7 +45071,7 @@ var shapeTelephonyAssistantText = (text, options = {}) => {
   return ensureTerminalPunctuation(normalizeWhitespace(limitedChars));
 };
 // src/proofPack.ts
-import { Elysia as Elysia69 } from "elysia";
+import { Elysia as Elysia70 } from "elysia";
 import { mkdir as mkdir5 } from "fs/promises";
 import { dirname as dirname3, join as join4 } from "path";
 var toGeneratedAt = (value) => value === undefined ? new Date().toISOString() : typeof value === "number" ? new Date(value).toISOString() : value;
@@ -45101,7 +45657,7 @@ var createVoiceProofPackArtifacts = (input) => [
 var createVoiceProofPackRoutes = (options) => {
   const jsonPath = options.jsonPath ?? "/api/voice/proof-pack";
   const markdownPath = options.markdownPath ?? "/voice/proof-pack.md";
-  const app = new Elysia69({ name: options.name ?? "voice-proof-pack" });
+  const app = new Elysia70({ name: options.name ?? "voice-proof-pack" });
   if (jsonPath !== false) {
     app.get(jsonPath, async () => new Response(JSON.stringify(await resolveProofPack(options.source), null, 2), {
       headers: {
@@ -46202,7 +46758,7 @@ var buildVoiceMultilingualProofReadinessCheck = (report, options = {}) => {
   };
 };
 // src/monitor.ts
-import { Elysia as Elysia70 } from "elysia";
+import { Elysia as Elysia71 } from "elysia";
 var buildAudioFanout = () => {
   const handlers = new Set;
   return {
@@ -46491,7 +47047,7 @@ var createVoiceLiveMonitorRoutes = (options) => {
     transfer: options.controlHandlers?.transfer ?? buildDefaultControlHandler("transfer"),
     voicemail: options.controlHandlers?.voicemail ?? buildDefaultControlHandler("voicemail")
   };
-  const app = new Elysia70({ name: "absolutejs-voice-monitor" });
+  const app = new Elysia71({ name: "absolutejs-voice-monitor" });
   const unsubscribers = new WeakMap;
   if (listenPath !== false && listenPath.length > 0) {
     app.ws(`/${listenPath.replace(/^\/+/, "")}`, {
@@ -46889,6 +47445,7 @@ export {
   recommendVoiceProviderStack,
   recommendVoiceProfileSwitch,
   readVoiceProofTrendReportFile,
+  purgeVoiceRetentionStore,
   pruneVoiceTraceEvents,
   pruneVoiceIncidentBundleArtifacts,
   parseVoiceTelephonyWebhookEvent,
@@ -46969,6 +47526,7 @@ export {
   describeVoiceIVRPlan,
   describeVoiceAssistantMode,
   describeVoiceAgentUIState,
+  deriveVoiceRecordingRedactionRanges,
   deriveVoiceAgentUIState,
   deliverVoiceTraceEventsToSinks,
   deliverVoiceObservabilityExport,
@@ -46978,6 +47536,7 @@ export {
   deliverVoiceHandoffDelivery,
   deliverVoiceHandoff,
   deliverVoiceAuditEventsToSinks,
+  defineVoiceAssistant,
   decodeTwilioMulawBase64,
   deadLetterVoiceOpsTask,
   createVoiceZeroRetentionPolicy,
@@ -47077,7 +47636,9 @@ export {
   createVoiceS3RecordingStore,
   createVoiceS3DeliverySink,
   createVoiceRoutingDecisionSummary,
+  createVoiceRouteAuth,
   createVoiceReviewSavedEvent,
+  createVoiceRetentionScheduler,
   createVoiceResilienceRoutes,
   createVoiceRedisTelnyxWebhookEventStore,
   createVoiceRedisTelephonyWebhookIdempotencyStore,
@@ -47226,6 +47787,7 @@ export {
   createVoiceHandoffDeliveryWorkerLoop,
   createVoiceHandoffDeliveryWorker,
   createVoiceHandoffDeliveryRecord,
+  createVoiceHMACAuthVerifier,
   createVoiceGuardrailRuntime,
   createVoiceGuardrailRoutes,
   createVoiceGuardrailPolicy,
@@ -47280,6 +47842,7 @@ export {
   createVoiceCRMActivitySink,
   createVoiceBrowserMediaRoutes,
   createVoiceBrowserCallProfileRoutes,
+  createVoiceBearerAuthVerifier,
   createVoiceBargeInRoutes,
   createVoiceBackchannelDriver,
   createVoiceAuditTrailRoutes,
@@ -47330,7 +47893,9 @@ export {
   createMemoryVoiceTelnyxWebhookEventStore,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createMemoryVoicePlivoWebhookNonceStore,
+  createLiveCallViewer,
   createJSONVoiceAssistantModel,
+  createInMemoryVoiceCallQuota,
   createInMemoryDNCList,
   createId,
   createGeminiVoiceAssistantModel,
@@ -47424,6 +47989,7 @@ export {
   buildVoiceDeliveryRuntimeReport,
   buildVoiceDataRetentionPlan,
   buildVoiceDataControlReport,
+  buildVoiceCostDashboardReport,
   buildVoiceCompetitiveCoverageReport,
   buildVoiceCampaignObservabilityReport,
   buildVoiceCallerMemoryNamespace,
@@ -47432,6 +47998,7 @@ export {
   buildVoiceAuditTrailReport,
   buildVoiceAuditExport,
   buildVoiceAuditDeliveryReport,
+  buildReplayTimelineReport,
   buildOTELTraceId,
   buildOTELSpanId,
   buildEmptyVoiceProofTrendReport,

package/dist/recordingRedaction.d.ts

@@ -0,0 +1,18 @@
+import type { 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[];

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.497",
+  "version": "0.0.22-beta.498",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",