mlform 0.1.7 → 0.1.9

package/dist/types/presentation/define-field-kind.d.ts

@@ -0,0 +1,18 @@
+import { FieldConfig, FieldDefinition, NormalizedFieldConfig } from '../schema';
+import { DeclarativeFieldKind, FieldDescriptor, FieldDescriptorContext, FieldPresenter } from './index';
+export type DefinedFieldKind<TConfig extends FieldConfig, TValue> = {
+    kind: string;
+    schema: import('zod').ZodType<TConfig>;
+    getDefaultValue?: (config: TConfig) => TValue;
+    normalizeValue?: (value: unknown, config: TConfig) => TValue;
+    cloneValue?: (value: TValue, config: TConfig) => TValue;
+    isEqual?: (previous: TValue, next: TValue, config: TConfig) => boolean;
+    serializeValue?: (value: TValue, config: TConfig) => unknown;
+    validate?: FieldDefinition<TConfig, TValue>["validate"];
+    describe?: (config: NormalizedFieldConfig<TConfig>, context: FieldDescriptorContext & {
+        value: TValue;
+    }) => FieldDescriptor;
+    definition: FieldDefinition<TConfig, TValue>;
+    presenter: FieldPresenter<TConfig, TValue>;
+};
+export declare const defineFieldKind: <TConfig extends FieldConfig, TValue>(kind: DeclarativeFieldKind<TConfig, TValue>) => DefinedFieldKind<TConfig, TValue>;

package/dist/types/presentation/define-report-kind.d.ts

@@ -0,0 +1,15 @@
+import { NormalizedReportConfig, ReportConfig, ReportDefinition } from '../schema';
+import { DeclarativeReportKind, ReportDescriptor, ReportDescriptorContext, ReportPresenter } from './index';
+export type DefinedReportKind<TConfig extends ReportConfig, _TPayload> = {
+    kind: string;
+    schema: import('zod').ZodType<TConfig>;
+    payloadSchema?: ReportDefinition<TConfig>["payloadSchema"];
+    payloadValidationPolicy?: ReportDefinition<TConfig>["payloadValidationPolicy"];
+    partialUpdatePolicy?: ReportDefinition<TConfig>["partialUpdatePolicy"];
+    clonePayload?: ReportDefinition<TConfig>["clonePayload"];
+    resolvePayload?: ReportDefinition<TConfig>["resolvePayload"];
+    describe?: (config: NormalizedReportConfig<TConfig>, context: ReportDescriptorContext) => ReportDescriptor | null;
+    definition: ReportDefinition<TConfig>;
+    presenter: ReportPresenter<TConfig>;
+};
+export declare const defineReportKind: <TConfig extends ReportConfig, TPayload>(kind: DeclarativeReportKind<TConfig, TPayload>) => DefinedReportKind<TConfig, TPayload>;

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

@@ -0,0 +1,10 @@
+export { defineExplanationKind, type DefinedExplanationKind } from './define-explanation-kind';
+export { defineFieldKind, type DefinedFieldKind } from './define-field-kind';
+export { defineReportKind, type DefinedReportKind } from './define-report-kind';
+export { registerDefinedExplanationKind, registerDefinedFieldKind, registerDefinedReportKind, } from './register-kind';
+export { createPresentationRegistry, PresentationRegistry } from './registry';
+export { toPresentationNodes } from './types/presentation';
+export type * from './types/explanation';
+export type * from './types/field';
+export type * from './types/presentation';
+export type * from './types/report';

package/dist/types/presentation/register-kind.d.ts

@@ -0,0 +1,6 @@
+import { Registry } from '../schema';
+import { DefinedExplanationKind, DefinedFieldKind, DefinedReportKind } from './index';
+import { PresentationRegistry } from './registry';
+export declare const registerDefinedFieldKind: <TConfig extends import('../schema').FieldConfig, TValue>(registry: Registry, presentationRegistry: PresentationRegistry, kind: DefinedFieldKind<TConfig, TValue>) => void;
+export declare const registerDefinedReportKind: <TConfig extends import('../schema').ReportConfig>(registry: Registry, presentationRegistry: PresentationRegistry, kind: DefinedReportKind<TConfig, unknown>) => void;
+export declare const registerDefinedExplanationKind: <TConfig extends import('../schema').ExplanationConfig>(registry: Registry, presentationRegistry: PresentationRegistry, kind: DefinedExplanationKind<TConfig, unknown>) => void;

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

