mlform 0.1.8 → 0.1.10

package/dist/types/{src/runtime → runtime}/submission/lifecycle.d.ts

@@ -3,10 +3,9 @@ import { SubmitResult } from '../types';
 type SubmissionTransitionOptions = {
     store: EngineStore;
     resetReports: () => void;
-    resetExplanations: () => void;
     syncAfterSubmissionTransition: () => void;
 };
-export declare const createSubmissionLifecycle: ({ store, resetReports, resetExplanations, syncAfterSubmissionTransition, }: SubmissionTransitionOptions) => {
+export declare const createSubmissionLifecycle: ({ store, resetReports, syncAfterSubmissionTransition, }: SubmissionTransitionOptions) => {
     start(submissionVersion: number): void;
     succeed(result: SubmitResult): void;
     abort(message: string): void;

package/dist/types/runtime/submission/pending-patches.d.ts

@@ -0,0 +1,2 @@
+import { EngineStore } from '../state';
+export declare const storePendingReportPatch: (store: EngineStore, reportId: string, patch: unknown) => void;

package/dist/types/{src/runtime → runtime}/submission/pipeline.d.ts

@@ -1,2 +1,2 @@
 import { ExecuteFormPipelineOptions, PipelineResult } from '../types';
-export declare const executeFormPipeline: <TArtifacts extends Record<string, unknown> = Record<string, never>>({ form, submit, artifactAdapter, explanationMode, }: ExecuteFormPipelineOptions<TArtifacts>) => Promise<PipelineResult<TArtifacts>>;
+export declare const executeFormPipeline: <TArtifacts extends Record<string, unknown> = Record<string, never>>({ form, submit, artifactAdapter, reportFetchMode, }: ExecuteFormPipelineOptions<TArtifacts>) => Promise<PipelineResult<TArtifacts>>;

package/dist/types/runtime/submission/report-fetches.d.ts

@@ -0,0 +1,2 @@
+import { ReportFetchExecutionContext, ReportFetchExecutionResult } from '../types';
+export declare const executeReportFetches: ({ reports, request, }: ReportFetchExecutionContext) => Promise<ReportFetchExecutionResult>;

package/dist/types/runtime/submission/stream-events.d.ts

@@ -0,0 +1,13 @@
+import { TransportStreamEvent } from '../types';
+import { SubmissionValueRecords } from './request';
+export type ApplySubmissionStreamEventOptions = {
+    event: TransportStreamEvent;
+    records: SubmissionValueRecords;
+    backend: string | undefined;
+    applyValidatedReportReplace: (reportId: string, payload: unknown, records: SubmissionValueRecords, backend: string | undefined) => Promise<void>;
+    applyValidatedReportPatch: (reportId: string, patch: unknown, strategy: "replace" | "shallow-merge" | "deep-merge" | undefined, records: SubmissionValueRecords, backend: string | undefined) => Promise<void>;
+    applyFieldUpdate: (event: Extract<TransportStreamEvent, {
+        type: "field-update";
+    }>) => void;
+};
+export declare const applySubmissionStreamEvent: ({ event, records, backend, applyValidatedReportReplace, applyValidatedReportPatch, applyFieldUpdate, }: ApplySubmissionStreamEventOptions) => Promise<void>;

package/dist/types/{src/runtime → runtime}/submission/types.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedFormSchema } from '../schema';
+import { NormalizedFormSchema } from '../../schema';
 import { InternalFieldState, EngineStore } from '../state';
 import { FormHooks, FormValidationResult, InactiveFieldPolicy, SubmissionProgressState, SubmitOptions, SubmitResult, Transport, TransportStreamEvent } from '../types';
 import { buildSubmissionValueRecords, SubmissionValueRecords } from './request';
@@ -30,7 +30,6 @@ export type CreateFormSubmitterOptions = {
     getSubmitCount: () => number;
     markReportsLoading: () => void;
     resetReports: () => void;
-    resetExplanations: () => void;
     syncDerivedFieldState: (options?: SyncDerivedFieldStateOptions) => void;
     shouldResetInactiveFields: () => boolean;
     resolveInactiveFieldPolicy: (field: SubmissionField) => InactiveFieldPolicy;

package/dist/types/{src/runtime → runtime}/types/behavior.d.ts

@@ -1,4 +1,4 @@
-import { Registry } from '../../../schema';
+import { Registry } from '../../schema';
 import { FieldHandle } from './field';
 import { FormStatus } from './form';
 type MaybePromise<T> = T | PromiseLike<T>;

package/dist/types/{src/runtime → runtime}/types/field.d.ts

@@ -1,6 +1,5 @@
-import { FieldDefinition as SchemaFieldDefinition, FieldStateSnapshot, FieldValidationResult, NormalizedFieldConfig } from '../../../schema';
-import { FieldDescriptor } from '../../../presentation';
-export type { AllConditions, AnyConditions, BaseFieldConfig, DeclarativeFieldCondition, FieldComparisonCondition, FieldCondition, FieldConditionContext, FieldConfig, FieldStateSnapshot, FieldStatus, FieldValidationContext, FieldValidationFnContext, FieldValidationResult, FieldValueAdapter, FieldValueCondition, FormStatusCondition, InactiveFieldPolicy, NormalizedFieldConfig, NotCondition, SelectorSubscriptionOptions, SubmitCountCondition, } from '../../../schema';
+import { FieldDefinition as SchemaFieldDefinition, FieldStateSnapshot, FieldValidationResult, NormalizedFieldConfig } from '../../schema';
+export type { AllConditions, AnyConditions, BaseFieldConfig, DeclarativeFieldCondition, FieldComparisonCondition, FieldCondition, FieldConditionContext, FieldConfig, FieldStateSnapshot, FieldStatus, FieldValidationContext, FieldValidationFnContext, FieldValidationResult, FieldValueAdapter, FieldValueCondition, FormStatusCondition, InactiveFieldPolicy, NormalizedFieldConfig, NotCondition, SelectorSubscriptionOptions, SubmitCountCondition, } from '../../schema';
 export interface FieldHandle {
     readonly id: string;
     readonly kind: string;
@@ -14,11 +13,5 @@ export interface FieldHandle {
     subscribe(listener: (state: FieldStateSnapshot) => void): () => void;
 }
 export type FieldController = FieldHandle;
-export type FieldDefinition<TConfig extends import('../../../schema').FieldConfig = import('../../../schema').FieldConfig, TValue = unknown> = SchemaFieldDefinition<TConfig, TValue> & {
-    describe?: (config: NormalizedFieldConfig<TConfig>, context: {
-        fieldId: string;
-        state: FieldStateSnapshot;
-    }) => FieldDescriptor;
-    [key: string]: unknown;
-};
+export type FieldDefinition<TConfig extends import('../../schema').FieldConfig = import('../../schema').FieldConfig, TValue = unknown> = SchemaFieldDefinition<TConfig, TValue>;
 export type RuntimeFieldDefinition = FieldDefinition;

package/dist/types/{src/runtime → runtime}/types/form.d.ts

@@ -1,7 +1,6 @@
-import { ExplanationConfig, FieldConfig, FieldStateSnapshot, FormSchema, InactiveFieldPolicy, NormalizedFieldConfig, NormalizedReportConfig, Registry, ReportConfig, ReportStateSnapshot, SelectorSubscriptionOptions } from '../../../schema';
+import { FieldConfig, FieldStateSnapshot, FormSchema, InactiveFieldPolicy, NormalizedFieldConfig, NormalizedReportConfig, Registry, ReportConfig, ReportStateSnapshot, SelectorSubscriptionOptions } from '../../schema';
 import { RuntimeBehavior } from './behavior';
 import { AfterSubmitContext, BeforeSubmitContext, SubmitErrorContext, SubmitOptions, SubmitResult, Transport, TransportStreamEvent } from './transport';
-import { ExplanationController, ExplanationStateSnapshot } from './explanation';
 import { FieldController } from './field';
 import { ReportController } from './report';
 type MaybePromise<T> = T | PromiseLike<T>;
@@ -31,7 +30,6 @@ export interface FormState {
     touched: boolean;
     values: Record<string, unknown>;
     reportStates: Record<string, ReportStateSnapshot>;
-    explanationStates: Record<string, ExplanationStateSnapshot>;
     submissionProgress: SubmissionProgressState | null;
     errors: {
         form: string[];
@@ -63,13 +61,13 @@ export interface AfterValidateContext {
     result: FormValidationResult;
     submitCount: number;
 }
-export interface AfterExplanationContext {
-    explanationId: string;
+export interface AfterReportFetchContext {
+    reportId: string;
     kind: string;
-    result: unknown;
+    payload: unknown;
 }
-export interface ExplanationErrorContext {
-    explanationId: string;
+export interface ReportFetchErrorContext {
+    reportId: string;
     kind: string;
     error: unknown;
 }
@@ -79,8 +77,8 @@ export interface FormHooks {
     beforeSubmit?: (context: BeforeSubmitContext) => MaybePromise<void>;
     afterSubmit?: (context: AfterSubmitContext) => MaybePromise<void>;
     onSubmitError?: (context: SubmitErrorContext) => MaybePromise<void>;
-    afterExplanation?: (context: AfterExplanationContext) => MaybePromise<void>;
-    onExplanationError?: (context: ExplanationErrorContext) => MaybePromise<void>;
+    afterReportFetch?: (context: AfterReportFetchContext) => MaybePromise<void>;
+    onReportFetchError?: (context: ReportFetchErrorContext) => MaybePromise<void>;
 }
 export interface CreateFormConfig {
     schema: FormSchema;
@@ -100,11 +98,9 @@ export interface CreateFormConfig {
 export interface FormController {
     readonly fields: readonly FieldController[];
     readonly reports: readonly ReportController[];
-    readonly explanations: readonly ExplanationController[];
     readonly state: FormState;
     getField(id: string): FieldController | undefined;
     getReport(id: string): ReportController | undefined;
-    getExplanation(id: string): ExplanationController | undefined;
     getValues(): Record<string, unknown>;
     setValues(values: Record<string, unknown>): void;
     validate(): Promise<FormValidationResult>;
@@ -114,4 +110,4 @@ export interface FormController {
     subscribe(listener: (state: FormState) => void): () => void;
     subscribeSelector<TSelected>(selector: (state: FormState) => TSelected, listener: (selected: TSelected, state: FormState) => void, options?: SelectorSubscriptionOptions<TSelected>): () => void;
 }
-export type { ExplanationConfig, FieldConfig, FormSchema, Registry, ReportConfig };
+export type { FieldConfig, FormSchema, Registry, ReportConfig };

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

@@ -0,0 +1,7 @@
+export type MaybePromise<T> = T | PromiseLike<T>;
+export * from './behavior';
+export * from './field';
+export * from './form';
+export * from './pipeline';
+export * from './report';
+export * from './transport';

package/dist/types/{src/runtime → runtime}/types/pipeline.d.ts

@@ -1,14 +1,14 @@
-import { ExplanationController, ExplanationFetchRequest } from './explanation';
 import { FormController } from './form';
+import { ReportController, ReportFetchRequest } from './report';
 import { SubmitOptions, SubmitResult } from './transport';
-export interface ExplanationExecutionResult {
+export interface ReportFetchExecutionResult {
     results: Record<string, unknown>;
     errors: Record<string, string>;
 }
 export interface PipelineArtifactContext {
     submitResult: SubmitResult;
-    explanationResults: Record<string, unknown>;
-    explanationErrors: Record<string, string>;
+    reportFetchResults: Record<string, unknown>;
+    reportFetchErrors: Record<string, string>;
 }
 export interface PipelineArtifactAdapter<TArtifacts extends Record<string, unknown> = {}> {
     derive(context: PipelineArtifactContext): TArtifacts | Promise<TArtifacts>;
@@ -17,15 +17,15 @@ export interface ExecuteFormPipelineOptions<TArtifacts extends Record<string, un
     form: FormController;
     submit?: SubmitOptions;
     artifactAdapter?: PipelineArtifactAdapter<TArtifacts>;
-    explanationMode?: "none" | "all";
+    reportFetchMode?: "none" | "all";
 }
 export interface PipelineResult<TArtifacts extends Record<string, unknown> = {}> {
     submitResult: SubmitResult;
-    explanationResults: Record<string, unknown>;
-    explanationErrors: Record<string, string>;
+    reportFetchResults: Record<string, unknown>;
+    reportFetchErrors: Record<string, string>;
     artifacts: TArtifacts;
 }
-export interface ExplanationExecutionContext {
-    explanations: readonly ExplanationController[];
-    request: ExplanationFetchRequest;
+export interface ReportFetchExecutionContext {
+    reports: readonly ReportController[];
+    request: ReportFetchRequest;
 }

package/dist/types/runtime/types/registry.d.ts

@@ -0,0 +1,5 @@
+import { FieldDefinition, Registry as SchemaRegistry, ReportDefinition } from '../../schema';
+export interface Registry extends Omit<SchemaRegistry, "registerField" | "registerReport"> {
+    registerField(definition: FieldDefinition): Registry;
+    registerReport(definition: ReportDefinition): Registry;
+}

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

@@ -0,0 +1,16 @@
+import { NormalizedReportConfig as SchemaNormalizedReportConfig, ReportDefinition as SchemaReportDefinition, ReportStateSnapshot } from '../../schema';
+export type { BaseReportConfig, PartialReportUpdatePolicy, ReportConfig, ReportFetchContext, ReportFetchFactory, ReportFetchRequest, ReportFetchStatus, ReportFetchTransport, ReportPayloadContext, ReportPayloadValidationPolicy, ReportResolveContext, ReportStateSnapshot, ReportStatus, } from '../../schema';
+export interface ReportHandle {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: SchemaNormalizedReportConfig;
+    readonly state: ReportStateSnapshot;
+    readonly canFetch: boolean;
+    fetch(request: import('../../schema').ReportFetchRequest): Promise<void>;
+    abort(): void;
+    subscribe(listener: (state: ReportStateSnapshot) => void): () => void;
+}
+export type ReportController = ReportHandle;
+export type ReportDefinition<TConfig extends import('../../schema').ReportConfig = import('../../schema').ReportConfig> = SchemaReportDefinition<TConfig>;
+export type NormalizedReportConfig<TConfig extends import('../../schema').ReportConfig = import('../../schema').ReportConfig> = SchemaNormalizedReportConfig<TConfig>;
+export type RuntimeReportDefinition = ReportDefinition;

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

@@ -1,11 +1,10 @@
-import { SubmitRequest as BaseSubmitRequest, SubmitResult as BaseSubmitResult, Transport as BaseTransport, TransportStreamEvent as BaseTransportStreamEvent } from '../../../transport';
+import { SubmitRequest as BaseSubmitRequest, Transport as BaseTransport, TransportStreamEvent as BaseTransportStreamEvent } from '../../transport';
+import { SubmitResult as SchemaSubmitResult } from '../../schema';
 import { NormalizedFieldConfig } from './field';
 import { NormalizedReportConfig, ReportStateSnapshot } from './report';
-export type { CapabilityRequirement, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, RateLimitLeaseRequest, SharedRateLimiter, SharedRateLimiterLease, SubmitRequestMetadata, SubmitRequestTransportContext, TransportAuthKind, TransportBackpressureMode, TransportCacheEntry, TransportCacheStore, TransportCapabilities, TransportCollection, TransportConsistency, TransportDeliveryMode, TransportHealthSnapshot, TransportHealthState, TransportPolicyContext, TransportResponse, TransportSession, TransportSessionCloseEvent, TransportSessionErrorEvent, TransportSessionEvent, TransportSessionMessage, TransportSessionMessageEvent, TransportSessionMetaEvent, TransportSessionProgressEvent, TransportSessionResultEvent, TransportStreamChunkEvent, TransportStreamErrorEvent, TransportStreamMetaEvent, TransportStreamProgressEvent, TransportStreamReportPatchEvent, TransportStreamReportReplaceEvent, } from '../../../transport';
+export type { CapabilityRequirement, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, RateLimitLeaseRequest, SharedRateLimiter, SharedRateLimiterLease, SubmitRequestMetadata, SubmitRequestTransportContext, TransportAuthKind, TransportBackpressureMode, TransportCacheEntry, TransportCacheStore, TransportCapabilities, TransportCollection, TransportConsistency, TransportDeliveryMode, TransportHealthSnapshot, TransportHealthState, TransportPolicyContext, TransportResponse, TransportSession, TransportSessionCloseEvent, TransportSessionErrorEvent, TransportSessionEvent, TransportSessionMessage, TransportSessionMessageEvent, TransportSessionMetaEvent, TransportSessionProgressEvent, TransportSessionResultEvent, TransportStreamChunkEvent, TransportStreamErrorEvent, TransportStreamMetaEvent, TransportStreamProgressEvent, TransportStreamReportPatchEvent, TransportStreamReportReplaceEvent, } from '../../transport';
 export type SubmitRequest = BaseSubmitRequest<NormalizedFieldConfig, NormalizedReportConfig>;
-export type SubmitResult = Omit<BaseSubmitResult, "reportStates"> & {
-    reportStates: Record<string, ReportStateSnapshot>;
-};
+export type SubmitResult = SchemaSubmitResult<ReportStateSnapshot>;
 export type Transport = BaseTransport<NormalizedFieldConfig, NormalizedReportConfig>;
 export type TransportStreamEvent = BaseTransportStreamEvent;
 export interface SubmitOptions {

package/dist/types/{src/runtime → runtime}/utils.d.ts

@@ -1,9 +1,7 @@
 import { MaybePromise } from './types';
-import { isRecord, slugify } from '../../shared';
-export { isRecord, slugify };
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
 export declare const isPromiseLike: <T>(value: MaybePromise<T>) => value is PromiseLike<T>;
 export declare const isEmptyValue: (value: unknown) => boolean;
-export declare const toDate: (value: unknown) => Date | null;
 export declare const identity: <T>(value: T) => T;
 export declare const deepFreeze: <T>(value: T) => T;
 export declare const delay: (ms: number, signal?: AbortSignal) => Promise<void>;

package/dist/types/{src/runtime → runtime}/validation/form.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedFormSchema } from '../schema';
+import { NormalizedFormSchema } from '../../schema';
 import { EngineStore } from '../state';
 import { FieldValidationResult, FormHooks, FormStatus, FormValidationIssue, FormValidationResult, FormValidator, InactiveFieldPolicy } from '../types';
 type FormValidationField = {

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

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

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

@@ -1,7 +1,9 @@
+export { normalizeSchemaId } from './ids';
 export * from './normalize';
+export { createReportFetchRequest } from './report-fetch-request';
 export * from './registry';
-export type * from './types/explanation';
 export type * from './types/field';
 export type * from './types/form';
 export type * from './types/registry';
 export type * from './types/report';
+export type * from './types/submit';

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

@@ -0,0 +1,7 @@
+import { FieldConfig, FieldDefinition, Registry, ReportConfig, ReportDefinition } from './index';
+export declare class RegistryError extends Error {
+    constructor(message: string);
+}
+export declare const createRegistry: () => Registry;
+export declare const defineFieldDefinition: <TDefinition extends FieldDefinition<FieldConfig, unknown>>(definition: TDefinition) => TDefinition;
+export declare const defineReportDefinition: <TDefinition extends ReportDefinition<ReportConfig>>(definition: TDefinition) => TDefinition;

package/dist/types/schema/report-fetch-request.d.ts

@@ -0,0 +1,6 @@
+import { ReportFetchRequest } from './types/report';
+import { SubmitResult } from './types/submit';
+export declare const createReportFetchRequest: (submitResult: SubmitResult, options?: {
+    reportId?: string;
+    signal?: AbortSignal;
+}) => ReportFetchRequest;

package/dist/types/{src/schema → schema}/types/form.d.ts

@@ -1,13 +1,10 @@
-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/{src/schema → schema}/types/registry.d.ts

@@ -1,4 +1,3 @@
-import { ExplanationConfig, ExplanationDefinition } from './explanation';
 import { FieldConfig, FieldDefinition } from './field';
 import { ReportConfig, ReportDefinition } from './report';
 export interface Registry {
@@ -10,8 +9,4 @@ export interface Registry {
     unregisterReport(kind: string): Registry;
     getReport<TConfig extends ReportConfig = ReportConfig>(kind: string): ReportDefinition<TConfig> | undefined;
     listReports(): ReportDefinition<ReportConfig>[];
-    registerExplanation<TConfig extends ExplanationConfig>(definition: ExplanationDefinition<TConfig>): Registry;
-    unregisterExplanation(kind: string): Registry;
-    getExplanation<TConfig extends ExplanationConfig = ExplanationConfig>(kind: string): ExplanationDefinition<TConfig> | undefined;
-    listExplanations(): ExplanationDefinition<ExplanationConfig>[];
 }

package/dist/types/{src/schema → schema}/types/report.d.ts

@@ -1,7 +1,8 @@
 import { ZodType } from 'zod';
 import { MaybePromise } from './field';
-import { SubmitResult } from '../../../runtime/types/transport';
+import { SubmitResult } from './submit';
 export type ReportStatus = "idle" | "loading" | "ready" | "error";
+export type ReportFetchStatus = ReportStatus;
 export type ReportPayloadValidationPolicy = "report-error" | "fail-submit";
 export type PartialReportUpdatePolicy = "trust" | "validate" | "defer";
 export interface BaseReportConfig {
@@ -25,13 +26,33 @@ export interface ReportStateSnapshot {
 }
 export interface ReportPayloadContext<TConfig extends ReportConfig = ReportConfig> {
     report: NormalizedReportConfig<TConfig>;
-    result: SubmitResult;
+    result: SubmitResult<ReportStateSnapshot>;
 }
 export interface ReportResolveContext<TConfig extends ReportConfig = ReportConfig> {
     config: NormalizedReportConfig<TConfig>;
     report: NormalizedReportConfig<TConfig>;
-    result: SubmitResult;
+    result: SubmitResult<ReportStateSnapshot>;
 }
+export interface ReportFetchRequest {
+    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;
+}
+export interface ReportFetchTransport {
+    submit: (request: ReportFetchRequest) => Promise<unknown>;
+}
+export interface ReportFetchContext<TConfig extends ReportConfig = ReportConfig> {
+    config: NormalizedReportConfig<TConfig>;
+    reportId: string;
+}
+export type ReportFetchFactory<TConfig extends ReportConfig = ReportConfig> = (context: ReportFetchContext<TConfig>) => ReportFetchTransport;
 export interface ReportDefinition<TConfig extends ReportConfig = ReportConfig> {
     kind: string;
     schema: ZodType<TConfig>;
@@ -39,5 +60,6 @@ export interface ReportDefinition<TConfig extends ReportConfig = ReportConfig> {
     payloadValidationPolicy?: ReportPayloadValidationPolicy;
     partialUpdatePolicy?: PartialReportUpdatePolicy;
     clonePayload?: (payload: unknown, config: TConfig) => unknown;
+    fetch?: ReportFetchFactory<TConfig>;
     resolvePayload?: (config: TConfig, context: ReportPayloadContext<TConfig>) => MaybePromise<unknown>;
 }

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

@@ -0,0 +1,11 @@
+export interface SubmitResult<TReportState = unknown> {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    reports: Record<string, unknown>;
+    reportStates: Record<string, TReportState>;
+    meta: Record<string, unknown>;
+    raw: unknown;
+}

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/{src/transport → transport}/errors.d.ts

@@ -1,4 +1,3 @@
-import { MLFormError } from '../../shared';
 export declare const transportErrorCodes: {
     readonly TIMEOUT: "TIMEOUT";
     readonly AUTH_FAILED: "AUTH_FAILED";
@@ -16,7 +15,7 @@ export declare const transportErrorCodes: {
     readonly QUORUM_NOT_REACHED: "QUORUM_NOT_REACHED";
 };
 export type TransportErrorCode = (typeof transportErrorCodes)[keyof typeof transportErrorCodes] | (string & {});
-export declare class TransportError extends MLFormError {
+export declare class TransportError extends Error {
     readonly cause: unknown;
     readonly source?: string;
     readonly status?: number;

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

@@ -3,6 +3,8 @@ export { TransportError, transportErrorCodes, type TransportErrorCode } from './
 export { transportDefaults, transportErrorMessages } from './constants';
 export { assertPayloadWithinLimits, assertTransportCapabilities, cloneCapabilities, inferTransportCapabilities, mergeTransportCapabilities, normalizeTransportCapabilities, } from './capabilities';
 export { getTransportPolicyContext, withTransportPolicyContext } from './policy-context';
+export { createTransportRequestRunner, extractErrorMessage } from './request-runner';
+export type { TransportRequestOutcome, TransportRequestRunner } from './request-runner';
 export * from './protocols';
 export * from './middleware';
 export * from './composition';

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

@@ -0,0 +1,16 @@
+export type TransportRequestOutcome<TResult> = {
+    status: "completed";
+    value: TResult;
+} | {
+    status: "aborted";
+} | {
+    status: "failed";
+    error: unknown;
+    message: string;
+};
+export type TransportRequestRunner = {
+    run<TResult>(submit: (signal: AbortSignal | undefined) => Promise<TResult>, signals?: readonly (AbortSignal | undefined)[]): Promise<TransportRequestOutcome<TResult>>;
+    abort(reason?: unknown): void;
+};
+export declare const extractErrorMessage: (error: unknown) => string;
+export declare const createTransportRequestRunner: () => TransportRequestRunner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlform",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "private": false,
   "description": "Composable form generation utilities for machine learning backend integration",
   "keywords": [
@@ -50,12 +50,7 @@
     "dist/**"
   ],
   "type": "module",
-  "types": "dist/types/src/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/types/src/index.d.ts",
-      "import": "./dist/mlform.mjs"
-    },
     "./kit": {
       "types": "./dist/types/src/kit/index.d.ts",
       "import": "./dist/mlform/kit.mjs"
@@ -68,17 +63,9 @@
       "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"
+    "./builtins": {
+      "types": "./dist/types/src/builtins/index.d.ts",
+      "import": "./dist/mlform/builtins.mjs"
     },
     "./transport": {
       "types": "./dist/types/src/transport/index.d.ts",
@@ -88,9 +75,9 @@
       "types": "./dist/types/src/primitives/index.d.ts",
       "import": "./dist/mlform/primitives.mjs"
     },
-    "./design-system": {
-      "types": "./dist/types/src/design-system/index.d.ts",
-      "import": "./dist/mlform/design-system.mjs"
+    "./design": {
+      "types": "./dist/types/src/design/index.d.ts",
+      "import": "./dist/mlform/design.mjs"
     }
   },
   "publishConfig": {
@@ -98,15 +85,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.9.1",
+    "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.1",
     "vite-plus": "latest",
     "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
   },