mlform 0.1.2 → 0.1.4

package/dist/types/src/primitives/types.d.ts

@@ -0,0 +1,128 @@
+import { ExplanationController, ExplanationDescriptor, ExplanationFetchRequest, ExplanationFetchTransport, FieldController, FieldDescriptor, FormController, FormState, FormStatus, ReportController, ReportDescriptor, SubmitResult } from '../../engine';
+import { PrimitiveText, PrimitiveTextOverrides } from './constants';
+export type PrimitiveLayout = "stacked" | "split";
+export type PrimitiveContainerStrategy = "error" | "replace";
+export interface PrimitiveRegistry {
+    registerField(component: string, tagName: string): PrimitiveRegistry;
+    unregisterField(component: string): PrimitiveRegistry;
+    resolveField(component: string): string | undefined;
+    registerReport(component: string, tagName: string): PrimitiveRegistry;
+    unregisterReport(component: string): PrimitiveRegistry;
+    resolveReport(component: string): string | undefined;
+    registerExplanation(component: string, tagName: string): PrimitiveRegistry;
+    unregisterExplanation(component: string): PrimitiveRegistry;
+    resolveExplanation(component: string): string | undefined;
+    clone(): PrimitiveRegistry;
+}
+/**
+ * Request passed to a PrimitiveReportTransport when a report becomes ready.
+ * Contains the full submit result so a report renderer can fetch any
+ * post-submit data it needs, plus the `reportId` identifying that report.
+ */
+export interface PrimitiveReportRequest {
+    reportId: string;
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    reports: Record<string, unknown>;
+    meta: Record<string, unknown>;
+    raw: unknown;
+    signal?: AbortSignal;
+}
+/**
+ * Transport for fetching post-submit report content.
+ * Receives the full submit result + report context; may return any value.
+ * Renderers decide how to display loading, success, and error states.
+ */
+export interface PrimitiveReportTransport {
+    submit: (request: PrimitiveReportRequest) => Promise<unknown>;
+}
+/**
+ * Re-exports of engine explanation types for convenience in the primitives
+ * layer. Explanation transport is now per-plugin (defined in ExplanationDefinition)
+ * rather than a global mount-time option.
+ */
+export type ExplanationRequest = ExplanationFetchRequest;
+export type ExplanationTransport = ExplanationFetchTransport;
+export interface MountFormOptions {
+    registry?: PrimitiveRegistry;
+    layout?: PrimitiveLayout;
+    containerStrategy?: PrimitiveContainerStrategy;
+    formLabel?: string;
+    reportsLabel?: string;
+    submitLabel?: string;
+    validatingLabel?: string;
+    submittingLabel?: string;
+    reportPane?: "auto" | "always" | "hidden";
+    text?: PrimitiveTextOverrides;
+    /** Optional transport for report renderers that fetch extra data after submit. */
+    reportTransport?: PrimitiveReportTransport;
+}
+export interface MountedForm {
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly registry: PrimitiveRegistry;
+    readonly text: PrimitiveText;
+    unmount(): void;
+}
+export interface PrimitiveFieldRenderContext {
+    controlId: string;
+    label: string;
+    description?: string;
+    errors: readonly string[];
+    descriptionId?: string;
+    errorId?: string;
+    describedBy?: string;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+}
+export interface PrimitiveReportRenderContext {
+    regionId: string;
+    label: string;
+    description?: string;
+}
+export interface PrimitiveExplanationRenderContext {
+    regionId: string;
+    label?: string;
+    description?: string;
+}
+export interface PrimitiveFieldRendererElement extends HTMLElement {
+    controller?: FieldController;
+    descriptor?: FieldDescriptor | null;
+    context?: PrimitiveFieldRenderContext;
+    text?: PrimitiveText;
+}
+export interface PrimitiveReportRendererElement extends HTMLElement {
+    controller?: ReportController;
+    descriptor?: ReportDescriptor | null;
+    context?: PrimitiveReportRenderContext;
+    text?: PrimitiveText;
+    transport?: PrimitiveReportTransport;
+    request?: PrimitiveReportRequest | null;
+}
+export interface PrimitiveExplanationRendererElement extends HTMLElement {
+    controller?: ExplanationController;
+    descriptor?: ExplanationDescriptor | null;
+    context?: PrimitiveExplanationRenderContext;
+    text?: PrimitiveText;
+}
+export interface PrimitiveSubmitStartDetail {
+    form: FormController;
+    state: FormState;
+}
+export interface PrimitiveSubmitSuccessDetail {
+    form: FormController;
+    state: FormState;
+    result: SubmitResult;
+}
+export interface PrimitiveSubmitErrorDetail {
+    form: FormController;
+    state: FormState;
+    error: unknown;
+    status: FormStatus;
+}
+export type { PrimitiveText, PrimitiveTextOverrides } from './constants';

