@absolutejs/voice 0.0.22-beta.55 → 0.0.22-beta.551

package/dist/telephony/telnyx.d.ts

@@ -0,0 +1,291 @@
+import { Database } from "bun:sqlite";
+import type { RedisClient } from "bun";
+import { Elysia } from "elysia";
+import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from "./contract";
+import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from "../core/telephonyOutcome";
+import type { VoiceServerMessage, VoiceSessionRecord } from "../core/types";
+import { type TwilioMediaStreamBridgeOptions } from "./twilio";
+import type { VoicePostgresClient } from "../core/postgresStore";
+export type TelnyxMediaPayload = {
+    chunk?: string;
+    payload: string;
+    timestamp?: string;
+    track?: "inbound" | "outbound" | "inbound_track" | "outbound_track";
+};
+export type TelnyxInboundMessage = {
+    event: "connected";
+    version?: string;
+} | {
+    event: "start";
+    sequence_number?: string;
+    start?: {
+        call_control_id?: string;
+        call_leg_id?: string;
+        call_session_id?: string;
+        custom_parameters?: Record<string, string>;
+        media_format?: {
+            channels?: number;
+            encoding?: string;
+            sample_rate?: number;
+        };
+        user_id?: string;
+    };
+    stream_id?: string;
+} | {
+    event: "media";
+    media: TelnyxMediaPayload;
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: "mark";
+    mark?: {
+        name?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: "dtmf";
+    dtmf?: {
+        digit?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: "error";
+    payload?: {
+        code?: number;
+        detail?: string;
+        title?: string;
+    };
+    stream_id?: string;
+} | {
+    event: "stop";
+    sequence_number?: string;
+    stop?: {
+        call_control_id?: string;
+        user_id?: string;
+    };
+    stream_id?: string;
+};
+export type TelnyxOutboundMediaMessage = {
+    event: "media";
+    media: {
+        payload: string;
+    };
+};
+export type TelnyxOutboundClearMessage = {
+    event: "clear";
+};
+export type TelnyxOutboundMarkMessage = {
+    event: "mark";
+    mark: {
+        name: string;
+    };
+};
+export type TelnyxOutboundMessage = TelnyxOutboundMediaMessage | TelnyxOutboundClearMessage | TelnyxOutboundMarkMessage;
+export type TelnyxMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type TelnyxMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>, "onVoiceMessage"> & {
+    onVoiceMessage?: (input: {
+        callControlId?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamId?: string;
+    }) => Promise<void> | void;
+};
+export type TelnyxMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamId: () => string | null;
+    handleMessage: (raw: string | TelnyxInboundMessage) => Promise<void>;
+};
+export type TelnyxVoiceResponseOptions = {
+    bidirectionalCodec?: "AMR-WB" | "G722" | "OPUS" | "PCMA" | "PCMU";
+    bidirectionalMode?: "mp3" | "rtp";
+    codec?: "AMR-WB" | "G722" | "OPUS" | "PCMA" | "PCMU" | "default";
+    streamName?: string;
+    streamUrl: string;
+    track?: "both_tracks" | "inbound_track" | "outbound_track";
+};
+export type TelnyxVoiceSetupStatus = VoiceTelephonySetupStatus<"telnyx"> & {
+    urls: VoiceTelephonySetupStatus<"telnyx">["urls"] & {
+        texml: string;
+    };
+};
+export type TelnyxVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TelnyxVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TelnyxVoiceSmokeReport = VoiceTelephonySmokeReport<"telnyx"> & {
+    contract: VoiceTelephonyContractReport<"telnyx">;
+    setup: TelnyxVoiceSetupStatus;
+    texml?: {
+        status: number;
+        streamUrl?: string;
+    };
+};
+export type TelnyxVoiceSmokeOptions = {
+    callControlId?: string;
+    callLegId?: string;
+    eventType?: string;
+    path?: false | string;
+    sessionId?: string;
+    title?: string;
+};
+export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    bridge?: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>;
+    context?: TContext;
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    setup?: TelnyxVoiceSetupOptions;
+    smoke?: TelnyxVoiceSmokeOptions;
+    streamPath?: string;
+    texml?: {
+        path?: string;
+        response?: Omit<TelnyxVoiceResponseOptions, "streamUrl">;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+    };
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, "context" | "path" | "policy" | "provider"> & {
+        eventStore?: VoiceTelnyxWebhookEventStore;
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+        publicKey?: string;
+        toleranceSeconds?: number;
+    };
+};
+export type VoiceTelnyxWebhookEventStore = {
+    claim?: (eventId: string) => Promise<boolean> | boolean;
+    has: (eventId: string) => Promise<boolean> | boolean;
+    set: (eventId: string) => Promise<void> | void;
+};
+export type VoiceTelnyxWebhookEventStoreOptions = {
+    ttlSeconds?: number;
+};
+export type VoiceSQLiteTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    database?: Database;
+    path?: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceRedisTelnyxWebhookEventClient = Pick<RedisClient, "exists" | "set">;
+export type VoiceRedisTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    client?: VoiceRedisTelnyxWebhookEventClient;
+    keyPrefix?: string;
+    url?: string;
+};
+export type VoiceTelnyxWebhookVerifierOptions = {
+    eventStore?: VoiceTelnyxWebhookEventStore;
+    publicKey?: string;
+    toleranceSeconds?: number;
+};
+export declare const createTelnyxVoiceResponse: (options: TelnyxVoiceResponseOptions) => string;
+export declare const createTelnyxMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TelnyxMediaStreamSocket, options: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>) => TelnyxMediaStreamBridge;
+export declare const createMemoryVoiceTelnyxWebhookEventStore: () => VoiceTelnyxWebhookEventStore;
+export declare const verifyVoiceTelnyxWebhookSignature: (input: {
+    body: string;
+    headers: Headers;
+    publicKey?: string;
+    toleranceSeconds?: number;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createVoiceSQLiteTelnyxWebhookEventStore: (options: VoiceSQLiteTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoicePostgresTelnyxWebhookEventStore: (options?: VoicePostgresTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoiceRedisTelnyxWebhookEventStore: (options?: VoiceRedisTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoiceTelnyxWebhookVerifier: (options: VoiceTelnyxWebhookVerifierOptions) => (input: {
+    rawBody: string;
+    headers: Headers;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createTelnyxVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>) => 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;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/telephony/twilio.d.ts

@@ -1,18 +1,21 @@
-import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from '../testing/review';
-import type { AudioFormat, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
+import { Elysia } from "elysia";
+import type { VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from "./contract";
+import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions } from "../core/telephonyOutcome";
+import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from "../testing/review";
+import type { AudioFormat, STTAdapter, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from "../core/types";
 type TwilioMediaPayload = {
     chunk?: string;
     payload: string;
     timestamp?: string;
-    track?: 'inbound' | 'outbound';
+    track?: "inbound" | "outbound";
 };
 type TwilioConnectedMessage = {
-    event: 'connected';
+    event: "connected";
     protocol?: string;
     version?: string;
 };
 type TwilioStartMessage = {
-    event: 'start';
+    event: "start";
     sequenceNumber?: string;
     start: {
         accountSid?: string;
@@ -29,13 +32,13 @@ type TwilioStartMessage = {
     streamSid?: string;
 };
 type TwilioMediaMessage = {
-    event: 'media';
+    event: "media";
     media: TwilioMediaPayload;
     sequenceNumber?: string;
     streamSid: string;
 };
 type TwilioMarkMessage = {
-    event: 'mark';
+    event: "mark";
     mark?: {
         name?: string;
     };
@@ -43,7 +46,7 @@ type TwilioMarkMessage = {
     streamSid: string;
 };
 type TwilioStopMessage = {
-    event: 'stop';
+    event: "stop";
     sequenceNumber?: string;
     stop?: {
         accountSid?: string;
@@ -53,18 +56,18 @@ type TwilioStopMessage = {
 };
 export type TwilioInboundMessage = TwilioConnectedMessage | TwilioStartMessage | TwilioMediaMessage | TwilioMarkMessage | TwilioStopMessage;
 export type TwilioOutboundMediaMessage = {
-    event: 'media';
+    event: "media";
     media: {
         payload: string;
     };
     streamSid: string;
 };
 export type TwilioOutboundClearMessage = {
-    event: 'clear';
+    event: "clear";
     streamSid: string;
 };
 export type TwilioOutboundMarkMessage = {
-    event: 'mark';
+    event: "mark";
     mark: {
         name: string;
     };
@@ -75,7 +78,15 @@ export type TwilioMediaStreamSocket = {
     close: (code?: number, reason?: string) => void | Promise<void>;
     send: (data: string) => void | Promise<void>;
 };
-export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoicePluginConfig<TContext, TSession, TResult>, 'htmx' | 'path'> & {
+export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoicePluginConfig<TContext, TSession, TResult>, "htmx" | "path" | "stt"> & {
+    /**
+     * Legacy barge-in: send the carrier a "clear" on every inbound media frame
+     * once the assistant has spoken. Defaults to `false` — a phone line streams
+     * inbound audio continuously (silence included), so this flushes the
+     * assistant constantly. Barge-in is handled speech-gated by the session
+     * (`socket.clear()` on detected speech); only set `true` to force the old
+     * frame-level behavior.
+     */
     clearOnInboundMedia?: boolean;
     context: TContext;
     logger?: VoiceLogger;
@@ -94,6 +105,24 @@ export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends
     };
     scenarioId?: string;
     sessionId?: string;
+    stt: STTAdapter;
+    telephonyMediaCarrier?: "plivo" | "telnyx" | "twilio";
+    /** Capture call audio (per-channel) to a recording store. */
+    recording?: import("../core/types").VoiceSessionRecordingConfig;
+    /** Per-call cost accounting (STT/LLM/TTS) — emits turn.cost/cost.ready traces. */
+    costAccountant?: import("../core/costAccounting").VoiceCostAccountant;
+    /** Telephony cost provider for the accountant (e.g. "twilio"). */
+    costTelephony?: {
+        provider?: string;
+    };
+    /**
+     * Per-transcript semantic end-of-turn detector. Called on every transcript
+     * event; an `endOfTurn=true` verdict EARLY-commits the turn (the runtime
+     * still falls back to `turnDetection.silenceMs` if the detector says
+     * `false`). Useful for raising silenceMs for thinking time while keeping
+     * snappy responses on clear-cut answers. See VoiceSemanticTurnDetector.
+     */
+    semanticTurnDetector?: import("../core/semanticTurn").VoiceSemanticTurnDetector;
 };
 export type TwilioMediaStreamBridge = {
     close: (reason?: string) => Promise<void>;
@@ -105,12 +134,141 @@ export type TwilioVoiceResponseOptions = {
     parameters?: Record<string, string | number | boolean | undefined>;
     streamName?: string;
     streamUrl: string;
-    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+    track?: "both_tracks" | "inbound_track" | "outbound_track";
+};
+export type TwilioVoiceRouteParameters = Record<string, string | number | boolean | undefined> | ((input: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<Record<string, string | number | boolean | undefined>> | Record<string, string | number | boolean | undefined>);
+export type TwilioVoiceSetupStatus = VoiceTelephonySetupStatus<"twilio"> & {
+    urls: VoiceTelephonySetupStatus<"twilio">["urls"] & {
+        twiml: string;
+    };
+};
+export type TwilioVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TwilioVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TwilioVoiceSmokeReport = VoiceTelephonySmokeReport<"twilio"> & {
+    setup: TwilioVoiceSetupStatus;
+};
+export type TwilioVoiceSmokeOptions = {
+    callSid?: string;
+    path?: false | string;
+    scenarioId?: string;
+    sessionId?: string;
+    sipCode?: number;
+    status?: string;
+    title?: string;
+};
+export type TwilioVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = TwilioMediaStreamBridgeOptions<TContext, TSession, TResult> & {
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    smoke?: TwilioVoiceSmokeOptions;
+    setup?: TwilioVoiceSetupOptions;
+    streamPath?: string;
+    twiml?: {
+        parameters?: TwilioVoiceRouteParameters;
+        path?: string;
+        streamName?: string;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+        track?: TwilioVoiceResponseOptions["track"];
+    };
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, "context" | "path" | "policy" | "provider"> & {
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+    };
 };
 export declare const decodeTwilioMulawBase64: (payload: string) => Int16Array<ArrayBuffer>;
 export declare const encodeTwilioMulawBase64: (samples: Int16Array) => string;
-export declare const transcodeTwilioInboundPayloadToPCM16: (payload: string) => Uint8Array<ArrayBuffer>;
 export declare const transcodePCMToTwilioOutboundPayload: (chunk: Uint8Array, format: AudioFormat) => string;
-export declare const createTwilioVoiceResponse: (options: TwilioVoiceResponseOptions) => string;
+export declare const transcodeTwilioInboundPayloadToPCM16: (payload: string) => Uint8Array<ArrayBuffer>;
 export declare const createTwilioMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TwilioMediaStreamSocket, options: TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>) => TwilioMediaStreamBridge;
+export declare const createTwilioVoiceResponse: (options: TwilioVoiceResponseOptions) => string;
+export declare const createTwilioVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: TwilioVoiceRoutesOptions<TContext, TSession, TResult>) => 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;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
 export {};

package/dist/testing/accuracy.d.ts

@@ -1,4 +1,4 @@
-import type { Transcript } from '../types';
+import type { Transcript } from "../core/types";
 export type VoiceTranscriptAccuracy = {
     actualText: string;
     charDistance: number;

package/dist/testing/benchmark.d.ts

@@ -1,6 +1,6 @@
-import type { STTAdapter, STTAdapterOpenOptions } from '../types';
-import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult } from './stt';
-import type { VoiceTestFixture } from './fixtures';
+import type { STTAdapter, STTAdapterOpenOptions } from "../core/types";
+import { type VoiceSTTAdapterHarnessOptions, type VoiceSTTAdapterHarnessResult } from "./stt";
+import type { VoiceTestFixture } from "./fixtures";
 export type VoiceExpectedTermAccuracy = {
     allMatched: boolean;
     expectedTerms: string[];
@@ -8,7 +8,7 @@ export type VoiceExpectedTermAccuracy = {
     missingTerms: string[];
     recall: number;
 };
-export type VoiceSTTFixtureEnvironment = 'accent' | 'accent-noisy' | 'clean' | 'code-switch' | 'jargon' | 'multilingual' | 'multi-speaker' | 'noisy' | 'telephony' | 'other';
+export type VoiceSTTFixtureEnvironment = "accent" | "accent-noisy" | "clean" | "code-switch" | "jargon" | "multilingual" | "multi-speaker" | "noisy" | "telephony" | "other";
 export type VoiceSpeakerTurnAccuracy = {
     available: boolean;
     actualTurnCount: number;
@@ -18,9 +18,9 @@ export type VoiceSpeakerTurnAccuracy = {
     postClustered?: boolean;
 };
 export type VoiceSTTBenchmarkFixtureResult = {
-    accuracy: VoiceSTTAdapterHarnessResult['accuracy'];
+    accuracy: VoiceSTTAdapterHarnessResult["accuracy"];
     closeCount: number;
-    difficulty?: VoiceTestFixture['difficulty'];
+    difficulty?: VoiceTestFixture["difficulty"];
     elapsedMs: number;
     endOfTurnCount: number;
     errorCount: number;
@@ -141,27 +141,27 @@ export type VoiceSTTBenchmarkAcceptanceResult = {
     score: number;
 };
 export type VoiceSTTBenchmarkOptions = VoiceSTTAdapterHarnessOptions & {
-    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, 'fixtureOptions' | 'openOptions'>>;
+    fixtureOptions?: Record<string, Omit<VoiceSTTAdapterHarnessOptions, "fixtureOptions" | "openOptions">>;
     openOptions?: Partial<STTAdapterOpenOptions> | ((fixture: VoiceTestFixture) => Partial<STTAdapterOpenOptions> | undefined);
 };
 export declare const resolveFixtureEnvironment: (fixture: Pick<VoiceTestFixture, "language" | "tags">) => VoiceSTTFixtureEnvironment;
-export declare const summarizeSTTBenchmark: (adapterId: string, fixtures: VoiceSTTBenchmarkFixtureResult[]) => VoiceSTTBenchmarkSummary;
-export declare const evaluateSTTBenchmarkAcceptance: (report: VoiceSTTBenchmarkReport, thresholds?: VoiceSTTBenchmarkAcceptanceThresholds) => VoiceSTTBenchmarkAcceptanceResult;
 export declare const compareSTTBenchmarks: (reports: VoiceSTTBenchmarkReport[]) => VoiceSTTBenchmarkComparison;
-export declare const runSTTAdapterBenchmark: ({ adapter, adapterId, fixtures, options }: {
+export declare const evaluateSTTBenchmarkAcceptance: (report: VoiceSTTBenchmarkReport, thresholds?: VoiceSTTBenchmarkAcceptanceThresholds) => VoiceSTTBenchmarkAcceptanceResult;
+export declare const runSTTAdapterBenchmark: ({ adapter, adapterId, fixtures, options, }: {
     adapter: STTAdapter;
     adapterId: string;
     fixtures: VoiceTestFixture[];
     options?: VoiceSTTBenchmarkOptions;
 }) => Promise<VoiceSTTBenchmarkReport>;
-export declare const summarizeSTTBenchmarkSeries: (input: {
-    adapterId: string;
-    reports: VoiceSTTBenchmarkReport[];
-}) => VoiceSTTBenchmarkSeriesReport;
-export declare const runSTTAdapterBenchmarkSeries: ({ adapter, adapterId, fixtures, options, runs }: {
+export declare const runSTTAdapterBenchmarkSeries: ({ adapter, adapterId, fixtures, options, runs, }: {
     adapter: STTAdapter;
     adapterId: string;
     fixtures: VoiceTestFixture[];
     options?: VoiceSTTBenchmarkOptions;
     runs: number;
 }) => Promise<VoiceSTTBenchmarkSeriesReport>;
+export declare const summarizeSTTBenchmark: (adapterId: string, fixtures: VoiceSTTBenchmarkFixtureResult[]) => VoiceSTTBenchmarkSummary;
+export declare const summarizeSTTBenchmarkSeries: (input: {
+    adapterId: string;
+    reports: VoiceSTTBenchmarkReport[];
+}) => VoiceSTTBenchmarkSeriesReport;

package/dist/testing/corrected.d.ts

@@ -1,8 +1,8 @@
-import type { VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from '../types';
-import { type VoiceExpectedTermAccuracy, type VoiceSTTBenchmarkReport } from './benchmark';
-import type { VoiceSessionBenchmarkReport } from './sessionBenchmark';
-import type { VoiceTestFixture } from './fixtures';
-export type VoiceCorrectionHintProfile = 'generic' | 'benchmark-seeded';
+import type { VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from "../core/types";
+import { type VoiceExpectedTermAccuracy, type VoiceSTTBenchmarkReport } from "./benchmark";
+import type { VoiceSessionBenchmarkReport } from "./sessionBenchmark";
+import type { VoiceTestFixture } from "./fixtures";
+export type VoiceCorrectionHintProfile = "generic" | "benchmark-seeded";
 type VoiceCorrectionAuditSlice<TReport> = {
     fixtureIds: string[];
     raw: TReport;
@@ -28,14 +28,14 @@ export type VoiceSessionCorrectionAudit = {
 };
 export declare const isCorrectionHoldoutFixtureId: (fixtureId: string) => boolean;
 export declare const buildFixturePhraseHints: (fixture: Pick<VoiceTestFixture, "expectedTerms" | "expectedText">, profile?: VoiceCorrectionHintProfile) => VoicePhraseHint[];
+export declare const applyCorrectedBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[], profile?: VoiceCorrectionHintProfile) => VoiceSTTBenchmarkReport;
+export declare const applyExperimentalBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[]) => VoiceSTTBenchmarkReport;
+export declare const applyLexiconCorrectedBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[], buildLexicon: (fixture: Pick<VoiceTestFixture, "expectedTerms" | "expectedText" | "language" | "tags">) => VoiceLexiconEntry[]) => VoiceSTTBenchmarkReport;
 export declare const buildCodeSwitchBenchmarkLexicon: (fixture: Pick<VoiceTestFixture, "expectedTerms" | "expectedText" | "language" | "tags">) => VoiceLexiconEntry[];
 export declare const buildCodeSwitchBenchmarkPhraseHints: (fixture: Pick<VoiceTestFixture, "expectedTerms" | "expectedText" | "language" | "tags">) => VoicePhraseHint[];
-export declare const createCodeSwitchBenchmarkCorrectionHandler: () => VoiceTurnCorrectionHandler;
 export declare const createBenchmarkCorrectionHandler: (profile: VoiceCorrectionHintProfile) => VoiceTurnCorrectionHandler;
+export declare const createCodeSwitchBenchmarkCorrectionHandler: () => VoiceTurnCorrectionHandler;
 export declare const scoreCorrectedExpectedTerms: (actualText: string, expectedTerms: string[] | undefined) => VoiceExpectedTermAccuracy;
-export declare const applyCorrectedBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[], profile?: VoiceCorrectionHintProfile) => VoiceSTTBenchmarkReport;
-export declare const applyExperimentalBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[]) => VoiceSTTBenchmarkReport;
-export declare const applyLexiconCorrectedBenchmarkReport: (report: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[], buildLexicon: (fixture: Pick<VoiceTestFixture, "expectedTerms" | "expectedText" | "language" | "tags">) => VoiceLexiconEntry[]) => VoiceSTTBenchmarkReport;
 export declare const buildCorrectionBenchmarkAudit: (rawReport: VoiceSTTBenchmarkReport, fixtures: VoiceTestFixture[]) => VoiceCorrectionBenchmarkAudit;
 export declare const buildSessionCorrectionAudit: (raw: VoiceSessionBenchmarkReport, generic: VoiceSessionBenchmarkReport, experimental: VoiceSessionBenchmarkReport, benchmarkSeeded: VoiceSessionBenchmarkReport, scenarios: Array<Pick<VoiceTestFixture, "expectedTerms" | "expectedText" | "expectedTurnTexts" | "id">>) => VoiceSessionCorrectionAudit;
 export {};