mlform 0.1.7 → 0.1.9

package/dist/types/schema/types/form.d.ts

@@ -0,0 +1,13 @@
+import { ExplanationConfig, NormalizedExplanationConfig } from './explanation';
+import { FieldConfig, NormalizedFieldConfig } from './field';
+import { NormalizedReportConfig, ReportConfig } from './report';
+export interface FormSchema {
+    fields: FieldConfig[];
+    reports?: ReportConfig[];
+    explanations?: ExplanationConfig[];
+}
+export interface NormalizedFormSchema {
+    fields: NormalizedFieldConfig[];
+    reports: NormalizedReportConfig[];
+    explanations: NormalizedExplanationConfig[];
+}

package/dist/types/schema/types/report.d.ts

@@ -0,0 +1,43 @@
+import { ZodType } from 'zod';
+import { MaybePromise } from './field';
+import { SubmitResult } from '../../runtime/types/transport';
+export type ReportStatus = "idle" | "loading" | "ready" | "error";
+export type ReportPayloadValidationPolicy = "report-error" | "fail-submit";
+export type PartialReportUpdatePolicy = "trust" | "validate" | "defer";
+export interface BaseReportConfig {
+    id?: string;
+    kind: string;
+    label?: string;
+    description?: string;
+    source?: string;
+    ui?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type ReportConfig = BaseReportConfig;
+export type NormalizedReportConfig<TConfig extends ReportConfig = ReportConfig> = TConfig & {
+    id: string;
+    source: string;
+};
+export interface ReportStateSnapshot {
+    payload: unknown;
+    error: string | null;
+    status: ReportStatus;
+}
+export interface ReportPayloadContext<TConfig extends ReportConfig = ReportConfig> {
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+export interface ReportResolveContext<TConfig extends ReportConfig = ReportConfig> {
+    config: NormalizedReportConfig<TConfig>;
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+export interface ReportDefinition<TConfig extends ReportConfig = ReportConfig> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    payloadSchema?: ZodType<unknown>;
+    payloadValidationPolicy?: ReportPayloadValidationPolicy;
+    partialUpdatePolicy?: PartialReportUpdatePolicy;
+    clonePayload?: (payload: unknown, config: TConfig) => unknown;
+    resolvePayload?: (config: TConfig, context: ReportPayloadContext<TConfig>) => MaybePromise<unknown>;
+}

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

@@ -0,0 +1,3 @@
+export { MLFormError } from './errors';
+export { isRecord } from './object';
+export { slugify } from './strings';

package/dist/types/shared/object.d.ts

@@ -0,0 +1 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/types/shared/strings.d.ts

@@ -0,0 +1 @@
+export declare const slugify: (value: string) => string;

package/dist/types/transport/composition/fanout-helpers.d.ts

@@ -0,0 +1,2 @@
+import { FanoutTransportFailure } from '../types';
+export declare const createFanoutFailure: (failures: readonly FanoutTransportFailure[]) => Error;

package/dist/types/transport/composition/fanout-options.d.ts

@@ -0,0 +1,9 @@
+import { FanoutTransportOptions, SubmitRequest, TransportCapabilities } from '../types';
+export type FanoutTransportEntry<TTransportId extends string> = {
+    id: TTransportId | undefined;
+    index: number;
+    transport: import('../types').Transport;
+};
+export declare const resolveActiveFanoutEntries: <TTransportId extends string>(entries: readonly FanoutTransportEntry<TTransportId>[], options: FanoutTransportOptions<TTransportId>, request: SubmitRequest) => Promise<readonly FanoutTransportEntry<TTransportId>[]>;
+export declare const collectFanoutCapabilities: (entries: readonly FanoutTransportEntry<string>[]) => TransportCapabilities | undefined;
+export declare const createFanoutAbortOthers: (controllers: readonly AbortController[]) => (reason: string, skipIndex: number) => void;

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

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

package/dist/types/{src/transport → transport}/composition/index.d.ts

@@ -1,6 +1,7 @@
 export * from './routing';
 export * from './load-balancing';
 export * from './fanout';
+export * from './quorum-fanout';
 export * from './fallback';
 export * from './pipeline';
 export * from './racing';

package/dist/types/transport/composition/quorum-fanout.d.ts

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

package/dist/types/{src/transport → transport}/errors.d.ts

@@ -1,4 +1,4 @@
-import { MLFormError } from '../../shared';
+import { MLFormError } from '../shared';
 export declare const transportErrorCodes: {
     readonly TIMEOUT: "TIMEOUT";
     readonly AUTH_FAILED: "AUTH_FAILED";

package/dist/types/transport/internal-core.d.ts

@@ -0,0 +1,21 @@
+import { SubmitRequest, Transport, TransportCapabilities, TransportSession, 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 createTransport: (submit: Transport["submit"], stream?: StreamFactory, options?: {
+    openSession?: SessionFactory;
+    capabilities?: TransportCapabilities;
+}) => Transport;
+export declare const createAsyncQueue: <T>() => AsyncQueue<T>;
+export {};

package/dist/types/transport/internal-errors.d.ts

@@ -0,0 +1,21 @@
+import { TransportError } from './errors';
+import { Transport } from './types';
+export declare const isAbortError: (error: unknown) => boolean;
+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 createAggregateFailure: (message: string, failures: readonly {
+    label: string;
+    error: unknown;
+}[]) => TransportError;
+export declare const resolveErrorMessage: (status: number, statusText: string, payload: unknown) => string;
+export declare const resolveErrorCode: (payload: unknown) => string | undefined;

package/dist/types/transport/internal-request.d.ts

@@ -0,0 +1,21 @@
+import { CapabilityRequirement, MaybePromise, SubmitRequest, Transport } from './types';
+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 defaultDedupKey: (request: SubmitRequest) => string;
+export declare const resolveGraphqlValue: <TValue>(value: TValue | ((request: SubmitRequest) => MaybePromise<TValue>), request: SubmitRequest) => Promise<TValue>;
+export declare const defaultBody: (request: Parameters<Transport["submit"]>[0]) => {
+    inputs: Record<string, unknown>;
+};
+export declare const resolveMethod: (method: string | undefined) => "POST" | "PUT" | "PATCH" | "DELETE";
+export declare const resolveSecret: (value: string | (() => MaybePromise<string>)) => Promise<string>;
+export declare const resolveTransportEntries: (transports: import('./types').TransportCollection, factoryName: string) => readonly import('./internal-core').TransportEntry[];

package/dist/types/transport/internal-routing.d.ts

@@ -0,0 +1,25 @@
+import { MaybePromise, SubmitRequest, TransportResponse } from './types';
+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;

package/dist/types/transport/internal-sse.d.ts

@@ -0,0 +1,14 @@
+import { TransportStreamEvent } from './types';
+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 defaultParse: (response: Response) => Promise<unknown>;

package/dist/types/transport/internal-stream.d.ts

@@ -0,0 +1,13 @@
+import { SubmitRequest, Transport, TransportResponse, TransportSessionEvent, TransportStreamEvent } from './types';
+export declare const resolveStream: (transport: Transport, request: SubmitRequest) => Promise<AsyncIterable<TransportStreamEvent>>;
+export declare const normalizeTransportResponse: (response: unknown) => TransportResponse;
+export declare const normalizeStreamEvent: (event: unknown) => TransportStreamEvent;
+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>>;

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

@@ -0,0 +1,6 @@
+export * from './internal-core';
+export * from './internal-request';
+export * from './internal-errors';
+export * from './internal-stream';
+export * from './internal-sse';
+export * from './internal-routing';

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

@@ -0,0 +1,85 @@
+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/transport/types/options-middleware.d.ts

@@ -0,0 +1,96 @@
+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/transport/types/options-routing.d.ts

@@ -0,0 +1,82 @@
+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/transport/types/options.d.ts

@@ -0,0 +1,3 @@
+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/utils-J5o8lkea.js

@@ -0,0 +1,29 @@
+//#region src/shared/object.ts
+var e = (e) => typeof e == "object" && !!e && !Array.isArray(e), t = (e) => typeof e == "object" && !!e || typeof e == "function", n = (e) => t(e) && "then" in e && typeof e.then == "function", r = (e) => e == null ? !0 : typeof e == "string" ? e.trim() === "" : Array.isArray(e) ? e.length === 0 : e instanceof Date ? Number.isNaN(e.getTime()) : !1, i = (e) => {
+	if (e instanceof Date) return Number.isNaN(e.getTime()) ? null : e;
+	if (typeof e == "string" || typeof e == "number") {
+		let t = new Date(e);
+		return Number.isNaN(t.getTime()) ? null : t;
+	}
+	return null;
+}, a = (e) => e, o = (e) => {
+	let t = typeof ArrayBuffer < "u" && ArrayBuffer.isView(e), n = typeof ArrayBuffer < "u" && e instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && e instanceof SharedArrayBuffer, r = typeof Blob < "u" && e instanceof Blob || typeof File < "u" && e instanceof File;
+	if (e !== null && (typeof e == "object" || typeof e == "function") && !t && !n && !r && !Object.isFrozen(e)) {
+		Object.freeze(e);
+		for (let t of Object.values(e)) o(t);
+	}
+	return e;
+}, s = (e, t) => e <= 0 ? Promise.resolve() : new Promise((n, r) => {
+	let i = setTimeout(() => {
+		t?.removeEventListener("abort", a), n();
+	}, e), a = () => {
+		clearTimeout(i), r(t?.reason ?? /* @__PURE__ */ Error("Operation aborted."));
+	};
+	if (t?.aborted) {
+		a();
+		return;
+	}
+	t?.addEventListener("abort", a, { once: !0 });
+});
+//#endregion
+export { n as a, r as i, s as n, i as o, a as r, e as s, o as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlform",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "private": false,
   "description": "Composable form generation utilities for machine learning backend integration",
   "keywords": [
@@ -60,9 +60,25 @@
       "types": "./dist/types/src/kit/index.d.ts",
       "import": "./dist/mlform/kit.mjs"
     },
-    "./engine": {
-      "types": "./dist/types/src/engine/index.d.ts",
-      "import": "./dist/mlform/engine.mjs"
+    "./runtime": {
+      "types": "./dist/types/src/runtime/index.d.ts",
+      "import": "./dist/mlform/runtime.mjs"
+    },
+    "./schema": {
+      "types": "./dist/types/src/schema/index.d.ts",
+      "import": "./dist/mlform/schema.mjs"
+    },
+    "./presentation": {
+      "types": "./dist/types/src/presentation/index.d.ts",
+      "import": "./dist/mlform/presentation.mjs"
+    },
+    "./builtins-ml": {
+      "types": "./dist/types/src/builtins-ml/index.d.ts",
+      "import": "./dist/mlform/builtins-ml.mjs"
+    },
+    "./behaviors": {
+      "types": "./dist/types/src/behaviors/index.d.ts",
+      "import": "./dist/mlform/behaviors.mjs"
     },
     "./transport": {
       "types": "./dist/types/src/transport/index.d.ts",
@@ -75,10 +91,6 @@
     "./design-system": {
       "types": "./dist/types/src/design-system/index.d.ts",
       "import": "./dist/mlform/design-system.mjs"
-    },
-    "./questionnaire": {
-      "types": "./dist/types/src/questionnaire/index.d.ts",
-      "import": "./dist/mlform/questionnaire.mjs"
     }
   },
   "publishConfig": {
@@ -86,15 +98,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "lit": "3.3.2",
-    "zod": "4.3.6"
+    "lit": "3.3.3",
+    "zod": "4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
-    "jsdom": "^29.0.2",
-    "typescript": "~6.0.2",
+    "@types/node": "^25.8.0",
+    "jsdom": "^29.1.1",
+    "typescript": "~6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@latest",
-    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-dts": "^5.0.0",
     "vite-plus": "latest",
     "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
   },