mlform 0.1.7 → 0.1.9

package/dist/types/runtime/runtime-behaviors.d.ts

@@ -0,0 +1,23 @@
+import { Registry } from '../schema';
+import { InternalFieldController } from './fields';
+import { CreateFormConfig, FormState, RuntimeBehavior, RuntimeBehaviorContext, RuntimeBehaviorValueChangeEvent } from './types';
+type CreateRuntimeBehaviorsOptions = {
+    registry: Registry;
+    behaviors: RuntimeBehavior[];
+    fields: readonly InternalFieldController[];
+    getValues: () => Record<string, unknown>;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormState["status"];
+    commitDerivedValue: (targetId: string, value: unknown) => void;
+    syncDerivedState: (values: Record<string, unknown>) => void;
+    onListenerError: CreateFormConfig["onListenerError"];
+};
+export declare const createRuntimeBehaviors: ({ registry, behaviors, fields, getValues, getSubmitCount, getFormStatus, commitDerivedValue, syncDerivedState, onListenerError, }: CreateRuntimeBehaviorsOptions) => {
+    createBehaviorContext: () => RuntimeBehaviorContext;
+    runBehaviorValueChange: (event: RuntimeBehaviorValueChangeEvent) => void;
+    runBeforeSubmitRecords: (records: import('./types').RuntimeBehaviorSubmissionRecords) => Promise<void>;
+    validateBehaviors: () => void;
+    fieldMap: Map<string, InternalFieldController>;
+    resolveField: (targetId: string) => InternalFieldController | undefined;
+};
+export {};

package/dist/types/runtime/runtime-controller.d.ts

@@ -0,0 +1,34 @@
+import { FormController, FormState, RuntimeBehaviorValueChangeEvent } from './types';
+import { InternalExplanationController } from './explanations';
+import { InternalFieldController } from './fields';
+import { InternalReportController } from './reports';
+import { EngineStore } from './state';
+type CreateRuntimeControllerOptions = {
+    fields: InternalFieldController[];
+    reports: InternalReportController[];
+    explanations: InternalExplanationController[];
+    fieldMap: Map<string, InternalFieldController>;
+    reportMap: Map<string, InternalReportController>;
+    explanationMap: Map<string, InternalExplanationController>;
+    store: EngineStore;
+    getPublicState: () => FormState;
+    getValues: () => Record<string, unknown>;
+    getInternalValues: () => Record<string, unknown>;
+    formValidator: {
+        validate(): Promise<import('./types').FormValidationResult>;
+    };
+    formSubmitter: {
+        submit(options?: import('./types').SubmitOptions): Promise<import('./types').SubmitResult>;
+        abort(reason?: string): void;
+        reset(): void;
+    };
+    syncDerivedFieldState: (options?: import('./fields').RefreshOptions) => void;
+    shouldResetInactiveFields: () => boolean;
+    inactiveFieldPolicy: import('./types').InactiveFieldPolicy | undefined;
+    bumpLifecycleVersion: () => number;
+    resetReports: () => void;
+    resetExplanations: () => void;
+    runBehaviorValueChange: (event: RuntimeBehaviorValueChangeEvent) => void;
+};
+export declare const createRuntimeController: ({ fields, reports, explanations, fieldMap, reportMap, explanationMap, store, getPublicState, getValues, getInternalValues, formValidator, formSubmitter, syncDerivedFieldState, shouldResetInactiveFields, inactiveFieldPolicy, bumpLifecycleVersion, resetReports, resetExplanations, runBehaviorValueChange, }: CreateRuntimeControllerOptions) => FormController;
+export {};

package/dist/types/runtime/runtime-refresh.d.ts

