mlform 0.1.6 → 0.1.8

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

@@ -0,0 +1,42 @@
+import { nothing, TemplateResult } from 'lit';
+import { PresentationRegistry } from '../../../presentation';
+import { FormController } from '../../../runtime';
+import { PrimitiveText } from '../constants';
+import { PrimitiveRegistry, PrimitiveReportTransport } from '../types';
+import { FormRenderState } from './form-root-state';
+import { PresentedField, PresentedReport } from './form-root-presenters';
+export declare const renderExplanations: (form: FormController, state: FormRenderState, registry: PrimitiveRegistry | undefined, presentationRegistry: PresentationRegistry | undefined, text: PrimitiveText) => TemplateResult | typeof nothing;
+export declare const renderStackedLayout: (options: {
+    form: FormController;
+    state: FormRenderState;
+    visibleFields: readonly PresentedField[];
+    reportsToRender: readonly PresentedReport[];
+    showReports: boolean;
+    registry: PrimitiveRegistry | undefined;
+    presentationRegistry: PresentationRegistry | undefined;
+    text: PrimitiveText;
+    formLabel: string;
+    reportsLabel: string;
+    submitLabel: string;
+    validatingLabel: string;
+    submittingLabel: string;
+    reportTransport: PrimitiveReportTransport | undefined;
+    onSubmitRequest: () => Promise<void>;
+}) => TemplateResult;
+export declare const renderSplitLayout: (options: {
+    form: FormController;
+    state: FormRenderState;
+    visibleFields: readonly PresentedField[];
+    reportsToRender: readonly PresentedReport[];
+    showReports: boolean;
+    registry: PrimitiveRegistry | undefined;
+    presentationRegistry: PresentationRegistry | undefined;
+    text: PrimitiveText;
+    formLabel: string;
+    reportsLabel: string;
+    submitLabel: string;
+    validatingLabel: string;
+    submittingLabel: string;
+    reportTransport: PrimitiveReportTransport | undefined;
+    onSubmitRequest: () => Promise<void>;
+}) => TemplateResult;

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

@@ -1,5 +1,6 @@
 import { LitElement } from 'lit';
