@absolutejs/voice 0.0.22-beta.125 → 0.0.22-beta.127

package/dist/audit.d.ts

@@ -0,0 +1,128 @@
+export type VoiceAuditEventType = 'handoff' | 'operator.action' | 'provider.call' | 'retention.policy' | 'tool.call';
+export type VoiceAuditActor = {
+    id: string;
+    kind: 'agent' | 'operator' | 'system' | 'worker';
+    name?: string;
+};
+export type VoiceAuditResource = {
+    id?: string;
+    type: string;
+};
+export type VoiceAuditOutcome = 'error' | 'skipped' | 'success';
+export type VoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
+    action: string;
+    actor?: VoiceAuditActor;
+    at?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: TPayload;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    traceId?: string;
+    type: VoiceAuditEventType;
+};
+export type StoredVoiceAuditEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = Omit<VoiceAuditEvent<TPayload>, 'at' | 'id'> & {
+    at: number;
+    id: string;
+};
+export type VoiceAuditEventFilter = {
+    actorId?: string;
+    after?: number;
+    afterOrAt?: number;
+    before?: number;
+    beforeOrAt?: number;
+    limit?: number;
+    outcome?: VoiceAuditOutcome | VoiceAuditOutcome[];
+    resourceId?: string;
+    resourceType?: string;
+    sessionId?: string;
+    traceId?: string;
+    type?: VoiceAuditEventType | VoiceAuditEventType[];
+};
+export type VoiceAuditEventStore<TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent> = {
+    append: (event: VoiceAuditEvent | TEvent) => Promise<TEvent> | TEvent;
+    get: (id: string) => Promise<TEvent | undefined> | TEvent | undefined;
+    list: (filter?: VoiceAuditEventFilter) => Promise<TEvent[]> | TEvent[];
+};
+export type VoiceAuditLogger = {
+    handoff: (input: Omit<VoiceHandoffAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    operatorAction: (input: Omit<VoiceOperatorAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    providerCall: (input: Omit<VoiceProviderAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    record: (event: VoiceAuditEvent) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    retention: (input: Omit<VoiceRetentionAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+    toolCall: (input: Omit<VoiceToolAuditEventInput, 'store'>) => Promise<StoredVoiceAuditEvent> | StoredVoiceAuditEvent;
+};
+export type VoiceProviderAuditEventInput = {
+    actor?: VoiceAuditActor;
+    cost?: Record<string, unknown>;
+    elapsedMs?: number;
+    error?: string;
+    kind: 'llm' | 'stt' | 'tts' | string;
+    metadata?: Record<string, unknown>;
+    model?: string;
+    outcome: VoiceAuditOutcome;
+    provider: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export type VoiceToolAuditEventInput = {
+    actor?: VoiceAuditActor;
+    elapsedMs?: number;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    toolCallId?: string;
+    toolName: string;
+    traceId?: string;
+};
+export type VoiceHandoffAuditEventInput = {
+    actor?: VoiceAuditActor;
+    fromAgentId?: string;
+    metadata?: Record<string, unknown>;
+    outcome: VoiceAuditOutcome;
+    reason?: string;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    target?: string;
+    toAgentId?: string;
+    traceId?: string;
+};
+export type VoiceRetentionAuditEventInput = {
+    actor?: VoiceAuditActor;
+    dryRun: boolean;
+    metadata?: Record<string, unknown>;
+    report: {
+        deletedCount: number;
+        scopes: Array<{
+            deletedCount: number;
+            scope: string;
+            skippedReason?: string;
+        }>;
+    };
+    store: VoiceAuditEventStore;
+};
+export type VoiceOperatorAuditEventInput = {
+    action: string;
+    actor: VoiceAuditActor;
+    metadata?: Record<string, unknown>;
+    outcome?: VoiceAuditOutcome;
+    payload?: Record<string, unknown>;
+    resource?: VoiceAuditResource;
+    sessionId?: string;
+    store: VoiceAuditEventStore;
+    traceId?: string;
+};
+export declare const createVoiceAuditEvent: <TPayload extends Record<string, unknown> = Record<string, unknown>>(event: VoiceAuditEvent<TPayload>) => StoredVoiceAuditEvent<TPayload>;
+export declare const filterVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], filter?: VoiceAuditEventFilter) => TEvent[];
+export declare const createVoiceMemoryAuditEventStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>() => VoiceAuditEventStore<TEvent>;
+export declare const recordVoiceAuditEvent: (store: VoiceAuditEventStore, event: VoiceAuditEvent) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceProviderAuditEvent: (input: VoiceProviderAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceToolAuditEvent: (input: VoiceToolAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceHandoffAuditEvent: (input: VoiceHandoffAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceRetentionAuditEvent: (input: VoiceRetentionAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const recordVoiceOperatorAuditEvent: (input: VoiceOperatorAuditEventInput) => StoredVoiceAuditEvent<Record<string, unknown>> | Promise<StoredVoiceAuditEvent<Record<string, unknown>>>;
+export declare const createVoiceAuditLogger: (store: VoiceAuditEventStore) => VoiceAuditLogger;

package/dist/auditDeliveryRoutes.d.ts

@@ -0,0 +1,85 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditSinkDeliveryQueueStatus, type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryRecord, type VoiceAuditSinkDeliveryStore, type VoiceAuditSinkDeliveryWorkerResult } from './auditSinks';
+export type VoiceAuditDeliveryReport = {
+    checkedAt: number;
+    deliveries: VoiceAuditSinkDeliveryRecord[];
+    filter: VoiceAuditDeliveryFilter;
+    summary: VoiceAuditSinkDeliveryQueueSummary;
+};
+export type VoiceAuditDeliveryDrainWorker = {
+    drain: () => Promise<VoiceAuditSinkDeliveryWorkerResult> | VoiceAuditSinkDeliveryWorkerResult;
+};
+export type VoiceAuditDeliveryDrainReport = VoiceAuditSinkDeliveryWorkerResult & {
+    drainedAt: number;
+};
+export type VoiceAuditDeliveryFilter = {
+    limit?: number;
+    q?: string;
+    status?: VoiceAuditSinkDeliveryQueueStatus | 'all';
+};
+export type VoiceAuditDeliveryRoutesOptions = {
+    deadLetters?: VoiceAuditSinkDeliveryStore;
+    filter?: VoiceAuditDeliveryFilter;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    limit?: number;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceAuditDeliveryReport) => string | Promise<string>;
+    store: VoiceAuditSinkDeliveryStore;
+    title?: string;
+    worker?: VoiceAuditDeliveryDrainWorker;
+    workerPath?: false | string;
+};
+export declare const resolveVoiceAuditDeliveryFilter: (query?: Record<string, unknown>, base?: VoiceAuditDeliveryFilter) => VoiceAuditDeliveryFilter;
+export declare const buildVoiceAuditDeliveryReport: (options: VoiceAuditDeliveryRoutesOptions, filter?: VoiceAuditDeliveryFilter) => Promise<VoiceAuditDeliveryReport>;
+export declare const renderVoiceAuditDeliveryHTML: (report: VoiceAuditDeliveryReport, options?: {
+    title?: string;
+    workerPath?: false | string;
+}) => string;
+export declare const createVoiceAuditDeliveryJSONHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceAuditDeliveryReport>;
+export declare const createVoiceAuditDeliveryHTMLHandler: (options: VoiceAuditDeliveryRoutesOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceAuditDeliveryRoutes: (options: VoiceAuditDeliveryRoutesOptions) => 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: VoiceAuditDeliveryReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/auditExport.d.ts

@@ -0,0 +1,34 @@
+import type { StoredVoiceAuditEvent, VoiceAuditEventFilter, VoiceAuditEventStore } from './audit';
+import { type VoiceTraceRedactionConfig } from './trace';
+import { type VoiceAuditTrailSummary } from './auditRoutes';
+export type VoiceAuditExport = {
+    events: StoredVoiceAuditEvent[];
+    exportedAt: number;
+    filter?: VoiceAuditEventFilter;
+    redacted: boolean;
+    summary: VoiceAuditTrailSummary;
+};
+export declare const redactVoiceAuditEvent: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(event: TEvent, options?: VoiceTraceRedactionConfig) => TEvent;
+export declare const redactVoiceAuditEvents: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(events: TEvent[], options?: VoiceTraceRedactionConfig) => TEvent[];
+export declare const exportVoiceAuditTrail: (input: {
+    filter?: VoiceAuditEventFilter;
+    redact?: VoiceTraceRedactionConfig;
+    store: VoiceAuditEventStore;
+}) => Promise<VoiceAuditExport>;
+export declare const renderVoiceAuditMarkdown: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => string;
+export declare const renderVoiceAuditHTML: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => string;
+export declare const buildVoiceAuditExport: (events: StoredVoiceAuditEvent[], options?: {
+    redact?: VoiceTraceRedactionConfig;
+    title?: string;
+}) => {
+    events: StoredVoiceAuditEvent[];
+    html: string;
+    markdown: string;
+    summary: VoiceAuditTrailSummary;
+};

package/dist/auditRoutes.d.ts

@@ -0,0 +1,66 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceAuditEvent, VoiceAuditEventFilter, VoiceAuditEventStore, VoiceAuditEventType } from './audit';
+export type VoiceAuditTrailSummary = {
+    byActor: Array<[string, number]>;
+    byOutcome: Array<[string, number]>;
+    byResourceType: Array<[string, number]>;
+    byType: Array<[VoiceAuditEventType, number]>;
+    errors: number;
+    latestAt?: number;
+    total: number;
+};
+export type VoiceAuditTrailReport = {
+    checkedAt: number;
+    events: StoredVoiceAuditEvent[];
+    filter: VoiceAuditEventFilter;
+    summary: VoiceAuditTrailSummary;
+};
+export type VoiceAuditTrailOptions = {
+    filter?: VoiceAuditEventFilter;
+    limit?: number;
+    store: VoiceAuditEventStore;
+};
+export type VoiceAuditTrailRoutesOptions = VoiceAuditTrailOptions & {
+    exportHtmlPath?: false | string;
+    exportPath?: false | string;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceAuditTrailReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const resolveVoiceAuditTrailFilter: (query?: Record<string, unknown>, base?: VoiceAuditEventFilter) => VoiceAuditEventFilter;
+export declare const summarizeVoiceAuditTrail: (events: StoredVoiceAuditEvent[]) => VoiceAuditTrailSummary;
+export declare const buildVoiceAuditTrailReport: (options: VoiceAuditTrailOptions) => Promise<VoiceAuditTrailReport>;
+export declare const renderVoiceAuditTrailHTML: (report: VoiceAuditTrailReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceAuditTrailRoutes: (options: VoiceAuditTrailRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/auditSinks.d.ts

@@ -0,0 +1,133 @@
+import type { StoredVoiceAuditEvent, VoiceAuditEventStore, VoiceAuditEventType } from './audit';
+import type { VoiceIdempotencyStore, VoiceRedisTaskLeaseCoordinator } from './queue';
+import type { VoiceTraceRedactionConfig } from './trace';
+export type VoiceAuditSinkDeliveryStatus = 'delivered' | 'failed' | 'skipped';
+export type VoiceAuditSinkDeliveryQueueStatus = VoiceAuditSinkDeliveryStatus | 'pending';
+export type VoiceAuditSinkDeliveryResult = {
+    attempts: number;
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    eventCount: number;
+    responseBody?: unknown;
+    status: VoiceAuditSinkDeliveryStatus;
+};
+export type VoiceAuditSink = {
+    deliver: (input: {
+        events: StoredVoiceAuditEvent[];
+    }) => Promise<VoiceAuditSinkDeliveryResult> | VoiceAuditSinkDeliveryResult;
+    eventTypes?: VoiceAuditEventType[];
+    id: string;
+    kind?: string;
+};
+export type VoiceAuditSinkFanoutResult = {
+    deliveredAt: number;
+    eventCount: number;
+    sinkDeliveries: Record<string, VoiceAuditSinkDeliveryResult>;
+    status: VoiceAuditSinkDeliveryStatus;
+};
+export type VoiceAuditSinkDeliveryRecord = {
+    createdAt: number;
+    deliveredAt?: number;
+    deliveryAttempts?: number;
+    deliveryError?: string;
+    deliveryStatus: VoiceAuditSinkDeliveryQueueStatus;
+    events: StoredVoiceAuditEvent[];
+    id: string;
+    sinkDeliveries?: Record<string, VoiceAuditSinkDeliveryResult>;
+    updatedAt: number;
+};
+export type VoiceAuditSinkDeliveryStore<TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = {
+    get: (id: string) => Promise<TDelivery | undefined> | TDelivery | undefined;
+    list: () => Promise<TDelivery[]> | TDelivery[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, delivery: TDelivery) => Promise<void> | void;
+};
+export type VoiceAuditHTTPSinkOptions<TBody extends Record<string, unknown> = Record<string, unknown>> = {
+    backoffMs?: number;
+    body?: (input: {
+        events: StoredVoiceAuditEvent[];
+    }) => Promise<TBody> | TBody;
+    eventTypes?: VoiceAuditEventType[];
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    id: string;
+    kind?: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    retries?: number;
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceAuditSinkStoreOptions<TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent> = {
+    awaitDelivery?: boolean;
+    deliveryQueue?: VoiceAuditSinkDeliveryStore;
+    onDelivery?: (result: VoiceAuditSinkFanoutResult) => Promise<void> | void;
+    onError?: (error: unknown) => Promise<void> | void;
+    redact?: VoiceTraceRedactionConfig;
+    sinks: VoiceAuditSink[];
+    store: VoiceAuditEventStore<TEvent>;
+};
+export type VoiceAuditSinkDeliveryWorkerOptions<TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = {
+    deadLetters?: VoiceAuditSinkDeliveryStore<TDelivery>;
+    deliveries: VoiceAuditSinkDeliveryStore<TDelivery>;
+    idempotency?: VoiceIdempotencyStore;
+    idempotencyTtlSeconds?: number;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxFailures?: number;
+    onDeadLetter?: (delivery: TDelivery) => Promise<void> | void;
+    redact?: VoiceTraceRedactionConfig;
+    sinks: VoiceAuditSink[];
+    statuses?: VoiceAuditSinkDeliveryQueueStatus[];
+    workerId: string;
+};
+export type VoiceAuditSinkDeliveryWorkerResult = {
+    alreadyProcessed: number;
+    attempted: number;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    skipped: number;
+};
+export type VoiceAuditSinkDeliveryWorkerLoopOptions<TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceAuditSinkDeliveryWorker<TDelivery>>;
+};
+export type VoiceAuditSinkDeliveryWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceAuditSinkDeliveryWorkerResult>;
+};
+export type VoiceAuditSinkDeliveryQueueSummary = {
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    total: number;
+};
+export declare const createVoiceAuditSinkDeliveryId: (events: StoredVoiceAuditEvent[]) => string;
+export declare const createVoiceAuditSinkDeliveryRecord: (input: {
+    createdAt?: number;
+    events: StoredVoiceAuditEvent[];
+    id?: string;
+} & Partial<Omit<VoiceAuditSinkDeliveryRecord, "createdAt" | "events" | "id">>) => VoiceAuditSinkDeliveryRecord;
+export declare const createVoiceAuditHTTPSink: <TBody extends Record<string, unknown> = Record<string, unknown>>(options: VoiceAuditHTTPSinkOptions<TBody>) => VoiceAuditSink;
+export declare const deliverVoiceAuditEventsToSinks: (input: {
+    events: StoredVoiceAuditEvent[];
+    redact?: VoiceTraceRedactionConfig;
+    sinks: VoiceAuditSink[];
+}) => Promise<VoiceAuditSinkFanoutResult>;
+export declare const createVoiceAuditSinkStore: <TEvent extends StoredVoiceAuditEvent = StoredVoiceAuditEvent>(options: VoiceAuditSinkStoreOptions<TEvent>) => VoiceAuditEventStore<TEvent>;
+export declare const createVoiceMemoryAuditSinkDeliveryStore: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>() => VoiceAuditSinkDeliveryStore<TDelivery>;
+export declare const summarizeVoiceAuditSinkDeliveries: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(deliveries: TDelivery[], input?: {
+    deadLetters?: VoiceAuditSinkDeliveryStore<TDelivery>;
+}) => Promise<VoiceAuditSinkDeliveryQueueSummary> | VoiceAuditSinkDeliveryQueueSummary;
+export declare const createVoiceAuditSinkDeliveryWorker: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceAuditSinkDeliveryWorkerOptions<TDelivery>) => {
+    drain: () => Promise<VoiceAuditSinkDeliveryWorkerResult>;
+};
+export declare const createVoiceAuditSinkDeliveryWorkerLoop: <TDelivery extends VoiceAuditSinkDeliveryRecord = VoiceAuditSinkDeliveryRecord>(options: VoiceAuditSinkDeliveryWorkerLoopOptions<TDelivery>) => VoiceAuditSinkDeliveryWorkerLoop;

package/dist/client/index.d.ts

@@ -7,7 +7,7 @@ export { bindVoiceHTMX } from './htmx';
 export { createMicrophoneCapture } from './microphone';
 export { createVoiceBargeInMonitor } from './bargeInMonitor';
 export { createVoiceLiveTurnLatencyMonitor } from './liveTurnLatency';
-export { createVoiceAppKitStatusStore, fetchVoiceAppKitStatus } from './appKitStatus';
+export { createVoiceOpsStatusStore, fetchVoiceOpsStatus } from './opsStatus';
 export { createVoiceOpsStatusViewModel, defineVoiceOpsStatusElement, getVoiceOpsStatusCSS, getVoiceOpsStatusLabel, mountVoiceOpsStatus, renderVoiceOpsStatusHTML } from './opsStatusWidget';
 export { createVoiceRoutingStatusStore, fetchVoiceRoutingStatus } from './routingStatus';
 export { createVoiceRoutingStatusViewModel, defineVoiceRoutingStatusElement, getVoiceRoutingStatusCSS, mountVoiceRoutingStatus, renderVoiceRoutingStatusHTML } from './routingStatusWidget';
@@ -25,7 +25,7 @@ export { createVoiceTurnQualityViewModel, defineVoiceTurnQualityElement, getVoic
 export { createVoiceTurnLatencyViewModel, defineVoiceTurnLatencyElement, mountVoiceTurnLatency, renderVoiceTurnLatencyHTML } from './turnLatencyWidget';
 export { createVoiceTraceTimelineViewModel, defineVoiceTraceTimelineElement, getVoiceTraceTimelineCSS, mountVoiceTraceTimeline, renderVoiceTraceTimelineWidgetHTML } from './traceTimelineWidget';
 export { createVoiceWorkflowStatusStore, fetchVoiceWorkflowStatus } from './workflowStatus';
-export type { VoiceAppKitStatusClientOptions, VoiceAppKitStatusSnapshot } from './appKitStatus';
+export type { VoiceOpsStatusClientOptions, VoiceOpsStatusSnapshot } from './opsStatus';
 export type { VoiceBargeInMonitorOptions } from './bargeInMonitor';
 export type { VoiceLiveTurnLatencyEvent, VoiceLiveTurnLatencyMonitorOptions, VoiceLiveTurnLatencySnapshot, VoiceLiveTurnLatencyStatus } from './liveTurnLatency';
 export type { VoiceOpsStatusSurfaceView, VoiceOpsStatusViewModel, VoiceOpsStatusWidgetOptions } from './opsStatusWidget';

package/dist/client/index.js

@@ -1852,16 +1852,16 @@ var createVoiceLiveTurnLatencyMonitor = (options = {}) => {
     }
   };
 };
-// src/client/appKitStatus.ts
-var fetchVoiceAppKitStatus = async (path = "/app-kit/status", options = {}) => {
+// src/client/opsStatus.ts
+var fetchVoiceOpsStatus = async (path = "/api/voice/ops-status", options = {}) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const response = await fetchImpl(path);
   if (!response.ok) {
-    throw new Error(`Voice app kit status failed: HTTP ${response.status}`);
+    throw new Error(`Voice ops status failed: HTTP ${response.status}`);
   }
   return await response.json();
 };
-var createVoiceAppKitStatusStore = (path = "/app-kit/status", options = {}) => {
+var createVoiceOpsStatusStore = (path = "/api/voice/ops-status", options = {}) => {
   const listeners = new Set;
   let closed = false;
   let timer;
@@ -1885,7 +1885,7 @@ var createVoiceAppKitStatusStore = (path = "/app-kit/status", options = {}) => {
     };
     emit();
     try {
-      const report = await fetchVoiceAppKitStatus(path, options);
+      const report = await fetchVoiceOpsStatus(path, options);
       snapshot = {
         error: null,
         isLoading: false,
@@ -1932,7 +1932,7 @@ var createVoiceAppKitStatusStore = (path = "/app-kit/status", options = {}) => {
 };
 // src/client/opsStatusWidget.ts
 var DEFAULT_TITLE = "Voice Ops Status";
-var DEFAULT_DESCRIPTION = "Certified workflow, provider, and handoff readiness from the AbsoluteJS voice app kit.";
+var DEFAULT_DESCRIPTION = "Certified workflow, provider, and handoff readiness from your AbsoluteJS voice app.";
 var SURFACE_LABELS = {
   handoffs: "Handoffs",
   providers: "Providers",
@@ -2017,8 +2017,8 @@ var renderVoiceOpsStatusHTML = (snapshot, options = {}) => {
 </section>`;
 };
 var getVoiceOpsStatusCSS = () => `.absolute-voice-ops-status{border:1px solid #d8d2c4;border-radius:20px;background:#fffaf0;color:#16130d;padding:18px;box-shadow:0 18px 40px rgba(47,37,18,.12);font-family:inherit}.absolute-voice-ops-status--fail,.absolute-voice-ops-status--error{border-color:#f2a7a7;background:#fff5f3}.absolute-voice-ops-status__header{align-items:start;display:flex;gap:12px;justify-content:space-between}.absolute-voice-ops-status__eyebrow{color:#73664f;font-size:12px;font-weight:800;letter-spacing:.08em;text-transform:uppercase}.absolute-voice-ops-status__label{font-size:28px;line-height:1}.absolute-voice-ops-status__description{color:#514733;margin:12px 0 0}.absolute-voice-ops-status__summary,.absolute-voice-ops-status__links{display:flex;flex-wrap:wrap;gap:8px;margin-top:14px}.absolute-voice-ops-status__summary span,.absolute-voice-ops-status__links a{border:1px solid #e6ddca;border-radius:999px;color:inherit;padding:6px 10px;text-decoration:none}.absolute-voice-ops-status__surfaces{display:grid;gap:8px;list-style:none;margin:16px 0 0;padding:0}.absolute-voice-ops-status__surface{align-items:center;background:#fff;border:1px solid #eee4d2;border-radius:14px;display:flex;gap:12px;justify-content:space-between;padding:10px 12px}.absolute-voice-ops-status__surface--fail{border-color:#f2a7a7}.absolute-voice-ops-status__surface span{color:#655944}.absolute-voice-ops-status__error{color:#9f1239;font-weight:700}`;
-var mountVoiceOpsStatus = (element, path = "/app-kit/status", options = {}) => {
-  const store = createVoiceAppKitStatusStore(path, options);
+var mountVoiceOpsStatus = (element, path = "/api/voice/ops-status", options = {}) => {
+  const store = createVoiceOpsStatusStore(path, options);
   const render = () => {
     element.innerHTML = renderVoiceOpsStatusHTML(store.getSnapshot(), options);
   };
@@ -2041,7 +2041,7 @@ var defineVoiceOpsStatusElement = (tagName = "absolute-voice-ops-status") => {
     mounted;
     connectedCallback() {
       const intervalMs = Number(this.getAttribute("interval-ms") ?? 5000);
-      this.mounted = mountVoiceOpsStatus(this, this.getAttribute("path") ?? "/app-kit/status", {
+      this.mounted = mountVoiceOpsStatus(this, this.getAttribute("path") ?? "/api/voice/ops-status", {
         description: this.getAttribute("description") ?? undefined,
         includeLinks: this.getAttribute("include-links") !== "false",
         intervalMs: Number.isFinite(intervalMs) ? intervalMs : 5000,
@@ -3571,8 +3571,8 @@ export {
   fetchVoiceRoutingStatus,
   fetchVoiceProviderStatus,
   fetchVoiceProviderCapabilities,
+  fetchVoiceOpsStatus,
   fetchVoiceCampaignDialerProofStatus,
-  fetchVoiceAppKitStatus,
   defineVoiceTurnQualityElement,
   defineVoiceTurnLatencyElement,
   defineVoiceTraceTimelineElement,
@@ -3599,6 +3599,7 @@ export {
   createVoiceProviderCapabilitiesViewModel,
   createVoiceProviderCapabilitiesStore,
   createVoiceOpsStatusViewModel,
+  createVoiceOpsStatusStore,
   createVoiceLiveTurnLatencyMonitor,
   createVoiceDuplexController,
   createVoiceController,
@@ -3606,7 +3607,6 @@ export {
   createVoiceCampaignDialerProofStore,
   createVoiceBargeInMonitor,
   createVoiceAudioPlayer,
-  createVoiceAppKitStatusStore,
   createMicrophoneCapture,
   bindVoiceProviderSimulationControls,
   bindVoiceHTMX,

package/dist/client/opsStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceOpsStatusReport } from '../opsStatus';
+export type VoiceOpsStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceOpsStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceOpsStatusReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceOpsStatus: (path?: string, options?: Pick<VoiceOpsStatusClientOptions, "fetch">) => Promise<VoiceOpsStatusReport>;
+export declare const createVoiceOpsStatusStore: (path?: string, options?: VoiceOpsStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceOpsStatusSnapshot;
+    getSnapshot: () => VoiceOpsStatusSnapshot;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/opsStatusWidget.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceAppKitStatusReport } from '../appKit';
-import { type VoiceAppKitStatusClientOptions, type VoiceAppKitStatusSnapshot } from './appKitStatus';
+import type { VoiceOpsStatusReport } from '../opsStatus';
+import { type VoiceOpsStatusClientOptions, type VoiceOpsStatusSnapshot } from './opsStatus';
 export type VoiceOpsStatusSurfaceView = {
     detail: string;
     failed: number;
@@ -24,17 +24,17 @@ export type VoiceOpsStatusViewModel = {
     total: number;
     updatedAt?: number;
 };
-export type VoiceOpsStatusWidgetOptions = VoiceAppKitStatusClientOptions & {
+export type VoiceOpsStatusWidgetOptions = VoiceOpsStatusClientOptions & {
     description?: string;
     includeLinks?: boolean;
     title?: string;
 };
-export declare const getVoiceOpsStatusLabel: (report?: VoiceAppKitStatusReport | null, error?: string | null) => "Needs attention" | "Passing" | "Unavailable" | "Checking";
-export declare const createVoiceOpsStatusViewModel: (snapshot: VoiceAppKitStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => VoiceOpsStatusViewModel;
-export declare const renderVoiceOpsStatusHTML: (snapshot: VoiceAppKitStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => string;
+export declare const getVoiceOpsStatusLabel: (report?: VoiceOpsStatusReport | null, error?: string | null) => "Needs attention" | "Passing" | "Unavailable" | "Checking";
+export declare const createVoiceOpsStatusViewModel: (snapshot: VoiceOpsStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => VoiceOpsStatusViewModel;
+export declare const renderVoiceOpsStatusHTML: (snapshot: VoiceOpsStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => string;
 export declare const getVoiceOpsStatusCSS: () => string;
 export declare const mountVoiceOpsStatus: (element: Element, path?: string, options?: VoiceOpsStatusWidgetOptions) => {
     close: () => void;
-    refresh: () => Promise<VoiceAppKitStatusReport | undefined>;
+    refresh: () => Promise<VoiceOpsStatusReport | undefined>;
 };
 export declare const defineVoiceOpsStatusElement: (tagName?: string) => void;

package/dist/dataControl.d.ts

@@ -0,0 +1,47 @@
+import type { VoiceCampaignStore } from './campaign';
+import { type VoiceAuditActor, type VoiceAuditEventStore } from './audit';
+import type { VoiceAuditSinkDeliveryStore } from './auditSinks';
+import type { VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
+import type { VoiceCallReviewStore } from './testing/review';
+import type { VoiceTraceEventStore, VoiceTracePruneFilter, VoiceTraceSinkDeliveryStore } from './trace';
+import type { VoiceSessionStore } from './types';
+export type VoiceDataRetentionScope = 'auditDeliveries' | 'campaigns' | 'events' | 'reviews' | 'sessions' | 'tasks' | 'traceDeliveries' | 'traces';
+export type VoiceDataRetentionStores = {
+    campaigns?: VoiceCampaignStore;
+    events?: VoiceIntegrationEventStore;
+    reviews?: VoiceCallReviewStore;
+    session?: VoiceSessionStore;
+    sessions?: VoiceSessionStore;
+    tasks?: VoiceOpsTaskStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceDataRetentionPolicy = VoiceDataRetentionStores & {
+    audit?: VoiceAuditEventStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    auditActor?: VoiceAuditActor;
+    before?: number;
+    beforeOrAt?: number;
+    dryRun?: boolean;
+    keepNewest?: Partial<Record<VoiceDataRetentionScope, number>>;
+    limit?: number;
+    scopes?: VoiceDataRetentionScope[];
+    traceFilter?: VoiceTracePruneFilter;
+};
+export type VoiceDataRetentionScopeReport = {
+    deletedIds: string[];
+    deletedCount: number;
+    dryRun: boolean;
+    keepNewest?: number;
+    scannedCount: number;
+    scope: VoiceDataRetentionScope;
+    skippedReason?: 'missing-store' | 'missing-selector';
+};
+export type VoiceDataRetentionReport = {
+    checkedAt: number;
+    deletedCount: number;
+    dryRun: boolean;
+    scopes: VoiceDataRetentionScopeReport[];
+};
+export declare const applyVoiceDataRetentionPolicy: (options: VoiceDataRetentionPolicy) => Promise<VoiceDataRetentionReport>;
+export declare const buildVoiceDataRetentionPlan: (options: Omit<VoiceDataRetentionPolicy, "dryRun">) => Promise<VoiceDataRetentionReport>;