@adaptic/utils 0.0.1014 → 0.0.1016

package/dist/types/__tests__/llm/client/support/rejections.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Typed access to the error a call was supposed to raise.
+ *
+ * `await promise.catch((error) => error)` types the result as the union of the
+ * error and the value the promise might have resolved to, which erases exactly
+ * the properties an assertion wants to read. Worse, a call that wrongly
+ * SUCCEEDS then surfaces as a missing property rather than as the contract
+ * violation it is. This narrows once, and fails loudly on a resolution.
+ *
+ * @module __tests__/llm/client/support/rejections
+ */
+/**
+ * Await a call that must fail, and return its error at the expected type.
+ *
+ * @param promise The call under test.
+ * @param expected The error class the call is contracted to raise.
+ * @returns The raised error.
+ * @throws When the call resolves, or raises something of another type.
+ */
+export declare function rejection<E extends Error>(promise: Promise<unknown>, expected: new (...args: never[]) => E): Promise<E>;
+//# sourceMappingURL=rejections.d.ts.map

package/dist/types/__tests__/llm/client/support/rejections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rejections.d.ts","sourceRoot":"","sources":["../../../../../../src/__tests__/llm/client/support/rejections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,KAAK,EAC7C,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,QAAQ,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,GACpC,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/dist/types/__tests__/llm/client/support/routes.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Route fixtures for the alias-client test suite.
+ *
+ * The canonical route table is the product's routing policy, not a test
+ * fixture: most of its open-weight legs are deliberately unconfirmed today, and
+ * no leg declares a missing capability. Exercising a three-leg walk, or a
+ * provider that rejects a sampling parameter, therefore needs routes built
+ * here. They are built from the same public `ResolvedRoute` shape the resolver
+ * emits, so a change to that shape breaks these fixtures rather than letting
+ * them drift into describing a chain the client can no longer produce.
+ *
+ * @module __tests__/llm/client/support/routes
+ */
+import type { LlmAlias, LlmProvider, LlmRouteParams, LlmRouteRole, ResolvedRoute } from "../../../../llm/types";
+/** Per-leg budget used wherever a test needs a timeout it can drive by hand. */
+export declare const TEST_LEG_TIMEOUT_MS = 1000;
+/** Retry budget carried on fixture routes; the chain itself does the retrying. */
+export declare const TEST_RETRIES_PER_LEG = 1;
+/** An open-weight host: an OpenAI-compatible wire format the degraded path must refuse. */
+export declare const OPEN_PROVIDER: LlmProvider;
+/** A retained closed vendor speaking the Anthropic wire format (PD-11). */
+export declare const CLOSED_PROVIDER: LlmProvider;
+/** An aggregator backstop, used where a third tier value has to be distinguishable. */
+export declare const AGGREGATOR_PROVIDER: LlmProvider;
+/** Fields a fixture route may override; everything else takes a serving default. */
+export interface RouteOverrides {
+    readonly alias?: LlmAlias;
+    readonly isolated?: boolean;
+    readonly role?: LlmRouteRole;
+    readonly provider?: LlmProvider;
+    readonly providerName?: string;
+    readonly modelId?: string;
+    readonly lumicModel?: string | null;
+    readonly params?: LlmRouteParams;
+    readonly timeoutMs?: number;
+}
+/**
+ * Build one resolved leg.
+ *
+ * The route key is derived through the production `routeKeyFor` rather than
+ * spelled out, so a fixture and the breaker registry can never disagree about
+ * which leg a key names.
+ *
+ * @param overrides Fields to set; the rest take serving defaults.
+ * @returns A resolved leg ready to hand to the chain executor.
+ */
+export declare function makeRoute(overrides?: RouteOverrides): ResolvedRoute;
+/**
+ * Build a full primary -> secondary -> closed-incumbent chain.
+ *
+ * @param alias The alias the legs belong to.
+ * @returns The three legs in chain order.
+ */
+export declare function makeThreeLegChain(alias?: LlmAlias): ResolvedRoute[];
+/**
+ * Name an alias the type union deliberately forbids.
+ *
+ * `LlmAlias` is a closed union precisely so a mistyped alias cannot compile,
+ * which leaves the resolver's runtime guard unreachable from well-typed code.
+ * Reaching it requires one deliberate widening; it is confined here so the
+ * assertion appears once rather than at each call site that tests the guard.
+ *
+ * @param name The alias name to pass through.
+ * @returns The same name, typed as an alias.
+ */
+export declare function asAlias(name: string): LlmAlias;
+//# sourceMappingURL=routes.d.ts.map