-import { FormController } from '../../../engine';
+import { PresentationRegistry } from '../../../presentation';
+import { FormController } from '../../../runtime';
 import { primitiveTagNames, PrimitiveText } from '../constants';
 import { PrimitiveLayout, PrimitiveRegistry, PrimitiveReportTransport } from '../types';
 export declare class PrimitiveFormElement extends LitElement {
@@ -7,6 +8,7 @@ export declare class PrimitiveFormElement extends LitElement {
     static styles: import('lit').CSSResult;
     accessor form: FormController | undefined;
     accessor registry: PrimitiveRegistry | undefined;
+    accessor presentationRegistry: PresentationRegistry | undefined;
     accessor layout: PrimitiveLayout;
     accessor formLabel: string;
     accessor reportsLabel: string;
@@ -20,7 +22,7 @@ export declare class PrimitiveFormElement extends LitElement {
     protected willUpdate(changedProperties: Map<string, unknown>): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    render(): import('lit').TemplateResult<1>;
+    render(): import('lit').TemplateResult;
 }
 declare global {
     interface HTMLElementTagNameMap {

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

@@ -1,4 +1,4 @@
 import { nothing, TemplateResult } from 'lit';
-import { PresentationNode, PresentationSummary } from '../../../engine';
+import { PresentationNode, PresentationSummary } from '../../../runtime';
 export declare const renderPresentationSummary: (summary: PresentationSummary | null | undefined, fallbackTitle?: string) => TemplateResult | typeof nothing;
 export declare const renderPresentationNodes: (nodes: PresentationNode[]) => TemplateResult | typeof nothing;

package/dist/types/src/primitives/components/report-frame.d.ts

@@ -1,5 +1,6 @@
 import { LitElement } from 'lit';
-import { ReportController, SubmitResult } from '../../../engine';
+import { ReportController, SubmitResult } from '../../../runtime';
+import { ReportDescriptor } from '../../../presentation';
 import { primitiveTagNames, PrimitiveText } from '../constants';
 import { PrimitiveReportTransport, PrimitiveRegistry } from '../types';
 export declare class PrimitiveReportFrameElement extends LitElement {
@@ -10,7 +11,8 @@ export declare class PrimitiveReportFrameElement extends LitElement {
     accessor text: PrimitiveText;
     accessor transport: PrimitiveReportTransport | undefined;
     accessor lastResult: SubmitResult | null;
-    private accessor descriptor;
+    accessor descriptor: ReportDescriptor | null;
+    private accessor resolvedDescriptor;
     private accessor reportState;
     protected willUpdate(changedProperties: Map<string, unknown>): void;
     render(): import('lit').TemplateResult;

package/dist/types/src/primitives/components/submit-button.d.ts

@@ -1,5 +1,5 @@
 import { LitElement } from 'lit';
-import { FormStatus } from '../../../engine';
+import { FormStatus } from '../../../runtime';
 import { primitiveTagNames } from '../constants';
 export declare class PrimitiveSubmitButtonElement extends LitElement {
     #private;

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

@@ -1,4 +1,4 @@
-import { FormStatus, ReportStatus } from '../../engine';
+import { FormStatus, ReportStatus } from '../../runtime';
 export declare const primitiveTagNames: {
     readonly form: "mlf-form";
     readonly formErrors: "mlf-form-errors";

package/dist/types/src/primitives/fields/series-field-helpers.d.ts

@@ -0,0 +1,23 @@
+export type SeriesSubFieldConfig = {
+    kind?: unknown;
+    label?: unknown;
+    required?: unknown;
+    options?: unknown;
+    min?: unknown;
+    max?: unknown;
+    step?: unknown;
+    unit?: unknown;
+    placeholder?: unknown;
+    trueLabel?: unknown;
+    falseLabel?: unknown;
+};
+export type DraftRow = {
+    key: string;
+    field1: unknown;
+    field2: unknown;
+};
+export declare const createRowKey: () => string;
+export declare const normalizeCellValue: (config: SeriesSubFieldConfig, value: unknown) => unknown;
+export declare const normalizeRows: (value: unknown, field1Config: SeriesSubFieldConfig, field2Config: SeriesSubFieldConfig) => DraftRow[];
+export declare const commitSeriesCellValue: (config: SeriesSubFieldConfig, value: unknown) => unknown;
+export declare const seriesNumberUnit: (config: SeriesSubFieldConfig) => string;

package/dist/types/src/primitives/fields/series-field-styles.d.ts

@@ -0,0 +1 @@
+export declare const seriesFieldStyles: import('lit').CSSResult;

package/dist/types/src/primitives/mount-form.d.ts

@@ -1,4 +1,4 @@
-import { FormController } from '../../engine';
+import { FormController } from '../../runtime';
 import { MountFormOptions, MountedForm } from './types';
 export declare const mountForm: (container: HTMLElement, form: FormController, options?: MountFormOptions) => MountedForm;
 export declare const unmountForm: (mounted: MountedForm) => void;

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

@@ -0,0 +1,8 @@
+import { ExplanationDescriptor, FieldDescriptor, PresentationRegistry, ReportDescriptor } from '../../presentation';
+import { ExplanationController, FieldController, FormController, ReportController } from '../../runtime';
+export declare const fallbackFieldDescriptor: (field: FieldController) => FieldDescriptor;
+export declare const fallbackReportDescriptor: (report: ReportController) => ReportDescriptor;
+export declare const fallbackExplanationDescriptor: (explanation: ExplanationController) => ExplanationDescriptor;
+export declare const resolveFieldDescriptor: (field: FieldController, presentationRegistry: PresentationRegistry | undefined) => FieldDescriptor;
+export declare const resolveReportDescriptor: (report: ReportController, form: FormController, presentationRegistry: PresentationRegistry | undefined) => ReportDescriptor | null;
+export declare const resolveExplanationDescriptor: (explanation: ExplanationController, presentationRegistry: PresentationRegistry | undefined) => ExplanationDescriptor | null;

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

@@ -1,5 +1,6 @@
-import { ExplanationController, ExplanationDescriptor, ExplanationFetchRequest, ExplanationFetchTransport, FieldController, FieldDescriptor, FormController, FormState, FormStatus, ReportController, ReportDescriptor, SubmitResult } from '../../engine';
+import { ExplanationController, ExplanationFetchRequest, ExplanationFetchTransport, FieldController, FormController, FormState, FormStatus, ReportController, SubmitResult } from '../../runtime';
 import { PrimitiveText, PrimitiveTextOverrides } from './constants';
+import { ExplanationDescriptor, FieldDescriptor, PresentationRegistry, ReportDescriptor } from '../../presentation';
 export type PrimitiveLayout = "stacked" | "split";
 export type PrimitiveContainerStrategy = "error" | "replace";
 export interface PrimitiveRegistry {
@@ -48,6 +49,7 @@ export type ExplanationRequest = ExplanationFetchRequest;
 export type ExplanationTransport = ExplanationFetchTransport;
 export interface MountFormOptions {
     registry?: PrimitiveRegistry;
+    presentationRegistry?: PresentationRegistry;
     layout?: PrimitiveLayout;
     containerStrategy?: PrimitiveContainerStrategy;
     formLabel?: string;
@@ -64,6 +66,7 @@ export interface MountedForm {
     readonly form: FormController;
     readonly host: HTMLElement;
     readonly registry: PrimitiveRegistry;
+    readonly presentationRegistry: PresentationRegistry;
     readonly text: PrimitiveText;
     unmount(): void;
 }

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

@@ -1,4 +1,3 @@
-import { Registry } from '../types';
 import { booleanFieldDefinition } from './fields/boolean';
 import { categoryFieldDefinition } from './fields/category';
 import { mappedCategoryFieldDefinition } from './fields/mapped-category';
@@ -96,10 +95,9 @@ export declare const builtinFieldDefinitions: readonly [import('..').FieldDefini
 export declare const builtinReportDefinitions: readonly [import('..').ReportDefinition<import('..').BaseReportConfig & {
     kind: "classifier";
     labels?: string[];
-    details?: boolean;
+    showClassProbabilities?: boolean;
 }>, import('..').ReportDefinition<import('..').BaseReportConfig & {
     kind: "regressor";
     unit?: string;
     precision?: number;
 }>];
-export declare const createBuiltinRegistry: () => Registry;

package/dist/types/src/{engine → runtime}/builtins/reports/classifier.d.ts

@@ -2,7 +2,7 @@ import { BaseReportConfig, ReportDefinition } from '../../types';
 type ClassifierReportConfig = BaseReportConfig & {
     kind: "classifier";
     labels?: string[];
-    details?: boolean;
+    showClassProbabilities?: boolean;
 };
 export declare const classifierReportDefinition: ReportDefinition<ClassifierReportConfig>;
 export {};

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

@@ -5,6 +5,7 @@ export declare const baseFieldShape: {
     id: z.ZodOptional<z.ZodString>;
     label: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
+    showDescriptionInline: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     disabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     hidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -42,6 +43,7 @@ export declare const makeFieldDescriptor: (component: string, config: Normalized
         kind: string;
         label: string;
         description: string;
+        showDescriptionInline: boolean;
         required: boolean;
         disabled: boolean;
     };

package/dist/types/src/runtime/declarative/presentation.d.ts

@@ -0,0 +1,61 @@
+export type PresentationTone = "neutral" | "info" | "success" | "warning" | "danger";
+export interface PresentationSummary {
+    title?: string;
+    description?: string;
+    value?: unknown;
+    badge?: string;
+    tone?: PresentationTone;
+}
+export interface PresentationTextNode {
+    type: "text";
+    label?: string;
+    value: unknown;
+    tone?: PresentationTone;
+}
+export interface PresentationMetricNode {
+    type: "metric";
+    label: string;
+    value: unknown;
+    hint?: string;
+    tone?: PresentationTone;
+}
+export interface PresentationKeyValueEntry {
+    label: string;
+    value: unknown;
+}
+export interface PresentationKeyValueNode {
+    type: "kv";
+    label?: string;
+    entries: PresentationKeyValueEntry[] | Record<string, unknown>;
+}
+export interface PresentationListNode {
+    type: "list";
+    label?: string;
+    items: unknown[];
+    ordered?: boolean;
+}
+export interface PresentationTableNode {
+    type: "table";
+    label?: string;
+    columns: string[];
+    rows: Array<Record<string, unknown> | unknown[]>;
+}
+export interface PresentationBadgeNode {
+    type: "badge";
+    label: string;
+    tone?: PresentationTone;
+}
+export interface PresentationNoticeNode {
+    type: "notice";
+    title?: string;
+    body: unknown;
+    tone?: PresentationTone;
+}
+export interface PresentationJsonNode {
+    type: "json";
+    label?: string;
+    value: unknown;
+}
+export type PresentationNode = PresentationTextNode | PresentationMetricNode | PresentationKeyValueNode | PresentationListNode | PresentationTableNode | PresentationBadgeNode | PresentationNoticeNode | PresentationJsonNode;
+export type PresentationContent = PresentationNode | PresentationNode[];
+export declare const toPresentationNodes: (value: PresentationContent | undefined) => PresentationNode[];

package/dist/types/src/runtime/fields/state-calculations.d.ts

@@ -0,0 +1,25 @@
+import { InternalFieldState } from '../state';
+import { FieldDefinition, FormStatus, InactiveFieldPolicy, NormalizedFieldConfig } from '../types';
+export declare const prepareFieldState: ({ config, definition, value, values, currentState, getSubmitCount, getFormStatus, }: {
+    config: NormalizedFieldConfig;
+    definition: FieldDefinition;
+    value: unknown;
+    values: Record<string, unknown>;
+    currentState: InternalFieldState;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormStatus;
+}) => InternalFieldState;
+export declare const refreshFieldState: ({ config, definition, currentState, values, getSubmitCount, getFormStatus, options, }: {
+    config: NormalizedFieldConfig;
+    definition: FieldDefinition;
+    currentState: InternalFieldState;
+    values: Record<string, unknown>;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormStatus;
+    options?: {
+        preserveValidationErrors?: boolean;
+        preserveExternalErrors?: boolean;
+        resetInactiveToInitial?: boolean;
+        inactiveFieldPolicy?: InactiveFieldPolicy;
+    };
+}) => InternalFieldState;

package/dist/types/src/runtime/fields/state.d.ts

@@ -0,0 +1,2 @@
+import { EngineStore, InternalFieldState } from '../state';
+export declare const setFieldState: (store: EngineStore, fieldId: string, nextState: InternalFieldState) => void;

package/dist/types/src/runtime/form.d.ts

@@ -0,0 +1 @@
+export { createForm } from './create-runtime';

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

@@ -0,0 +1,16 @@
+export { booleanFieldDefinition, categoryFieldDefinition, classifierReportDefinition, dateFieldDefinition, mappedCategoryFieldDefinition, longTextFieldDefinition, multiChoiceFieldDefinition, numberFieldDefinition, ratingFieldDefinition, regressorReportDefinition, seriesFieldDefinition, singleChoiceFieldDefinition, textFieldDefinition, } from './builtins';
+export { createExplanationController } from './explanations';
+export { executeExplanations, executeFormPipeline } from './submission';
+export { EngineError, ReportPayloadError, RegistryError, SubmissionAbortedError, SubmitError, TransportError, transportErrorCodes, ValidationError, } from './errors';
+export type { TransportErrorCode } from './errors';
+export { createForm, createForm as createFormRuntime } from './form';
+export { createRegistry, defineExplanationDefinition, defineFieldDefinition, defineReportDefinition, } from './registry';
+export { defineExplanationKind, defineFieldKind, defineReportKind } from '../../presentation';
+export { defaultEquality, shallowArrayEquality, shallowEquality, shallowObjectEquality, } from './equality';
+export { identity, isPromiseLike } from './utils';
+export type { AfterExplanationContext, AllConditions, AfterSubmitContext, AfterValidateContext, AnyConditions, BaseExplanationConfig, BaseFieldConfig, BaseReportConfig, BeforeSubmitContext, BeforeValidateContext, ExplanationFetchContext, ExplanationFetchFactory, CreateFormConfig, DeclarativeFieldCondition, ExplanationConfig, ExplanationController, ExplanationDefinition, ExplanationErrorContext, ExplanationExecutionContext, ExplanationExecutionResult, ExplanationFetchRequest, ExplanationFetchTransport, ExplanationStateSnapshot, ExplanationStatus, FieldValidationFnContext, FieldValueAdapter, FieldConfig, FieldComparisonCondition, FieldCondition, FieldConditionContext, FieldController, FieldDefinition, FieldStateSnapshot, FieldStatus, FieldValueCondition, FieldValidationContext, FieldValidationResult, FormController, FormHooks, FormSchema, FormState, FormStatusCondition, FormStatus, FormValidator, FormValidationContext, FormValidationIssue, FormValidationResult, InactiveFieldPolicy, MaybePromise, NormalizedExplanationConfig, NormalizedFieldConfig, NormalizedReportConfig, Registry, ReportConfig, ReportController, ReportDefinition, ReportResolveContext, ReportStateSnapshot, ReportStatus, PipelineArtifactAdapter, PipelineArtifactContext, PipelineResult, ExecuteFormPipelineOptions, SelectorSubscriptionOptions, SubmitCountCondition, SubmitErrorContext, SubmitOptions, SubmitRequest, SubmitRequestTransportContext, SubmitResult, Transport, TransportAuthKind, TransportBackpressureMode, TransportCapabilities, TransportConsistency, TransportDeliveryMode, TransportPolicyContext, TransportSession, TransportSessionEvent, TransportSessionMessage, TransportStreamEvent, TransportResponse, NotCondition, RuntimeBehavior, RuntimeBehaviorContext, RuntimeBehaviorSubmissionRecords, RuntimeBehaviorValueChangeEvent, } from './types';
+export type { DeclarativeExplanationKind, DeclarativeFieldKind, DeclarativeReportKind, ExplanationDescriptor, ExplanationDescriptorContext, ExplanationRenderSpec, ExplanationRenderSpecContext, FieldDescriptor, FieldRenderHints, FieldRenderSpec, FieldRenderSpecContext, FieldWidget, PresentationContent, PresentationNode, PresentationSummary, PresentationTone, ReportDescriptor, ReportRenderSpec, ReportRenderSpecContext, } from '../../presentation';
+export type FieldHandle = import('./types').FieldController;
+export type ReportHandle = import('./types').ReportController;
+export type ExplanationHandle = import('./types').ExplanationController;
+export type FormRuntime = import('./types').FormController;

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

@@ -0,0 +1,5 @@
+import { ExplanationDefinition, FieldDefinition, Registry, ReportDefinition } from '../types';
+export declare const createRegistry: () => Registry;
+export declare const defineFieldDefinition: <TConfig extends import('../../../schema').FieldConfig, TValue>(definition: FieldDefinition<TConfig, TValue>) => FieldDefinition<TConfig, TValue>;
+export declare const defineReportDefinition: <TConfig extends import('../../../schema').ReportConfig>(definition: ReportDefinition<TConfig>) => ReportDefinition<TConfig>;
+export declare const defineExplanationDefinition: <TConfig extends import('../../../schema').ExplanationConfig>(definition: ExplanationDefinition<TConfig>) => ExplanationDefinition<TConfig>;

package/dist/types/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/runtime/submission/submitter.d.ts

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

package/dist/types/src/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/src/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/src/runtime/types/explanation.d.ts

@@ -0,0 +1,22 @@
+import { ExplanationDefinition as SchemaExplanationDefinition, ExplanationFetchRequest, ExplanationStateSnapshot, NormalizedExplanationConfig as SchemaNormalizedExplanationConfig } from '../../../schema';
+import { ExplanationDescriptor } from '../../../presentation';
+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> & {
+    describe?: (config: SchemaNormalizedExplanationConfig<TConfig>, context: {
+        explanationId: string;
+        state: ExplanationStateSnapshot;
+    }) => ExplanationDescriptor | null;
+    [key: string]: unknown;
+};
+export type NormalizedExplanationConfig<TConfig extends import('../../../schema').ExplanationConfig = import('../../../schema').ExplanationConfig> = SchemaNormalizedExplanationConfig<TConfig>;