@@ -0,0 +1,14 @@
+import { InternalFieldState, EngineStore } from './state';
+import { RefreshOptions, InternalFieldController } from './fields';
+type CreateRuntimeRefreshOptions = {
+    store: EngineStore;
+    fields: readonly InternalFieldController[];
+    shouldResetInactiveFields: () => boolean;
+    inactiveFieldPolicy: RefreshOptions["inactiveFieldPolicy"];
+    hasInteractiveFieldState: (fieldStates: Record<string, InternalFieldState>) => boolean;
+};
+export declare const createRuntimeRefresh: ({ store, fields, shouldResetInactiveFields, inactiveFieldPolicy, hasInteractiveFieldState, }: CreateRuntimeRefreshOptions) => {
+    syncDerivedFieldState: (options?: RefreshOptions) => void;
+    setRestingStatus: () => void;
+};
+export {};

package/dist/types/runtime/runtime-values.d.ts

@@ -0,0 +1,19 @@
+import { RefreshOptions, InternalFieldController } from './fields';
+import { InternalFieldState } from './state';
+type GetFieldMap = () => Map<string, InternalFieldController>;
+type GetValues = () => Record<string, unknown>;
+type CreateRuntimeValuesOptions = {
+    getFieldMap: GetFieldMap;
+    getValues: GetValues;
+    getCurrentFieldState: (fieldId: string) => InternalFieldState | undefined;
+    syncDerivedFieldState: (options?: RefreshOptions) => void;
+    shouldResetInactiveFields: () => boolean;
+    inactiveFieldPolicy: RefreshOptions["inactiveFieldPolicy"];
+};
+export declare const createRuntimeValues: ({ getFieldMap, getValues, getCurrentFieldState, syncDerivedFieldState, shouldResetInactiveFields, inactiveFieldPolicy, }: CreateRuntimeValuesOptions) => {
+    getValues: () => {
+        [k: string]: unknown;
+    };
+    commitDerivedValue: (targetId: string, value: unknown) => void;
+};
+export {};

package/dist/types/runtime/submission/create-submitter.d.ts

@@ -0,0 +1,2 @@
+import { CreateFormSubmitterOptions, FormSubmitter } from './types';
+export declare const createFormSubmitter: ({ store, transport, hooks, hookFailurePolicy, normalizedSchema, fields, reports, validate, getSubmitCount, markReportsLoading, resetReports, resetExplanations, syncDerivedFieldState, shouldResetInactiveFields, resolveInactiveFieldPolicy, inactiveFieldPolicy, onRemoteFieldUpdate, beforeSubmitRecords, }: CreateFormSubmitterOptions) => FormSubmitter;

package/dist/types/runtime/submission/error-flow.d.ts

@@ -0,0 +1,19 @@
+import { EngineStore } from '../state';
+import { FormHooks } from '../types';
+import { SubmissionValueRecords } from './request';
+import { createSubmissionAbortManager } from './abort';
+import { createSubmissionLifecycle } from './lifecycle';
+type AbortManager = ReturnType<typeof createSubmissionAbortManager>;
+type Lifecycle = ReturnType<typeof createSubmissionLifecycle>;
+type CreateSubmissionErrorFlowOptions = {
+    hooks: FormHooks | undefined;
+    abortManager: AbortManager;
+    lifecycle: Lifecycle;
+    store: EngineStore;
+};
+export declare const createSubmissionErrorFlow: ({ hooks, abortManager, lifecycle, store, }: CreateSubmissionErrorFlowOptions) => {
+    notifySubmitError: (backend: string | undefined, records: SubmissionValueRecords, submitCount: number, error: unknown) => Promise<void>;
+    handleSubmissionAbort: (error: unknown, submissionRequestId: number, lifecycleVersion: number, submitCount: number, records: SubmissionValueRecords, backend: string | undefined) => Promise<never>;
+    handleSubmissionError: (error: unknown, submissionRequestId: number, lifecycleVersion: number, submitCount: number, records: SubmissionValueRecords, backend: string | undefined) => Promise<never>;
+};
+export {};

package/dist/types/runtime/submission/field-updates.d.ts

