mlform 0.1.2 → 0.1.4

package/dist/types/src/transport/middleware/retry.d.ts

@@ -0,0 +1,2 @@
+import { RetryOptions, TransportMiddleware } from '../types';
+export declare const withRetry: (options: RetryOptions) => TransportMiddleware;

package/dist/types/src/transport/middleware/timeout.d.ts

@@ -0,0 +1,2 @@
+import { TransportMiddleware } from '../types';
+export declare const withTimeout: (ms: number) => TransportMiddleware;

package/dist/types/src/transport/middleware/tracing.d.ts

@@ -0,0 +1,2 @@
+import { TransportMiddleware, TransportTraceOptions } from '../types';
+export declare const withTracing: (options: TransportTraceOptions) => TransportMiddleware;

package/dist/types/src/transport/middleware/transform.d.ts

@@ -0,0 +1,3 @@
+import { MaybePromise, SubmitRequest, TransportMiddleware } from '../types';
+export declare const withRequestTransform: (transform: (request: SubmitRequest) => MaybePromise<SubmitRequest>) => TransportMiddleware;
+export declare const withResponseTransform: (transform: (response: unknown, request: SubmitRequest) => MaybePromise<unknown>) => TransportMiddleware;

package/dist/types/src/transport/policy-context.d.ts

@@ -0,0 +1,3 @@
+import { SubmitRequest, TransportPolicyContext } from './types';
+export declare const getTransportPolicyContext: (request: SubmitRequest) => TransportPolicyContext;
+export declare const withTransportPolicyContext: (request: SubmitRequest, policy: Partial<TransportPolicyContext>) => SubmitRequest;

package/dist/types/src/transport/protocols/graphql.d.ts

@@ -0,0 +1,2 @@
+import { GraphqlTransportOptions, Transport } from '../types';
+export declare const createGraphqlTransport: (options: GraphqlTransportOptions) => Transport;

package/dist/types/src/transport/protocols/grpc.d.ts

@@ -0,0 +1,5 @@
+import { GrpcSessionTransportOptions, GrpcStreamTransportOptions, GrpcTransportOptions, GrpcUnaryTransportOptions, Transport } from '../types';
+export declare const createGrpcUnaryTransport: (options: GrpcUnaryTransportOptions) => Transport;
+export declare const createGrpcStreamTransport: (options: GrpcStreamTransportOptions) => Transport;
+export declare const createGrpcSessionTransport: (options: GrpcSessionTransportOptions) => Transport;
+export declare const createGrpcTransport: (options: GrpcTransportOptions) => Transport;

package/dist/types/src/transport/protocols/index.d.ts

@@ -0,0 +1,5 @@
+export * from './json';
+export * from './graphql';
+export * from './sse';
+export * from './websocket';
+export * from './grpc';

package/dist/types/src/transport/protocols/json.d.ts

@@ -0,0 +1,2 @@
+import { JsonTransportOptions, Transport } from '../types';
+export declare const createJsonTransport: (options: JsonTransportOptions) => Transport;

package/dist/types/src/transport/protocols/sse.d.ts

@@ -0,0 +1,2 @@
+import { SseTransportOptions, Transport } from '../types';
+export declare const createSseTransport: (options: SseTransportOptions) => Transport;

package/dist/types/src/transport/protocols/websocket.d.ts

@@ -0,0 +1,2 @@
+import { WebSocketSessionTransportOptions } from '../types';
+export declare const createWebSocketSessionTransport: (options: WebSocketSessionTransportOptions) => import('..').Transport<Record<string, unknown>, Record<string, unknown>>;

package/dist/types/src/transport/runtime.d.ts

@@ -0,0 +1,4 @@
+export * from './protocols';
+export * from './middleware';
+export * from './composition';
+export * from './state';

package/dist/types/src/transport/state/cache-store.d.ts

@@ -0,0 +1,2 @@
+import { TransportCacheStore } from '../types';
+export declare const createMemoryTransportCacheStore: () => TransportCacheStore;

package/dist/types/src/transport/state/circuit-breaker.d.ts