@@ -0,0 +1,15 @@
+import { BaseExplanationConfig, BaseFieldConfig, BaseReportConfig } from '../schema';
+import { ExplanationPresenter, FieldPresenter, ReportPresenter } from './index';
+export declare class PresentationRegistry {
+    private readonly fieldPresenters;
+    private readonly reportPresenters;
+    private readonly explanationPresenters;
+    registerField<TConfig extends BaseFieldConfig, TValue>(presenter: FieldPresenter<TConfig, TValue>): this;
+    registerReport<TConfig extends BaseReportConfig>(presenter: ReportPresenter<TConfig>): this;
+    registerExplanation<TConfig extends BaseExplanationConfig>(presenter: ExplanationPresenter<TConfig>): this;
+    getField(kind: string): FieldPresenter<BaseFieldConfig, unknown> | undefined;
+    getReport(kind: string): ReportPresenter<BaseReportConfig> | undefined;
+    getExplanation(kind: string): ExplanationPresenter<BaseExplanationConfig> | undefined;
+    clone(): PresentationRegistry;
+}
+export declare const createPresentationRegistry: () => PresentationRegistry;

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

@@ -0,0 +1,32 @@
+import { ExplanationConfig, ExplanationFetchFactory, ExplanationStateSnapshot, NormalizedExplanationConfig } from '../../schema';
+import { ZodType } from 'zod';
+import { PresentationContent, PresentationSummary } from './presentation';
+export interface ExplanationDescriptor {
+    component: string;
+    props: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface ExplanationDescriptorContext {
+    explanationId: string;
+    state: ExplanationStateSnapshot;
+}
+export interface ExplanationRenderSpecContext<TConfig extends ExplanationConfig = ExplanationConfig, TResult = unknown> {
+    config: NormalizedExplanationConfig<TConfig>;
+    explanationId: string;
+    state: ExplanationStateSnapshot;
+    result: TResult;
+}
+export interface ExplanationRenderSpec<TConfig extends ExplanationConfig = ExplanationConfig, TResult = unknown> {
+    summary?: (context: ExplanationRenderSpecContext<TConfig, TResult>) => PresentationSummary | undefined;
+    content: (context: ExplanationRenderSpecContext<TConfig, TResult>) => PresentationContent;
+}
+export interface DeclarativeExplanationKind<TConfig extends ExplanationConfig = ExplanationConfig, TResult = unknown> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    fetch: ExplanationFetchFactory<TConfig>;
+    render: ExplanationRenderSpec<TConfig, TResult>;
+}
+export interface ExplanationPresenter<TConfig extends ExplanationConfig = ExplanationConfig> {
+    kind: string;
+    describe(config: NormalizedExplanationConfig<TConfig>, context: ExplanationDescriptorContext): ExplanationDescriptor | null;
+}

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

@@ -0,0 +1,36 @@
+import { FieldConfig, FieldStateSnapshot, FieldValidationFnContext, FieldValueAdapter, NormalizedFieldConfig } from '../../schema';
+import { ZodType } from 'zod';
+export interface FieldDescriptor {
+    component: string;
+    props: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export type FieldWidget = "text" | "number" | "boolean" | "select" | "date" | "series";
+export type FieldRenderHints = Record<string, unknown>;
+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>) => string[] | PromiseLike<string[]>;
+    render: FieldRenderSpec<TConfig, TValue>;
+}
+export interface FieldDescriptorContext {
+    fieldId: string;
+    state: FieldStateSnapshot;
+}
+export interface FieldPresenter<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    kind: string;
+    describe(config: NormalizedFieldConfig<TConfig>, context: FieldDescriptorContext & {
+        value: TValue;
+    }): FieldDescriptor;
+}

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