package/dist/types/src/primitives/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const joinMessages: (messages: readonly string[]) => string;
+export declare const toText: (value: unknown, fallback?: string) => string;

package/dist/types/src/questionnaire/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const questionnaireTagNames: {
+    readonly questionnaire: "mlf-questionnaire";
+    readonly stepIndicator: "mlf-step-indicator";
+};
+export declare const questionnaireEventNames: {
+    readonly stepChange: "mlf-step-change";
+    readonly stepValidationError: "mlf-step-validation-error";
+    readonly submitStart: "mlf-q-submit-start";
+    readonly submitAbort: "mlf-q-submit-abort";
+    readonly submitSuccess: "mlf-q-submit-success";
+    readonly submitError: "mlf-q-submit-error";
+};
+export interface QuestionnaireLabels {
+    prev?: string;
+    next?: string;
+    submit?: string;
+    validating?: string;
+    submitting?: string;
+}
+export interface QuestionnaireText {
+    stepLabel: (current: number, total: number) => string;
+    prevLabel: string;
+    nextLabel: string;
+    submitLabel: string;
+    validatingLabel: string;
+    submittingLabel: string;
+}
+export type QuestionnaireTextOverrides = Partial<QuestionnaireText>;
+export declare const questionnaireDefaultLabels: Required<QuestionnaireLabels>;
+export declare const questionnaireStaticText: QuestionnaireText;
+export declare const resolveQuestionnaireText: (overrides?: QuestionnaireTextOverrides) => QuestionnaireText;

package/dist/types/src/questionnaire/defaults.d.ts

@@ -0,0 +1,8 @@
+import { DesignSystemConfig, DesignSystemRegistry } from '../../design-system';
+import { Registry } from '../../engine';
+import { PrimitiveRegistry } from '../../primitives';
+export declare const defaultQuestionnaireDesignSystem: DesignSystemConfig;
+export declare const cloneQuestionnaireEngineRegistry: (registry?: Registry) => Registry;
+export declare const resolveQuestionnairePrimitiveRegistry: (registry?: PrimitiveRegistry) => PrimitiveRegistry;
+export declare const resolveQuestionnaireDesignSystemRegistry: (registry?: DesignSystemRegistry) => DesignSystemRegistry;
+export declare const resolveQuestionnaireDesignSystem: (config?: DesignSystemConfig) => DesignSystemConfig;

package/dist/types/src/questionnaire/engine/controller.d.ts

@@ -0,0 +1,12 @@
+import { FormController } from '../../../engine';
+import { IQuestionnaireController, NormalizedStepConfig, QuestionnaireState } from '../types';
+export declare class QuestionnaireController implements IQuestionnaireController {
+    #private;
+    constructor(form: FormController, steps: readonly NormalizedStepConfig[]);
+    get steps(): readonly NormalizedStepConfig[];
+    get form(): FormController;
+    get state(): QuestionnaireState;
+    next(): Promise<boolean>;
+    prev(): void;
+    subscribe(listener: (state: QuestionnaireState) => void): () => void;
+}

package/dist/types/src/questionnaire/engine/schema.d.ts

@@ -0,0 +1,9 @@
+import { FormSchema, Registry } from '../../../engine';
+import { NormalizedStepConfig, QuestionnaireSchema } from '../types';
+export interface NormalizedQuestionnaireSchema {
+    steps: NormalizedStepConfig[];
+    formSchema: FormSchema;
+}
+export declare const normalizeQuestionnaireSchema: (schema: QuestionnaireSchema, _registry: Registry) => NormalizedQuestionnaireSchema;
+/** Identity helper for typed schema construction. */
+export declare const createQuestionnaireSchema: (schema: QuestionnaireSchema) => QuestionnaireSchema;

