mlform 0.1.2 → 0.1.4

package/dist/types/src/engine/types/field.d.ts

@@ -0,0 +1,172 @@
+import { ZodType } from 'zod';
+import { FormStatus } from './form';
+type MaybePromise<T> = T | PromiseLike<T>;
+export type FieldStatus = "idle" | "validating" | "valid" | "invalid";
+export type InactiveFieldPolicy = "include" | "omit" | "reset-on-hide";
+export interface FieldDescriptor {
+    component: string;
+    props: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface BaseFieldConfig {
+    id?: string;
+    kind: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    readOnly?: boolean;
+    disabledWhen?: FieldCondition;
+    hiddenWhen?: FieldCondition;
+    readOnlyWhen?: FieldCondition;
+    asyncValidationDebounceMs?: number;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+    valuePath?: string | string[];
+    defaultValue?: unknown;
+    ui?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type FieldConfig = BaseFieldConfig;
+export type NormalizedFieldConfig<TConfig extends FieldConfig = FieldConfig> = TConfig & {
+    id: string;
+};
+export interface FieldStateSnapshot {
+    value: unknown;
+    initialValue: unknown;
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    visible: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    errors: string[];
+    status: FieldStatus;
+}
+export interface FieldValidationResult {
+    fieldId: string;
+    valid: boolean;
+    errors: string[];
+}
+export interface FieldValidationContext<TConfig extends FieldConfig = FieldConfig> {
+    field: NormalizedFieldConfig<TConfig>;
+    values: Record<string, unknown>;
+    submitCount: number;
+    validationVersion: number;
+    signal?: AbortSignal;
+}
+export interface FieldConditionContext<TConfig extends FieldConfig = FieldConfig> {
+    field: NormalizedFieldConfig<TConfig>;
+    values: Record<string, unknown>;
+    submitCount: number;
+    formStatus: FormStatus;
+}
+export interface FieldValueCondition {
+    kind: "field-value";
+    field: string;
+    equals?: unknown;
+    notEquals?: unknown;
+    greaterThan?: unknown;
+    greaterThanOrEqual?: unknown;
+    lessThan?: unknown;
+    lessThanOrEqual?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
+    empty?: boolean;
+    notEmpty?: boolean;
+    truthy?: boolean;
+    falsy?: boolean;
+}
+export interface FieldComparisonCondition {
+    kind: "field-comparison";
+    field: string;
+    otherField: string;
+    operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte";
+}
+export interface FormStatusCondition {
+    kind: "form-status";
+    equals: FormStatus | FormStatus[];
+}
+export interface SubmitCountCondition {
+    kind: "submit-count";
+    eq?: number;
+    gte?: number;
+    lte?: number;
+}
+export interface AllConditions {
+    kind: "all";
+    conditions: DeclarativeFieldCondition[];
+}
+export interface AnyConditions {
+    kind: "any";
+    conditions: DeclarativeFieldCondition[];
+}
+export interface NotCondition {
+    kind: "not";
+    condition: DeclarativeFieldCondition;
+}
+export type DeclarativeFieldCondition = FieldValueCondition | FieldComparisonCondition | FormStatusCondition | SubmitCountCondition | AllConditions | AnyConditions | NotCondition;
+export type FieldCondition<TConfig extends FieldConfig = FieldConfig> = DeclarativeFieldCondition | ((context: FieldConditionContext<TConfig>) => boolean);
+export interface FieldDescriptorContext {
+    fieldId: string;
+    state: FieldStateSnapshot;
+}
+export type FieldWidget = "text" | "number" | "boolean" | "select" | "date" | "series";
+export type FieldRenderHints = Record<string, unknown>;
+export interface FieldValueAdapter<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    default?: (config: TConfig) => TValue;
+    normalize?: (value: unknown, config: TConfig) => TValue;
+    clone?: (value: TValue, config: TConfig) => TValue;
+    isEqual?: (previous: TValue, next: TValue, config: TConfig) => boolean;
+    serialize?: (value: TValue, config: TConfig) => unknown;
+}
+export interface FieldValidationFnContext<TConfig extends FieldConfig = FieldConfig, TValue = unknown> extends FieldValidationContext<TConfig> {
+    config: TConfig;
+    value: TValue;
+}
+export interface FieldRenderSpecContext<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    config: TConfig;
+    fieldId: string;
+    state: FieldStateSnapshot;
+    value: TValue;
+}
+export interface FieldRenderSpec<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    widget: FieldWidget;
+    hints?: FieldRenderHints | ((context: FieldRenderSpecContext<TConfig, TValue>) => FieldRenderHints);
+}
+export interface DeclarativeFieldKind<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    value?: FieldValueAdapter<TConfig, TValue>;
+    validate?: (context: FieldValidationFnContext<TConfig, TValue>) => MaybePromise<string[]>;
+    render: FieldRenderSpec<TConfig, TValue>;
+}
+export interface FieldDefinition<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    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?: (value: TValue, config: TConfig, context: FieldValidationContext<TConfig>) => MaybePromise<string[]>;
+    describe: (config: TConfig, context: FieldDescriptorContext) => FieldDescriptor;
+}
+export interface FieldController {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: NormalizedFieldConfig;
+    readonly state: FieldStateSnapshot;
+    readonly descriptor: FieldDescriptor;
+    setValue(value: unknown): void;
+    blur(): void;
+    focus(): void;
+    validate(): Promise<FieldValidationResult>;
+    reset(): void;
+    subscribe(listener: (state: FieldStateSnapshot) => void): () => void;
+}
+export interface SelectorSubscriptionOptions<TSelected> {
+    emitInitial?: boolean;
+    equality?: (previous: TSelected, next: TSelected) => boolean;
+}
+export {};

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

