mlform 0.1.19 → 0.1.22

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

@@ -1,85 +0,0 @@
-import { TransportCapabilities } from './capabilities';
-import { MaybePromise, SubmitRequest } from './core';
-import { TransportStreamEvent } from './events';
-import { TransportSession, TransportSessionMessage } from './session';
-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;
-}

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

@@ -1,96 +0,0 @@
-import { MaybePromise, SubmitRequest, Transport, TransportPolicyContext } from './core';
-import { TransportStreamEvent } from './events';
-import { CircuitBreakerSharedState, SharedRateLimiter, TransportCacheStore } from './state';
-export interface SessionTransportOptions {
-    submit?: Transport["submit"];
-    stream?: Transport["stream"];
-    openSession: NonNullable<Transport["openSession"]>;
-    capabilities?: import('./capabilities').TransportCapabilities;
-}
-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/options-routing.d.ts

@@ -1,82 +0,0 @@
-import { CapabilityRequirement } from './capabilities';
-import { MaybePromise, SubmitRequest, Transport, TransportResponse } from './core';
-import { TransportCollection } from './middleware';
-import { TransportHealthState } from './state';
-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>;
-}

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

@@ -1,3 +0,0 @@
-export type { JsonTransportMethod, JsonTransportOptions, GraphqlTransportOptions, SseTransportOptions, WebSocketSessionTransportOptions, GrpcUnaryTransportOptions, GrpcStreamTransportOptions, GrpcSessionTransportOptions, GrpcTransportOptions, } from './options-http';
-export type { RoutingTransportOptions, WeightedRoutingTransportOptions, FanoutTransportResult, FanoutTransportFailure, FanoutTransportOptions, FallbackTransportFailure, FallbackTransportOptions, PipelineStage, PipelineTransportOptions, RacingTransportOptions, HedgedTransportOptions, QuorumFanoutTransportOptions, LoadBalancingTransportOptions, } from './options-routing';
-export type { SessionTransportOptions, RetryOptions, ApiKeyAuthOptions, BearerAuthOptions, CustomAuthOptions, TransportContextAuthOptions, AuthOptions, CircuitBreakerOptions, RateLimitOptions, DedupOptions, CacheOptions, TransportTraceOptions, TransportTelemetryEvent, TransportMetricsOptions, TransportLogOptions, TransportContextPolicy, } from './options-middleware';

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

@@ -1,48 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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>;
-}