@@ -0,0 +1,41 @@
+import { NormalizedReportConfig, ReportConfig, ReportResolveContext, ReportStateSnapshot } from '../../schema';
+import { SubmitResult } from '../../runtime/types/transport';
+import { ZodType } from 'zod';
+import { PresentationContent, PresentationSummary } from './presentation';
+export interface ReportDescriptor {
+    component: string;
+    props: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface ReportDescriptorContext {
+    reportId: string;
+    state: ReportStateSnapshot;
+    payload: unknown;
+    result: SubmitResult | null;
+}
+export interface ReportRenderSpecContext<TConfig extends ReportConfig = ReportConfig, TPayload = unknown> {
+    config: NormalizedReportConfig<TConfig>;
+    report: NormalizedReportConfig<TConfig>;
+    reportId: string;
+    state: ReportStateSnapshot;
+    payload: TPayload;
+    result: SubmitResult | null;
+}
+export interface ReportRenderSpec<TConfig extends ReportConfig = ReportConfig, TPayload = unknown> {
+    summary?: (context: ReportRenderSpecContext<TConfig, TPayload>) => PresentationSummary | undefined;
+    content: (context: ReportRenderSpecContext<TConfig, TPayload>) => PresentationContent;
+}
+export interface DeclarativeReportKind<TConfig extends ReportConfig = ReportConfig, TPayload = unknown> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    payloadSchema?: ZodType<unknown>;
+    payloadValidationPolicy?: "report-error" | "fail-submit";
+    partialUpdatePolicy?: "trust" | "validate" | "defer";
+    clonePayload?: (payload: TPayload, config: TConfig) => TPayload;
+    resolve: (context: ReportResolveContext<TConfig>) => unknown;
+    render: ReportRenderSpec<TConfig, TPayload>;
+}
+export interface ReportPresenter<TConfig extends ReportConfig = ReportConfig> {
+    kind: string;
+    describe(config: NormalizedReportConfig<TConfig>, context: ReportDescriptorContext): ReportDescriptor | null;
+}

package/dist/types/{src/primitives → primitives}/base-explanation-element.d.ts

@@ -1,5 +1,6 @@
 import { LitElement, CSSResultGroup } from 'lit';