@@ -0,0 +1,14 @@
+import { EngineStore } from '../state';
+import { TransportStreamEvent } from '../types';
+import { LiveSubmissionField } from './types';
+type CreateFieldUpdatesOptions = {
+    store: EngineStore;
+    fieldMap: Map<string, LiveSubmissionField>;
+    onRemoteFieldUpdate?: (fieldId: string) => Promise<void>;
+};
+export declare const createFieldUpdates: ({ store, fieldMap, onRemoteFieldUpdate, }: CreateFieldUpdatesOptions) => {
+    applyFieldUpdate: (event: Extract<TransportStreamEvent, {
+        type: "field-update";
+    }>) => void;
+};
+export {};

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/runtime/submission/report-updates.d.ts

@@ -0,0 +1,16 @@
+import { LiveSubmissionReport } from './types';
+import { SubmissionValueRecords } from './request';
+type CreateReportUpdatesOptions = {
+    reportMap: Map<string, LiveSubmissionReport>;
+    getReportState: (reportId: string) => {
+        payload?: unknown;
+    } | undefined;
+    getReportStates: () => Record<string, unknown>;
+    getSubmissionMeta: () => Record<string, unknown>;
+    storePendingPatch: (reportId: string, patch: Record<string, unknown>) => void;
+};
+export declare const createReportUpdates: ({ reportMap, getReportState, getReportStates, getSubmissionMeta, storePendingPatch, }: CreateReportUpdatesOptions) => {
+    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>;
+};
+export {};

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/runtime/submission/stream-progress.d.ts

@@ -0,0 +1,4 @@
+import { EngineStore } from '../state';
+import { SubmissionProgressState, TransportStreamEvent } from '../types';
+export declare const updateStreamProgress: (store: EngineStore, currentRequestId: () => number | null, progress: SubmissionProgressState, submissionRequestId: number, lifecycleVersion: number) => void;
+export declare const toSubmissionProgress: (previous: SubmissionProgressState | null, event: TransportStreamEvent) => SubmissionProgressState;

package/dist/types/runtime/submission/submitter.d.ts

@@ -0,0 +1,2 @@
+export { createFormSubmitter } from './create-submitter';
+export type { FormSubmitter, CreateFormSubmitterOptions } from './types';

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

@@ -0,0 +1,60 @@
+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';
+import { SubmissionReport } from './reports';
+export type SubmissionField = Parameters<typeof buildSubmissionValueRecords>[0][number];
+export type LiveSubmissionField = SubmissionField & {
+    coerceValue(value: unknown): unknown;
+    commitState(state: InternalFieldState): void;
+};
+export type LiveSubmissionReport = SubmissionReport;
+export type SyncDerivedFieldStateOptions = {
+    values?: Record<string, unknown>;
+    preserveValidationErrors?: boolean;
+    preserveExternalErrors?: boolean;
+    resetInactiveToInitial?: boolean;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+};
+export type CreateFormSubmitterOptions = {
+    store: EngineStore;
+    transport: Transport;
+    hooks?: FormHooks;
+    hookFailurePolicy?: {
+        afterSubmit?: "fail-submit" | "preserve-success";
+    };
+    normalizedSchema: NormalizedFormSchema;
+    fields: readonly SubmissionField[];
+    reports: readonly SubmissionReport[];
+    validate: () => Promise<FormValidationResult>;
+    getSubmitCount: () => number;
+    markReportsLoading: () => void;
+    resetReports: () => void;
+    resetExplanations: () => void;
+    syncDerivedFieldState: (options?: SyncDerivedFieldStateOptions) => void;
+    shouldResetInactiveFields: () => boolean;
+    resolveInactiveFieldPolicy: (field: SubmissionField) => InactiveFieldPolicy;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+    onRemoteFieldUpdate?: (fieldId: string) => Promise<void>;
+    beforeSubmitRecords?: (records: SubmissionValueRecords) => Promise<void>;
+};
+export type FormSubmitter = {
+    submit(options?: SubmitOptions): Promise<SubmitResult>;
+    abort(reason?: string): void;
+    reset(): void;
+};
+export type SubmissionMaps = {
+    fieldMap: Map<string, LiveSubmissionField>;
+    reportMap: Map<string, LiveSubmissionReport>;
+};
+export type SubmissionRuntime = {
+    store: EngineStore;
+    maps: SubmissionMaps;
+    onRemoteFieldUpdate?: (fieldId: string) => Promise<void>;
+};
+export type StreamApplyContext = {
+    records: SubmissionValueRecords;
+    backend: string | undefined;
+};
+export type StreamProgressHandler = (progress: SubmissionProgressState, submissionRequestId: number, lifecycleVersion: number) => void;
+export type StreamEventApplier = (event: TransportStreamEvent, context: StreamApplyContext) => Promise<void>;

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