package/dist/types/src/questionnaire/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class QuestionnaireError extends Error {
+    constructor(message: string);
+}

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

@@ -0,0 +1,6 @@
+export { mountQuestionnaire, unmountQuestionnaire } from './mount';
+export { QuestionnaireController } from './engine/controller';
+export { createQuestionnaireSchema, normalizeQuestionnaireSchema } from './engine/schema';
+export { QuestionnaireError } from './errors';
+export { questionnaireDefaultLabels, questionnaireEventNames, questionnaireStaticText, questionnaireTagNames, resolveQuestionnaireText, } from './constants';
+export type { IQuestionnaireController, MountedQuestionnaire, MountQuestionnaireOptions, NormalizedStepConfig, QuestionnaireLabels, QuestionnaireSchema, QuestionnaireState, QuestionnaireStepConfig, QuestionnaireStepProgress, QuestionnaireText, QuestionnaireTextOverrides, } from './types';

package/dist/types/src/questionnaire/mount.d.ts

@@ -0,0 +1,3 @@
+import { MountQuestionnaireOptions, MountedQuestionnaire } from './types';
+export declare const mountQuestionnaire: (container: HTMLElement, options: MountQuestionnaireOptions) => MountedQuestionnaire;
+export declare const unmountQuestionnaire: (mounted: MountedQuestionnaire) => void;

package/dist/types/src/questionnaire/primitives/components/questionnaire-root.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+import { PrimitiveText } from '../../../../primitives/constants';
+import { PrimitiveRegistry } from '../../../../primitives/types';
+import { questionnaireTagNames, QuestionnaireText } from '../../constants';
+import { IQuestionnaireController } from '../../types';
+export declare class QuestionnaireRootElement extends LitElement {
+    #private;
+    static styles: import('lit').CSSResult;
+    accessor controller: IQuestionnaireController | undefined;
+    accessor registry: PrimitiveRegistry | undefined;
+    accessor text: QuestionnaireText;
+    accessor primitiveText: PrimitiveText;
+    private accessor qState;
+    private accessor formStatus;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [questionnaireTagNames.questionnaire]: QuestionnaireRootElement;
+    }
+}

package/dist/types/src/questionnaire/primitives/components/step-indicator.d.ts

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+import { questionnaireTagNames } from '../../constants';
+export declare class QuestionnaireStepIndicatorElement extends LitElement {
+    static styles: import('lit').CSSResult;
+    accessor current: number;
+    accessor total: number;
+    accessor label: string;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [questionnaireTagNames.stepIndicator]: QuestionnaireStepIndicatorElement;
+    }
+}

package/dist/types/src/questionnaire/types.d.ts