package/dist/types/__tests__/llm/client/support/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../../../src/__tests__/llm/client/support/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,cAAc,EACd,YAAY,EACZ,aAAa,EACd,MAAM,uBAAuB,CAAC;AAE/B,gFAAgF;AAChF,eAAO,MAAM,mBAAmB,OAAQ,CAAC;AAEzC,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,2FAA2F;AAC3F,eAAO,MAAM,aAAa,EAAE,WAU3B,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,eAAe,EAAE,WAW7B,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,mBAAmB,EAAE,WAUjC,CAAC;AAEF,oFAAoF;AACpF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,SAAS,GAAE,cAAmB,GAAG,aAAa,CAkBvE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,GAAE,QAAwB,GAAG,aAAa,EAAE,CAgBlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAE9C"}

package/dist/types/__tests__/llm/client/support/streams.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Wire-format stream builders for the streaming normalisation tests.
+ *
+ * The normaliser's hardest requirement is that a chunk boundary is not a
+ * message boundary: the network splits bytes wherever it likes, including
+ * inside a JSON payload. These builders therefore emit the wire text and let a
+ * test choose the byte-chunking independently, so the same logical stream can
+ * be replayed whole, split per line, or split every few bytes.
+ *
+ * @module __tests__/llm/client/support/streams
+ */
+/** Sentinel closing an OpenAI-compatible server-sent event stream. */
+export declare const SSE_DONE_LINE = "data: [DONE]";
+/**
+ * Render an OpenAI-compatible SSE body.
+ *
+ * @param deltas Text increments, in order.
+ * @param options Rendering options.
+ * @param options.terminate Emit the `[DONE]` sentinel. Omitting it models a truncated stream.
+ * @param options.errorAfter Emit a provider error event after this many deltas.
+ * @returns The wire text.
+ */
+export declare function openAiSseBody(deltas: readonly string[], options?: {
+    readonly terminate?: boolean;
+    readonly errorAfter?: number;
+}): string;
+/**
+ * Render an Anthropic event-stream body.
+ *
+ * Each event carries both the `event:` line a real stream sends and the `data:`
+ * line the normaliser reads, so the test proves the normaliser ignores the
+ * former rather than merely never meeting it.
+ *
+ * @param deltas Text increments, in order.
+ * @param options Rendering options.
+ * @param options.terminate Emit `message_stop`. Omitting it models a truncated stream.
+ * @param options.errorAfter Emit a provider error event after this many deltas.
+ * @returns The wire text.
+ */
+export declare function anthropicSseBody(deltas: readonly string[], options?: {
+    readonly terminate?: boolean;
+    readonly errorAfter?: number;
+}): string;
+/**
+ * Split text into fixed-size pieces.
+ *
+ * Sized in characters rather than lines so a piece can land inside a JSON
+ * payload, which is the boundary case a line-oriented parser gets wrong.
+ *
+ * @param text The wire text.
+ * @param size Characters per piece.
+ * @returns The pieces, in order.
+ */
+export declare function splitEvery(text: string, size: number): string[];
+/**
+ * Present pieces of wire text as the byte stream a response body would be.
+ *
+ * @param pieces The pieces, in order.
+ * @returns An async iterable of encoded chunks.
+ */
+export declare function byteStream(pieces: readonly string[]): AsyncIterable<Uint8Array>;
+/**
+ * Present wire text as a byte stream chopped at fixed BYTE offsets.
+ *
+ * Chopping the encoded bytes rather than the string is what puts a boundary
+ * inside a multi-byte character as well as inside a JSON payload, which is the
+ * case an incremental decoder exists for.
+ *
+ * @param text The wire text.
+ * @param size Bytes per chunk.
+ * @returns An async iterable of encoded chunks.
+ */
+export declare function byteStreamSplitEvery(text: string, size: number): AsyncIterable<Uint8Array>;
+//# sourceMappingURL=streams.d.ts.map

package/dist/types/__tests__/llm/client/support/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../../../../../src/__tests__/llm/client/support/streams.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sEAAsE;AACtE,eAAO,MAAM,aAAa,iBAAiB,CAAC;AAE5C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3E,MAAM,CAqBR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3E,MAAM,CA4BR;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAM/D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CAAC,UAAU,CAAC,CAS/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CAAC,UAAU,CAAC,CAS3B"}