-import { ExplanationController, ExplanationDescriptor } from '../../engine';
+import { ExplanationDescriptor } from '../presentation';
+import { ExplanationController } from '../runtime';
 import { PrimitiveText } from './constants';
 import { PrimitiveExplanationRenderContext } from './types';
 /**

package/dist/types/{src/primitives → primitives}/base-field-element.d.ts

@@ -1,5 +1,6 @@
 import { LitElement, nothing, CSSResultGroup, TemplateResult } from 'lit';
-import { FieldController, FieldDescriptor } from '../../engine';
+import { FieldDescriptor } from '../presentation';
+import { FieldController } from '../runtime';
 import { PrimitiveText } from './constants';
 import { PrimitiveFieldRenderContext } from './types';
 export declare abstract class PrimitiveFieldElement extends LitElement {

package/dist/types/{src/primitives → primitives}/base-report-element.d.ts

@@ -1,5 +1,6 @@
 import { LitElement, CSSResultGroup } from 'lit';
-import { ReportController, ReportDescriptor } from '../../engine';
+import { ReportDescriptor } from '../presentation';
+import { ReportController } from '../runtime';
 import { PrimitiveText } from './constants';
 import { PrimitiveReportRenderContext, PrimitiveReportRequest, PrimitiveReportTransport } from './types';
 export declare abstract class PrimitiveReportElement extends LitElement {

package/dist/types/primitives/components/error-focus.d.ts

@@ -0,0 +1,4 @@
+import { FieldController } from '../../runtime';
+export declare const findFieldFrame: (root: ParentNode, fieldId: string) => HTMLElement | null;
+export declare const scrollFieldFrameIntoView: (frame: HTMLElement | null) => Promise<boolean>;
+export declare const findFirstInvalidField: (fields: readonly FieldController[]) => FieldController | null;

package/dist/types/{src/primitives → primitives}/components/explanation-panel.d.ts

@@ -1,5 +1,6 @@
 import { LitElement } from 'lit';
-import { ExplanationController, SubmitResult } from '../../../engine';
+import { ExplanationController, SubmitResult } from '../../runtime';
+import { ExplanationDescriptor } from '../../presentation';
 import { primitiveTagNames, PrimitiveText } from '../constants';
 import { PrimitiveRegistry } from '../types';
 export declare class PrimitiveExplanationPanelElement extends LitElement {
@@ -9,7 +10,8 @@ export declare class PrimitiveExplanationPanelElement extends LitElement {
     accessor registry: PrimitiveRegistry | undefined;
     accessor lastResult: SubmitResult | null;
     accessor text: PrimitiveText;
-    private accessor descriptor;
+    accessor descriptor: ExplanationDescriptor | null;
+    private accessor resolvedDescriptor;
     private accessor explanationState;
     protected willUpdate(changedProperties: Map<string, unknown>): void;
     disconnectedCallback(): void;

package/dist/types/primitives/components/field-frame-feedback.d.ts

@@ -0,0 +1,9 @@
+import { FieldStateSnapshot } from '../../runtime';
+import { PrimitiveText } from '../constants';
+export declare const resolveFieldFeedbackComponent: (component: string, props: Record<string, unknown>) => string;
+export declare const resolveCategorySelection: (props: Record<string, unknown>, value: unknown) => {
+    label: string;
+    value: string;
+} | null;
+export declare const hasIntroducedValue: (component: string, props: Record<string, unknown>, state: FieldStateSnapshot, defaultValue: unknown) => boolean;
+export declare const createFieldSuccessMessage: (component: string, props: Record<string, unknown>, state: FieldStateSnapshot, text: PrimitiveText) => string;

package/dist/types/primitives/components/field-frame-styles.d.ts

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

package/dist/types/{src/primitives → primitives}/components/field-frame.d.ts

@@ -1,16 +1,18 @@
 import { LitElement } from 'lit';
-import { FieldController } from '../../../engine';
+import { FieldController } from '../../runtime';
+import { FieldDescriptor } from '../../presentation';
 import { primitiveTagNames, PrimitiveText } from '../constants';
 import { PrimitiveRegistry } from '../types';
 export declare class PrimitiveFieldFrameElement extends LitElement {
     #private;
     static styles: import('lit').CSSResult;
     accessor controller: FieldController | undefined;
+    accessor descriptor: FieldDescriptor | null;
     accessor registry: PrimitiveRegistry | undefined;
     accessor text: PrimitiveText;
-    private accessor descriptor;
+    private accessor resolvedDescriptor;
     private accessor fieldState;
-    private accessor descriptionVisible;
+    private accessor descriptionVisibilityOverride;
     protected willUpdate(changedProperties: Map<string, unknown>): void;
     render(): import('lit').TemplateResult;
 }

package/dist/types/{src/primitives → primitives}/components/form-errors.d.ts

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

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

@@ -0,0 +1,17 @@
+import { FieldDescriptor, PresentationRegistry, ReportDescriptor } from '../../presentation';
+import { ExplanationController, FormController, ReportController } from '../../runtime';
+export type PresentedField = {
+    controller: NonNullable<ReturnType<FormController["getField"]>>;
+    descriptor: FieldDescriptor;
+};
+export type PresentedReport = {
+    controller: ReportController;
+    descriptor: ReportDescriptor | null;
+};
+export type PresentedExplanation = {
+    controller: ExplanationController;
+    descriptor: import('../../presentation').ExplanationDescriptor | null;
+};
+export declare const presentVisibleFields: (form: FormController, fieldIds: readonly string[], presentationRegistry: PresentationRegistry | undefined) => PresentedField[];
+export declare const presentVisibleReports: (form: FormController, reportIds: readonly string[], reportPane: "auto" | "always" | "hidden", presentationRegistry: PresentationRegistry | undefined) => PresentedReport[];
+export declare const presentExplanations: (form: FormController, explanationIds: readonly string[], presentationRegistry: PresentationRegistry | undefined) => PresentedExplanation[];

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

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

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

@@ -0,0 +1,19 @@
+import { FormController, FormStatus, ReportController } from '../../runtime';
+export type FormRenderState = {
+    status: FormStatus;
+    submitCount: number;
+    hasFormErrors: boolean;
+    hasLastResult: boolean;
+    submissionLoaded?: number;
+    submissionTotal?: number;
+    submissionMessage?: string;
+    submissionSessionMessageCount?: number;
+    visibleFieldIds: string[];
+    visibleReportIds: string[];
+    explanationIds: string[];
+    reportStateKeys: string[];
+    explanationStateKeys: string[];
+};
+export declare const sameFormRenderState: (left: FormRenderState, right: FormRenderState) => boolean;
+export declare const selectFormRenderState: (form: FormController) => FormRenderState;
+export declare const resolveVisibleReports: (form: FormController, visibleReportIds: string[], reportPane: "auto" | "always" | "hidden") => readonly ReportController[];

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

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

package/dist/types/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 → 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 → primitives}/components/presentation.d.ts

@@ -1,4 +1,4 @@
 import { nothing, TemplateResult } from 'lit';
-import { PresentationNode, PresentationSummary } from '../../../engine';
+import { PresentationNode, PresentationSummary } from '../../presentation';
 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 → 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 → 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 → 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/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/primitives/fields/series-field-renderers.d.ts

@@ -0,0 +1,18 @@
+import { PrimitiveText } from '../constants';
+import { PrimitiveFieldRenderContext } from '../types';
+import { SeriesSubFieldConfig } from './series-field-helpers';
+export type RenderSeriesCellOptions = {
+    config: SeriesSubFieldConfig;
+    value: unknown;
+    index: number;
+    id: string;
+    disabled: boolean;
+    readOnly: boolean;
+    field: 1 | 2;
+    context: PrimitiveFieldRenderContext | undefined;
+    text: PrimitiveText;
+    onInput: (index: number, field: 1 | 2, value: unknown) => void;
+    onBlur: () => void;
+    label: string;
+};
+export declare const renderSeriesCell: ({ config, value, index, id, disabled, readOnly, field, context, text, onInput, onBlur, label, }: RenderSeriesCellOptions) => import('lit').TemplateResult<1>;

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

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

package/dist/types/{src/primitives → 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/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 → 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/runtime/create-runtime-helpers.d.ts

@@ -0,0 +1,11 @@
+import { EngineError } from './errors';
+import { InternalFieldState } from './state';
+import { CreateFormConfig, InactiveFieldPolicy } from './types';
+export declare const assertTransport: (transport: CreateFormConfig["transport"]) => void;
+export declare const hasInteractiveFieldState: (fieldStates: Record<string, InternalFieldState>) => boolean;
+export declare const resolveInactiveFieldPolicy: (field: {
+    readonly config: {
+        readonly inactiveFieldPolicy?: InactiveFieldPolicy;
+    };
+}, fallbackPolicy: InactiveFieldPolicy | undefined) => InactiveFieldPolicy;
+export declare const missingDefinitionError: (type: string, kind: string) => EngineError;

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

@@ -1,4 +1,4 @@
-import { MLFormError } from '../../shared';
+import { MLFormError } from '../shared';
 import { FormValidationResult } from './types';
 export declare class EngineError extends MLFormError {
     constructor(message: string);
@@ -24,5 +24,5 @@ export declare class SubmissionAbortedError extends SubmitError {
 }
 export declare const createAbortError: (reason?: string) => SubmissionAbortedError;
 export declare const isAbortLikeError: (error: unknown) => boolean;
-export { TransportError, transportErrorCodes } from '../../transport';
-export type { TransportErrorCode } from '../../transport';
+export { TransportError, transportErrorCodes } from '../transport';
+export type { TransportErrorCode } from '../transport';

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

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

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

@@ -0,0 +1,12 @@
+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 { 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 FieldHandle = import('./types').FieldController;
+export type ReportHandle = import('./types').ReportController;
+export type ExplanationHandle = import('./types').ExplanationController;
+export type FormRuntime = import('./types').FormController;