@@ -0,0 +1,120 @@
+import { FieldConfig, FieldController, FieldStateSnapshot, InactiveFieldPolicy, NormalizedFieldConfig, SelectorSubscriptionOptions } from './field';
+import { ExplanationConfig, ExplanationController, ExplanationStateSnapshot } from './explanation';
+import { NormalizedReportConfig, ReportConfig, ReportController, ReportStateSnapshot } from './report';
+import { AfterSubmitContext, BeforeSubmitContext, SubmitOptions, SubmitResult, Transport, TransportStreamEvent, SubmitErrorContext } from './transport';
+import { Registry } from './registry';
+type MaybePromise<T> = T | PromiseLike<T>;
+export type FormStatus = "idle" | "editing" | "validating" | "submitting" | "success" | "error";
+export interface FormValidationResult {
+    valid: boolean;
+    fields: Record<string, string[]>;
+    formErrors: string[];
+}
+export interface SubmissionProgressState {
+    loaded?: number;
+    total?: number;
+    message?: string;
+    meta: Record<string, unknown>;
+    chunkCount: number;
+    sessionState?: "opening" | "open" | "closing" | "closed";
+    bufferedMessages?: number;
+    sessionMessageCount?: number;
+    lastSessionMessageType?: string;
+    lastEventType?: TransportStreamEvent["type"];
+}
+export interface FormState {
+    status: FormStatus;
+    submitCount: number;
+    valid: boolean;
+    dirty: boolean;
+    touched: boolean;
+    values: Record<string, unknown>;
+    reportStates: Record<string, ReportStateSnapshot>;
+    explanationStates: Record<string, ExplanationStateSnapshot>;
+    submissionProgress: SubmissionProgressState | null;
+    errors: {
+        form: string[];
+        fields: Record<string, string[]>;
+    };
+    lastResult: SubmitResult | null;
+}
+export interface FormValidationIssue {
+    form?: string[];
+    fields?: Record<string, string[]>;
+}
+export interface FormValidationContext {
+    values: Record<string, unknown>;
+    submitCount: number;
+    formStatus: FormStatus;
+    fields: Record<string, FieldStateSnapshot>;
+    schema: {
+        fields: readonly NormalizedFieldConfig[];
+        reports: readonly NormalizedReportConfig[];
+    };
+}
+export type FormValidator = (context: FormValidationContext) => MaybePromise<FormValidationIssue | string[] | void>;
+export interface BeforeValidateContext {
+    values: Record<string, unknown>;
+    submitCount: number;
+}
+export interface AfterValidateContext {
+    values: Record<string, unknown>;
+    result: FormValidationResult;
+    submitCount: number;
+}
+export interface AfterExplanationContext {
+    explanationId: string;
+    kind: string;
+    result: unknown;
+}
+export interface ExplanationErrorContext {
+    explanationId: string;
+    kind: string;
+    error: unknown;
+}
+export interface FormHooks {
+    beforeValidate?: (context: BeforeValidateContext) => MaybePromise<void>;
+    afterValidate?: (context: AfterValidateContext) => MaybePromise<void>;
+    beforeSubmit?: (context: BeforeSubmitContext) => MaybePromise<void>;
+    afterSubmit?: (context: AfterSubmitContext) => MaybePromise<void>;
+    onSubmitError?: (context: SubmitErrorContext) => MaybePromise<void>;
+    afterExplanation?: (context: AfterExplanationContext) => MaybePromise<void>;
+    onExplanationError?: (context: ExplanationErrorContext) => MaybePromise<void>;
+}
+export interface FormSchema {
+    fields: FieldConfig[];
+    reports?: ReportConfig[];
+    explanations?: ExplanationConfig[];
+}
+export interface CreateFormConfig {
+    schema: FormSchema;
+    registry: Registry;
+    transport: Transport;
+    initialValues?: Record<string, unknown>;
+    validators?: FormValidator[];
+    hooks?: FormHooks;
+    hookFailurePolicy?: {
+        afterSubmit?: "fail-submit" | "preserve-success";
+    };
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+    listenerErrorPolicy?: "ignore" | "throw-aggregate";
+    onListenerError?: (error: unknown) => void;
+}
+export interface FormController {
+    readonly fields: readonly FieldController[];
+    readonly reports: readonly ReportController[];
+    readonly explanations: readonly ExplanationController[];
+    readonly state: FormState;
+    getField(id: string): FieldController | undefined;
+    getReport(id: string): ReportController | undefined;
+    getExplanation(id: string): ExplanationController | undefined;
+    getValues(): Record<string, unknown>;
+    setValues(values: Record<string, unknown>): void;
+    validate(): Promise<FormValidationResult>;
+    submit(options?: SubmitOptions): Promise<SubmitResult>;
+    abortSubmit(reason?: string): void;
+    reset(): void;
+    subscribe(listener: (state: FormState) => void): () => void;
+    subscribeSelector<TSelected>(selector: (state: FormState) => TSelected, listener: (selected: TSelected, state: FormState) => void, options?: SelectorSubscriptionOptions<TSelected>): () => void;
+}
+export type { SubmitErrorContext } from './transport';

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

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