package/dist/types/__tests__/llm/client/support/transports.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Scripted transport doubles for the alias-client test suite.
+ *
+ * The client's guarantees are all about what it does BETWEEN transports —
+ * which leg it tries next, how long it waits, what it records, what it refuses
+ * to invent. Observing those needs a transport whose every outcome is chosen by
+ * the test and whose every invocation is recorded, so an assertion can be made
+ * about a leg that was never called at all. A real provider, or a network
+ * mock, would make exactly those assertions unavailable.
+ *
+ * @module __tests__/llm/client/support/transports
+ */
+import type { LlmResponseFormat, LlmToolCall, LlmTransport, LlmTransportRequest, LlmTransportResponse, LlmUsageRecord, ResolvedRoute } from "../../../../llm/types";
+/** One invocation, captured for assertions about routing and normalisation. */
+export interface ScriptedCall {
+    /** Zero-based invocation order across the whole transport. */
+    readonly index: number;
+    readonly route: ResolvedRoute;
+    readonly content: string | readonly unknown[];
+    readonly params: Readonly<Record<string, unknown>>;
+    readonly responseFormat: LlmResponseFormat;
+    /** The per-leg signal, kept live so a test can observe an abort after the fact. */
+    readonly signal: AbortSignal;
+    readonly correlationId?: string;
+}
+/** What a scripted leg does when invoked. */
+export type LegBehaviour = {
+    readonly kind: "ok";
+    readonly response: unknown;
+    readonly usage: LlmUsageRecord;
+    readonly toolCalls?: readonly LlmToolCall[];
+} | {
+    readonly kind: "fail";
+    readonly error: Error;
+}
+/** Never settles on its own: the leg ends only when its signal aborts. */
+ | {
+    readonly kind: "hang";
+};
+/** Token counts a scripted leg reports. */
+export interface UsageOverrides {
+    readonly promptTokens?: number;
+    readonly completionTokens?: number;
+    readonly cost?: number;
+    readonly provider?: string;
+    readonly model?: string;
+}
+/**
+ * Build a usage record attributed to a leg.
+ *
+ * @param route The leg the usage belongs to.
+ * @param overrides Counts to report.
+ * @returns The usage record.
+ */
+export declare function usageFor(route: ResolvedRoute, overrides?: UsageOverrides): LlmUsageRecord;
+/**
+ * A leg that answers.
+ *
+ * @param response The payload to return.
+ * @param usage The usage to report.
+ * @param toolCalls Tool calls the model asked for, if any.
+ * @returns The behaviour.
+ */
+export declare function answers(response: unknown, usage: LlmUsageRecord, toolCalls?: readonly LlmToolCall[]): LegBehaviour;
+/**
+ * A leg that throws.
+ *
+ * @param error The error to throw.
+ * @returns The behaviour.
+ */
+export declare function fails(error: Error): LegBehaviour;
+/**
+ * A leg that never answers until its signal aborts.
+ *
+ * @returns The behaviour.
+ */
+export declare function hangs(): LegBehaviour;
+/**
+ * A transport whose every outcome is chosen by the test and whose every
+ * invocation is recorded.
+ */
+export declare class ScriptedTransport implements LlmTransport {
+    /** Identifies which transport answered, so degraded-path tests can tell them apart. */
+    readonly name: string;
+    /** Every invocation, in order. */
+    readonly calls: ScriptedCall[];
+    private readonly plan;
+    /**
+     * @param name Transport name, surfaced on the `LlmTransport` contract.
+     * @param plan Decides what each invocation does, given the recorded call.
+     */
+    constructor(name: string, plan: (call: ScriptedCall) => LegBehaviour);
+    /** Route keys invoked, in order. */
+    get routeKeys(): string[];
+    /** Provider tiers invoked, in order, for the degraded path's closed-only rule. */
+    get tiers(): string[];
+    /**
+     * Execute one scripted leg.
+     *
+     * @param request The normalised leg request.
+     * @returns Whatever the plan decided for this invocation.
+     */
+    execute<T>(request: LlmTransportRequest): Promise<LlmTransportResponse<T>>;
+}
+//# sourceMappingURL=transports.d.ts.map

package/dist/types/__tests__/llm/client/support/transports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transports.d.ts","sourceRoot":"","sources":["../../../../../../src/__tests__/llm/client/support/transports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,aAAa,EACd,MAAM,uBAAuB,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,cAAc,EAAE,iBAAiB,CAAC;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,6CAA6C;AAC7C,MAAM,MAAM,YAAY,GACpB;IACE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;CAC7C,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE;AAClD,0EAA0E;GACxE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9B,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,aAAa,EACpB,SAAS,GAAE,cAAmB,GAC7B,cAAc,CAQhB;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,cAAc,EACrB,SAAS,CAAC,EAAE,SAAS,WAAW,EAAE,GACjC,YAAY,CAEd;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,YAAY,CAEpC;AAkBD;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,YAAY;IACpD,uFAAuF;IACvF,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,kCAAkC;IAClC,SAAgB,KAAK,EAAE,YAAY,EAAE,CAAM;IAE3C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuC;IAE5D;;;OAGG;gBACgB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY;IAK3E,oCAAoC;IACpC,IAAW,SAAS,IAAI,MAAM,EAAE,CAE/B;IAED,kFAAkF;IAClF,IAAW,KAAK,IAAI,MAAM,EAAE,CAE3B;IAED;;;;;OAKG;IACU,OAAO,CAAC,CAAC,EACpB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAwCpC"}

