@absolutejs/voice 0.0.22-beta.6 → 0.0.22-beta.600

package/dist/core/ragTool.d.ts

@@ -0,0 +1,52 @@
+import { type VoiceAgentTool } from "./agent";
+import type { VoiceSessionRecord, VoiceTurnCitation } from "./types";
+export type VoiceRAGQueryResult = {
+    chunkId: string;
+    chunkText: string;
+    score: number;
+    source?: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+};
+export type VoiceRAGSearchInput = {
+    filter?: Record<string, unknown>;
+    query: string;
+    scoreThreshold?: number;
+    signal?: AbortSignal;
+    topK?: number;
+};
+export type VoiceRAGCollectionLike = {
+    search: (input: VoiceRAGSearchInput) => Promise<readonly VoiceRAGQueryResult[]> | readonly VoiceRAGQueryResult[];
+};
+export type VoiceRAGToolArgs = {
+    filter?: Record<string, unknown>;
+    query: string;
+    topK?: number;
+};
+export type VoiceRAGToolResult = {
+    citations: VoiceRAGQueryResult[];
+    message: string;
+    query: string;
+    topK: number;
+};
+export type VoiceRAGCitationSummary = VoiceTurnCitation;
+export declare const extractVoiceRAGCitations: (toolResults: ReadonlyArray<{
+    result?: unknown;
+    toolName: string;
+}>, toolName?: string) => VoiceRAGCitationSummary[];
+export type VoiceRAGToolOptions<TContext = unknown> = {
+    allowedFilterKeys?: readonly string[];
+    description?: string;
+    fixedFilter?: Record<string, unknown> | ((input: {
+        context: TContext;
+    }) => Record<string, unknown> | undefined);
+    formatResult?: (citations: readonly VoiceRAGQueryResult[], args: VoiceRAGToolArgs) => string;
+    maxChunkChars?: number;
+    maxTopK?: number;
+    name?: string;
+    parameters?: Record<string, unknown>;
+    resultToMessage?: (result: VoiceRAGToolResult) => string;
+    scoreThreshold?: number;
+    topK?: number;
+};
+export declare const createVoiceRAGTool: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(collection: VoiceRAGCollectionLike, options?: VoiceRAGToolOptions<TContext>) => VoiceAgentTool<TContext, TSession, VoiceRAGToolArgs, VoiceRAGToolResult>;

package/dist/core/readinessProfiles.d.ts

@@ -0,0 +1,45 @@
+import type { VoiceProductionReadinessAuditOptions, VoiceProductionReadinessAuditDeliveryOptions, VoiceProductionReadinessOpsActionHistoryOptions, VoiceProductionReadinessRoutesOptions, VoiceProductionReadinessTraceDeliveryOptions } from "./productionReadiness";
+export type VoiceReadinessProfileName = "meeting-recorder" | "ops-heavy" | "phone-agent";
+export type VoiceReadinessProfileOptions = {
+    audit?: VoiceProductionReadinessAuditOptions;
+    auditDeliveries?: VoiceProductionReadinessAuditDeliveryOptions;
+    bargeInReports?: VoiceProductionReadinessRoutesOptions["bargeInReports"];
+    campaignReadiness?: VoiceProductionReadinessRoutesOptions["campaignReadiness"];
+    carriers?: VoiceProductionReadinessRoutesOptions["carriers"];
+    deliveryRuntime?: VoiceProductionReadinessRoutesOptions["deliveryRuntime"];
+    explain?: boolean;
+    gate?: VoiceProductionReadinessRoutesOptions["gate"];
+    links?: VoiceProductionReadinessRoutesOptions["links"];
+    observabilityExportDeliveryHistory?: VoiceProductionReadinessRoutesOptions["observabilityExportDeliveryHistory"];
+    opsActionHistory?: VoiceProductionReadinessOpsActionHistoryOptions;
+    phoneAgentSmokes?: VoiceProductionReadinessRoutesOptions["phoneAgentSmokes"];
+    proofSources?: VoiceProductionReadinessRoutesOptions["proofSources"];
+    providerRoutingContracts?: VoiceProductionReadinessRoutesOptions["providerRoutingContracts"];
+    reconnectContracts?: VoiceProductionReadinessRoutesOptions["reconnectContracts"];
+    reconnectContractsMinCount?: VoiceProductionReadinessRoutesOptions["reconnectContractsMinCount"];
+    reconnectContractsMinSnapshotsPerContract?: VoiceProductionReadinessRoutesOptions["reconnectContractsMinSnapshotsPerContract"];
+    telephonyMediaMinCarriers?: VoiceProductionReadinessRoutesOptions["telephonyMediaMinCarriers"];
+    telephonyMediaMinMediaEvents?: VoiceProductionReadinessRoutesOptions["telephonyMediaMinMediaEvents"];
+    browserMediaMinActiveCandidatePairs?: VoiceProductionReadinessRoutesOptions["browserMediaMinActiveCandidatePairs"];
+    browserMediaMinLiveAudioTracks?: VoiceProductionReadinessRoutesOptions["browserMediaMinLiveAudioTracks"];
+    browserMediaMinTotalStats?: VoiceProductionReadinessRoutesOptions["browserMediaMinTotalStats"];
+    telephonyWebhookSecurity?: VoiceProductionReadinessRoutesOptions["telephonyWebhookSecurity"];
+    traceDeliveries?: VoiceProductionReadinessTraceDeliveryOptions;
+};
+export type VoiceReadinessProfileRoutesOptions = Partial<Omit<VoiceProductionReadinessRoutesOptions, "store">>;
+export type VoiceReadinessProfileRecommendationScore = {
+    configured: string[];
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+};
+export type VoiceReadinessProfileRecommendation = {
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    scores: VoiceReadinessProfileRecommendationScore[];
+};
+export declare const createVoiceReadinessProfile: (profile: VoiceReadinessProfileName, options?: VoiceReadinessProfileOptions) => VoiceReadinessProfileRoutesOptions;
+export declare const recommendVoiceReadinessProfile: (options: VoiceReadinessProfileOptions) => VoiceReadinessProfileRecommendation;

