mlform 0.1.7 → 0.1.9

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

@@ -1 +0,0 @@
-export { MLFormError } from './errors';

package/dist/types/src/transport/composition/fanout.d.ts

@@ -1,3 +0,0 @@
-import { FanoutTransportOptions, QuorumFanoutTransportOptions, Transport } from '../types';
-export declare const createFanoutTransport: <TTransportId extends string = string>(options: FanoutTransportOptions<TTransportId>) => Transport;
-export declare const createQuorumFanoutTransport: <TTransportId extends string = string>(options: QuorumFanoutTransportOptions<TTransportId>) => Transport;

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

@@ -1,110 +0,0 @@
-import { TransportError } from './errors';
-import { CapabilityRequirement, MaybePromise, SubmitRequest, Transport, TransportCapabilities, TransportCollection, TransportResponse, TransportSession, TransportSessionEvent, TransportStreamEvent } from './types';
-export type TransportEntry = {
-    id: string | undefined;
-    index: number;
-    label: string;
-    transport: Transport;
-};
-export type StreamFactory = (request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
-type SessionFactory = (request: SubmitRequest) => TransportSession | PromiseLike<TransportSession>;
-export type AsyncQueue<T> = {
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-};
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const isAbortError: (error: unknown) => boolean;
-export declare const createTransport: (submit: Transport["submit"], stream?: StreamFactory, options?: {
-    openSession?: SessionFactory;
-    capabilities?: TransportCapabilities;
-}) => Transport;
-export declare const createAsyncQueue: <T>() => AsyncQueue<T>;
-export declare const resolveStream: (transport: Transport, request: SubmitRequest) => Promise<AsyncIterable<TransportStreamEvent>>;
-export declare const mergeHeaders: (baseHeaders: HeadersInit | undefined, extraHeaders: HeadersInit | undefined) => Headers;
-export declare const resolveRequestCredentials: (optionsCredentials: RequestCredentials | undefined, request: SubmitRequest) => RequestCredentials | undefined;
-export declare const withRequestTransportContext: (request: SubmitRequest, context: NonNullable<SubmitRequest["transport"]>) => SubmitRequest;
-export declare const ensureRequestPolicyContext: (request: SubmitRequest) => SubmitRequest;
-export declare const withCapabilityRequirement: (request: SubmitRequest, requirement: CapabilityRequirement | undefined, transport: Transport, context: string) => SubmitRequest;
-export declare const normalizeRequest: (request: SubmitRequest, transport: Transport, context: string) => SubmitRequest;
-export declare const getTransportScope: (request: SubmitRequest, fallback: string) => string;
-export declare const withRequestPolicyScope: (request: SubmitRequest, scope: string, extras?: {
-    source?: string;
-    backend?: string;
-    requestId?: string;
-}) => SubmitRequest;
-export declare const getErrorMessage: (error: unknown) => string;
-export declare const toTransportError: (error: unknown, defaults?: {
-    source?: string;
-    status?: number;
-    code?: string;
-    retryable?: boolean;
-    response?: unknown;
-    details?: unknown;
-}) => TransportError;
-export declare const assertRetrySafe: (transport: Transport, allowUnsafeRetry?: boolean) => void;
-export declare const assertCacheSafe: (transport: Transport, allowUnsafeCache?: boolean) => void;
-export declare const assertHedgingSafe: (transport: Transport, allowUnsafeHedging?: boolean) => void;
-export declare const defaultDedupKey: (request: SubmitRequest) => string;
-export declare const normalizeTransportResponse: (response: unknown) => TransportResponse;
-export declare const normalizeStreamEvent: (event: unknown) => TransportStreamEvent;
-export declare const resolveTransportEntries: (transports: TransportCollection, factoryName: string) => readonly TransportEntry[];
-export declare const createAggregateFailure: (message: string, failures: readonly {
-    label: string;
-    error: unknown;
-}[]) => TransportError;
-export declare const combineSignals: (signals: (AbortSignal | undefined)[]) => {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-export declare const waitForDelay: (ms: number, signal?: AbortSignal) => Promise<void>;
-export declare const withEventMeta: (event: TransportStreamEvent, meta: Record<string, unknown>) => TransportStreamEvent;
-export declare const toSessionStreamEvent: (event: TransportSessionEvent) => TransportStreamEvent | null;
-export declare const createSubmitBackedStream: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent>;
-export declare const resolveStreamOrSubmit: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
-export declare const resolveGraphqlValue: <TValue>(value: TValue | ((request: SubmitRequest) => MaybePromise<TValue>), request: SubmitRequest) => Promise<TValue>;
-export declare const parseSseBlocks: (stream: ReadableStream<Uint8Array>) => AsyncIterable<{
-    id?: string;
-    event?: string;
-    data: string;
-    retry?: number;
-}>;
-export declare const defaultDecodeSseEvent: (event: {
-    id?: string;
-    event?: string;
-    data: string;
-    retry?: number;
-}) => Promise<TransportStreamEvent>;
-export declare const defaultBody: (request: Parameters<Transport["submit"]>[0]) => {
-    inputs: Record<string, unknown>;
-};
-export declare const defaultParse: (response: Response) => Promise<unknown>;
-export declare const resolveErrorMessage: (status: number, statusText: string, payload: unknown) => string;
-export declare const resolveErrorCode: (payload: unknown) => string | undefined;
-export declare const resolveMethod: (method: string | undefined) => "POST" | "PUT" | "PATCH" | "DELETE";
-export declare const resolveSecret: (value: string | (() => MaybePromise<string>)) => Promise<string>;
-export declare const chooseWeightedTransport: <TTransportId extends string>(request: SubmitRequest, transportIds: readonly TTransportId[], weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>), filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>) => Promise<TTransportId>;
-export declare const toFanoutMeta: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[], failures: readonly {
-    id: string | undefined;
-    index: number;
-    error: unknown;
-}[]) => Record<string, unknown>;
-export declare const toFanoutRaw: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[]) => unknown;
-export declare const mergeFanoutResponses: (results: readonly {
-    id: string | undefined;
-    index: number;
-    response: TransportResponse;
-}[], failures: readonly {
-    id: string | undefined;
-    index: number;
-    error: unknown;
-}[]) => TransportResponse;
-export {};

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

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