package/dist/types/index.d.ts

@@ -19,6 +19,7 @@ import * as ta from "./technical-analysis";
 import * as tu from "./time-utils";
 import * as Types from "./types";
 import * as volatilityNs from "./volatility";
+export * from "./llm";
 export { getLogger, resetLogger, setLogger, type Logger } from "./logger";
 export { AdapticUtilsError, type AlpacaBrokerErrorDetail, AlpacaApiError, AlphaVantageError, AuthenticationError, DataFormatError, DuplicateClientOrderIdError, enrichAlpacaError, extractAlpacaBrokerError, getAlpacaBrokerErrorCode, getAlpacaBrokerErrorDetail, HttpClientError, HttpServerError, MassiveApiError, NetworkError, RateLimitError, TimeoutError, UnsupportedBrokerError, ValidationError, WebSocketError, } from "./errors";
 export { validateAlpacaCredentials, validateAlphaVantageApiKey, validateMassiveApiKey, } from "./utils/auth-validator";

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,OAAO,iBAAiB,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,IAAI,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,EAAE,sBAAsB,EAAgB,MAAM,gBAAgB,CAAC;AACtE,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,YAAY,MAAM,cAAc,CAAC;AAM7C,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAG1E,OAAO,EACL,iBAAiB,EACjB,KAAK,uBAAuB,EAC5B,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,wBAAwB,EACxB,wBAAwB,EACxB,0BAA0B,EAC1B,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,eAAe,EACf,cAAc,GACf,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,WAAW,GACjB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,4BAA4B,EAC5B,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,6BAA6B,GACnC,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,SAAS,EACT,KAAK,WAAW,GACjB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGhD,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACV,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AAEtC,cAAc,gCAAgC,CAAC;AAG/C,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EAEpB,0BAA0B,EAC1B,eAAe,EACf,8BAA8B,EAC9B,kCAAkC,EAClC,8BAA8B,EAC9B,gCAAgC,EAChC,gCAAgC,EAChC,uBAAuB,EACvB,wBAAwB,EACxB,iBAAiB,EACjB,uBAAuB,EACvB,oCAAoC,EACpC,oBAAoB,EACpB,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EAEjB,+BAA+B,EAC/B,+BAA+B,EAC/B,2BAA2B,EAC3B,0BAA0B,EAC1B,iCAAiC,EACjC,8BAA8B,EAC9B,kCAAkC,EAClC,uBAAuB,EACvB,kBAAkB,IAAI,qBAAqB,EAC3C,2BAA2B,EAE3B,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,GACtB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,6BAA6B,EAC7B,yBAAyB,EACzB,uCAAuC,EACvC,eAAe,EACf,sBAAsB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC;AAG1B,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,eAAO,MAAM,sBAAsB,GACjC,aAAa,KAAK,CAAC,iBAAiB,qBAGrC,CAAC;AAEF,eAAO,MAAM,yBAAyB,2BAErC,CAAC;AAGF,cAAc,UAAU,CAAC;AAKzB,OAAO,EACL,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,GAChC,MAAM,UAAU,CAAC;AAGlB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,eAAe,EACf,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,WAAW,GACZ,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,uBAAuB,EACvB,0BAA0B,EAC1B,oBAAoB,EACpB,UAAU,EACV,sBAAsB,EACtB,cAAc,EACd,sBAAsB,GACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAG1F,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;QAoBhB,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAwLnE,CAAC;;;;;;;;;;;;;;;;;4BAjLyB,CAAC;0BACX,CAAC;;;;;;;;;;;QANlB,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEjF,2EAA2E;;QAE3E,6FAA6F;;QAE7F,yFAAyF;;QAIzF,4EAA4E;;;;;;;;;;QAU5E,sEAAsE;;;;;;;;QAQtE,sEAAsE;;QAEtE,mDAAmD;;QAEnD,iDAAiD;;QAEjD,8BAA8B;;QAE9B,+BAA+B;;QAE/B,4CAA4C;;;;;;;QAE5C,mDAAmD;;;;;QAEnD,+CAA+C;;QAI/C,+CAA+C;;;;;;;;QAQ/C,wCAAwC;;QAExC,+DAA+D;;QAE/D,mEAAmE;;QAEnE,sEAAsE;;QAEtE,kDAAkD;;;;QAIlD,4CAA4C;;;;;;;kBAjTnC,CAAC;;;iBA0HU,CAAC;eACb,CAAC;iBAEZ,CAAC;kBAAoB,CAAC;gBACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBA,CAAC;;;kBA6RmhV,CAAC;oBAAsB,CAAC;sBAAyB,CAAC;;;kBA3KrkV,CAAC;;;kBAwG8C,CAAC;;;kBAmE2kjB,CAAC;qBAAuB,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;iBAA4B,CAAC;iBAA2B,CAAC;gBAAkB,CAAC;;;;;eAAp/gB,CAAC;;;iBAAiE,CAAC;oBAAsB,CAAC;;kBAAoC,CAAC;;;;;eAA48L,CAAC;;;iBAAiE,CAAC;oBAAsB,CAAC;;kBAAoC,CAAC;;;;;kBAAk0N,CAAC;oBAAsB,CAAC;;;;;;kBAhZj5c,CAAC;;;kBAsED,CAAC;;;kBA0DmB,CAAC;;;kBAuDzB,CAAC;;;kBAgDA,CAAC;gBAAkB,CAAC;iBAAmB,CAAC;iBACpD,CAAH;gBACK,CAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoJC;;;WAGG;;QAEH;;;;WAIG;;;;;;;;;;;CAON,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;QA9Ld,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAwLnE,CAAC;;;;;;;;;;;;;;;;;4BAjLyB,CAAC;0BACX,CAAC;;;;;;;;;;;QANlB,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEjF,2EAA2E;;QAE3E,6FAA6F;;QAE7F,yFAAyF;;QAIzF,4EAA4E;;;;;;;;;;QAU5E,sEAAsE;;;;;;;;QAQtE,sEAAsE;;QAEtE,mDAAmD;;QAEnD,iDAAiD;;QAEjD,8BAA8B;;QAE9B,+BAA+B;;QAE/B,4CAA4C;;;;;;;QAE5C,mDAAmD;;;;;QAEnD,+CAA+C;;QAI/C,+CAA+C;;;;;;;;QAQ/C,wCAAwC;;QAExC,+DAA+D;;QAE/D,mEAAmE;;QAEnE,sEAAsE;;QAEtE,kDAAkD;;;;QAIlD,4CAA4C;;;;;;;kBAjTnC,CAAC;;;iBA0HU,CAAC;eACb,CAAC;iBAEZ,CAAC;kBAAoB,CAAC;gBACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBA,CAAC;;;kBA6RmhV,CAAC;oBAAsB,CAAC;sBAAyB,CAAC;;;kBA3KrkV,CAAC;;;kBAwG8C,CAAC;;;kBAmE2kjB,CAAC;qBAAuB,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;uBAAkC,CAAC;wBAAmC,CAAC;iBAA4B,CAAC;iBAA2B,CAAC;gBAAkB,CAAC;;;;;eAAp/gB,CAAC;;;iBAAiE,CAAC;oBAAsB,CAAC;;kBAAoC,CAAC;;;;;eAA48L,CAAC;;;iBAAiE,CAAC;oBAAsB,CAAC;;kBAAoC,CAAC;;;;;kBAAk0N,CAAC;oBAAsB,CAAC;;;;;;kBAhZj5c,CAAC;;;kBAsED,CAAC;;;kBA0DmB,CAAC;;;kBAuDzB,CAAC;;;kBAgDA,CAAC;gBAAkB,CAAC;iBAAmB,CAAC;iBACpD,CAAH;gBACK,CAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoJC;;;WAGG;;QAEH;;;;WAIG;;;;;;;;;;;CASqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/types/llm/alias-client.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The alias-resolving LLM client.
+ *
+ * This is the only supported way to reach a language model from application
+ * code. Its signature mirrors the incumbent client's — content, response
+ * format, options — so migrating a call site is replacing a model string with
+ * an alias, and nothing else. That similarity is the point: a migration that
+ * required rewriting call sites would be a migration that stalls half-done,
+ * leaving some calls inside the timeout, breaker and fallback controls and
+ * some outside them, which is worse than either end state.
+ *
+ * There is deliberately no way to name a model. PD-5 makes vendor strings a CI
+ * failure in application code, and an option that accepted one would let a call
+ * site opt out of the routing policy without anyone noticing.
+ *
+ * Every call gets, in order: alias resolution against the canonical route
+ * table, per-provider parameter normalisation, a hard per-leg timeout, a
+ * per-route circuit breaker, an ordered fallback chain ending at the closed
+ * incumbent, and — where the caller supplies a validator — one schema-feedback
+ * retry ahead of the chain. None of them is optional, because a control that a
+ * caller can switch off is a control that will be off on the call that needed
+ * it.
+ *
+ * @module llm/alias-client
+ */
+import { CircuitBreakerRegistry } from "./circuit-breaker";
+import type { AliasCallOptions, AliasCallResult, LlmAlias, LlmClientConfig, LlmResponseFormat } from "./types";
+/**
+ * Wire the client.
+ *
+ * Called once at process start. Transports are injectable so a consumer can
+ * supply its own instrumented client, and so tests can exercise the chain
+ * without a network — a fallback chain that could only be observed against live
+ * providers would in practice never be observed at all.
+ *
+ * @param next Runtime wiring; unspecified fields fall back to the environment.
+ * @returns void
+ */
+export declare function configureLlmClient(next: LlmClientConfig): void;
+/**
+ * Inspect route health.
+ *
+ * @returns The live breaker registry.
+ */
+export declare function llmBreakers(): CircuitBreakerRegistry;
+/**
+ * Call a language model by semantic alias.
+ *
+ * @param content The prompt, or multi-part content for a vision-capable route.
+ * @param responseFormat The response shape. Defaults to plain text.
+ * @param options Call options; `alias` is required and there is no model option.
+ * @returns The answer, with the routing decision and full attempt record attached.
+ * @throws {UnknownAliasError} When the alias is not in the route table.
+ * @throws {ChainExhaustedError} When no leg produced an answer.
+ * @throws {SchemaRetryExhaustedError} When a validated payload failed twice.
+ */
+export declare function callLLMByAlias<T = unknown>(content: string | readonly unknown[], responseFormat: LlmResponseFormat | undefined, options: AliasCallOptions<T>): Promise<AliasCallResult<T>>;
+/**
+ * The aliases application code may name.
+ *
+ * @returns The alias names, sorted.
+ */
+export declare function llmAliases(): LlmAlias[];
+//# sourceMappingURL=alias-client.d.ts.map