package/dist/core/realtimeChannel.d.ts

@@ -0,0 +1,136 @@
+import { Elysia } from "elysia";
+import type { AudioFormat } from "./types";
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceRealtimeChannelStatus = "fail" | "pass" | "warn";
+export type VoiceRealtimeChannelRuntimeSample = {
+    format?: AudioFormat;
+    observedAt?: number;
+    kind: "assistant-audio" | "browser-capture" | "input-audio" | "reconnect" | "turn-commit";
+    latencyMs?: number;
+    ok?: boolean;
+    sessionId?: string;
+    source?: string;
+    turnId?: string;
+};
+export type VoiceRealtimeChannelBrowserCapture = {
+    audioContextSampleRateHz?: number;
+    channelCount?: 1 | 2;
+    processorBufferSize?: number;
+    sampleRateHz?: number;
+};
+export type VoiceRealtimeChannelReportOptions = {
+    browserCapture?: VoiceRealtimeChannelBrowserCapture;
+    expectedInputFormat?: AudioFormat;
+    expectedOutputFormat?: AudioFormat;
+    inputFormat?: AudioFormat;
+    maxFirstAudioLatencyMs?: number;
+    minAssistantAudioSamples?: number;
+    minInputAudioSamples?: number;
+    operationsRecordHref?: string;
+    outputFormat?: AudioFormat;
+    provider: string;
+    readinessHref?: string;
+    runtimeSamples?: VoiceRealtimeChannelRuntimeSample[];
+    surface?: string;
+};
+export type VoiceRealtimeChannelIssue = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+};
+export type VoiceRealtimeChannelReport = {
+    browserCapture?: VoiceRealtimeChannelBrowserCapture & {
+        resamplingRequired: boolean;
+        resamplingTargetHz?: number;
+    };
+    checkedAt: number;
+    inputFormat: AudioFormat;
+    issues: VoiceRealtimeChannelIssue[];
+    operationsRecordHref?: string;
+    outputFormat: AudioFormat;
+    provider: string;
+    readinessHref?: string;
+    runtime: {
+        assistantAudioSamples: number;
+        firstAudioLatencyMs?: number;
+        inputAudioSamples: number;
+        samples: VoiceRealtimeChannelRuntimeSample[];
+    };
+    status: VoiceRealtimeChannelStatus;
+    surface: string;
+};
+export type VoiceRealtimeChannelAssertionInput = {
+    maxFirstAudioLatencyMs?: number;
+    minAssistantAudioSamples?: number;
+    minInputAudioSamples?: number;
+    requireBrowserCapture?: boolean;
+    requireOperationsRecordHref?: boolean;
+    requirePass?: boolean;
+    requireReadinessHref?: boolean;
+};
+export type VoiceRealtimeChannelAssertionReport = {
+    issues: string[];
+    ok: boolean;
+    provider: string;
+    status: VoiceRealtimeChannelStatus;
+    surface: string;
+};
+export type VoiceRealtimeChannelRoutesOptions = VoiceRealtimeChannelReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceRealtimeChannelReport) => Promise<string> | string;
+    source?: (() => Promise<VoiceRealtimeChannelReportOptions> | VoiceRealtimeChannelReportOptions) | VoiceRealtimeChannelReportOptions;
+    title?: string;
+};
+export declare const assertVoiceRealtimeChannelEvidence: (report: VoiceRealtimeChannelReport, input?: VoiceRealtimeChannelAssertionInput) => VoiceRealtimeChannelAssertionReport;
+export declare const buildVoiceRealtimeChannelReport: (options: VoiceRealtimeChannelReportOptions) => VoiceRealtimeChannelReport;
+export declare const buildVoiceRealtimeChannelRuntimeSamplesFromTrace: (events: readonly StoredVoiceTraceEvent[], options?: {
+    format?: AudioFormat;
+    source?: string;
+}) => VoiceRealtimeChannelRuntimeSample[];
+export declare const createVoiceRealtimeChannelRoutes: (options: VoiceRealtimeChannelRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const evaluateVoiceRealtimeChannelEvidence: (report: VoiceRealtimeChannelReport, input?: VoiceRealtimeChannelAssertionInput) => VoiceRealtimeChannelAssertionReport;
+export declare const renderVoiceRealtimeChannelHTML: (report: VoiceRealtimeChannelReport, title?: string) => string;
+export declare const renderVoiceRealtimeChannelMarkdown: (report: VoiceRealtimeChannelReport) => string;

package/dist/core/realtimeProviderContracts.d.ts

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

package/dist/core/reconnectContract.d.ts

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

package/dist/core/recordingRedaction.d.ts

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

package/dist/core/recordingStore.d.ts

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

package/dist/core/redaction.d.ts

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