@@ -0,0 +1,32 @@
+import { Registry } from '../../schema';
+import { FieldHandle } from './field';
+import { FormStatus } from './form';
+type MaybePromise<T> = T | PromiseLike<T>;
+export interface RuntimeBehaviorValueChangeEvent {
+    fieldId: string;
+    source: "local" | "remote";
+    values: Record<string, unknown>;
+}
+export interface RuntimeBehaviorSubmissionRecords {
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+}
+export interface RuntimeBehaviorContext {
+    readonly registry: Registry;
+    readonly fields: readonly FieldHandle[];
+    getField(id: string): FieldHandle | undefined;
+    resolveFieldId(id: string): string | undefined;
+    getValues(): Record<string, unknown>;
+    getSubmitCount(): number;
+    getFormStatus(): FormStatus;
+    commitDerivedValue(fieldId: string, value: unknown): void;
+    syncDerivedState(values?: Record<string, unknown>): void;
+}
+export interface RuntimeBehavior {
+    validate?(context: RuntimeBehaviorContext): void;
+    onValuesChanged?(event: RuntimeBehaviorValueChangeEvent, context: RuntimeBehaviorContext): MaybePromise<void>;
+    beforeSubmitRecords?(records: RuntimeBehaviorSubmissionRecords, context: RuntimeBehaviorContext): MaybePromise<void>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { ExplanationDefinition as SchemaExplanationDefinition, ExplanationFetchRequest, ExplanationStateSnapshot, NormalizedExplanationConfig as SchemaNormalizedExplanationConfig } from '../../schema';
+export type { BaseExplanationConfig, ExplanationConfig, ExplanationFetchContext, ExplanationFetchFactory, ExplanationFetchRequest, ExplanationFetchTransport, ExplanationStateSnapshot, ExplanationStatus, } from '../../schema';
+export interface ExplanationHandle {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: SchemaNormalizedExplanationConfig;
+    readonly state: ExplanationStateSnapshot;
+    fetch(request: ExplanationFetchRequest): Promise<void>;
+    abort(): void;
+    reset(): void;
+    subscribe(listener: (state: ExplanationStateSnapshot) => void): () => void;
+}
+export type ExplanationController = ExplanationHandle;
+export type ExplanationDefinition<TConfig extends import('../../schema').ExplanationConfig = import('../../schema').ExplanationConfig> = SchemaExplanationDefinition<TConfig>;
+export type NormalizedExplanationConfig<TConfig extends import('../../schema').ExplanationConfig = import('../../schema').ExplanationConfig> = SchemaNormalizedExplanationConfig<TConfig>;

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

@@ -0,0 +1,17 @@
+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;
+    readonly config: NormalizedFieldConfig;
+    readonly state: FieldStateSnapshot;
+    setValue(value: unknown): void;
+    blur(): void;
+    focus(): void;
+    validate(): Promise<FieldValidationResult>;
+    reset(): void;
+    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>;
+export type RuntimeFieldDefinition = FieldDefinition;

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

@@ -1,8 +1,9 @@
-import { FieldConfig, FieldController, FieldStateSnapshot, InactiveFieldPolicy, NormalizedFieldConfig, SelectorSubscriptionOptions } from './field';
-import { ExplanationConfig, ExplanationController, ExplanationStateSnapshot } from './explanation';
-import { NormalizedReportConfig, ReportConfig, ReportController, ReportStateSnapshot } from './report';
-import { AfterSubmitContext, BeforeSubmitContext, SubmitOptions, SubmitResult, Transport, TransportStreamEvent, SubmitErrorContext } from './transport';
-import { Registry } from './registry';
+import { ExplanationConfig, 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>;
 export type FormStatus = "idle" | "editing" | "validating" | "submitting" | "success" | "error";
 export interface FormValidationResult {
@@ -81,15 +82,11 @@ export interface FormHooks {
     afterExplanation?: (context: AfterExplanationContext) => MaybePromise<void>;
     onExplanationError?: (context: ExplanationErrorContext) => MaybePromise<void>;
 }
-export interface FormSchema {
-    fields: FieldConfig[];
-    reports?: ReportConfig[];
-    explanations?: ExplanationConfig[];
-}
 export interface CreateFormConfig {
     schema: FormSchema;
     registry: Registry;
     transport: Transport;
+    behaviors?: RuntimeBehavior[];
     initialValues?: Record<string, unknown>;
     validators?: FormValidator[];
     hooks?: FormHooks;
@@ -117,4 +114,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 { SubmitErrorContext } from './transport';
+export type { ExplanationConfig, FieldConfig, FormSchema, Registry, ReportConfig };

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

@@ -1,9 +1,8 @@
 export type MaybePromise<T> = T | PromiseLike<T>;
+export * from './behavior';
 export * from './explanation';
 export * from './field';
 export * from './form';
 export * from './pipeline';
-export * from './registry';
 export * from './report';
 export * from './transport';
-export * from '../declarative/presentation';

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

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

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

@@ -0,0 +1,13 @@
+import { NormalizedReportConfig as SchemaNormalizedReportConfig, ReportDefinition as SchemaReportDefinition, ReportStateSnapshot } from '../../schema';
+export type { BaseReportConfig, PartialReportUpdatePolicy, ReportConfig, ReportPayloadContext, ReportPayloadValidationPolicy, ReportResolveContext, ReportStateSnapshot, ReportStatus, } from '../../schema';
+export interface ReportHandle {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: SchemaNormalizedReportConfig;
+    readonly state: ReportStateSnapshot;
+    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/engine → runtime}/types/transport.d.ts

@@ -1,7 +1,7 @@
-import { SubmitRequest as BaseSubmitRequest, SubmitResult as BaseSubmitResult, Transport as BaseTransport, TransportStreamEvent as BaseTransportStreamEvent } from '../../../transport';
+import { SubmitRequest as BaseSubmitRequest, SubmitResult as BaseSubmitResult, Transport as BaseTransport, TransportStreamEvent as BaseTransportStreamEvent } from '../../transport';
 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>;

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

@@ -1,6 +1,6 @@
 import { MaybePromise } from './types';
-export declare const slugify: (value: string) => string;
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+import { isRecord, slugify } from '../shared';
+export { isRecord, slugify };
 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;

package/dist/types/{src/engine/validation/field.d.ts → runtime/validation/field-state.d.ts}

@@ -1,29 +1,13 @@
-import { EngineStore, InternalFieldState } from '../state';
-import { FieldDefinition, FieldValidationResult, FormStatus, NormalizedFieldConfig } from '../types';
+import { InternalFieldState } from '../state';
+import { FieldDefinition, FormStatus, NormalizedFieldConfig } from '../types';
 import { DerivedFieldFlags } from './conditions';
-export type FieldStateCommitter = (fieldId: string, nextState: InternalFieldState) => void;
-export type FieldValidator = {
-    abort(reason?: string): void;
-    validate(currentState: InternalFieldState, validationVersion?: number): Promise<FieldValidationResult>;
-};
 export declare const combineErrors: (state: Pick<InternalFieldState, "syncErrors" | "validationErrors" | "externalErrors">) => string[];
 export declare const toSnapshotState: (state: InternalFieldState) => InternalFieldState;
 export declare const toValidatingState: (state: InternalFieldState) => InternalFieldState;
 export declare const requiredErrors: (config: NormalizedFieldConfig, value: unknown) => string[];
-export declare const normalizeValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
 export declare const cloneFieldValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
+export declare const normalizeValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
 export declare const areFieldValuesEqual: (definition: FieldDefinition, config: NormalizedFieldConfig, previous: unknown, next: unknown) => boolean;
 export declare const runSyncValidation: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown, values: Record<string, unknown>, submitCount: number) => string[];
 export declare const computeSyncErrors: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown, values: Record<string, unknown>, submitCount: number, flags: DerivedFieldFlags) => string[];
 export declare const makeFieldState: (definition: FieldDefinition, config: NormalizedFieldConfig, initialValue: unknown, values: Record<string, unknown>, submitCount: number, formStatus: FormStatus) => InternalFieldState;
-type CreateFieldValidatorOptions = {
-    config: NormalizedFieldConfig;
-    definition: FieldDefinition;
-    store: EngineStore;
-    getValues: () => Record<string, unknown>;
-    getSubmitCount: () => number;
-    getFormStatus: () => FormStatus;
-    commitState: FieldStateCommitter;
-};
-export declare const createFieldValidator: ({ config, definition, store, getValues, getSubmitCount, getFormStatus, commitState, }: CreateFieldValidatorOptions) => FieldValidator;
-export {};

package/dist/types/runtime/validation/field-validator.d.ts

@@ -0,0 +1,18 @@
+import { EngineStore, InternalFieldState } from '../state';
+import { FieldDefinition, FieldValidationResult, FormStatus, NormalizedFieldConfig } from '../types';
+export type FieldStateCommitter = (fieldId: string, nextState: InternalFieldState) => void;
+export type FieldValidator = {
+    abort(reason?: string): void;
+    validate(currentState: InternalFieldState, validationVersion?: number): Promise<FieldValidationResult>;
+};
+type CreateFieldValidatorOptions = {
+    config: NormalizedFieldConfig;
+    definition: FieldDefinition;
+    store: EngineStore;
+    getValues: () => Record<string, unknown>;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormStatus;
+    commitState: FieldStateCommitter;
+};
+export declare const createFieldValidator: ({ config, definition, store, getValues, getSubmitCount, getFormStatus, commitState, }: CreateFieldValidatorOptions) => FieldValidator;
+export {};

package/dist/types/runtime/validation/field.d.ts

@@ -0,0 +1,2 @@
+export * from './field-state';
+export * from './field-validator';

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

@@ -0,0 +1,7 @@
+export * from './normalize';
+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';

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

@@ -0,0 +1,2 @@
+import { FormSchema, NormalizedFormSchema, Registry } from './index';
+export declare const normalizeSchema: (schema: FormSchema, registry: Registry) => NormalizedFormSchema;

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

@@ -0,0 +1,9 @@
+import { MLFormError } from '../shared';
+import { ExplanationConfig, ExplanationDefinition, FieldConfig, FieldDefinition, Registry, ReportConfig, ReportDefinition } from './index';
+export declare class RegistryError extends MLFormError {
+    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;
+export declare const defineExplanationDefinition: <TDefinition extends ExplanationDefinition<ExplanationConfig>>(definition: TDefinition) => TDefinition;

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

@@ -0,0 +1,43 @@
+import { ZodType } from 'zod';
+export type ExplanationStatus = "idle" | "loading" | "done" | "error";
+export interface BaseExplanationConfig {
+    id?: string;
+    kind: string;
+    label?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export type ExplanationConfig = BaseExplanationConfig;
+export type NormalizedExplanationConfig<TConfig extends ExplanationConfig = ExplanationConfig> = TConfig & {
+    id: string;
+};
+export interface ExplanationStateSnapshot {
+    status: ExplanationStatus;
+    result: unknown;
+    error: string | null;
+}
+export interface ExplanationFetchContext<TConfig extends ExplanationConfig = ExplanationConfig> {
+    config: NormalizedExplanationConfig<TConfig>;
+    explanationId: string;
+}
+export interface ExplanationFetchRequest {
+    explanationId: 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 ExplanationFetchTransport {
+    submit: (request: ExplanationFetchRequest) => Promise<unknown>;
+}
+export type ExplanationFetchFactory<TConfig extends ExplanationConfig = ExplanationConfig> = (context: ExplanationFetchContext<TConfig>) => ExplanationFetchTransport;
+export interface ExplanationDefinition<TConfig extends ExplanationConfig = ExplanationConfig> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    transport: (config: TConfig) => ExplanationFetchTransport;
+}

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

@@ -1,18 +1,14 @@
 import { ZodType } from 'zod';
-import { FormStatus } from './form';
-type MaybePromise<T> = T | PromiseLike<T>;
+export type MaybePromise<T> = T | PromiseLike<T>;
+export type FormStatus = "idle" | "editing" | "validating" | "submitting" | "success" | "error";
 export type FieldStatus = "idle" | "validating" | "valid" | "invalid";
 export type InactiveFieldPolicy = "include" | "omit" | "reset-on-hide";
-export interface FieldDescriptor {
-    component: string;
-    props: Record<string, unknown>;
-    meta?: Record<string, unknown>;
-}
 export interface BaseFieldConfig {
     id?: string;
     kind: string;
     label: string;
     description?: string;
+    showDescriptionInline?: boolean;
     required?: boolean;
     disabled?: boolean;
     hidden?: boolean;
@@ -108,12 +104,6 @@ export interface NotCondition {
 }
 export type DeclarativeFieldCondition = FieldValueCondition | FieldComparisonCondition | FormStatusCondition | SubmitCountCondition | AllConditions | AnyConditions | NotCondition;
 export type FieldCondition<TConfig extends FieldConfig = FieldConfig> = DeclarativeFieldCondition | ((context: FieldConditionContext<TConfig>) => boolean);
-export interface FieldDescriptorContext {
-    fieldId: string;
-    state: FieldStateSnapshot;
-}
-export type FieldWidget = "text" | "number" | "boolean" | "select" | "date" | "series";
-export type FieldRenderHints = Record<string, unknown>;
 export interface FieldValueAdapter<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
     default?: (config: TConfig) => TValue;
     normalize?: (value: unknown, config: TConfig) => TValue;
@@ -125,23 +115,6 @@ export interface FieldValidationFnContext<TConfig extends FieldConfig = FieldCon
     config: TConfig;
     value: TValue;
 }
-export interface FieldRenderSpecContext<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    config: TConfig;
-    fieldId: string;
-    state: FieldStateSnapshot;
-    value: TValue;
-}
-export interface FieldRenderSpec<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    widget: FieldWidget;
-    hints?: FieldRenderHints | ((context: FieldRenderSpecContext<TConfig, TValue>) => FieldRenderHints);
-}
-export interface DeclarativeFieldKind<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    kind: string;
-    schema: ZodType<TConfig>;
-    value?: FieldValueAdapter<TConfig, TValue>;
-    validate?: (context: FieldValidationFnContext<TConfig, TValue>) => MaybePromise<string[]>;
-    render: FieldRenderSpec<TConfig, TValue>;
-}
 export interface FieldDefinition<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
     kind: string;
     schema: ZodType<TConfig>;
@@ -151,23 +124,8 @@ export interface FieldDefinition<TConfig extends FieldConfig = FieldConfig, TVal
     isEqual?: (previous: TValue, next: TValue, config: TConfig) => boolean;
     serializeValue?: (value: TValue, config: TConfig) => unknown;
     validate?: (value: TValue, config: TConfig, context: FieldValidationContext<TConfig>) => MaybePromise<string[]>;
-    describe: (config: TConfig, context: FieldDescriptorContext) => FieldDescriptor;
-}
-export interface FieldController {
-    readonly id: string;
-    readonly kind: string;
-    readonly config: NormalizedFieldConfig;
-    readonly state: FieldStateSnapshot;
-    readonly descriptor: FieldDescriptor;
-    setValue(value: unknown): void;
-    blur(): void;
-    focus(): void;
-    validate(): Promise<FieldValidationResult>;
-    reset(): void;
-    subscribe(listener: (state: FieldStateSnapshot) => void): () => void;
 }
 export interface SelectorSubscriptionOptions<TSelected> {
     emitInitial?: boolean;
     equality?: (previous: TSelected, next: TSelected) => boolean;
 }
-export {};