@@ -0,0 +1,2 @@
+import { CircuitBreakerSharedState } from '../types';
+export declare const createMemoryCircuitBreakerState: () => CircuitBreakerSharedState;

package/dist/types/src/transport/state/health.d.ts

@@ -0,0 +1,2 @@
+import { TransportHealthState } from '../types';
+export declare const createMemoryTransportHealthState: <TTransportId extends string = string>() => TransportHealthState<TTransportId>;

package/dist/types/src/transport/state/index.d.ts

@@ -0,0 +1,5 @@
+export * from './session';
+export * from './cache-store';
+export * from './circuit-breaker';
+export * from './rate-limiter';
+export * from './health';

package/dist/types/src/transport/state/rate-limiter.d.ts

@@ -0,0 +1,2 @@
+import { SharedRateLimiter } from '../types';
+export declare const createMemorySharedRateLimiter: () => SharedRateLimiter;

package/dist/types/src/transport/state/session.d.ts

@@ -0,0 +1,2 @@
+import { SessionTransportOptions, Transport } from '../types';
+export declare const createSessionTransport: (options: SessionTransportOptions) => Transport;

package/dist/types/src/transport/types/capabilities.d.ts

@@ -0,0 +1,35 @@
+export type TransportAuthKind = "none" | "api-key" | "bearer" | "basic" | "oauth2" | "mtls" | "transport-context" | "custom";
+export type TransportConsistency = "unknown" | "at-most-once" | "at-least-once" | "best-effort";
+export type TransportDeliveryMode = "request-response" | "stream" | "session";
+export type TransportBackpressureMode = "none" | "consumer-pull" | "bounded-buffer";
+export interface TransportCapabilities {
+    modes: {
+        submit: boolean;
+        stream: boolean;
+        session: boolean;
+    };
+    safety: {
+        idempotent: boolean;
+        retrySafe: boolean;
+        cacheable: boolean;
+        hedgeSafe: boolean;
+    };
+    limits: {
+        maxPayloadBytes?: number;
+        maxBufferedMessages?: number;
+    };
+    auth: {
+        kinds: readonly TransportAuthKind[];
+    };
+    delivery: {
+        mode: TransportDeliveryMode;
+        consistency: TransportConsistency;
+        backpressure: TransportBackpressureMode;
+    };
+}
+export interface CapabilityRequirement {
+    modes?: Partial<TransportCapabilities["modes"]>;
+    safety?: Partial<TransportCapabilities["safety"]>;
+    authKinds?: readonly TransportAuthKind[];
+    maxPayloadBytes?: number;
+}

package/dist/types/src/transport/types/core.d.ts

@@ -0,0 +1,57 @@
+import { TransportCapabilities } from './capabilities';
+import { TransportStreamEvent } from './events';
+import { TransportSession } from './session';
+export type MaybePromise<T> = T | PromiseLike<T>;
+export interface TransportPolicyContext {
+    scope: string;
+    source?: string;
+    backend?: string;
+    requestId?: string;
+}
+export interface SubmitRequestTransportContext {
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    attributes?: Record<string, unknown>;
+    policy?: TransportPolicyContext;
+}
+export interface SubmitRequestMetadata {
+    estimatedPayloadBytes?: number;
+}
+export interface SubmitRequest<TField extends Record<string, unknown> = Record<string, unknown>, TReport extends Record<string, unknown> = Record<string, unknown>> {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    fields: readonly TField[];
+    reports: readonly TReport[];
+    transport?: SubmitRequestTransportContext;
+    metadata?: SubmitRequestMetadata;
+    signal?: AbortSignal;
+}
+export interface TransportResponse {
+    reports?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+    raw?: unknown;
+}
+export interface SubmitResult<TReportState extends Record<string, unknown> = Record<string, unknown>> {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    reports: Record<string, unknown>;
+    reportStates: Record<string, TReportState>;
+    meta: Record<string, unknown>;
+    raw: unknown;
+}
+export interface Transport<TField extends Record<string, unknown> = Record<string, unknown>, TReport extends Record<string, unknown> = Record<string, unknown>> {
+    submit: (request: SubmitRequest<TField, TReport>) => Promise<unknown>;
+    stream?: (request: SubmitRequest<TField, TReport>) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
+    openSession?: (request: SubmitRequest<TField, TReport>) => MaybePromise<TransportSession>;
+    capabilities?: TransportCapabilities;
+}
+export interface SubmitOptions {
+    signal?: AbortSignal;
+    backend?: string;
+}