package/dist/types/src/engine/types/pipeline.d.ts

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

package/dist/types/src/engine/types/registry.d.ts

@@ -0,0 +1,17 @@
+import { FieldConfig, FieldDefinition } from './field';
+import { ExplanationConfig, ExplanationDefinition } from './explanation';
+import { ReportConfig, ReportDefinition } from './report';
+export interface Registry {
+    registerField<TConfig extends FieldConfig, TValue>(definition: FieldDefinition<TConfig, TValue>): Registry;
+    unregisterField(kind: string): Registry;
+    getField<TConfig extends FieldConfig = FieldConfig, TValue = unknown>(kind: string): FieldDefinition<TConfig, TValue> | undefined;
+    listFields(): FieldDefinition<FieldConfig, unknown>[];
+    registerReport<TConfig extends ReportConfig>(definition: ReportDefinition<TConfig>): Registry;
+    unregisterReport(kind: string): Registry;
+    getReport<TConfig extends ReportConfig = ReportConfig>(kind: string): ReportDefinition<TConfig> | undefined;
+    listReports(): ReportDefinition<ReportConfig>[];
+    registerExplanation<TConfig extends ExplanationConfig>(definition: ExplanationDefinition<TConfig>): Registry;
+    unregisterExplanation(kind: string): Registry;
+    getExplanation<TConfig extends ExplanationConfig = ExplanationConfig>(kind: string): ExplanationDefinition<TConfig> | undefined;
+    listExplanations(): ExplanationDefinition<ExplanationConfig>[];
+}