@@ -0,0 +1,69 @@
+import { AttachedDesignSystem, DesignSystemConfig, DesignSystemRegistry, ResolvedDesignSystem } from '../../design-system';
+import { FieldConfig, FieldController, FormController, FormHooks, FormValidator, InactiveFieldPolicy, Registry, Transport } from '../../engine';
+import { PrimitiveRegistry, PrimitiveTextOverrides } from '../../primitives';
+import { QuestionnaireLabels, QuestionnaireText, QuestionnaireTextOverrides } from './constants';
+export type { QuestionnaireLabels, QuestionnaireText, QuestionnaireTextOverrides };
+export interface QuestionnaireStepConfig {
+    id?: string;
+    title: string;
+    description?: string;
+    fields: FieldConfig[];
+}
+export interface QuestionnaireSchema {
+    steps: QuestionnaireStepConfig[];
+}
+export interface NormalizedStepConfig {
+    id: string;
+    title: string;
+    description?: string;
+    fieldIds: string[];
+}
+export interface QuestionnaireStepProgress {
+    current: number;
+    total: number;
+}
+export interface QuestionnaireState {
+    stepIndex: number;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    isLastStep: boolean;
+    stepProgress: QuestionnaireStepProgress;
+    currentStep: NormalizedStepConfig;
+}
+export interface IQuestionnaireController {
+    readonly steps: readonly NormalizedStepConfig[];
+    readonly state: QuestionnaireState;
+    readonly form: FormController;
+    next(): Promise<boolean>;
+    prev(): void;
+    subscribe(listener: (state: QuestionnaireState) => void): () => void;
+}
+export type StepFieldEntry = {
+    id: string;
+    controller: FieldController;
+};
+export interface MountQuestionnaireOptions {
+    schema: QuestionnaireSchema;
+    transport: Transport;
+    registry?: Registry;
+    primitiveRegistry?: PrimitiveRegistry;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    initialValues?: Record<string, unknown>;
+    validators?: FormValidator[];
+    hooks?: FormHooks;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+    listenerErrorPolicy?: "ignore" | "throw-aggregate";
+    onListenerError?: (error: unknown) => void;
+    labels?: QuestionnaireLabels;
+    text?: QuestionnaireTextOverrides;
+    primitiveText?: PrimitiveTextOverrides;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export interface MountedQuestionnaire {
+    readonly controller: IQuestionnaireController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}

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

@@ -0,0 +1,3 @@
+export declare class MLFormError extends Error {
+    constructor(message: string);
+}

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

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

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

@@ -0,0 +1,7 @@
+import { CapabilityRequirement, SubmitRequest, Transport, TransportCapabilities } from './types';
+export declare const normalizeTransportCapabilities: (capabilities?: Partial<TransportCapabilities>, inferred?: Partial<TransportCapabilities>) => TransportCapabilities;
+export declare const mergeTransportCapabilities: (current?: TransportCapabilities, next?: TransportCapabilities) => TransportCapabilities | undefined;
+export declare const inferTransportCapabilities: (transport: Pick<Transport, "stream" | "openSession" | "capabilities">) => TransportCapabilities;
+export declare const cloneCapabilities: (capabilities: TransportCapabilities | undefined) => TransportCapabilities | undefined;
+export declare const assertTransportCapabilities: (transport: Transport, requirement: CapabilityRequirement, context: string) => void;
+export declare const assertPayloadWithinLimits: (transport: Transport, request: SubmitRequest, context: string) => void;

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

@@ -0,0 +1,6 @@
+/**
+ * Minimal deep clone for transport-layer data: plain objects, arrays, Date,
+ * Map, Set, and primitives. Does **not** handle File, Blob, TypedArray, or
+ * DataView — use the engine-level {@link cloneValue} for those.
+ */
+export declare const cloneValue: <T>(value: T) => T;

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

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

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

@@ -0,0 +1,3 @@
+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/composition/hedged.d.ts

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

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

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

package/dist/types/src/transport/composition/load-balancing.d.ts

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { RoutingTransportOptions, Transport, WeightedRoutingTransportOptions } from '../types';
+export declare const createRoutingTransport: <TTransportId extends string = string>(options: RoutingTransportOptions<TTransportId>) => Transport;
+export declare const createWeightedRoutingTransport: <TTransportId extends string = string>(options: WeightedRoutingTransportOptions<TTransportId>) => Transport;

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

@@ -0,0 +1,34 @@
+export declare const transportDefaults: {
+    readonly method: "POST";
+    readonly acceptHeader: "application/json";
+    readonly contentTypeHeader: "application/json";
+    readonly requestBodyKey: "inputs";
+};
+export declare const transportErrorMessages: {
+    readonly missingFetch: "A fetch implementation is required to use the default transport.";
+    readonly unsupportedMethod: (method: string) => string;
+    readonly requestFailed: (status: number, statusText: string) => string;
+    readonly emptyComposedTransport: (factoryName: string) => string;
+    readonly unknownComposedTransport: (factoryName: string, transportId: string, availableTransportIds: readonly string[]) => string;
+    readonly duplicateFanoutReport: (reportId: string, firstSource: string, secondSource: string) => string;
+    readonly fanoutFailed: (failedSources: readonly string[]) => string;
+    readonly fanoutEmpty: "createFanoutTransport: all transports filtered out. No submissions dispatched.";
+    readonly fallbackFailed: (failedSources: readonly string[]) => string;
+    readonly emptyPipeline: "createPipelineTransport requires at least one stage.";
+    readonly pipelineAborted: (stageId: string) => string;
+    readonly racingAllFailed: "createRacingTransport: all transports failed.";
+    readonly missingStream: (source: string) => string;
+    readonly retryInvalidAttempts: "withRetry: attempts must be at least 1.";
+    readonly timeoutInvalid: "withTimeout: timeout must be a positive number.";
+    readonly retryUnsafe: "withRetry: transport declares retrySafe=false. Pass `allowUnsafeRetry: true` to override.";
+    readonly cacheUnsafe: "withCache: transport declares cacheable=false. Pass `allowUnsafeCache: true` to override.";
+    readonly circuitInvalidFailureThreshold: "withCircuitBreaker: failureThreshold must be at least 1.";
+    readonly circuitInvalidResetTimeout: "withCircuitBreaker: resetTimeout must be a positive number.";
+    readonly rateLimitInvalid: "withRateLimit: provide at least one positive maxConcurrent or perSecond limit.";
+    readonly rateLimitQueueFull: "withRateLimit: queue limit exceeded.";
+    readonly cacheInvalidTtl: "withCache: ttl must be a positive number.";
+    readonly circuitOpen: (source: string) => string;
+    readonly hedgedUnsafe: "createHedgedTransport: every transport must declare retrySafe !== false or allowUnsafeHedging must be true.";
+    readonly sseInvalidEvent: "createSseTransport: failed to parse SSE event payload.";
+    readonly websocketMissing: "createWebSocketSessionTransport requires a WebSocket implementation in this environment.";
+};

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

@@ -0,0 +1,36 @@
+import { MLFormError } from '../../shared';
+export declare const transportErrorCodes: {
+    readonly TIMEOUT: "TIMEOUT";
+    readonly AUTH_FAILED: "AUTH_FAILED";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly OPEN_CIRCUIT: "OPEN_CIRCUIT";
+    readonly PARSE_FAILED: "PARSE_FAILED";
+    readonly UPSTREAM_5XX: "UPSTREAM_5XX";
+    readonly ABORTED: "ABORTED";
+    readonly CAPABILITY_MISMATCH: "CAPABILITY_MISMATCH";
+    readonly PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+    readonly SESSION_RESULT_MISSING: "SESSION_RESULT_MISSING";
+    readonly GRAPHQL_ERROR: "GRAPHQL_ERROR";
+    readonly WEBSOCKET_BUFFER_OVERFLOW: "WEBSOCKET_BUFFER_OVERFLOW";
+    readonly POLICY_STORE_CONFLICT: "POLICY_STORE_CONFLICT";
+    readonly QUORUM_NOT_REACHED: "QUORUM_NOT_REACHED";
+};
+export type TransportErrorCode = (typeof transportErrorCodes)[keyof typeof transportErrorCodes] | (string & {});
+export declare class TransportError extends MLFormError {
+    readonly cause: unknown;
+    readonly source?: string;
+    readonly status?: number;
+    readonly code?: TransportErrorCode;
+    readonly retryable?: boolean;
+    readonly details?: unknown;
+    readonly response?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        source?: string;
+        status?: number;
+        code?: TransportErrorCode;
+        retryable?: boolean;
+        details?: unknown;
+        response?: unknown;
+    });
+}

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

@@ -0,0 +1,9 @@
+export * from './types';
+export { TransportError, transportErrorCodes, type TransportErrorCode } from './errors';
+export { transportDefaults, transportErrorMessages } from './constants';
+export { assertPayloadWithinLimits, assertTransportCapabilities, cloneCapabilities, inferTransportCapabilities, mergeTransportCapabilities, normalizeTransportCapabilities, } from './capabilities';
+export { getTransportPolicyContext, withTransportPolicyContext } from './policy-context';
+export * from './protocols';
+export * from './middleware';
+export * from './composition';
+export * from './state';

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

@@ -0,0 +1,110 @@
+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/middleware/auth.d.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+export * from './pipe';
+export * from './retry';
+export * from './timeout';
+export * from './transform';
+export * from './logging';
+export * from './tracing';
+export * from './metrics';
+export * from './auth';
+export * from './circuit-breaker';
+export * from './rate-limit';
+export * from './dedup';
+export * from './cache';

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

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

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

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

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

@@ -0,0 +1,2 @@
+import { Transport, TransportMiddleware } from '../types';
+export declare const pipe: (transport: Transport, ...middleware: TransportMiddleware[]) => Transport;

package/dist/types/src/transport/middleware/rate-limit.d.ts

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