package/dist/types/src/transport/types/events.d.ts

@@ -0,0 +1,50 @@
+export interface TransportStreamProgressEvent {
+    type: "progress";
+    loaded?: number;
+    total?: number;
+    message?: string;
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamMetaEvent {
+    type: "meta";
+    meta: Record<string, unknown>;
+}
+export interface TransportStreamChunkEvent {
+    type: "chunk";
+    chunk: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamReportReplaceEvent {
+    type: "report-replace";
+    reportId: string;
+    payload: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamReportPatchEvent {
+    type: "report-patch";
+    reportId: string;
+    patch: unknown;
+    strategy?: "replace" | "shallow-merge" | "deep-merge";
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamFieldUpdateEvent {
+    type: "field-update";
+    fieldId: string;
+    value?: unknown;
+    errors?: string[];
+    touched?: boolean;
+    dirty?: boolean;
+    status?: string;
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamResultEvent {
+    type: "result";
+    result: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportStreamErrorEvent {
+    type: "error";
+    error: unknown;
+    meta?: Record<string, unknown>;
+}
+export type TransportStreamEvent = TransportStreamProgressEvent | TransportStreamMetaEvent | TransportStreamChunkEvent | TransportStreamReportReplaceEvent | TransportStreamReportPatchEvent | TransportStreamFieldUpdateEvent | TransportStreamResultEvent | TransportStreamErrorEvent;

package/dist/types/src/transport/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core';
+export * from './capabilities';
+export * from './events';
+export * from './session';
+export * from './options';
+export * from './middleware';
+export * from './state';

package/dist/types/src/transport/types/middleware.d.ts

@@ -0,0 +1,3 @@
+import { Transport } from './core';
+export type TransportMiddleware = (transport: Transport) => Transport;
+export type TransportCollection<TTransportId extends string = string> = Record<TTransportId, Transport> | readonly Transport[];

package/dist/types/src/transport/types/options.d.ts

@@ -0,0 +1,258 @@
+import { TransportCapabilities, CapabilityRequirement } from './capabilities';
+import { MaybePromise, SubmitRequest, Transport, TransportPolicyContext, TransportResponse } from './core';
+import { TransportStreamEvent } from './events';
+import { TransportSession, TransportSessionMessage } from './session';
+import { CircuitBreakerSharedState, SharedRateLimiter, TransportCacheStore, TransportHealthState } from './state';
+import { TransportCollection } from './middleware';
+export type JsonTransportMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+export interface JsonTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    method?: JsonTransportMethod;
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    body?: (request: SubmitRequest) => BodyInit | null | undefined;
+    parse?: (response: Response) => Promise<unknown>;
+    stream?: (response: Response, request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+}
+export interface GraphqlTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    query: string | ((request: SubmitRequest) => MaybePromise<string>);
+    operationName?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    variables?: (request: SubmitRequest) => MaybePromise<Record<string, unknown>>;
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    parse?: (response: Response) => Promise<unknown>;
+    resultPath?: "data" | `data.${string}`;
+    resolveResult?: (payload: unknown, request: SubmitRequest) => MaybePromise<unknown>;
+}
+export interface SseTransportOptions {
+    endpoint: string | URL;
+    source?: string;
+    fetch?: typeof globalThis.fetch;
+    method?: "POST" | "PUT" | "PATCH";
+    headers?: HeadersInit | (() => MaybePromise<HeadersInit>);
+    credentials?: RequestCredentials;
+    body?: (request: SubmitRequest) => BodyInit | null | undefined;
+    decodeEvent?: (event: {
+        id?: string;
+        event?: string;
+        data: string;
+        retry?: number;
+    }, request: SubmitRequest) => MaybePromise<TransportStreamEvent>;
+    resultEvent?: string | ((event: {
+        id?: string;
+        event?: string;
+        data: string;
+        retry?: number;
+    }) => boolean);
+    maxPayloadBytes?: number;
+}
+export interface WebSocketSessionTransportOptions {
+    url: string | URL | ((request: SubmitRequest) => MaybePromise<string | URL>);
+    source?: string;
+    WebSocket?: typeof globalThis.WebSocket;
+    protocols?: string | string[] | ((request: SubmitRequest) => MaybePromise<string | string[]>);
+    serializeMessage?: (message: unknown) => string | ArrayBuffer | Blob | Uint8Array;
+    deserializeMessage?: (data: string | ArrayBuffer | Blob) => MaybePromise<unknown>;
+    sessionInit?: TransportSessionMessage | ((request: SubmitRequest) => MaybePromise<TransportSessionMessage | undefined>);
+    closeTimeoutMs?: number;
+    maxBufferedMessages?: number;
+    bufferOverflow?: "close" | "drop-oldest" | "drop-newest" | "error";
+}
+export interface GrpcUnaryTransportOptions {
+    source?: string;
+    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcStreamTransportOptions {
+    source?: string;
+    stream: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcSessionTransportOptions {
+    source?: string;
+    session: (request: SubmitRequest) => MaybePromise<TransportSession>;
+    capabilities?: TransportCapabilities;
+}
+export interface GrpcTransportOptions {
+    source?: string;
+    unary?: (request: SubmitRequest) => MaybePromise<unknown>;
+    stream?: (request: SubmitRequest) => MaybePromise<AsyncIterable<TransportStreamEvent>>;
+    session?: (request: SubmitRequest) => MaybePromise<TransportSession>;
+    capabilities?: TransportCapabilities;
+}
+export interface SessionTransportOptions {
+    submit?: Transport["submit"];
+    stream?: Transport["stream"];
+    openSession: NonNullable<Transport["openSession"]>;
+    capabilities?: TransportCapabilities;
+}
+export interface RoutingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    selectTransport: (request: SubmitRequest, context: {
+        transportIds: readonly TTransportId[];
+    }) => MaybePromise<TTransportId>;
+}
+export interface WeightedRoutingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
+    filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>;
+}
+export interface FanoutTransportResult<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    response: TransportResponse;
+}
+export interface FanoutTransportFailure<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    error: unknown;
+}
+export interface FanoutTransportOptions<TTransportId extends string = string> {
+    transports: TransportCollection<TTransportId>;
+    requiredCapabilities?: CapabilityRequirement;
+    filter?: (transportId: string, request: SubmitRequest) => MaybePromise<boolean>;
+    transformRequest?: (transportId: string, request: SubmitRequest) => MaybePromise<SubmitRequest>;
+    failurePolicy?: "fail-all" | "partial-success";
+    abortPolicy?: "wait-all" | "abort-pending-on-first-failure" | "abort-pending-on-first-success";
+    merge?: (context: {
+        request: SubmitRequest;
+        results: readonly FanoutTransportResult<TTransportId>[];
+        failures: readonly FanoutTransportFailure<TTransportId>[];
+    }) => MaybePromise<unknown>;
+}
+export interface FallbackTransportFailure<TTransportId extends string = string> {
+    id: TTransportId | undefined;
+    index: number;
+    error: unknown;
+}
+export interface FallbackTransportOptions<TTransportId extends string = string> {
+    transports: TransportCollection<TTransportId>;
+    shouldFallback?: (error: unknown, context: {
+        request: SubmitRequest;
+        id: TTransportId | undefined;
+        index: number;
+        failures: readonly FallbackTransportFailure<TTransportId>[];
+    }) => MaybePromise<boolean>;
+}
+export interface PipelineStage {
+    id?: string;
+    transport: Transport;
+    mapToNext?: (response: unknown, originalRequest: SubmitRequest) => MaybePromise<SubmitRequest>;
+    nextStageRequirements?: CapabilityRequirement;
+}
+export interface PipelineTransportOptions {
+    stages: readonly PipelineStage[];
+}
+export interface RacingTransportOptions {
+    transports: TransportCollection;
+}
+export interface HedgedTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    hedgeDelayMs: number;
+    maxAttempts?: number;
+    allowUnsafeHedging?: boolean;
+}
+export interface QuorumFanoutTransportOptions<TTransportId extends string = string> extends FanoutTransportOptions<TTransportId> {
+    quorum: number;
+}
+export interface LoadBalancingTransportOptions<TTransportId extends string = string> {
+    transports: Record<TTransportId, Transport>;
+    requiredCapabilities?: CapabilityRequirement;
+    strategy?: "round-robin" | "least-loaded" | "random" | "weighted" | "health-weighted";
+    weights?: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>);
+    healthState?: TransportHealthState<TTransportId>;
+}
+export interface RetryOptions {
+    attempts: number;
+    backoff?: "exponential" | "linear" | number[] | ((attempt: number) => number);
+    baseDelay?: number;
+    maxDelay?: number;
+    jitter?: boolean;
+    allowUnsafeRetry?: boolean;
+    retryOn?: (error: unknown, attempt: number) => boolean;
+}
+export interface ApiKeyAuthOptions {
+    type: "api-key";
+    key: string | (() => MaybePromise<string>);
+    header?: string;
+    prefix?: string;
+}
+export interface BearerAuthOptions {
+    type: "bearer";
+    token: string | (() => MaybePromise<string>);
+    header?: string;
+    prefix?: string;
+}
+export interface CustomAuthOptions {
+    type: "custom";
+    apply: (request: SubmitRequest) => MaybePromise<SubmitRequest>;
+}
+export interface TransportContextAuthOptions {
+    type: "transport-context";
+    context: NonNullable<SubmitRequest["transport"]> | (() => MaybePromise<NonNullable<SubmitRequest["transport"]>>);
+}
+export type AuthOptions = ApiKeyAuthOptions | BearerAuthOptions | CustomAuthOptions | TransportContextAuthOptions;
+export interface CircuitBreakerOptions {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxRequests?: number;
+    key?: string;
+    scope?: string;
+    sharedState?: CircuitBreakerSharedState;
+    tripOn?: (error: unknown) => boolean;
+    onStateChange?: (state: "closed" | "open" | "half-open") => void;
+}
+export interface RateLimitOptions {
+    maxConcurrent?: number;
+    perSecond?: number;
+    queueLimit?: number;
+    key?: string;
+    scope?: string;
+    limiter?: SharedRateLimiter;
+}
+export interface DedupOptions {
+    key?: (request: SubmitRequest) => string;
+}
+export interface CacheOptions {
+    key: (request: SubmitRequest) => string;
+    ttl: number;
+    maxEntries?: number;
+    scope?: string;
+    store?: TransportCacheStore;
+    allowUnsafeCache?: boolean;
+    shouldCache?: (response: unknown, request: SubmitRequest) => boolean;
+}
+export interface TransportTraceOptions {
+    traceparent?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    baggage?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    attributes?: (request: SubmitRequest) => MaybePromise<Record<string, unknown> | undefined>;
+    preserveExistingHeaders?: boolean;
+    requestId?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+    scope?: string | ((request: SubmitRequest) => MaybePromise<string | undefined>);
+}
+export interface TransportTelemetryEvent {
+    kind: "request-start" | "request-success" | "request-error" | "stream-event" | "session-open" | "session-close" | "capability-reject" | "policy-block";
+    source?: string;
+    scope?: string;
+    durationMs?: number;
+    error?: unknown;
+    request: SubmitRequest;
+    meta?: Record<string, unknown>;
+}
+export interface TransportMetricsOptions {
+    emit(event: TransportTelemetryEvent): void;
+}
+export interface TransportLogOptions {
+    onRequest?: (request: SubmitRequest) => void;
+    onResponse?: (response: unknown, request: SubmitRequest, durationMs: number) => void;
+    onError?: (error: unknown, request: SubmitRequest, durationMs: number) => void;
+    onStreamEvent?: (event: TransportStreamEvent, request: SubmitRequest) => void;
+}
+export type TransportContextPolicy = TransportPolicyContext;

package/dist/types/src/transport/types/session.d.ts

@@ -0,0 +1,48 @@
+import { TransportBackpressureMode } from './capabilities';
+import { MaybePromise } from './core';
+export interface TransportSessionMessage {
+    type: string;
+    data?: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportSessionProgressEvent {
+    type: "progress";
+    loaded?: number;
+    total?: number;
+    message?: string;
+    meta?: Record<string, unknown>;
+}
+export interface TransportSessionMetaEvent {
+    type: "meta";
+    meta: Record<string, unknown>;
+}
+export interface TransportSessionMessageEvent {
+    type: "message";
+    message: TransportSessionMessage;
+    meta?: Record<string, unknown>;
+}
+export interface TransportSessionResultEvent {
+    type: "result";
+    result: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportSessionErrorEvent {
+    type: "error";
+    error: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface TransportSessionCloseEvent {
+    type: "close";
+    reason?: string;
+    meta?: Record<string, unknown>;
+}
+export type TransportSessionEvent = TransportSessionProgressEvent | TransportSessionMetaEvent | TransportSessionMessageEvent | TransportSessionResultEvent | TransportSessionErrorEvent | TransportSessionCloseEvent;
+export interface TransportSession {
+    send: (message: TransportSessionMessage) => MaybePromise<void>;
+    receive: () => AsyncIterable<TransportSessionEvent> | PromiseLike<AsyncIterable<TransportSessionEvent>>;
+    close: (reason?: string) => MaybePromise<void>;
+    capabilities?: {
+        bufferedMessages?: number;
+        backpressure: TransportBackpressureMode;
+    };
+}

package/dist/types/src/transport/types/state.d.ts

@@ -0,0 +1,46 @@
+import { MaybePromise, SubmitRequest } from './core';
+export interface TransportCacheEntry {
+    expiresAt: number;
+    response: unknown;
+}
+export interface TransportCacheStore {
+    get(scope: string, key: string): MaybePromise<TransportCacheEntry | undefined>;
+    set(scope: string, key: string, entry: TransportCacheEntry): MaybePromise<void>;
+    delete(scope: string, key: string): MaybePromise<void>;
+    evictExpired?(scope: string, now: number): MaybePromise<void>;
+    keys?(scope: string): MaybePromise<readonly string[]>;
+}
+export interface CircuitBreakerStateSnapshot {
+    state: "closed" | "open" | "half-open";
+    failureCount: number;
+    openUntil: number;
+    halfOpenActive: number;
+}
+export interface CircuitBreakerSharedState {
+    get(scope: string): MaybePromise<CircuitBreakerStateSnapshot | undefined>;
+    compareAndSet?(scope: string, expected: CircuitBreakerStateSnapshot | undefined, next: CircuitBreakerStateSnapshot): MaybePromise<boolean>;
+    set(scope: string, snapshot: CircuitBreakerStateSnapshot): MaybePromise<void>;
+}
+export interface SharedRateLimiterLease {
+    release: () => MaybePromise<void>;
+}
+export interface RateLimitLeaseRequest {
+    request: SubmitRequest;
+    maxConcurrent?: number;
+    perSecond?: number;
+    queueLimit?: number;
+}
+export interface SharedRateLimiter {
+    acquire: (scope: string, lease: RateLimitLeaseRequest) => MaybePromise<SharedRateLimiterLease>;
+}
+export interface TransportHealthSnapshot {
+    consecutiveFailures: number;
+    lastFailureAt?: number;
+    lastSuccessAt?: number;
+    averageLatencyMs?: number;
+}
+export interface TransportHealthState<TTransportId extends string = string> {
+    getSnapshot: (scope: string, transportId: TTransportId) => MaybePromise<TransportHealthSnapshot | undefined>;
+    recordSuccess: (scope: string, transportId: TTransportId, durationMs: number) => MaybePromise<void>;
+    recordFailure: (scope: string, transportId: TTransportId, error: unknown) => MaybePromise<void>;
+}