mlform 0.1.7 → 0.1.8

package/dist/types/src/kit/view-types.d.ts

@@ -0,0 +1,172 @@
+import { DesignSystemConfig, DesignSystemRegistry, ResolvedDesignSystem, AttachedDesignSystem } from '../../design-system';
+import { PresentationRegistry } from '../../presentation';
+import { ExplanationController, ExplanationDescriptor, ExplanationStateSnapshot, FieldController, FieldDescriptor, FieldStateSnapshot, FormController, FormState, FormValidationResult, Registry, ReportController, ReportDescriptor, ReportStateSnapshot, SubmitOptions, SubmitResult } from '../../runtime';
+import { PrimitiveRegistry, PrimitiveTextOverrides } from '../../primitives';
+import { LayoutReferences } from './layout-utils';
+import { FormLayoutConfig, ResolvedFormLayout, ResolvedFormLayoutNode } from './layout-types';
+import { MountFormOptions, KitLabels } from './mount-types';
+import { PanelState } from './panel-nav';
+import { WizardLabels, WizardTextOverrides } from './wizard-constants';
+export interface WizardState {
+    stepIndex: number;
+    stepCount: number;
+    currentStepId: string;
+    canNext: boolean;
+    canPrev: boolean;
+    isLastStep: boolean;
+}
+export interface TabsState {
+    activeTabIndex: number;
+    tabCount: number;
+    currentTabId: string;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+}
+export interface AccordionState {
+    openSectionIds: string[];
+    sectionCount: number;
+}
+export interface FormViewFieldItem {
+    id: string;
+    kind: string;
+    config: FieldController["config"];
+    controller: FieldController;
+    state: FieldStateSnapshot;
+    descriptor: FieldDescriptor;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewReportItem {
+    id: string;
+    kind: string;
+    config: ReportController["config"];
+    controller: ReportController;
+    state: ReportStateSnapshot;
+    descriptor: ReportDescriptor | null;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewExplanationItem {
+    id: string;
+    kind: string;
+    config: ExplanationController["config"];
+    controller: ExplanationController;
+    state: ExplanationStateSnapshot;
+    descriptor: ExplanationDescriptor | null;
+    stepId: string | null;
+    tabId: string | null;
+    visibleInLayout: boolean;
+}
+export interface FormViewState {
+    form: FormState;
+    wizard: WizardState | null;
+    tabs: TabsState | null;
+    accordion: AccordionState | null;
+}
+export interface FormViewSnapshot {
+    form: FormState;
+    layout: ResolvedFormLayout;
+    fields: FormViewFieldItem[];
+    reports: FormViewReportItem[];
+    explanations: FormViewExplanationItem[];
+    wizard: WizardState | null;
+    tabs: TabsState | null;
+    accordion: AccordionState | null;
+}
+export interface CreateFormViewOptions extends Omit<MountFormOptions, "layout"> {
+    layout?: FormLayoutConfig;
+}
+export interface FormViewController {
+    readonly form: FormController;
+    readonly engineRegistry: Registry;
+    readonly presentationRegistry: PresentationRegistry;
+    readonly primitiveRegistry: PrimitiveRegistry;
+    readonly designSystemRegistry: DesignSystemRegistry;
+    readonly state: FormViewState;
+    getSnapshot(): FormViewSnapshot;
+    getNodeById(id: string): ResolvedFormLayoutNode | undefined;
+    getField(id: string): FormViewFieldItem | undefined;
+    getReport(id: string): FormViewReportItem | undefined;
+    getExplanation(id: string): FormViewExplanationItem | undefined;
+    getVisibleFields(): FormViewFieldItem[];
+    getVisibleReports(): FormViewReportItem[];
+    getVisibleExplanations(): FormViewExplanationItem[];
+    getActiveLayoutNodes(): ResolvedFormLayoutNode[];
+    getLayoutReferences(): LayoutReferences;
+    validate(): Promise<FormValidationResult>;
+    submit(options?: SubmitOptions): Promise<SubmitResult>;
+    reset(): void;
+    subscribe(listener: (snapshot: FormViewSnapshot) => void): () => void;
+    nextStep(): Promise<boolean>;
+    prevStep(): void;
+    goToStep(stepId: string): Promise<boolean>;
+    setActiveTab(tabId: string): void;
+    nextTab(): boolean;
+    prevTab(): boolean;
+    toggleSection(sectionId: string): void;
+    openSection(sectionId: string): void;
+    closeSection(sectionId: string): void;
+    openAllSections(): void;
+    closeAllSections(): void;
+}
+export interface WizardMountUiOptions {
+    labels?: WizardLabels;
+    text?: WizardTextOverrides;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountWizardFormOptions = ({
+    view: FormViewController;
+} & WizardMountUiOptions) | (CreateFormViewOptions & WizardMountUiOptions & {
+    layout: import('./layout-types').WizardLayoutConfig;
+});
+export interface MountedWizardForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export interface TabsMountUiOptions {
+    labels?: KitLabels;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountTabsFormOptions = ({
+    view: FormViewController;
+} & TabsMountUiOptions) | (CreateFormViewOptions & TabsMountUiOptions & {
+    layout: import('./layout-types').TabsLayoutConfig;
+});
+export interface MountedTabsForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export interface AccordionMountUiOptions {
+    labels?: KitLabels;
+    primitiveText?: PrimitiveTextOverrides;
+    designSystem?: DesignSystemConfig;
+    designSystemRegistry?: DesignSystemRegistry;
+    onDesignSystemChange?: (resolved: ResolvedDesignSystem) => void;
+}
+export type MountAccordionFormOptions = ({
+    view: FormViewController;
+} & AccordionMountUiOptions) | (CreateFormViewOptions & AccordionMountUiOptions & {
+    layout: import('./layout-types').AccordionLayoutConfig;
+});
+export interface MountedAccordionForm {
+    readonly view: FormViewController;
+    readonly form: FormController;
+    readonly host: HTMLElement;
+    readonly designSystem: AttachedDesignSystem;
+    unmount(): void;
+}
+export type { LayoutReferences, PanelState };

package/dist/types/src/kit/view.d.ts

@@ -0,0 +1,8 @@
+import { PresentationRegistry } from '../../presentation';
+import { CreateFormViewOptions, FormViewController } from './types';
+type InternalCreateFormViewOptions = CreateFormViewOptions & {
+    presentationRegistry?: PresentationRegistry;
+    behaviors?: import('../../runtime').RuntimeBehavior[];
+};
+export declare const createFormView: (options: InternalCreateFormViewOptions) => FormViewController;
+export {};

package/dist/types/src/kit/wizard-constants.d.ts

@@ -0,0 +1,19 @@
+export interface WizardLabels {
+    prev?: string;
+    next?: string;
+    submit?: string;
+    validating?: string;
+    submitting?: string;
+}
+export interface WizardText {
+    stepLabel: (current: number, total: number) => string;
+    prevLabel: string;
+    nextLabel: string;
+    submitLabel: string;
+    validatingLabel: string;
+    submittingLabel: string;
+}
+export type WizardTextOverrides = Partial<WizardText>;
+export declare const defaultWizardLabels: Required<WizardLabels>;
+export declare const wizardStaticText: WizardText;
+export declare const resolveWizardText: (overrides?: WizardTextOverrides) => WizardText;

package/dist/types/src/kit/wizard-root-styles.d.ts

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

package/dist/types/src/kit/wizard-root.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+import { PrimitiveText } from '../../primitives/constants';
+import { PrimitiveRegistry } from '../../primitives/types';
+import { kitTagNames } from './constants';
+import { FormViewController } from './types';
+export declare class KitWizardElement extends LitElement {
+    #private;
+    static styles: import('lit').CSSResult;
+    accessor view: FormViewController | undefined;
+    accessor registry: PrimitiveRegistry | undefined;
+    accessor primitiveText: PrimitiveText;
+    accessor labels: Required<import('./wizard-constants').WizardLabels>;
+    accessor text: import('./wizard-constants').WizardText;
+    private accessor snapshot;
+    protected willUpdate(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [kitTagNames.wizard]: KitWizardElement;
+    }
+}

package/dist/types/src/kit/wizard.d.ts

@@ -0,0 +1,2 @@
+import { MountWizardFormOptions, MountedWizardForm } from './types';
+export declare const mountWizardForm: (container: HTMLElement, options: MountWizardFormOptions) => MountedWizardForm;

package/dist/types/src/packs/default.d.ts

@@ -0,0 +1,2 @@
+import { RegistryPack } from './shared';
+export declare const createDefaultRegistryPack: () => RegistryPack;

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

@@ -0,0 +1,3 @@
+export { createDefaultRegistryPack } from './default';
+export { createMlRegistryPack } from './ml';
+export type { RegistryPack } from './shared';

package/dist/types/src/packs/ml.d.ts

@@ -0,0 +1,2 @@
+import { RegistryPack } from './shared';
+export declare const createMlRegistryPack: () => RegistryPack;

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

@@ -0,0 +1,25 @@
+import { ExplanationPresenter, FieldPresenter, PresentationRegistry, ReportPresenter } from '../../presentation';
+import { RuntimeBehavior } from '../../runtime';
+import { ExplanationConfig, FieldConfig, Registry, ReportConfig } from '../../schema';
+type DescriptorCapableFieldDefinition = {
+    kind: string;
+    describe?: FieldPresenter<FieldConfig, unknown>["describe"];
+};
+type DescriptorCapableReportDefinition = {
+    kind: string;
+    describe?: ReportPresenter<ReportConfig>["describe"];
+};
+type DescriptorCapableExplanationDefinition = {
+    kind: string;
+    describe?: ExplanationPresenter<ExplanationConfig>["describe"];
+};
+export type RegistryPack = {
+    registry: Registry;
+    presentationRegistry: PresentationRegistry;
+    behaviors: RuntimeBehavior[];
+};
+export declare const registerFieldPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableFieldDefinition) => void;
+export declare const registerReportPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableReportDefinition) => void;
+export declare const registerExplanationPresenterFromDefinition: (presentationRegistry: PresentationRegistry, definition: DescriptorCapableExplanationDefinition) => void;
+export declare const registerPresentersFromRegistry: (presentationRegistry: PresentationRegistry, registry: Registry) => void;
+export {};

package/dist/types/src/presentation/define-explanation-kind.d.ts

@@ -0,0 +1,11 @@
+import { ExplanationConfig, ExplanationDefinition, NormalizedExplanationConfig } from '../../schema';
+import { DeclarativeExplanationKind, ExplanationDescriptor, ExplanationDescriptorContext, ExplanationPresenter } from './index';
+export type DefinedExplanationKind<TConfig extends ExplanationConfig, _TResult> = {
+    kind: string;
+    schema: import('zod').ZodType<TConfig>;
+    transport: ExplanationDefinition<TConfig>["transport"];
+    describe?: (config: NormalizedExplanationConfig<TConfig>, context: ExplanationDescriptorContext) => ExplanationDescriptor | null;
+    definition: ExplanationDefinition<TConfig>;
+    presenter: ExplanationPresenter<TConfig>;
+};
+export declare const defineExplanationKind: <TConfig extends ExplanationConfig, TResult>(kind: DeclarativeExplanationKind<TConfig, TResult>) => DefinedExplanationKind<TConfig, TResult>;

package/dist/types/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/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/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/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/src/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/src/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/src/primitives/components/field-frame-styles.d.ts

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

package/dist/types/src/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/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/src/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/src/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/src/primitives/components/form-root-styles.d.ts

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