package/dist/types/src/engine/types/report.d.ts

@@ -0,0 +1,87 @@
+import { ZodType } from 'zod';
+import { PresentationContent, PresentationSummary } from '../declarative/presentation';
+import { SubmitResult } from './transport';
+type MaybePromise<T> = T | PromiseLike<T>;
+export type ReportStatus = "idle" | "loading" | "ready" | "error";
+export interface ReportDescriptor {
+    component: string;
+    props: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface BaseReportConfig {
+    id?: string;
+    kind: string;
+    label?: string;
+    description?: string;
+    source?: string;
+    ui?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type ReportConfig = BaseReportConfig;
+export type NormalizedReportConfig<TConfig extends ReportConfig = ReportConfig> = TConfig & {
+    id: string;
+    source: string;
+};
+export interface ReportStateSnapshot {
+    payload: unknown;
+    error: string | null;
+    status: ReportStatus;
+}
+export interface ReportDescriptorContext {
+    reportId: string;
+    state: ReportStateSnapshot;
+    payload: unknown;
+    result: SubmitResult | null;
+}
+export interface ReportPayloadContext<TConfig extends ReportConfig = ReportConfig> {
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+export interface ReportResolveContext<TConfig extends ReportConfig = ReportConfig> {
+    config: NormalizedReportConfig<TConfig>;
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+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?: ReportPayloadValidationPolicy;
+    partialUpdatePolicy?: PartialReportUpdatePolicy;
+    clonePayload?: (payload: TPayload, config: TConfig) => TPayload;
+    resolve: (context: ReportResolveContext<TConfig>) => MaybePromise<TPayload>;
+    render: ReportRenderSpec<TConfig, TPayload>;
+}
+export type ReportPayloadValidationPolicy = "report-error" | "fail-submit";
+export type PartialReportUpdatePolicy = "trust" | "validate" | "defer";
+export interface ReportDefinition<TConfig extends ReportConfig = ReportConfig> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    payloadSchema?: ZodType<unknown>;
+    payloadValidationPolicy?: ReportPayloadValidationPolicy;
+    partialUpdatePolicy?: PartialReportUpdatePolicy;
+    clonePayload?: (payload: unknown, config: TConfig) => unknown;
+    resolvePayload?: (config: TConfig, context: ReportPayloadContext<TConfig>) => MaybePromise<unknown>;
+    describe: (config: TConfig, context: ReportDescriptorContext) => ReportDescriptor | null;
+}
+export interface ReportController {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: NormalizedReportConfig;
+    readonly state: ReportStateSnapshot;
+    readonly descriptor: ReportDescriptor | null;
+    subscribe(listener: (state: ReportStateSnapshot) => void): () => void;
+}
+export {};

package/dist/types/src/engine/types/transport.d.ts

@@ -0,0 +1,41 @@
+import { SubmitRequest as BaseSubmitRequest, SubmitResult as BaseSubmitResult, Transport as BaseTransport, TransportStreamEvent as BaseTransportStreamEvent } from '../../../transport';
+import { NormalizedFieldConfig } from './field';
+import { NormalizedReportConfig, ReportStateSnapshot } from './report';
+export type { CapabilityRequirement, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, RateLimitLeaseRequest, SharedRateLimiter, SharedRateLimiterLease, SubmitRequestMetadata, SubmitRequestTransportContext, TransportAuthKind, TransportBackpressureMode, TransportCacheEntry, TransportCacheStore, TransportCapabilities, TransportCollection, TransportConsistency, TransportDeliveryMode, TransportHealthSnapshot, TransportHealthState, TransportPolicyContext, TransportResponse, TransportSession, TransportSessionCloseEvent, TransportSessionErrorEvent, TransportSessionEvent, TransportSessionMessage, TransportSessionMessageEvent, TransportSessionMetaEvent, TransportSessionProgressEvent, TransportSessionResultEvent, TransportStreamChunkEvent, TransportStreamErrorEvent, TransportStreamMetaEvent, TransportStreamProgressEvent, TransportStreamReportPatchEvent, TransportStreamReportReplaceEvent, } from '../../../transport';
+export type SubmitRequest = BaseSubmitRequest<NormalizedFieldConfig, NormalizedReportConfig>;
+export type SubmitResult = Omit<BaseSubmitResult, "reportStates"> & {
+    reportStates: Record<string, ReportStateSnapshot>;
+};
+export type Transport = BaseTransport<NormalizedFieldConfig, NormalizedReportConfig>;
+export type TransportStreamEvent = BaseTransportStreamEvent;
+export interface SubmitOptions {
+    signal?: AbortSignal;
+    backend?: string;
+}
+export interface BeforeSubmitContext {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    submitCount: number;
+    signal: AbortSignal;
+}
+export interface AfterSubmitContext {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    submitCount: number;
+    result: SubmitResult;
+}
+export interface SubmitErrorContext {
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    submitCount: number;
+    error: unknown;
+}

package/dist/types/src/engine/utils.d.ts

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

package/dist/types/src/engine/validation/conditions.d.ts

@@ -0,0 +1,11 @@
+import { DeclarativeFieldCondition, FieldComparisonCondition, FieldCondition, FieldConditionContext, FormStatus, NormalizedFieldConfig } from '../types';
+export type DerivedFieldFlags = {
+    visible: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+};
+export declare const evaluateCondition: (condition: FieldCondition | undefined, context: FieldConditionContext, fallback: boolean) => boolean;
+export declare const matchesValueList: (value: unknown, list: unknown[]) => boolean;
+export declare const matchesComparison: (left: unknown, right: unknown, operator: FieldComparisonCondition["operator"]) => boolean;
+export declare const evaluateDeclarativeCondition: (condition: DeclarativeFieldCondition, context: FieldConditionContext) => boolean;
+export declare const resolveDerivedFlags: (config: NormalizedFieldConfig, values: Record<string, unknown>, submitCount: number, formStatus: FormStatus) => DerivedFieldFlags;

package/dist/types/src/engine/validation/field.d.ts

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

package/dist/types/src/engine/validation/form.d.ts

@@ -0,0 +1,35 @@
+import { NormalizedFormSchema } from '../schema';
+import { EngineStore } from '../state';
+import { FieldValidationResult, FormHooks, FormStatus, FormValidationIssue, FormValidationResult, FormValidator, InactiveFieldPolicy } from '../types';
+type FormValidationField = {
+    readonly id: string;
+    validate(validationVersion?: number): Promise<FieldValidationResult>;
+    setExternalErrors(errors: string[]): void;
+};
+type SyncDerivedFieldStateOptions = {
+    values?: Record<string, unknown>;
+    preserveValidationErrors?: boolean;
+    preserveExternalErrors?: boolean;
+    resetInactiveToInitial?: boolean;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+};
+type CreateFormValidatorOptions = {
+    store: EngineStore;
+    fields: readonly FormValidationField[];
+    normalizedSchema: NormalizedFormSchema;
+    validators?: FormValidator[];
+    hooks?: FormHooks;
+    getValues: () => Record<string, unknown>;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormStatus;
+    syncDerivedFieldState: (options?: SyncDerivedFieldStateOptions) => void;
+    setRestingStatus: () => void;
+    shouldResetInactiveFields: () => boolean;
+    inactiveFieldPolicy?: InactiveFieldPolicy;
+};
+export declare const createValidationResult: (store: EngineStore) => FormValidationResult;
+export declare const mergeValidationIssue: (fieldErrors: Record<string, string[]>, formErrors: string[], issue: FormValidationIssue | string[] | void) => void;
+export declare const createFormValidator: ({ store, fields, normalizedSchema, validators, hooks, getValues, getSubmitCount, getFormStatus, syncDerivedFieldState, setRestingStatus, shouldResetInactiveFields, inactiveFieldPolicy, }: CreateFormValidatorOptions) => {
+    validate(): Promise<FormValidationResult>;
+};
+export {};

package/dist/types/src/engine/validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './conditions';
+export * from './field';
+export * from './form';

package/dist/types/src/engine/values.d.ts

@@ -0,0 +1,2 @@
+export declare const cloneValue: <T>(value: T) => T;
+export declare const deepValueEquality: (previous: unknown, next: unknown) => boolean;

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

@@ -0,0 +1,7 @@
+export { defaultKitDesignSystem, defaultKitLabels, mountForm, unmountForm } from '../kit';
+export { assertPayloadWithinLimits, assertTransportCapabilities, cloneCapabilities, createFanoutTransport, createFallbackTransport, createGraphqlTransport, createGrpcSessionTransport, createGrpcStreamTransport, createGrpcTransport, createGrpcUnaryTransport, createHedgedTransport, createJsonTransport, createLoadBalancedTransport, createMemoryCircuitBreakerState, createMemorySharedRateLimiter, createMemoryTransportCacheStore, createMemoryTransportHealthState, createPipelineTransport, createQuorumFanoutTransport, createRacingTransport, createRoutingTransport, createSessionTransport, createSseTransport, createWebSocketSessionTransport, createWeightedRoutingTransport, inferTransportCapabilities, mergeTransportCapabilities, normalizeTransportCapabilities, pipe, transportDefaults, transportErrorMessages, transportErrorCodes, TransportError, withAuth, withCache, withCircuitBreaker, withDedup, withLogging, withMetrics, withRateLimit, withRequestTransform, withResponseTransform, withRetry, withTracing, withTimeout, } from '../transport';
+export type { ApiKeyAuthOptions, AuthOptions, BearerAuthOptions, CacheOptions, CapabilityRequirement, CircuitBreakerOptions, CircuitBreakerSharedState, CircuitBreakerStateSnapshot, CustomAuthOptions, DedupOptions, FanoutTransportFailure, FanoutTransportOptions, FanoutTransportResult, FallbackTransportFailure, FallbackTransportOptions, GraphqlTransportOptions, GrpcSessionTransportOptions, GrpcStreamTransportOptions, GrpcTransportOptions, GrpcUnaryTransportOptions, HedgedTransportOptions, JsonTransportMethod, JsonTransportOptions, LoadBalancingTransportOptions, PipelineStage, PipelineTransportOptions, QuorumFanoutTransportOptions, RateLimitLeaseRequest, RateLimitOptions, RacingTransportOptions, RetryOptions, RoutingTransportOptions, SessionTransportOptions, SharedRateLimiter, SharedRateLimiterLease, SseTransportOptions, TransportBackpressureMode, TransportCacheEntry, TransportCacheStore, TransportCapabilities, TransportCollection, TransportConsistency, TransportContextAuthOptions, TransportDeliveryMode, TransportErrorCode, TransportHealthSnapshot, TransportHealthState, TransportLogOptions, TransportMetricsOptions, TransportMiddleware, TransportTelemetryEvent, TransportTraceOptions, WebSocketSessionTransportOptions, WeightedRoutingTransportOptions, } from '../transport';
+export type { KitDesignSystemSnapshot, KitLabels, MountFormOptions, MountedForm } from '../kit';
+export type { ExplanationRequest, ExplanationTransport, PrimitiveFieldRenderContext, PrimitiveExplanationRenderContext, PrimitiveExplanationRendererElement, PrimitiveFieldRendererElement, PrimitiveReportRenderContext, PrimitiveReportRendererElement, } from '../primitives';
+export { createExplanationController, defineExplanationDefinition, defineExplanationKind, defineFieldKind, defineReportKind, executeExplanations, executeFormPipeline, } from '../engine';
+export type { AfterExplanationContext, DeclarativeExplanationKind, DeclarativeFieldKind, DeclarativeReportKind, ExplanationConfig, ExplanationController, ExplanationDefinition, ExplanationDescriptor, ExplanationDescriptorContext, ExplanationErrorContext, ExplanationExecutionContext, ExplanationExecutionResult, ExplanationFetchContext, ExplanationFetchFactory, ExplanationFetchRequest, ExplanationFetchTransport, ExplanationRenderSpec, ExplanationRenderSpecContext, ExplanationStateSnapshot, ExplanationStatus, FieldRenderHints, FieldRenderSpec, FieldRenderSpecContext, FieldValidationFnContext, FieldValueAdapter, FieldWidget, NormalizedExplanationConfig, PipelineArtifactAdapter, PipelineArtifactContext, PipelineResult, ExecuteFormPipelineOptions, PresentationNode, PresentationSummary, ReportRenderSpec, ReportRenderSpecContext, ReportResolveContext, } from '../engine';

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

@@ -0,0 +1,4 @@
+export declare const kitErrorMessages: {
+    readonly invalidDesignSystemSnapshot: "replaceDesignSystem requires an explicit mode, theme, and recipe.";
+};
+export { transportDefaults as kitTransportDefaults, transportErrorMessages } from '../../transport';

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

@@ -0,0 +1,11 @@
+import { DesignSystemConfig, DesignSystemRegistry } from '../../design-system';
+import { Registry } from '../../engine';
+import { PrimitiveRegistry } from '../../primitives';
+import { KitLabels } from './types';
+export declare const defaultKitLabels: Required<KitLabels>;
+export declare const defaultKitDesignSystem: DesignSystemConfig;
+export declare const cloneEngineRegistry: (registry?: Registry) => Registry;
+export declare const resolvePrimitiveRegistry: (registry?: PrimitiveRegistry) => PrimitiveRegistry;
+export declare const resolveDesignSystemRegistry: (registry?: DesignSystemRegistry) => DesignSystemRegistry;
+export declare const resolveKitLabels: (labels?: KitLabels) => Required<KitLabels>;
+export declare const resolveKitDesignSystem: (config?: DesignSystemConfig) => DesignSystemConfig;

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

@@ -0,0 +1,4 @@
+export { defaultKitDesignSystem, defaultKitLabels } from './defaults';
+export { mountForm, unmountForm } from './mount-form';
+export { assertPayloadWithinLimits, assertTransportCapabilities, createFanoutTransport, createFallbackTransport, createGraphqlTransport, createGrpcSessionTransport, createGrpcStreamTransport, createGrpcTransport, createGrpcUnaryTransport, createHedgedTransport, createJsonTransport, createLoadBalancedTransport, createMemoryCircuitBreakerState, createMemorySharedRateLimiter, createMemoryTransportCacheStore, createMemoryTransportHealthState, createPipelineTransport, createQuorumFanoutTransport, createRacingTransport, createRoutingTransport, createSseTransport, createSessionTransport, createWebSocketSessionTransport, createWeightedRoutingTransport, pipe, withAuth, withCache, withCircuitBreaker, withDedup, withLogging, withMetrics, withRateLimit, withRequestTransform, withResponseTransform, withRetry, withTracing, withTimeout, } from '../../transport';
+export type { ApiKeyAuthOptions, AuthOptions, BearerAuthOptions, CapabilityRequirement, CacheOptions, CircuitBreakerSharedState, CircuitBreakerOptions, CustomAuthOptions, DedupOptions, FanoutTransportFailure, FanoutTransportOptions, FanoutTransportResult, FallbackTransportFailure, FallbackTransportOptions, GraphqlTransportOptions, GrpcSessionTransportOptions, GrpcStreamTransportOptions, GrpcTransportOptions, GrpcUnaryTransportOptions, HedgedTransportOptions, JsonTransportMethod, JsonTransportOptions, KitDesignSystemSnapshot, KitLabels, LoadBalancingTransportOptions, MountFormOptions, MountedForm, PipelineStage, PipelineTransportOptions, QuorumFanoutTransportOptions, RateLimitLeaseRequest, SharedRateLimiter, SharedRateLimiterLease, SessionTransportOptions, TransportCacheEntry, TransportCacheStore, TransportHealthSnapshot, TransportHealthState, RateLimitOptions, RacingTransportOptions, RetryOptions, RoutingTransportOptions, TransportContextAuthOptions, TransportCollection, TransportMetricsOptions, TransportTelemetryEvent, TransportLogOptions, TransportMiddleware, TransportTraceOptions, SseTransportOptions, WebSocketSessionTransportOptions, WeightedRoutingTransportOptions, } from './types';

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

@@ -0,0 +1,3 @@
+import { MountFormOptions, MountedForm } from './types';
+export declare const mountForm: (container: HTMLElement, options: MountFormOptions) => MountedForm;
+export declare const unmountForm: (mounted: MountedForm) => void;