package/dist/types/llm/alias-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-client.d.ts","sourceRoot":"","sources":["../../../src/llm/alias-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAY3D,OAAO,KAAK,EAEV,gBAAgB,EAChB,eAAe,EACf,QAAQ,EACR,eAAe,EACf,iBAAiB,EAGlB,MAAM,SAAS,CAAC;AAoBjB;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAQ9D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,sBAAsB,CAEpD;AA+ED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,CAAC,GAAG,OAAO,EAC9C,OAAO,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,EACpC,cAAc,EAAE,iBAAiB,YAAS,EAC1C,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAoK7B;AA8BD;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,QAAQ,EAAE,CAEvC"}

package/dist/types/llm/circuit-breaker.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Per-route circuit breaker for the alias client.
+ *
+ * A provider that has just failed five calls will almost certainly fail the
+ * sixth, and every attempt spends latency budget the next leg of the chain
+ * needs. The breaker converts that repeated discovery into a decision made
+ * once: an unhealthy leg is skipped outright until it has had time to recover,
+ * so a chain reaches its working leg quickly instead of paying the full
+ * timeout of each dead one first.
+ *
+ * Breakers are keyed by chain POSITION, not by provider. Two consequences
+ * follow, and both are intended. Reverting an alias to a different model at the
+ * same position inherits that position's health rather than starting blind. And
+ * an isolated route never shares a breaker with the shared one, so isolated
+ * traffic can neither trip nor be tripped by traffic on the other side of the
+ * PD-9 boundary.
+ *
+ * The clock is injected. Breaker behaviour is entirely about elapsed time, and
+ * a test that must sleep to observe a cooldown is a test nobody runs.
+ *
+ * @module llm/circuit-breaker
+ */
+import type { LlmBreakerDefaults } from "./types";
+/** What the breaker will currently permit for a route. */
+export type BreakerState = "closed" | "open" | "half-open";
+/** Snapshot of one route's breaker, for observability and tests. */
+export interface BreakerSnapshot {
+    readonly routeKey: string;
+    readonly state: BreakerState;
+    readonly consecutiveFailures: number;
+    readonly openedAtMs: number | null;
+    readonly probesInFlight: number;
+}
+/**
+ * Tracks route health and decides whether a leg may be attempted.
+ */
+export declare class CircuitBreakerRegistry {
+    private readonly records;
+    private readonly config;
+    private readonly now;
+    /**
+     * @param config Failure threshold, cooldown and half-open probe budget.
+     * @param now Clock, injected so cooldowns are testable without waiting.
+     */
+    constructor(config: LlmBreakerDefaults, now?: () => number);
+    /**
+     * Current state of a route's breaker.
+     *
+     * The transition from open to half-open is computed from elapsed time at read
+     * time rather than scheduled with a timer. A timer would keep the process
+     * awake for every route that ever failed, and would drift whenever the
+     * process was busy — which is exactly when a breaker matters most.
+     *
+     * @param routeKey The route's stable key.
+     * @returns Its state.
+     */
+    stateOf(routeKey: string): BreakerState;
+    /**
+     * Whether a route may be attempted now.
+     *
+     * A half-open route admits a bounded number of probes at once. Letting the
+     * whole queue through the moment a cooldown expires would re-hammer a
+     * provider that is still recovering, which is how a breaker turns into a
+     * synchronised retry storm.
+     *
+     * @param routeKey The route's stable key.
+     * @returns Whether an attempt is permitted.
+     */
+    allows(routeKey: string): boolean;
+    /**
+     * Register that an attempt is starting, so half-open probes stay bounded.
+     *
+     * @param routeKey The route's stable key.
+     * @returns void
+     */
+    onAttemptStart(routeKey: string): void;
+    /**
+     * Record a success, closing the breaker.
+     *
+     * A single success closes it fully rather than decrementing the failure
+     * count. The breaker's question is "is this route working now", and one
+     * working call answers it; requiring several would keep a recovered provider
+     * excluded while the chain paid for slower legs.
+     *
+     * @param routeKey The route's stable key.
+     * @returns void
+     */
+    onSuccess(routeKey: string): void;
+    /**
+     * Record a failure, opening the breaker once the threshold is reached.
+     *
+     * A failure while half-open re-opens immediately without waiting to
+     * re-accumulate the threshold: the probe was the test, and it failed.
+     *
+     * @param routeKey The route's stable key.
+     * @returns void
+     */
+    onFailure(routeKey: string): void;
+    /**
+     * Inspect a route's breaker.
+     *
+     * @param routeKey The route's stable key.
+     * @returns A snapshot.
+     */
+    snapshot(routeKey: string): BreakerSnapshot;
+    /**
+     * Every route the registry has observed.
+     *
+     * @returns Snapshots, sorted by route key for stable output.
+     */
+    snapshotAll(): BreakerSnapshot[];
+    /**
+     * Discard all breaker state.
+     *
+     * @returns void
+     */
+    reset(): void;
+    /**
+     * @param routeKey The route's stable key.
+     * @returns The mutable record, created on first use.
+     */
+    private recordFor;
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/types/llm/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/llm/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,0DAA0D;AAC1D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAQD;;GAEG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAE5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IAEnC;;;OAGG;gBACgB,MAAM,EAAE,kBAAkB,EAAE,GAAG,GAAE,MAAM,MAAiB;IAK3E;;;;;;;;;;OAUG;IACI,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY;IAS9C;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAYxC;;;;;OAKG;IACI,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAM7C;;;;;;;;;;OAUG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQxC;;;;;;;;OAQG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWxC;;;;;OAKG;IACI,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe;IAelD;;;;OAIG;IACI,WAAW,IAAI,eAAe,EAAE;IAMvC;;;;OAIG;IACI,KAAK,IAAI,IAAI;IAIpB;;;OAGG;IACH,OAAO,CAAC,SAAS;CAQlB"}

package/dist/types/llm/eval/comparators.d.ts

@@ -0,0 +1,127 @@
+/**
+ * The incumbent-relative comparators, one per assertion type in Section 6 of
+ * the migration backlog.
+ *
+ * Each is a pure function from two measured numbers to a verdict, which is what
+ * makes PD-6 enforceable: the gate is decided by code from recorded data, and
+ * there is no place in the call for judgement to enter. Keeping them separate
+ * and separately testable also keeps their tolerances honest — a tolerance
+ * buried inside a runner is a tolerance nobody re-reads.
+ *
+ * Three preconditions are shared by all of them, and all three yield
+ * `indeterminate` rather than a verdict:
+ *
+ * - no recorded incumbent value, because every gate here is a comparison and a
+ *   comparison with one side missing is not a strict measurement;
+ * - no candidate value, for the same reason;
+ * - fewer cases than the set's declared minimum, because a difference measured
+ *   on too few cases is indistinguishable from sampling noise.
+ *
+ * @module llm/eval/comparators
+ */
+import type { EvalAssertion, EvalGate, Verdict } from "./types";
+/**
+ * Tolerance for the match assertion, in points.
+ *
+ * Section 6: "exact-match or field-level F1 within 1 point of incumbent". The
+ * band is two-sided in principle and one-sided in effect — a candidate above
+ * the incumbent passes outright — so only the downside is checked.
+ */
+export declare const MATCH_TOLERANCE_POINTS = 1;
+/**
+ * Tolerance for the pinned-judge assertion, as a fraction of the incumbent's score.
+ *
+ * Section 6: "pinned-judge score within 3% of incumbent". Relative rather than
+ * absolute because judge scores are not linear across their range: three points
+ * near the top of the scale is a much larger regression than three points in
+ * the middle.
+ */
+export declare const JUDGE_TOLERANCE_FRACTION = 0.03;
+/** Scale factor converting a 0-1 rate into the 0-100 point scale tolerances are stated in. */
+export declare const RATE_TO_POINTS = 100;
+/** The measured inputs one comparator decides on. */
+export interface ComparatorInput {
+    /** The candidate's measured value, or `undefined` when it could not be measured. */
+    readonly candidate: number | undefined;
+    /** The recorded incumbent value, or `undefined` when the set has no baseline for it. */
+    readonly incumbent: number | undefined;
+    /** Cases the measurement was taken over. */
+    readonly n: number;
+    /** The set's declared minimum case count. */
+    readonly minN: number;
+}
+/** A comparator: measured inputs in, one verdict out. */
+export type Comparator = (input: ComparatorInput) => Verdict;
+/**
+ * Schema-valid rate: the candidate must parse at least as often as the incumbent.
+ *
+ * No tolerance band, because a malformed structured answer is not a slightly
+ * worse answer — it is one the call site cannot consume at all.
+ *
+ * @param input The measured rates, on a 0-1 scale.
+ * @returns The verdict.
+ */
+export declare const compareSchemaValidRate: Comparator;
+/**
+ * Tool-call valid-call rate: the candidate must call correctly at least as often.
+ *
+ * The permitted single structured retry is applied when the rate is derived, so
+ * by the time the comparison is made both sides have been measured under the
+ * same retry budget.
+ *
+ * @param input The measured rates, on a 0-1 scale.
+ * @returns The verdict.
+ */
+export declare const compareValidCallRate: Comparator;
+/**
+ * Exact-match or field-level F1: the candidate must stay within one point.
+ *
+ * Both measurements are expressed in points on a 0-100 scale before the
+ * comparison, so the same tolerance means the same thing whichever a set is
+ * scored on.
+ *
+ * @param input The measured scores, in points.
+ * @returns The verdict.
+ */
+export declare const compareMatchScore: Comparator;
+/**
+ * Pinned-judge score: the candidate must stay within 3% of the incumbent.
+ *
+ * The comparison assumes the pinning guard has already run; a judged verdict
+ * produced by an unpinned judge would grade one model's output against another
+ * model's standard, which is why the guard refuses rather than warns.
+ *
+ * @param input The measured scores, in points.
+ * @returns The verdict.
+ */
+export declare const compareJudgeScore: Comparator;
+/**
+ * Latency: the candidate's p95 must not exceed the incumbent's.
+ *
+ * Lower is better here, which is why this is the one comparator that cannot
+ * share the "at least as good" helper — inverting a comparison by reusing a
+ * helper with swapped arguments is exactly the kind of quiet sign error a
+ * latency gate would never surface on its own.
+ *
+ * @param input The measured p95 values, in milliseconds.
+ * @returns The verdict.
+ */
+export declare const compareLatencyP95: Comparator;
+/**
+ * Every assertion type mapped to the comparator that decides it.
+ *
+ * A registry rather than a switch, so "is every assertion type implemented" is
+ * a question code can answer — which is what the harness's own coverage check
+ * asks before it will certify anything.
+ */
+export declare const COMPARATORS: Readonly<Record<EvalAssertion, Comparator>>;
+/**
+ * The assertions each eval-gate category requires.
+ *
+ * `none-pinned-judge` requires none by design: the judge alias is the
+ * instrument, not a subject. It is held to the pinning guard instead, which is
+ * a stricter contract than any score comparison — the judge may not change at
+ * all, rather than merely not getting worse.
+ */
+export declare const EVAL_GATE_ASSERTIONS: Readonly<Record<EvalGate, readonly EvalAssertion[]>>;
+//# sourceMappingURL=comparators.d.ts.map