@ng-forge/dynamic-forms 0.5.1 → 0.6.0

package/types/ng-forge-dynamic-forms.d.ts

@@ -1,11 +1,11 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
 import { FieldTree, FieldContext, ValidationError as ValidationError$1, TreeValidationResult, SchemaPath, SchemaPathTree } from '@angular/forms/signals';
 import * as _angular_forms from '@angular/forms';
 import * as _ng_forge_dynamic_forms from '@ng-forge/dynamic-forms';
-import * as _angular_core from '@angular/core';
-import { Signal, Injector, WritableSignal, InjectionToken, Type, ResourceRef, OnDestroy, InputSignal, Provider, EnvironmentProviders, PipeTransform } from '@angular/core';
 import { FormSchema } from '@ng-forge/dynamic-forms/schema';
 
 type WithInputSignals<T> = {
@@ -251,6 +251,30 @@ interface FieldDef<TProps, TMeta extends FieldMeta = FieldMeta> {
      * ```
      */
     tabIndex?: number | undefined;
+    /**
+     * Whether to exclude this field's value from submission output when hidden.
+     *
+     * Overrides both the global `withValueExclusionDefaults()` and form-level `FormOptions` settings.
+     *
+     * @default undefined (uses form-level or global setting)
+     */
+    excludeValueIfHidden?: boolean;
+    /**
+     * Whether to exclude this field's value from submission output when disabled.
+     *
+     * Overrides both the global `withValueExclusionDefaults()` and form-level `FormOptions` settings.
+     *
+     * @default undefined (uses form-level or global setting)
+     */
+    excludeValueIfDisabled?: boolean;
+    /**
+     * Whether to exclude this field's value from submission output when readonly.
+     *
+     * Overrides both the global `withValueExclusionDefaults()` and form-level `FormOptions` settings.
+     *
+     * @default undefined (uses form-level or global setting)
+     */
+    excludeValueIfReadonly?: boolean;
     /**
      * Column sizing configuration for responsive grid layout.
      *
@@ -447,6 +471,249 @@ interface ResolvedField {
     inputs: Signal<Record<string, unknown>>;
 }
 
+/**
+ * Configuration for an HTTP request used by declarative HTTP validators, derivations, and conditions.
+ *
+ * All string values in `queryParams` are treated as expressions evaluated by ExpressionParser.
+ * When `evaluateBodyExpressions` is true, top-level string values in `body` are also evaluated as expressions (shallow only).
+ */
+interface HttpRequestConfig {
+    /** URL to send the request to */
+    url: string;
+    /** HTTP method. Defaults to 'GET' */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * URL path parameters. Keys correspond to `:key` placeholders in the URL.
+     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   url: '/api/users/:userId/orders/:orderId',
+     *   params: { userId: 'formValue.userId', orderId: 'fieldValue' }
+     * }
+     * // With userId=42 and fieldValue='abc' → '/api/users/42/orders/abc'
+     * ```
+     */
+    params?: Record<string, string>;
+    /**
+     * Query parameters appended to the URL.
+     * Values are expressions evaluated by ExpressionParser against the current EvaluationContext.
+     */
+    queryParams?: Record<string, string>;
+    /** Request body (for POST/PUT/PATCH) */
+    body?: Record<string, unknown>;
+    /**
+     * When true, top-level string values in `body` are treated as expressions
+     * and evaluated by ExpressionParser (shallow only — nested objects are passed through as-is).
+     */
+    evaluateBodyExpressions?: boolean;
+    /** HTTP headers to include in the request */
+    headers?: Record<string, string>;
+}
+
+/**
+ * Comparison operators for field value and form value conditions.
+ *
+ * @public
+ */
+type ComparisonOperator = 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual' | 'contains' | 'startsWith' | 'endsWith' | 'matches';
+/**
+ * Condition that compares a specific field's value against an expected value.
+ *
+ * @public
+ */
+interface FieldValueCondition {
+    type: 'fieldValue';
+    /** Path to the field whose value to compare */
+    fieldPath: string;
+    /** Comparison operator */
+    operator: ComparisonOperator;
+    /** Value to compare against */
+    value?: unknown;
+}
+/**
+ * Condition that compares the entire form value against an expected value.
+ *
+ * @deprecated Use `FieldValueCondition` for specific field checks, or
+ * `JavascriptCondition` with an expression for complex form-level comparisons.
+ * Will be removed in a future minor version.
+ *
+ * @public
+ */
+interface FormValueCondition {
+    type: 'formValue';
+    /** Comparison operator */
+    operator: ComparisonOperator;
+    /** Value to compare against */
+    value?: unknown;
+}
+/**
+ * Condition that invokes a registered custom function by name (new API).
+ *
+ * Register functions via `customFnConfig.customFunctions`.
+ *
+ * @internal
+ */
+interface CustomConditionNew {
+    type: 'custom';
+    /** Name of the registered custom function to invoke */
+    functionName: string;
+}
+/**
+ * @deprecated Use `CustomCondition` with `functionName` instead.
+ * The `expression` field was misnamed — it holds a function registry key, not a JS expression.
+ * Will be removed in a future minor version.
+ *
+ * @internal
+ */
+interface CustomConditionDeprecated {
+    type: 'custom';
+    /**
+     * @deprecated Use `functionName` instead. Will be removed in a future minor version.
+     */
+    expression: string;
+}
+/**
+ * Condition that invokes a registered custom function by name.
+ *
+ * Use `functionName` (new API). The `expression` field is deprecated.
+ * Register functions via `customFnConfig.customFunctions`.
+ *
+ * @public
+ */
+type CustomCondition = CustomConditionNew | CustomConditionDeprecated;
+/**
+ * Condition that evaluates a JavaScript expression using the secure AST-based parser.
+ *
+ * The expression has access to `formValue`, `fieldValue`, `externalData`, etc.
+ *
+ * @public
+ */
+interface JavascriptCondition {
+    type: 'javascript';
+    /** JavaScript expression string to evaluate */
+    expression: string;
+}
+/**
+ * Condition that evaluates based on an HTTP response from a remote server.
+ *
+ * The HTTP request is resolved reactively — when dependent form values change,
+ * the request is re-evaluated (with debouncing). The result is cached per
+ * resolved request to avoid redundant network calls.
+ *
+ * Since `LogicFn` must return `boolean` synchronously, this condition uses
+ * a signal-based async resolution pattern internally.
+ *
+ * @public
+ */
+interface HttpCondition {
+    type: 'http';
+    /** HTTP request configuration */
+    http: HttpRequestConfig;
+    /**
+     * Expression to extract boolean from response (scope: `{ response }`).
+     * e.g. `'response.allowed'`, `'response.permissions.canEdit'`
+     * When omitted, the entire response is coerced to boolean: `!!response`
+     */
+    responseExpression?: string;
+    /**
+     * Value to return while the HTTP request is in-flight.
+     *
+     * Choose based on the logic type and desired UX:
+     * - For `hidden`: `false` = visible while loading, `true` = hidden while loading
+     * - For `disabled`: `false` = enabled while loading, `true` = disabled while loading
+     * - For `required`: `false` = optional while loading, `true` = required while loading
+     *
+     * @default false
+     */
+    pendingValue?: boolean;
+    /** Cache duration in ms for HTTP responses. @default 30000 */
+    cacheDurationMs?: number;
+    /**
+     * Debounce time in milliseconds for re-evaluation when dependent form values change.
+     * @default 300
+     */
+    debounceMs?: number;
+}
+/**
+ * Condition that evaluates based on a registered async function.
+ *
+ * The function is resolved reactively — when dependent form values change,
+ * the function is re-evaluated (with debouncing). The result is cached per
+ * evaluation to avoid redundant calls.
+ *
+ * Since `LogicFn` must return `boolean` synchronously, this condition uses
+ * a signal-based async resolution pattern internally.
+ *
+ * @public
+ */
+interface AsyncCondition {
+    type: 'async';
+    /** Name of the registered async condition function */
+    asyncFunctionName: string;
+    /**
+     * Value to return while async resolution is pending.
+     *
+     * Choose based on the logic type and desired UX:
+     * - For `hidden`: `false` = visible while loading, `true` = hidden while loading
+     * - For `disabled`: `false` = enabled while loading, `true` = disabled while loading
+     * - For `required`: `false` = optional while loading, `true` = required while loading
+     *
+     * @default false
+     */
+    pendingValue?: boolean;
+    /**
+     * Debounce ms for re-evaluation.
+     * @default 300
+     */
+    debounceMs?: number;
+}
+/**
+ * Logical AND — all sub-conditions must be true.
+ *
+ * @public
+ */
+interface AndCondition {
+    type: 'and';
+    /** Sub-conditions that must all evaluate to true */
+    conditions: ConditionalExpression[];
+}
+/**
+ * Logical OR — at least one sub-condition must be true.
+ *
+ * @public
+ */
+interface OrCondition {
+    type: 'or';
+    /** Sub-conditions where at least one must evaluate to true */
+    conditions: ConditionalExpression[];
+}
+/**
+ * Discriminated union of all conditional expression types.
+ *
+ * Each variant only allows the properties relevant to its type,
+ * providing compile-time safety against invalid property combinations.
+ *
+ * @public
+ */
+type ConditionalExpression = FieldValueCondition | FormValueCondition | CustomCondition | JavascriptCondition | HttpCondition | AsyncCondition | AndCondition | OrCondition;
+
+/**
+ * Logic configuration for container fields (page, group, row, array).
+ * Containers only support the 'hidden' logic type since they are layout containers,
+ * not form controls (they can't be readonly, disabled, or required).
+ */
+interface ContainerLogicConfig {
+    /** Only 'hidden' is supported for container fields */
+    type: 'hidden';
+    /**
+     * Condition that determines when this container is hidden.
+     * Can be a boolean or a conditional expression evaluated against form values.
+     */
+    condition: ConditionalExpression | boolean;
+}
+
 /**
  * Row field interface for creating horizontal layouts
  * This is a special field type that contains other definitions arranged horizontally
@@ -467,6 +734,11 @@ interface RowField<TFields extends readonly RowAllowedChildren[] = readonly RowA
     readonly label?: never;
     /** Rows do not support meta - they have no native form element **/
     readonly meta?: never;
+    /**
+     * Logic configurations for conditional row visibility.
+     * Only 'hidden' type logic is supported for rows.
+     */
+    readonly logic?: ContainerLogicConfig[];
 }
 /**
  * Type guard for RowField with proper type narrowing
@@ -491,6 +763,11 @@ interface GroupField<TFields extends readonly GroupAllowedChildren[] = readonly
     readonly label?: never;
     /** Groups do not support meta - they have no native form element **/
     readonly meta?: never;
+    /**
+     * Logic configurations for conditional group visibility.
+     * Only 'hidden' type logic is supported for groups.
+     */
+    readonly logic?: ContainerLogicConfig[];
 }
 /**
  * Type guard for GroupField with proper type narrowing
@@ -559,13 +836,13 @@ interface HiddenField<TValue extends HiddenValue = HiddenValue> extends FieldDef
  * Fields that are allowed as children of Page fields
  * Pages can contain: rows, groups, arrays, and leaf fields (but NOT other pages)
  */
-type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField;
+type PageAllowedChildren = LeafFieldTypes | RowField | GroupField | ArrayField | SimplifiedArrayField;
 /**
  * Fields that are allowed as children of Row fields
  * Rows can contain: groups, arrays, and leaf fields (but NOT pages, other rows, or hidden fields)
  * Hidden fields are excluded because rows are for horizontal layouts and hidden fields don't render
  */
-type RowAllowedChildren = Exclude<LeafFieldTypes, HiddenField> | GroupField | ArrayField;
+type RowAllowedChildren = Exclude<LeafFieldTypes, HiddenField> | GroupField | ArrayField | SimplifiedArrayField;
 /**
  * Fields that are allowed as children of Group fields
  * Groups can contain: rows and leaf fields (but NOT pages or other groups)
@@ -578,92 +855,216 @@ type GroupAllowedChildren = LeafFieldTypes | RowField;
  */
 type ArrayAllowedChildren = LeafFieldTypes | RowField | GroupField;
 
+/**
+ * An array item template is an array of allowed children that defines one OBJECT array item's fields.
+ * Used for object arrays where each item is `{ key1: value1, key2: value2, ... }`.
+ */
+type ArrayItemTemplate = readonly ArrayAllowedChildren[];
+/**
+ * An array item definition can be either:
+ * - A single field (ArrayAllowedChildren) for PRIMITIVE array items - extracts field value directly
+ * - An array of fields (ArrayItemTemplate) for OBJECT array items - merges fields into object
+ *
+ * This allows support for:
+ * - Primitive arrays: `['tag1', 'tag2']`
+ * - Object arrays: `[{ name: 'Alice', email: '...' }]`
+ * - Heterogeneous arrays: `[{ value: 'x' }, 'y']` (mixed primitives and objects)
+ */
+type ArrayItemDefinition = ArrayAllowedChildren | ArrayItemTemplate;
 /**
  * Array field interface for creating dynamic field collections that map to array values.
  *
  * Key concepts:
- * - The `fields` array defines the TEMPLATE (single field definition), not instances
- * - Array items are created/removed dynamically at runtime via event bus
- * - For primitive arrays: Use a leaf field as template → `['value1', 'value2']`
- * - For object arrays: Use a group field as template → `[{key1: val1}, {key2: val2}]`
+ * - The outer `fields` array defines INITIAL ITEMS (each element is one array item to render)
+ * - Each element can be either:
+ *   - A single FieldDef (primitive item) - the field's value is extracted directly
+ *   - An array of FieldDefs (object item) - fields are merged into an object
+ * - Items can have different field configurations (heterogeneous arrays supported)
+ * - Empty `fields: []` means no initial items - user adds via buttons with explicit templates
+ * - Initial values are declared via `value` property on each field definition
  *
  * @example
- * // Primitive array (flat values)
+ * // Primitive array: ['angular', 'typescript']
  * {
  *   key: 'tags',
  *   type: 'array',
- *   fields: [{ key: 'tag', type: 'input' }]
+ *   fields: [
+ *     { key: 'tag', type: 'input', value: 'angular' },      // Single field = primitive
+ *     { key: 'tag', type: 'input', value: 'typescript' },
+ *   ]
  * }
- * // Creates: { tags: ['tag1', 'tag2', 'tag3'] }
  *
  * @example
- * // Object array (nested groups)
+ * // Object array: [{ name: 'Alice', email: '...' }]
  * {
  *   key: 'contacts',
  *   type: 'array',
- *   fields: [{
- *     type: 'group',
- *     fields: [
- *       { key: 'name', type: 'input' },
- *       { key: 'email', type: 'input' }
- *     ]
- *   }]
+ *   fields: [
+ *     [                                                      // Array = object
+ *       { key: 'name', type: 'input', value: 'Alice' },
+ *       { key: 'email', type: 'input', value: 'alice@example.com' }
+ *     ],
+ *   ]
+ * }
+ *
+ * @example
+ * // Heterogeneous array: [{ label: 'Structured' }, 'Simple']
+ * {
+ *   key: 'items',
+ *   type: 'array',
+ *   fields: [
+ *     [{ key: 'label', type: 'input', value: 'Structured' }],  // Object item
+ *     { key: 'value', type: 'input', value: 'Simple' },        // Primitive item
+ *   ]
+ * }
+ *
+ * @example
+ * // Empty array (add items via buttons)
+ * {
+ *   key: 'tags',
+ *   type: 'array',
+ *   fields: []  // No initial items - user adds via button with template
  * }
- * // Creates: { contacts: [{name: '', email: ''}, {name: '', email: ''}] }
  *
  * Nesting constraints: Arrays can contain rows, leaf fields, or groups (for object arrays),
  * but NOT pages or other arrays. Runtime validation enforces these rules.
  *
  * Note: Arrays are container fields and do not support `meta` since they have no native form element.
  */
-interface ArrayField<TFields extends readonly ArrayAllowedChildren[] = readonly ArrayAllowedChildren[]> extends FieldDef<never> {
+interface ArrayField<TFields extends readonly ArrayItemDefinition[] = readonly ArrayItemDefinition[]> extends FieldDef<never> {
     type: 'array';
     /**
-     * Template field definition(s) that will be cloned for each array item.
-     * Typically contains a single field definition:
-     * - For flat arrays: A leaf field (input, select, checkbox, etc.)
-     * - For object arrays: A group field containing multiple child fields
+     * Array of item definitions. Each element defines one array item:
+     * - Single FieldDef = primitive item (field's value is extracted directly)
+     * - Array of FieldDefs = object item (fields are merged into an object)
+     * - Empty array `[]` = no initial items (add via buttons with explicit templates)
+     * - Items can have different configurations (heterogeneous arrays supported)
+     * - Initial values are set via `value` property on each field definition
      */
     readonly fields: TFields;
     /** Array fields do not have a label property **/
     readonly label?: never;
     /** Arrays do not support meta - they have no native form element **/
     readonly meta?: never;
+    /**
+     * Logic configurations for conditional array visibility.
+     * Only 'hidden' type logic is supported for arrays.
+     */
+    readonly logic?: ContainerLogicConfig[];
+    /**
+     * Minimum number of items required in the array.
+     * Validation fails if the array has fewer items than this value.
+     */
+    readonly minLength?: number;
+    /**
+     * Maximum number of items allowed in the array.
+     * Validation fails if the array has more items than this value.
+     */
+    readonly maxLength?: number;
 }
 /**
- * Type guard for ArrayField with proper type narrowing
+ * Type guard for ArrayField with proper type narrowing.
+ * Validates that the field is an array type with a fields property that is an array.
+ * Fields can contain either single FieldDefs (primitive items) or arrays of FieldDefs (object items).
  */
 declare function isArrayField(field: FieldDef<any>): field is ArrayField;
-
-interface ConditionalExpression {
-    /** Expression type */
-    type: 'fieldValue' | 'formValue' | 'custom' | 'javascript' | 'and' | 'or';
-    /** Field path for fieldValue type */
-    fieldPath?: string;
-    /** Comparison operator */
-    operator?: 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual' | 'contains' | 'startsWith' | 'endsWith' | 'matches';
-    /** Value to compare against */
-    value?: unknown;
-    /** JavaScript expression for custom logic */
-    expression?: string;
-    /** Array of sub-conditions for 'and' and 'or' types */
-    conditions?: ConditionalExpression[];
+/**
+ * Configuration for auto-generated add/remove buttons in simplified array fields.
+ */
+interface ArrayButtonConfig {
+    /** Custom label for the button */
+    readonly label?: string;
+    /** Additional properties passed to the button component */
+    readonly props?: Record<string, unknown>;
 }
-
 /**
- * Logic configuration for page fields.
- * Pages only support the 'hidden' logic type since they are layout containers,
- * not form controls (they can't be readonly, disabled, or required).
+ * Simplified array field interface for common use cases.
+ *
+ * Instead of manually specifying each item in `fields`, provide a `template` that defines
+ * the structure of a single item, and a `value` array with initial data.
+ * The library auto-generates add/remove buttons.
+ *
+ * Discriminant: `template` presence → simplified API; `Array.isArray(template)` → object vs primitive.
+ *
+ * @example
+ * // Primitive array: ['angular', 'typescript']
+ * {
+ *   key: 'tags',
+ *   type: 'array',
+ *   template: { key: 'value', type: 'input', label: 'Tag', required: true },
+ *   value: ['angular', 'typescript']
+ * }
+ *
+ * @example
+ * // Object array: [{ name: 'Jane', phone: '555' }]
+ * {
+ *   key: 'contacts',
+ *   type: 'array',
+ *   template: [
+ *     { key: 'name', type: 'input', label: 'Contact Name', required: true },
+ *     { key: 'phone', type: 'input', label: 'Phone Number' },
+ *   ],
+ *   value: [{ name: 'Jane', phone: '555' }]
+ * }
+ *
+ * @example
+ * // Button customization / opt-out
+ * {
+ *   key: 'tags',
+ *   type: 'array',
+ *   template: { key: 'value', type: 'input', label: 'Tag' },
+ *   addButton: { label: 'Add Tag', props: { color: 'primary' } },
+ *   removeButton: false
+ * }
  */
-interface PageLogicConfig {
-    /** Only 'hidden' is supported for pages */
-    type: 'hidden';
+interface SimplifiedArrayField extends FieldDef<never> {
+    type: 'array';
     /**
-     * Condition that determines when this page is hidden.
-     * Can be a boolean or a conditional expression evaluated against form values.
+     * Template defining the structure of a single array item.
+     * - Single field (ArrayAllowedChildren) → primitive array (each item is a single value)
+     * - Array of fields (readonly ArrayAllowedChildren[]) → object array (each item is an object)
      */
-    condition: ConditionalExpression | boolean;
+    readonly template: ArrayAllowedChildren | readonly ArrayAllowedChildren[];
+    /** Initial values for the array. Each element creates one array item. */
+    readonly value?: readonly unknown[];
+    /**
+     * Configuration for the auto-generated "Add" button, or `false` to disable it.
+     * Defaults to a button with label "Add".
+     */
+    readonly addButton?: ArrayButtonConfig | false;
+    /**
+     * Configuration for the auto-generated "Remove" button on each item, or `false` to disable it.
+     * Defaults to a button with label "Remove".
+     */
+    readonly removeButton?: ArrayButtonConfig | false;
+    /** Simplified arrays do not support the label property */
+    readonly label?: never;
+    /** Simplified arrays do not support meta */
+    readonly meta?: never;
+    /**
+     * Logic configurations for conditional array visibility.
+     * Only 'hidden' type logic is supported for arrays.
+     */
+    readonly logic?: ContainerLogicConfig[];
+    /**
+     * Minimum number of items required in the array.
+     * Validation fails if the array has fewer items than this value.
+     */
+    readonly minLength?: number;
+    /**
+     * Maximum number of items allowed in the array.
+     * Validation fails if the array has more items than this value.
+     */
+    readonly maxLength?: number;
+    /** Mutually exclusive with `template` — use `fields` for the full API instead */
+    readonly fields?: never;
 }
+/**
+ * Type guard for SimplifiedArrayField.
+ * Checks for `type: 'array'` with a `template` property (discriminant from full ArrayField).
+ */
+declare function isSimplifiedArrayField(field: FieldDef<any>): field is SimplifiedArrayField;
+
 /**
  * Page field interface for creating top-level page layouts
  * This is a special field type that contains other field definitions
@@ -707,7 +1108,7 @@ interface PageField<TFields extends readonly PageAllowedChildren[] = PageAllowed
      * }
      * ```
      */
-    readonly logic?: PageLogicConfig[];
+    readonly logic?: ContainerLogicConfig[];
 }
 /**
  * Type guard for PageField with proper type narrowing
@@ -874,19 +1275,52 @@ interface DebouncedStateLogicConfig extends BaseStateLogicConfig {
  */
 type StateLogicConfig = ImmediateStateLogicConfig | DebouncedStateLogicConfig;
 /**
- * Base configuration for value derivation logic.
- *
- * All derivations target the field they are defined on (self-targeting).
- * This simplifies configuration by removing the need for `targetField` -
- * derivation logic is placed on the field that should receive the computed value.
+ * Shared fields that appear on all derivation logic config variants.
  *
  * @internal
  */
-interface BaseDerivationLogicConfig {
+interface SharedDerivationFields {
     /**
      * Logic type identifier for value derivation.
      */
     type: 'derivation';
+    /**
+     * Target property name for property derivation.
+     *
+     * When set, this derivation targets a field property (like `minDate`, `options`,
+     * `label`, `placeholder`) instead of the field's value. The derivation is routed
+     * to the property derivation pipeline.
+     *
+     * When absent, the derivation targets the field's value (default behavior).
+     *
+     * **Depth limit (max 2 levels):** Only simple and single-dot-nested paths are
+     * supported. Paths with 2+ dots (e.g., `'a.b.c'`) will throw at runtime.
+     *
+     * @example
+     * ```typescript
+     * // Property derivation (new unified API)
+     * {
+     *   key: 'endDate',
+     *   type: 'datepicker',
+     *   logic: [{
+     *     type: 'derivation',
+     *     targetProperty: 'minDate',
+     *     expression: 'formValue.startDate'
+     *   }]
+     * }
+     *
+     * // Value derivation (no targetProperty — existing behavior)
+     * {
+     *   key: 'total',
+     *   type: 'input',
+     *   logic: [{
+     *     type: 'derivation',
+     *     expression: 'formValue.quantity * formValue.unitPrice'
+     *   }]
+     * }
+     * ```
+     */
+    targetProperty?: string;
     /**
      * Optional name for this derivation for debugging purposes.
      *
@@ -934,74 +1368,199 @@ interface BaseDerivationLogicConfig {
      */
     condition?: ConditionalExpression | boolean;
     /**
-     * Static value to set on this field.
+     * When true, the derivation stops running after the user manually
+     * edits the target field.
      *
-     * Use when the derived value is a constant.
-     * Mutually exclusive with `expression` and `functionName`.
+     * This is useful for "smart defaults" — values that should be
+     * auto-filled initially but respected once the user explicitly changes them.
+     *
+     * Uses the field's `dirty()` signal to detect user modification.
+     * Derivations write directly to `value.set()` which does not trigger
+     * `markAsDirty()`, so `dirty === true` reliably indicates a user edit.
      *
      * @example
      * ```typescript
-     * value: '+1'           // String
-     * value: 100            // Number
-     * value: true           // Boolean
-     * value: { code: 'US' } // Object
+     * // Auto-fill display name from first + last name, but stop if user edits it
+     * {
+     *   key: 'displayName',
+     *   logic: [{
+     *     type: 'derivation',
+     *     expression: 'formValue.firstName + " " + formValue.lastName',
+     *     stopOnUserOverride: true
+     *   }]
+     * }
      * ```
      */
-    value?: unknown;
+    stopOnUserOverride?: boolean;
     /**
-     * JavaScript expression to evaluate for the derived value.
+     * When true (and `stopOnUserOverride` is also true), clears the
+     * user-override flag when any dependency of this derivation changes,
+     * allowing the derivation to run again.
      *
-     * Has access to `formValue` object containing all form values.
-     * For array fields, `formValue` is scoped to the current array item.
-     * Uses the same secure AST-based parser as other expressions.
-     * Mutually exclusive with `value` and `functionName`.
+     * This is useful when a user override should only persist until the
+     * underlying data changes — e.g., when switching countries, the
+     * phone prefix should re-derive even if the user previously edited it.
      *
      * @example
      * ```typescript
-     * expression: 'formValue.quantity * formValue.unitPrice'
-     * expression: 'formValue.firstName + " " + formValue.lastName'
-     * expression: 'formValue.price * (1 - formValue.discount / 100)'
+     * {
+     *   key: 'phonePrefix',
+     *   logic: [{
+     *     type: 'derivation',
+     *     value: '+1',
+     *     condition: { type: 'fieldValue', fieldPath: 'country', operator: 'equals', value: 'USA' },
+     *     stopOnUserOverride: true,
+     *     reEngageOnDependencyChange: true,
+     *     dependsOn: ['country']
+     *   }]
+     * }
      * ```
      */
-    expression?: string;
+    reEngageOnDependencyChange?: boolean;
+}
+/**
+ * Trigger variants for derivation timing.
+ * @internal
+ */
+type ImmediateDerivationTrigger = {
+    trigger?: 'onChange';
+    debounceMs?: never;
+};
+type DebouncedDerivationTrigger = {
+    trigger: 'debounced';
+    debounceMs?: number;
+};
+/**
+ * Base for HTTP derivations. `source: 'http'` is required.
+ * TypeScript enforces `dependsOn` and `responseExpression` at the type level.
+ *
+ * @internal
+ */
+interface HttpDerivationBase extends SharedDerivationFields {
+    /** Identifies this derivation as HTTP-driven. */
+    source: 'http';
     /**
-     * Name of a registered custom derivation function.
+     * HTTP request configuration for server-driven derivations.
      *
-     * The function receives the evaluation context and returns the derived value.
-     * Register functions in `customFnConfig.derivations`.
-     * Mutually exclusive with `value` and `expression`.
+     * The request is sent when dependencies change, with automatic
+     * debouncing and cancellation of in-flight requests.
+     *
+     * Configure debounce via the `trigger: 'debounced'` + `debounceMs` mechanism.
      *
      * @example
      * ```typescript
-     * functionName: 'getCurrencyForCountry'
-     * functionName: 'calculateTax'
-     * functionName: 'formatPhoneNumber'
+     * {
+     *   key: 'exchangeRate',
+     *   logic: [{
+     *     type: 'derivation',
+     *     source: 'http',
+     *     http: {
+     *       url: '/api/exchange-rate',
+     *       method: 'GET',
+     *       queryParams: {
+     *         from: 'formValue.sourceCurrency',
+     *         to: 'formValue.targetCurrency',
+     *       },
+     *     },
+     *     responseExpression: 'response.rate',
+     *     dependsOn: ['sourceCurrency', 'targetCurrency'],
+     *   }]
+     * }
      * ```
      */
-    functionName?: string;
+    http: HttpRequestConfig;
+    /**
+     * Explicit field dependencies. Required for HTTP derivations to prevent
+     * wildcard triggering on every keystroke.
+     */
+    dependsOn: string[];
     /**
-     * Explicit field dependencies for derivations.
+     * Expression to extract the derived value from the HTTP response.
      *
-     * When using `functionName`, you can optionally specify which fields
-     * the function depends on. This enables more efficient re-evaluation
-     * by only triggering when specific dependencies change.
+     * Evaluated via `ExpressionParser` with `{ response }` as the evaluation scope.
      *
-     * If not provided with `functionName`, defaults to all fields ('*').
-     * For `expression`, dependencies are automatically extracted from the expression.
-     * For `value`, no dependencies are needed (static value).
+     * @example
+     * ```typescript
+     * responseExpression: 'response.rate'
+     * responseExpression: 'response.data.suggestedPrice'
+     * ```
+     */
+    responseExpression: string;
+    value?: never;
+    expression?: never;
+    functionName?: never;
+    asyncFunctionName?: never;
+}
+/**
+ * Base for async function derivations. `source: 'asyncFunction'` is required.
+ * TypeScript enforces `dependsOn` at the type level.
+ *
+ * @internal
+ */
+interface AsyncFunctionDerivationBase extends SharedDerivationFields {
+    /** Identifies this derivation as async-function-driven. */
+    source: 'asyncFunction';
+    /**
+     * Name of a registered async derivation function.
+     *
+     * The function receives the evaluation context and returns a Promise or Observable
+     * of the derived value. Register functions in `customFnConfig.asyncDerivations`.
      *
      * @example
      * ```typescript
-     * // Only re-evaluate when country changes
      * {
-     *   key: 'currency',
+     *   key: 'suggestedPrice',
      *   logic: [{
      *     type: 'derivation',
-     *     functionName: 'getCurrencyForCountry',
-     *     dependsOn: ['country']
+     *     source: 'asyncFunction',
+     *     asyncFunctionName: 'fetchSuggestedPrice',
+     *     dependsOn: ['productId', 'quantity'],
      *   }]
      * }
+     * ```
+     */
+    asyncFunctionName: string;
+    /**
+     * Explicit field dependencies. Required for async derivations to prevent
+     * wildcard triggering on every form change.
+     */
+    dependsOn: string[];
+    value?: never;
+    expression?: never;
+    functionName?: never;
+    http?: never;
+    responseExpression?: never;
+}
+/**
+ * Base for expression derivations.
+ *
+ * @internal
+ */
+interface ExpressionDerivationBase extends SharedDerivationFields {
+    source?: never;
+    /**
+     * JavaScript expression to evaluate for the derived value.
+     *
+     * Has access to `formValue` object containing all form values.
+     * For array fields, `formValue` is scoped to the current array item.
+     * Uses the same secure AST-based parser as other expressions.
+     *
+     * @example
+     * ```typescript
+     * expression: 'formValue.quantity * formValue.unitPrice'
+     * expression: 'formValue.firstName + " " + formValue.lastName'
+     * expression: 'formValue.price * (1 - formValue.discount / 100)'
+     * ```
+     */
+    expression: string;
+    /**
+     * Explicit field dependencies for expressions.
      *
+     * For `expression`, dependencies are automatically extracted from the expression.
+     * Provide `dependsOn` to override automatic detection for complex expressions.
+     *
+     * @example
+     * ```typescript
      * // Override automatic detection for complex expressions
      * {
      *   key: 'total',
@@ -1014,41 +1573,144 @@ interface BaseDerivationLogicConfig {
      * ```
      */
     dependsOn?: string[];
+    value?: never;
+    functionName?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
 }
 /**
- * Derivation logic that evaluates immediately on change (default).
+ * Base for value derivations.
  *
  * @internal
  */
-interface OnChangeDerivationLogicConfig extends BaseDerivationLogicConfig {
+interface ValueDerivationBase extends SharedDerivationFields {
+    source?: never;
     /**
-     * Trigger for immediate evaluation.
-     * @default 'onChange'
+     * Static value to set on this field.
+     *
+     * Use when the derived value is a constant.
+     *
+     * @example
+     * ```typescript
+     * value: '+1'           // String
+     * value: 100            // Number
+     * value: true           // Boolean
+     * value: { code: 'US' } // Object
+     * ```
      */
-    trigger?: 'onChange';
-    /** Not allowed for onChange trigger */
-    debounceMs?: never;
+    value: unknown;
+    /**
+     * Explicit field dependencies for value derivations.
+     *
+     * For `value` (static), no dependencies are needed.
+     * Provide `dependsOn` to conditionally re-evaluate when specific fields change.
+     */
+    dependsOn?: string[];
+    expression?: never;
+    functionName?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
 }
 /**
- * Derivation logic that evaluates after a debounce period.
- *
- * Use this for self-transforms (lowercase, trim, format) to avoid
- * interrupting the user while they're actively typing.
+ * Base for custom sync function derivations.
  *
  * @internal
  */
-interface DebouncedDerivationLogicConfig extends BaseDerivationLogicConfig {
+interface FunctionDerivationBase extends SharedDerivationFields {
+    source?: never;
     /**
-     * Trigger for debounced evaluation.
-     * Evaluates after the value has stabilized for the debounce duration.
+     * Name of a registered custom derivation function.
+     *
+     * The function receives the evaluation context and returns the derived value.
+     * Register functions in `customFnConfig.derivations`.
+     *
+     * @example
+     * ```typescript
+     * functionName: 'getCurrencyForCountry'
+     * functionName: 'calculateTax'
+     * functionName: 'formatPhoneNumber'
+     * ```
      */
-    trigger: 'debounced';
+    functionName: string;
     /**
-     * Debounce duration in milliseconds.
-     * @default 500
+     * Explicit field dependencies for function derivations.
+     *
+     * If not provided, defaults to all fields ('*').
+     * Specify `dependsOn` for better performance when the function only
+     * depends on a subset of fields.
+     *
+     * @example
+     * ```typescript
+     * // Only re-evaluate when country changes
+     * {
+     *   key: 'currency',
+     *   logic: [{
+     *     type: 'derivation',
+     *     functionName: 'getCurrencyForCountry',
+     *     dependsOn: ['country']
+     *   }]
+     * }
+     * ```
      */
-    debounceMs?: number;
+    dependsOn?: string[];
+    value?: never;
+    expression?: never;
+    http?: never;
+    asyncFunctionName?: never;
+    responseExpression?: never;
 }
+/**
+ * HTTP derivation that evaluates immediately on change (default).
+ * @internal
+ */
+type OnChangeHttpDerivationLogicConfig = HttpDerivationBase & ImmediateDerivationTrigger;
+/**
+ * HTTP derivation that evaluates after a debounce period.
+ * @internal
+ */
+type DebouncedHttpDerivationLogicConfig = HttpDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Async function derivation that evaluates immediately on change (default).
+ * @internal
+ */
+type OnChangeAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Async function derivation that evaluates after a debounce period.
+ * @internal
+ */
+type DebouncedAsyncFunctionDerivationLogicConfig = AsyncFunctionDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Expression derivation that evaluates immediately on change (default).
+ * @internal
+ */
+type OnChangeExpressionDerivationLogicConfig = ExpressionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Expression derivation that evaluates after a debounce period.
+ * @internal
+ */
+type DebouncedExpressionDerivationLogicConfig = ExpressionDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Value derivation that evaluates immediately on change (default).
+ * @internal
+ */
+type OnChangeValueDerivationLogicConfig = ValueDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Value derivation that evaluates after a debounce period.
+ * @internal
+ */
+type DebouncedValueDerivationLogicConfig = ValueDerivationBase & DebouncedDerivationTrigger;
+/**
+ * Function derivation that evaluates immediately on change (default).
+ * @internal
+ */
+type OnChangeFunctionDerivationLogicConfig = FunctionDerivationBase & ImmediateDerivationTrigger;
+/**
+ * Function derivation that evaluates after a debounce period.
+ * @internal
+ */
+type DebouncedFunctionDerivationLogicConfig = FunctionDerivationBase & DebouncedDerivationTrigger;
 /**
  * Configuration for value derivation logic.
  *
@@ -1109,16 +1771,162 @@ interface DebouncedDerivationLogicConfig extends BaseDerivationLogicConfig {
  *
  * @public
  */
-type DerivationLogicConfig = OnChangeDerivationLogicConfig | DebouncedDerivationLogicConfig;
+type DerivationLogicConfig = OnChangeHttpDerivationLogicConfig | DebouncedHttpDerivationLogicConfig | OnChangeAsyncFunctionDerivationLogicConfig | DebouncedAsyncFunctionDerivationLogicConfig | OnChangeExpressionDerivationLogicConfig | DebouncedExpressionDerivationLogicConfig | OnChangeValueDerivationLogicConfig | DebouncedValueDerivationLogicConfig | OnChangeFunctionDerivationLogicConfig | DebouncedFunctionDerivationLogicConfig;
+/**
+ * Base configuration for property derivation logic.
+ *
+ * Property derivations compute values for field properties (like `minDate`, `options`,
+ * `label`, `placeholder`) based on form values and external data. Unlike value derivations
+ * which set the field's value, property derivations update component input properties.
+ *
+ * All property derivations are self-targeting: the logic is placed on the field whose
+ * property should be derived.
+ *
+ * @internal
+ */
+interface BasePropertyDerivationLogicConfig {
+    /**
+     * Logic type identifier for property derivation.
+     */
+    type: 'propertyDerivation';
+    /**
+     * The target property to set on the field component.
+     *
+     * **Depth limit (max 2 levels):** Only simple and single-dot-nested paths are
+     * supported. Paths with 2+ dots (e.g., `'a.b.c'`) will throw a `DynamicFormError`
+     * at runtime. This is an architectural constraint of the override merging strategy.
+     *
+     * Supported formats:
+     * - Simple: `'minDate'`, `'options'`, `'label'`, `'placeholder'`
+     * - Nested (1 dot): `'props.appearance'`, `'meta.autocomplete'`
+     *
+     * **Note:** There is no compile-time validation that the property name matches
+     * an actual input on the field component. Typos will silently write to the
+     * override store with no visible effect. A dev-mode warning is emitted when
+     * the override key doesn't match any existing input property.
+     *
+     * @example
+     * ```typescript
+     * targetProperty: 'minDate'           // ✅ Simple property
+     * targetProperty: 'options'           // ✅ Simple property
+     * targetProperty: 'props.appearance'  // ✅ Single-nested property
+     * targetProperty: 'a.b.c'            // ❌ Throws DynamicFormError (too deep)
+     * ```
+     */
+    targetProperty: string;
+    /**
+     * Optional name for this derivation for debugging purposes.
+     *
+     * When provided, this name appears in property derivation debug logs.
+     */
+    debugName?: string;
+    /**
+     * Condition that determines when this property derivation applies.
+     *
+     * Defaults to `true` (always apply).
+     *
+     * Note: FormStateCondition is not supported for property derivations.
+     */
+    condition?: ConditionalExpression | boolean;
+    /**
+     * Static value to set on the target property.
+     *
+     * Mutually exclusive with `expression` and `functionName`.
+     */
+    value?: unknown;
+    /**
+     * JavaScript expression to evaluate for the derived property value.
+     *
+     * Has access to `formValue` object containing all form values.
+     * For array fields, `formValue` is scoped to the current array item.
+     *
+     * Mutually exclusive with `value` and `functionName`.
+     *
+     * @example
+     * ```typescript
+     * expression: 'formValue.startDate'
+     * expression: 'formValue.quantity > 10 ? "bulk" : "standard"'
+     * ```
+     */
+    expression?: string;
+    /**
+     * Name of a registered custom property derivation function.
+     *
+     * Register functions in `customFnConfig.propertyDerivations`.
+     * Mutually exclusive with `value` and `expression`.
+     */
+    functionName?: string;
+    /**
+     * Explicit field dependencies for property derivations.
+     *
+     * When using `functionName`, you can optionally specify which fields
+     * the function depends on. If not provided with `functionName`, defaults
+     * to all fields ('*').
+     * For `expression`, dependencies are automatically extracted.
+     * For `value`, no dependencies are needed (static value).
+     */
+    dependsOn?: string[];
+}
+/**
+ * Property derivation that evaluates immediately on change (default).
+ *
+ * @internal
+ */
+interface OnChangePropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
+    /**
+     * Trigger for immediate evaluation.
+     * @default 'onChange'
+     */
+    trigger?: 'onChange';
+    /** Not allowed for onChange trigger */
+    debounceMs?: never;
+}
+/**
+ * Property derivation that evaluates after a debounce period.
+ *
+ * @internal
+ */
+interface DebouncedPropertyDerivationLogicConfig extends BasePropertyDerivationLogicConfig {
+    /**
+     * Trigger for debounced evaluation.
+     */
+    trigger: 'debounced';
+    /**
+     * Debounce duration in milliseconds.
+     * @default 500
+     */
+    debounceMs?: number;
+}
+/**
+ * Configuration for property derivation logic.
+ *
+ * @deprecated Use `DerivationLogicConfig` with `targetProperty` instead.
+ * The unified `type: 'derivation'` with `targetProperty` provides the same
+ * functionality with a simpler API surface.
+ *
+ * ```typescript
+ * // Before (deprecated)
+ * { type: 'propertyDerivation', targetProperty: 'minDate', expression: '...' }
+ *
+ * // After (preferred)
+ * { type: 'derivation', targetProperty: 'minDate', expression: '...' }
+ * ```
+ *
+ * Will be removed in a future minor version.
+ *
+ * @public
+ */
+type PropertyDerivationLogicConfig = OnChangePropertyDerivationLogicConfig | DebouncedPropertyDerivationLogicConfig;
 /**
  * Union type for all logic configurations.
  *
  * - `StateLogicConfig`: For field state changes (hidden, readonly, disabled, required)
  * - `DerivationLogicConfig`: For value derivation
+ * - `PropertyDerivationLogicConfig`: For property derivation
  *
  * @public
  */
-type LogicConfig = StateLogicConfig | DerivationLogicConfig;
+type LogicConfig = StateLogicConfig | DerivationLogicConfig | PropertyDerivationLogicConfig;
 /**
  * Log level for derivation debug output.
  *
@@ -1138,6 +1946,221 @@ type DerivationLogLevel = 'none' | 'summary' | 'verbose';
  * @public
  */
 declare function isFormStateCondition(condition: StateLogicConfig['condition'] | DerivationLogicConfig['condition']): condition is FormStateCondition;
+/**
+ * Type guard to check if a logic config is a PropertyDerivationLogicConfig.
+ *
+ * @deprecated Use `isDerivationLogicConfig(config) && hasTargetProperty(config)` instead.
+ * Will be removed in a future minor version.
+ *
+ * @param config - The logic config to check
+ * @returns true if the config is for property derivation
+ *
+ * @public
+ */
+declare function isPropertyDerivationLogicConfig(config: LogicConfig): config is PropertyDerivationLogicConfig;
+
+/**
+ * Interface for dynamic forms logger implementations.
+ * Allows custom logging integrations (Sentry, DataDog, etc.)
+ */
+interface Logger {
+    /**
+     * Log a debug message.
+     * Use for detailed diagnostic information during development.
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log an info message.
+     * Use for general operational information.
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log a warning message.
+     * Use for potentially problematic situations that don't prevent operation.
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log an error message.
+     * Use for error conditions that may affect functionality.
+     */
+    error(message: string, ...args: unknown[]): void;
+}
+
+/**
+ * Context for resolving button disabled state.
+ *
+ * @public
+ */
+interface ButtonLogicContext {
+    /** The form's FieldTree instance (supports both string and number keys for array indices) */
+    form: FieldTree<unknown, string | number>;
+    /** Form-level options */
+    formOptions?: FormOptions;
+    /** Field-level logic array (if provided) */
+    fieldLogic?: LogicConfig[];
+    /** Explicit disabled state from field definition */
+    explicitlyDisabled?: boolean;
+    /** Current page validity signal (for paged forms) */
+    currentPageValid?: Signal<boolean>;
+    /** Current form value for evaluating conditional expressions */
+    formValue?: unknown;
+    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
+    logger?: Logger;
+}
+/**
+ * Allowed logic types for non-form-bound elements (buttons, text fields, etc.).
+ * These elements only support hidden and disabled states - not readonly or required
+ * since they don't participate in form validation.
+ *
+ * @public
+ */
+type NonFieldLogicType = 'hidden' | 'disabled';
+/**
+ * Logic config restricted to types valid for non-form-bound elements.
+ * This is a subset of LogicConfig that only includes hidden and disabled types.
+ *
+ * @public
+ */
+type NonFieldLogicConfig = LogicConfig & {
+    type: NonFieldLogicType;
+};
+/**
+ * Context for resolving state (hidden/disabled) for non-form-bound elements.
+ *
+ * This is a generalized context that can be used by any field mapper (buttons, text fields,
+ * or any non-form-bound elements) to evaluate logic from a `logic` array.
+ *
+ * Note: While this context accepts the full `LogicConfig[]` for flexibility, the resolver
+ * functions only process hidden and disabled types. Other logic types (readonly, required,
+ * derivation) are ignored for non-form-bound elements.
+ *
+ * @public
+ */
+interface NonFieldLogicContext {
+    /** The form's FieldTree instance (supports both string and number keys for array indices) */
+    form: FieldTree<unknown, string | number>;
+    /**
+     * Field-level logic array containing conditions.
+     * Accepts full LogicConfig[] for compatibility, but only hidden and disabled types are processed.
+     */
+    fieldLogic?: LogicConfig[];
+    /** Explicit state from field definition (e.g., `hidden: true` or `disabled: true`) */
+    explicitValue?: boolean;
+    /** Current form value for evaluating conditional expressions */
+    formValue?: unknown;
+    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
+    logger?: Logger;
+}
+/**
+ * Resolves the disabled state for a submit button.
+ *
+ * The disabled state is determined by (in order of precedence):
+ * 1. Explicit `disabled: true` on the field definition
+ * 2. Field-level `logic` array (if present, overrides form-level defaults)
+ * 3. Form-level `options.submitButton` defaults
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ *
+ * @example
+ * ```typescript
+ * const disabled = resolveSubmitButtonDisabled({
+ *   form: formInstance,
+ *   formOptions: config.options,
+ *   fieldLogic: buttonField.logic,
+ *   explicitlyDisabled: buttonField.disabled,
+ * });
+ *
+ * // Use in template
+ * <button [disabled]="disabled()">Submit</button>
+ * ```
+ *
+ * @public
+ */
+declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+/**
+ * Resolves the disabled state for a next page button.
+ *
+ * The disabled state is determined by (in order of precedence):
+ * 1. Explicit `disabled: true` on the field definition
+ * 2. Field-level `logic` array (if present, overrides form-level defaults)
+ * 3. Form-level `options.nextButton` defaults
+ *
+ * @param ctx - The button logic context
+ * @returns A computed signal that returns true when the button should be disabled
+ *
+ * @example
+ * ```typescript
+ * const disabled = resolveNextButtonDisabled({
+ *   form: formInstance,
+ *   formOptions: config.options,
+ *   fieldLogic: buttonField.logic,
+ *   explicitlyDisabled: buttonField.disabled,
+ *   currentPageValid: pageOrchestrator.currentPageValid,
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function resolveNextButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+/**
+ * Evaluates the hidden state for non-form-bound elements synchronously.
+ *
+ * This is a pure function (no signal allocation) that can be called directly inside
+ * an existing `computed()` block without creating ephemeral signal allocations.
+ *
+ * The hidden state is determined by (in order of precedence):
+ * 1. Explicit `hidden: true` on the field definition
+ * 2. Field-level `logic` array with `type: 'hidden'` conditions
+ *
+ * @param ctx - The context containing form, logic array, and explicit hidden state
+ * @returns true when the element should be hidden
+ *
+ * @public
+ */
+declare function evaluateNonFieldHidden(ctx: NonFieldLogicContext): boolean;
+/**
+ * Resolves the hidden state for non-form-bound elements as a reactive signal.
+ *
+ * Wraps {@link evaluateNonFieldHidden} in a `computed()` for use cases where a standalone
+ * signal is needed. When calling from inside an existing `computed()`, prefer
+ * {@link evaluateNonFieldHidden} directly to avoid ephemeral signal allocation.
+ *
+ * @param ctx - The context containing form, logic array, and explicit hidden state
+ * @returns A computed signal that returns true when the element should be hidden
+ *
+ * @public
+ */
+declare function resolveNonFieldHidden(ctx: NonFieldLogicContext): Signal<boolean>;
+/**
+ * Evaluates the disabled state for non-form-bound elements synchronously.
+ *
+ * This is a pure function (no signal allocation) that can be called directly inside
+ * an existing `computed()` block without creating ephemeral signal allocations.
+ *
+ * The disabled state is determined by (in order of precedence):
+ * 1. Explicit `disabled: true` on the field definition
+ * 2. Field-level `logic` array with `type: 'disabled'` conditions
+ *
+ * @param ctx - The context containing form, logic array, and explicit disabled state
+ * @returns true when the element should be disabled
+ *
+ * @public
+ */
+declare function evaluateNonFieldDisabled(ctx: NonFieldLogicContext): boolean;
+/**
+ * Resolves the disabled state for non-form-bound elements as a reactive signal.
+ *
+ * Wraps {@link evaluateNonFieldDisabled} in a `computed()` for use cases where a standalone
+ * signal is needed. When calling from inside an existing `computed()`, prefer
+ * {@link evaluateNonFieldDisabled} directly to avoid ephemeral signal allocation.
+ *
+ * @param ctx - The context containing form, logic array, and explicit disabled state
+ * @returns A computed signal that returns true when the element should be disabled
+ *
+ * @public
+ */
+declare function resolveNonFieldDisabled(ctx: NonFieldLogicContext): Signal<boolean>;
 
 /**
  * Text element type for rendering different HTML text elements
@@ -1155,8 +2178,12 @@ type TextProps = {
  */
 interface TextField extends FieldDef<TextProps> {
     type: 'text';
-    /** Logic rules for conditional visibility (hidden, readonly, disabled) */
-    readonly logic?: LogicConfig[];
+    /**
+     * Logic rules for conditional visibility.
+     * Text fields only support 'hidden' logic type since they are display-only
+     * and don't participate in form validation (no disabled/readonly/required).
+     */
+    readonly logic?: NonFieldLogicConfig[];
 }
 
 /**
@@ -1175,7 +2202,7 @@ interface FieldRegistryContainers {
     page: PageField;
     row: RowField;
     group: GroupField;
-    array: ArrayField;
+    array: ArrayField | SimplifiedArrayField;
 }
 /**
  * Leaf fields registry - augment this interface to add custom leaf fields
@@ -1290,18 +2317,28 @@ type UnionToIntersection<U> = (U extends U ? (k: U) => void : never) extends (k:
  */
 type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 /**
- * Widens literal types to their primitive equivalents.
+ * Widens literal types to their primitive equivalents, recursively for objects and arrays.
  * This prevents `as const` from over-narrowing types like `''` to literal `''` instead of `string`.
  *
+ * Depth-limited to prevent slow type checking on deeply nested `as const` objects.
+ * Falls back to `T` (unwidened) when depth is exhausted.
+ *
+ * Note: For object types, `readonly` modifiers are intentionally stripped (`-readonly`)
+ * so that inferred form value types have mutable properties. This is by design since
+ * `as const` adds `readonly` to all properties, but form values should be mutable.
+ *
  * @example
  * ```typescript
  * type A = Widen<''>; // string
  * type B = Widen<false>; // boolean
  * type C = Widen<42>; // number
  * type D = Widen<string[]>; // string[]
+ * type E = Widen<{ name: 'Jane' }>; // { name: string }
  * ```
  */
-type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+type Widen<T, D extends number = 5> = [D] extends [never] ? T : T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer U)[] ? Widen<U, Depth[D]>[] : T extends Record<string, unknown> ? {
+    -readonly [K in keyof T]: Widen<T[K], Depth[D]>;
+} : T;
 /**
  * Infer value type based on field type and props.
  * - Slider fields: always number
@@ -1325,6 +2362,21 @@ type MaybeOptional<T, V> = T extends {
 } ? V : T extends {
     required: true;
 } ? V : V | undefined;
+/**
+ * Infers the value type for an array field.
+ * Handles three cases:
+ * 1. Simplified array with template + value → infer item type from value
+ * 2. Simplified array with template only → unknown[]
+ * 3. Full-API array with fields → infer from children
+ */
+type InferArrayValue<T, D extends number> = T extends {
+    template: unknown;
+    value: readonly (infer Item)[];
+} ? Widen<Item>[] : T extends {
+    template: unknown;
+} ? unknown[] : T extends {
+    fields: infer F;
+} ? F extends RegisteredFieldTypes[] ? InferFormValueWithDepth<F, Depth[D]>[] : unknown[] : unknown[];
 /**
  * Process a single field and determine its contribution to the form value type
  */
@@ -1342,11 +2394,8 @@ type ProcessField<T, D extends number = 5> = [D] extends [never] ? Record<string
 } : never : T extends {
     type: 'array';
     key: infer K;
-    fields: infer F;
-} ? K extends string ? F extends RegisteredFieldTypes[] ? {
-    [P in K]: InferFormValueWithDepth<F, Depth[D]>[];
-} : {
-    [P in K]: unknown[];
+} ? K extends string ? {
+    [P in K]: InferArrayValue<T, D>;
 } : never : T extends {
     type: 'text';
 } ? never : T extends {
@@ -1399,6 +2448,31 @@ type ExtractFields<T> = T extends {
  */
 type InferFormValue$1<T> = ExtractFields<T> extends readonly RegisteredFieldTypes[] ? InferFormValueWithDepth<ExtractFields<T> extends RegisteredFieldTypes[] ? ExtractFields<T> : [...ExtractFields<T>], 5> : never;
 
+/**
+ * Mapping configuration for interpreting HTTP responses as validation results.
+ *
+ * Expressions in `validWhen` and `errorParams` are evaluated with scope `{ response }` only —
+ * they do NOT have access to `formValue`, `fieldValue`, or the full `EvaluationContext`.
+ * This is intentional for v1: response mapping is purely about interpreting the HTTP response.
+ */
+interface HttpValidationResponseMapping {
+    /**
+     * Expression evaluated with scope `{ response }`. Truthy = valid (no error).
+     *
+     * NOTE: This is the OPPOSITE of the function-based HttpCustomValidator.onSuccess
+     * convention, which maps successful HTTP responses to validation errors.
+     * Here, truthy means "validation passed".
+     */
+    validWhen: string;
+    /** Error kind returned when validation fails — maps to field-level `validationMessages` */
+    errorKind: string;
+    /**
+     * Parameters to include in the validation error for message interpolation.
+     * Map of parameter names to expressions evaluated against `{ response }`.
+     */
+    errorParams?: Record<string, string>;
+}
+
 /**
  * Base configuration shared by all validators
  */
@@ -1450,34 +2524,80 @@ interface CustomValidatorConfig extends BaseValidatorConfig {
     errorParams?: Record<string, string>;
 }
 /**
- * Async custom validator configuration using Angular's validateAsync API
- * Returns Observable<ValidationError | ValidationError[] | null>
+ * Async custom validator configuration using Angular's validateAsync API.
+ * Returns Observable<ValidationError | ValidationError[] | null>.
+ *
+ * Accepts both `'async'` (preferred) and `'customAsync'` (deprecated) type literals.
  */
 interface AsyncValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'customAsync';
+    /**
+     * Validator type identifier.
+     *
+     * Use `'async'` for new code. `'customAsync'` is accepted for backward compatibility
+     * but emits a deprecation warning in dev mode.
+     */
+    type: 'async' | 'customAsync';
     /** Name of registered async validator function */
     functionName: string;
     /** Optional parameters to pass to validator function */
     params?: Record<string, unknown>;
 }
 /**
- * HTTP validator configuration using Angular's validateHttp API
- * Provides optimized HTTP validation with automatic request cancellation
+ * Function-based HTTP validator configuration — requires a registered function.
+ *
+ * Uses Angular's `validateHttp` API. The function is registered via
+ * `customFnConfig.httpValidators`.
+ *
+ * Discriminated from `DeclarativeHttpValidatorConfig` by the presence of `functionName`.
+ *
+ * Accepts both `'http'` (preferred) and `'customHttp'` (deprecated) type literals.
+ *
+ * @deprecated Prefer `DeclarativeHttpValidatorConfig` (`type: 'http'` with `http` + `responseMapping`)
+ * for fully JSON-serializable validation. Use this form only when function registration is required.
  */
-interface HttpValidatorConfig extends BaseValidatorConfig {
-    /** Validator type identifier */
-    type: 'customHttp';
+interface FunctionHttpValidatorConfig extends BaseValidatorConfig {
+    /**
+     * Validator type identifier.
+     *
+     * Use `'http'` for new code. `'customHttp'` is accepted for backward compatibility
+     * but emits a deprecation warning in dev mode.
+     */
+    type: 'http' | 'customHttp';
     /** Name of registered HTTP validator configuration */
     functionName: string;
     /** Optional parameters to pass to HTTP validator */
     params?: Record<string, unknown>;
 }
 /**
- * Configuration for signal forms validator functions that can be serialized from API
- * Discriminated union type for type-safe validator configuration
+ * @deprecated Use `FunctionHttpValidatorConfig` instead. Will be removed in a future minor version.
+ */
+type HttpValidatorConfig = FunctionHttpValidatorConfig;
+/**
+ * Declarative HTTP validator configuration — fully JSON-serializable, no function registration required.
+ *
+ * Uses `HttpRequestConfig` to define the HTTP request and `HttpValidationResponseMapping`
+ * to interpret the response as a validation result. Powered by Angular's `validateHttp` API.
+ *
+ * Discriminated from `FunctionHttpValidatorConfig` by the presence of `http` + `responseMapping`
+ * (and absence of `functionName`).
  */
-type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | HttpValidatorConfig;
+interface DeclarativeHttpValidatorConfig extends BaseValidatorConfig {
+    /** Validator type identifier */
+    type: 'http';
+    /** HTTP request configuration with expression-based query params and body */
+    http: HttpRequestConfig;
+    /** Mapping that interprets the HTTP response as a validation result */
+    responseMapping: HttpValidationResponseMapping;
+}
+/**
+ * Configuration for signal forms validator functions that can be serialized from API.
+ * Discriminated union type for type-safe validator configuration.
+ *
+ * Note: `FunctionHttpValidatorConfig` and `DeclarativeHttpValidatorConfig` both use `type: 'http'`.
+ * They are discriminated by property presence: `functionName` → function-based, `http` → declarative.
+ * Use `isFunctionHttpValidator()` for type-safe narrowing when `type` alone is insufficient.
+ */
+type ValidatorConfig = BuiltInValidatorConfig | CustomValidatorConfig | AsyncValidatorConfig | FunctionHttpValidatorConfig | DeclarativeHttpValidatorConfig;
 
 /**
  * Configuration for applying predefined schemas
@@ -1774,31 +2894,74 @@ interface HttpCustomValidator<TValue = unknown, TResult = unknown> {
 }
 
 /**
- * Interface for dynamic forms logger implementations.
- * Allows custom logging integrations (Sentry, DataDog, etc.)
+ * Tracks deprecated API usages that have already been warned about to prevent log spam.
+ * Scoped to a single form instance via DI.
+ *
+ * This follows the same pattern as DerivationWarningTracker — DI-scoped rather than
+ * module-scoped to avoid SSR issues where state would be shared across requests.
+ *
+ * @public
+ */
+interface DeprecationWarningTracker {
+    /** Set of deprecation keys we've already warned about */
+    warnedKeys: Set<string>;
+}
+
+/**
+ * Represents the state information of a single form field.
+ *
+ * Used in evaluation contexts to allow expressions and conditions
+ * to reference field state (e.g., `fieldState.touched`, `formFieldState.email.dirty`).
+ *
+ * @public
  */
-interface Logger {
-    /**
-     * Log a debug message.
-     * Use for detailed diagnostic information during development.
-     */
-    debug(message: string, ...args: unknown[]): void;
+interface FieldStateInfo {
+    readonly touched: boolean;
+    readonly dirty: boolean;
+    /** Convenience property: equivalent to `!dirty` */
+    readonly pristine: boolean;
+    readonly valid: boolean;
+    readonly invalid: boolean;
+    readonly pending: boolean;
     /**
-     * Log an info message.
-     * Use for general operational information.
+     * Whether the field is currently hidden.
+     *
+     * Note: This is a library-managed property, not a native Angular Signal Forms
+     * property. Returns `false` if the field instance does not expose a `hidden` signal.
      */
-    info(message: string, ...args: unknown[]): void;
+    readonly hidden: boolean;
     /**
-     * Log a warning message.
-     * Use for potentially problematic situations that don't prevent operation.
+     * Whether the field is currently readonly.
+     *
+     * Note: This is a library-managed property, not a native Angular Signal Forms
+     * property. Returns `false` if the field instance does not expose a `readonly` signal.
      */
-    warn(message: string, ...args: unknown[]): void;
+    readonly readonly: boolean;
     /**
-     * Log an error message.
-     * Use for error conditions that may affect functionality.
+     * Whether the field is currently disabled.
+     *
+     * Note: This is a library-managed property, not a native Angular Signal Forms
+     * property. Returns `false` if the field instance does not expose a `disabled` signal.
      */
-    error(message: string, ...args: unknown[]): void;
+    readonly disabled: boolean;
 }
+/**
+ * Map of field keys to their state information.
+ *
+ * Used as `formFieldState` in evaluation contexts to access
+ * state of any field in the form by key.
+ *
+ * @public
+ */
+type FormFieldStateMap = Record<string, FieldStateInfo | undefined>;
+/**
+ * Field state context for the current field being evaluated.
+ *
+ * Used as `fieldState` in evaluation contexts.
+ *
+ * @public
+ */
+type FieldStateContext = FieldStateInfo;
 
 interface EvaluationContext<TValue = unknown> {
     /** Current field value */
@@ -1871,6 +3034,43 @@ interface EvaluationContext<TValue = unknown> {
      * ```
      */
     externalData?: Record<string, unknown>;
+    /**
+     * DI-scoped tracker for deprecation warnings.
+     * Used by the condition evaluator to deduplicate deprecation warnings.
+     */
+    deprecationTracker?: DeprecationWarningTracker;
+    /**
+     * State of the current field being evaluated.
+     *
+     * Provides access to field state properties like `touched`, `dirty`, `valid`, etc.
+     * Uses a Proxy for lazy evaluation — properties are only read when accessed.
+     *
+     * @example
+     * ```typescript
+     * // In a JavaScript expression:
+     * condition: {
+     *   type: 'javascript',
+     *   expression: "fieldState.touched && fieldState.dirty"
+     * }
+     * ```
+     */
+    fieldState?: FieldStateContext;
+    /**
+     * State of all fields in the form, keyed by field key.
+     *
+     * Provides access to any field's state properties by key.
+     * Uses a Proxy for lazy evaluation — field state is only read when accessed.
+     *
+     * @example
+     * ```typescript
+     * // In a JavaScript expression:
+     * condition: {
+     *   type: 'javascript',
+     *   expression: "formFieldState.email.dirty && formFieldState.email.valid"
+     * }
+     * ```
+     */
+    formFieldState?: FormFieldStateMap;
     /** Allow additional properties for flexible expression evaluation */
     [key: string]: unknown;
 }
@@ -1916,6 +3116,43 @@ interface EvaluationContext<TValue = unknown> {
  */
 type CustomFunction = (context: EvaluationContext) => unknown;
 
+/**
+ * Async function for derivations — returns any value.
+ *
+ * The function receives the evaluation context and may return a Promise or Observable.
+ * Register functions in `customFnConfig.asyncDerivations`.
+ *
+ * @example
+ * ```typescript
+ * const fetchPrice: AsyncDerivationFunction = async (context) => {
+ *   const response = await fetch(`/api/price?product=${context.formValue.productId}`);
+ *   const data = await response.json();
+ *   return data.price;
+ * };
+ * ```
+ *
+ * @public
+ */
+type AsyncDerivationFunction = (context: EvaluationContext) => Promise<unknown> | Observable<unknown>;
+/**
+ * Async function for conditions — returns boolean.
+ *
+ * The function receives the evaluation context and may return a Promise or Observable.
+ * Register functions in `customFnConfig.asyncConditions`.
+ *
+ * @example
+ * ```typescript
+ * const checkPermission: AsyncConditionFunction = async (context) => {
+ *   const response = await fetch(`/api/permissions?user=${context.formValue.userId}`);
+ *   const data = await response.json();
+ *   return data.canEdit;
+ * };
+ * ```
+ *
+ * @public
+ */
+type AsyncConditionFunction = (context: EvaluationContext) => Promise<boolean> | Observable<boolean>;
+
 /**
  * Re-export Angular's ValidationError for consistency
  * This replaces our custom ValidationError interface
@@ -2421,6 +3658,103 @@ interface CustomFnConfig {
      * ```
      */
     derivations?: Record<string, CustomFunction>;
+    /**
+     * @deprecated Register functions under `derivations` instead. Use `type: 'derivation'`
+     * with `targetProperty` in field logic configs. Will be removed in a future minor version.
+     *
+     * Custom property derivation functions for reactive property updates.
+     *
+     * These functions compute derived values for field properties (like `minDate`,
+     * `options`, `label`, `placeholder`) and are called when a
+     * `PropertyDerivationLogicConfig` references them by `functionName`.
+     *
+     * Property derivation functions:
+     * - Receive an `EvaluationContext` with access to `formValue`
+     * - Return the value to set on the target property
+     * - Are called reactively when dependencies change
+     *
+     * @example
+     * ```typescript
+     * propertyDerivations: {
+     *   getCitiesForCountry: (context) => {
+     *     const countryCities: Record<string, Array<{ label: string; value: string }>> = {
+     *       'USA': [{ label: 'New York', value: 'ny' }, { label: 'LA', value: 'la' }],
+     *       'Germany': [{ label: 'Berlin', value: 'berlin' }, { label: 'Munich', value: 'munich' }],
+     *     };
+     *     return countryCities[context.formValue.country as string] ?? [];
+     *   },
+     * }
+     * ```
+     *
+     * Field configuration using a property derivation function:
+     * ```typescript
+     * {
+     *   key: 'city',
+     *   type: 'select',
+     *   logic: [{
+     *     type: 'propertyDerivation',
+     *     targetProperty: 'options',
+     *     functionName: 'getCitiesForCountry',
+     *     dependsOn: ['country']
+     *   }]
+     * }
+     * ```
+     */
+    propertyDerivations?: Record<string, CustomFunction>;
+    /**
+     * Async derivation functions for asynchronous value derivation logic.
+     *
+     * These functions perform asynchronous operations (service calls, complex pipelines)
+     * and return the derived value via a Promise or Observable. They are called when a
+     * `DerivationLogicConfig` references them by `asyncFunctionName`.
+     *
+     * Async derivation functions:
+     * - Receive an `EvaluationContext` with access to `formValue`
+     * - Return a Promise or Observable of the value to set on the target field
+     * - Handle their own I/O (no HttpClient provided — use injected services)
+     * - Require explicit `dependsOn` to avoid triggering on every form change
+     *
+     * @example
+     * ```typescript
+     * asyncDerivations: {
+     *   fetchSuggestedPrice: async (context) => {
+     *     const response = await fetch(`/api/price?product=${context.formValue.productId}`);
+     *     const data = await response.json();
+     *     return data.suggestedPrice;
+     *   },
+     *   lookupAddress: (context) => {
+     *     return addressService.lookup(context.formValue.zipCode).pipe(
+     *       map(result => result.formattedAddress)
+     *     );
+     *   },
+     * }
+     * ```
+     */
+    asyncDerivations?: Record<string, AsyncDerivationFunction>;
+    /**
+     * Async condition functions for asynchronous field state logic.
+     *
+     * These functions perform asynchronous operations and return a boolean
+     * indicating whether the condition is met. They are referenced by
+     * `asyncFunctionName` in `AsyncCondition` expressions.
+     *
+     * Async condition functions:
+     * - Receive an `EvaluationContext` with access to `formValue`
+     * - Return a Promise or Observable of boolean
+     * - Handle their own I/O (use injected services)
+     *
+     * @example
+     * ```typescript
+     * asyncConditions: {
+     *   checkPermission: async (context) => {
+     *     const response = await fetch(`/api/permissions?role=${context.formValue.role}`);
+     *     const data = await response.json();
+     *     return data.canEdit;
+     *   },
+     * }
+     * ```
+     */
+    asyncConditions?: Record<string, AsyncConditionFunction>;
     /**
      * Custom validators using Angular's public FieldContext API
      *
@@ -2538,6 +3872,10 @@ interface CustomFnConfig {
      */
     asyncValidators?: Record<string, AsyncCustomValidator>;
     /**
+     * @deprecated Prefer declarative HTTP validators using `type: 'http'` with `http` + `responseMapping`
+     * in the validators array. Function-based HTTP validators now also use `type: 'http'` with `functionName`.
+     * Will be removed in a future minor version.
+     *
      * HTTP validators using Angular's validateHttp() API
      *
      * Angular's validateHttp provides HTTP validation with automatic request
@@ -2680,233 +4018,128 @@ interface FormOptions {
      */
     nextButton?: NextButtonOptions;
     /**
-     * Whether to attach the current form value to all events dispatched through the EventBus.
+     * Whether to exclude values of hidden fields from submission output.
      *
-     * This per-form setting overrides the global `withEventFormValue()` feature:
-     * - `true` - Enable form value emission for this form (even if globally disabled)
-     * - `false` - Disable form value emission for this form (even if globally enabled)
-     * - `undefined` - Use global setting (default)
-     *
-     * When enabled, events will include a `formValue` property with the current form state.
-     * Use the `hasFormValue()` type guard to safely access this property.
-     *
-     * @example
-     * ```typescript
-     * // Enable for this form only (no global withEventFormValue() needed)
-     * const config: FormConfig = {
-     *   fields: [...],
-     *   options: { emitFormValueOnEvents: true }
-     * };
-     *
-     * // Disable for this form (when globally enabled)
-     * const config: FormConfig = {
-     *   fields: [...],
-     *   options: { emitFormValueOnEvents: false }
-     * };
-     * ```
+     * Overrides the global `withValueExclusionDefaults()` setting for this form.
+     * Can be further overridden per-field on individual `FieldDef` entries.
      *
      * @default undefined (uses global setting)
      */
-    emitFormValueOnEvents?: boolean;
-}
-/**
- * Options for controlling submit button disabled behavior.
- *
- * @public
- */
-interface SubmitButtonOptions {
+    excludeValueIfHidden?: boolean;
     /**
-     * Disable submit button when the form is invalid.
+     * Whether to exclude values of disabled fields from submission output.
      *
-     * @default true
+     * Overrides the global `withValueExclusionDefaults()` setting for this form.
+     * Can be further overridden per-field on individual `FieldDef` entries.
+     *
+     * @default undefined (uses global setting)
      */
-    disableWhenInvalid?: boolean;
+    excludeValueIfDisabled?: boolean;
     /**
-     * Disable submit button while the form is submitting.
+     * Whether to exclude values of readonly fields from submission output.
      *
-     * Requires `submission.action` to be configured for automatic detection.
+     * Overrides the global `withValueExclusionDefaults()` setting for this form.
+     * Can be further overridden per-field on individual `FieldDef` entries.
      *
-     * @default true
+     * @default undefined (uses global setting)
      */
-    disableWhileSubmitting?: boolean;
-}
-/**
- * Options for controlling next page button disabled behavior.
- *
- * @public
- */
-interface NextButtonOptions {
+    excludeValueIfReadonly?: boolean;
     /**
-     * Disable next button when the current page has invalid fields.
+     * Whether to attach the current form value to all events dispatched through the EventBus.
      *
-     * @default true
-     */
-    disableWhenPageInvalid?: boolean;
-    /**
-     * Disable next button while the form is submitting.
+     * This per-form setting overrides the global `withEventFormValue()` feature:
+     * - `true` - Enable form value emission for this form (even if globally disabled)
+     * - `false` - Disable form value emission for this form (even if globally enabled)
+     * - `undefined` - Use global setting (default)
      *
-     * @default true
-     */
-    disableWhileSubmitting?: boolean;
-}
-
-/**
- * Form mode enumeration distinguishing between paged and non-paged forms
- */
-type FormMode = 'paged' | 'non-paged';
-/**
- * Result of form mode detection with validation details
- */
-interface FormModeDetectionResult {
-    /** The detected form mode */
-    mode: FormMode;
-    /** Whether the form configuration is valid for the detected mode */
-    isValid: boolean;
-    /** Array of validation errors if form is invalid */
-    errors: string[];
-}
-
-/**
- * Type guard to check if a field is a container field (page, row, group, or array)
- * Container fields have a 'fields' property and don't contribute values directly.
- * This overload works with RegisteredFieldTypes for full type narrowing.
- */
-declare function isContainerField(field: RegisteredFieldTypes): field is ContainerFieldTypes;
-/**
- * Type guard to check if a field is a container field (page, row, group, or array).
- * This overload works with any FieldDef for looser type checking.
- */
-declare function isContainerField(field: FieldDef<unknown>): boolean;
-/**
- * Type guard to check if a field is a leaf field (value or display field)
- * Leaf fields don't have children and either contribute values or display content
- */
-declare function isLeafField(field: RegisteredFieldTypes): field is LeafFieldTypes;
-/**
- * Type guard to check if a field has a value property (value-bearing field)
- * These fields contribute to the form value output
- * Note: Using `unknown` in the Extract condition to match any value type
- */
-declare function isValueBearingField(field: RegisteredFieldTypes): field is Extract<RegisteredFieldTypes, {
-    value: unknown;
-}>;
-/**
- * Type guard to check if a field is excluded from form values (display-only field)
- * Currently this includes text fields and any other fields without a value property
- */
-declare function isDisplayOnlyField(field: RegisteredFieldTypes): boolean;
-
-/**
- * Helper types for creating type-safe field configurations with proper nesting constraints
- */
-
-/**
- * Type helper for accessing nested field paths safely
- * This allows accessing child paths while maintaining some type safety
- */
-type FieldPathAccess<TValue> = {
-    [K in keyof TValue]: SchemaPath<TValue[K]> | SchemaPathTree<TValue[K]>;
-};
-
-/**
- * Result of processing all pending derivations.
- *
- * @public
- */
-interface DerivationProcessingResult {
-    /** Number of derivations successfully applied */
-    appliedCount: number;
-    /** Number of derivations skipped (condition not met or value unchanged) */
-    skippedCount: number;
-    /** Number of derivations that failed with errors */
-    errorCount: number;
-    /**
-     * Number of derivations that encountered warnings (e.g., missing target field).
+     * When enabled, events will include a `formValue` property with the current form state.
+     * Use the `hasFormValue()` type guard to safely access this property.
      *
-     * These are not counted as errors because they may be intentional (conditional fields)
-     * but indicate potential configuration issues if unexpected.
+     * @example
+     * ```typescript
+     * // Enable for this form only (no global withEventFormValue() needed)
+     * const config: FormConfig = {
+     *   fields: [...],
+     *   options: { emitFormValueOnEvents: true }
+     * };
+     *
+     * // Disable for this form (when globally enabled)
+     * const config: FormConfig = {
+     *   fields: [...],
+     *   options: { emitFormValueOnEvents: false }
+     * };
+     * ```
+     *
+     * @default undefined (uses global setting)
      */
-    warnCount: number;
-    /** Total iterations performed */
-    iterations: number;
-    /** Whether max iterations was reached (potential loop) */
-    maxIterationsReached: boolean;
+    emitFormValueOnEvents?: boolean;
 }
-
 /**
- * Information about a single derivation evaluation for logging.
+ * Options for controlling submit button disabled behavior.
  *
  * @public
  */
-interface DerivationLogEntry {
-    /** Debug name if provided in the derivation config */
-    debugName?: string;
-    /** Field key where the derivation is defined and targets */
-    fieldKey: string;
-    /** Result of the derivation evaluation */
-    result: 'applied' | 'skipped' | 'error';
-    /** Reason for skipping (if result is 'skipped') */
-    skipReason?: 'condition-false' | 'value-unchanged' | 'already-applied' | 'target-not-found';
-    /** The new value that was set (if result is 'applied') */
-    newValue?: unknown;
-    /** The previous value before the derivation (if result is 'applied') */
-    previousValue?: unknown;
-    /** Error message (if result is 'error') */
-    error?: string;
-    /** Duration in milliseconds (optional, for performance tracking) */
-    durationMs?: number;
+interface SubmitButtonOptions {
+    /**
+     * Disable submit button when the form is invalid.
+     *
+     * @default true
+     */
+    disableWhenInvalid?: boolean;
+    /**
+     * Disable submit button while the form is submitting.
+     *
+     * Requires `submission.action` to be configured for automatic detection.
+     *
+     * @default true
+     */
+    disableWhileSubmitting?: boolean;
 }
-
 /**
- * Service interface for derivation logging.
- *
- * Provides methods to log derivation processing events at different verbosity levels.
- * Use `DERIVATION_LOGGER` injection token to get an instance.
+ * Options for controlling next page button disabled behavior.
  *
  * @public
  */
-interface DerivationLogger {
-    /**
-     * Logs the start of a derivation processing cycle.
-     * Only logs when config level is 'verbose'.
-     */
-    cycleStart(trigger: 'onChange' | 'debounced', entryCount: number): void;
-    /**
-     * Logs the start of a derivation iteration within a cycle.
-     * Only logs when config level is 'verbose'.
-     */
-    iteration(iterationNumber: number): void;
-    /**
-     * Logs a single derivation evaluation result.
-     * Only logs when config level is 'verbose'.
-     */
-    evaluation(entry: DerivationLogEntry): void;
+interface NextButtonOptions {
     /**
-     * Logs a summary of derivation processing results.
-     * Logs when config level is 'summary' or 'verbose' and something interesting happened.
+     * Disable next button when the current page has invalid fields.
+     *
+     * @default true
      */
-    summary(result: DerivationProcessingResult, trigger: 'onChange' | 'debounced'): void;
+    disableWhenPageInvalid?: boolean;
     /**
-     * Logs when max iterations are reached (always logged as warning).
+     * Disable next button while the form is submitting.
+     *
+     * @default true
      */
-    maxIterationsReached(result: DerivationProcessingResult, trigger: 'onChange' | 'debounced'): void;
+    disableWhileSubmitting?: boolean;
+}
+
+/**
+ * Form mode enumeration distinguishing between paged and non-paged forms
+ */
+type FormMode = 'paged' | 'non-paged';
+/**
+ * Result of form mode detection with validation details
+ */
+interface FormModeDetectionResult {
+    /** The detected form mode */
+    mode: FormMode;
+    /** Whether the form configuration is valid for the detected mode */
+    isValid: boolean;
+    /** Array of validation errors if form is invalid */
+    errors: string[];
 }
 
 /**
- * Minimal configuration for creating a DerivationOrchestrator.
- * Only includes form-specific signals that cannot be injected.
+ * Error from async field component loading.
  *
- * @internal
+ * @public
  */
-interface DerivationOrchestratorConfig {
-    /** Signal containing the flattened schema fields */
-    schemaFields: Signal<FieldDef<unknown>[] | undefined>;
-    /** Signal containing the current form value */
-    formValue: Signal<Record<string, unknown>>;
-    /** Signal containing the form accessor */
-    form: Signal<FieldTree<unknown>>;
-    /** Signal containing the derivation logger */
-    derivationLogger: Signal<DerivationLogger>;
+interface FieldLoadingError {
+    readonly fieldType: string;
+    readonly fieldKey: string;
+    readonly error: Error;
 }
 
 /**
@@ -3072,108 +4305,88 @@ declare class PageNavigationStateChangeEvent implements FormEvent {
 }
 
 /**
- * Dynamic form component that renders a complete form based on configuration.
- *
- * This is the main entry point for the dynamic form system. It handles form state management,
- * validation, field rendering, and event coordination using Angular's signal-based reactive forms.
- *
- * @typeParam TFields - Array of registered field types available for this form
- * @typeParam TModel - The strongly-typed interface for form values
+ * Dynamic form component — renders a form based on configuration.
+ * Delegates state management to `FormStateManager`.
  *
  * @example
  *```html
- * <form
- *  [dynamic-form]="formConfig"
- *  [(value)]="formData"
- *  (submitted)="handleSubmit($event)"
- *  (validityChange)="handleValidityChange($event)">
- * </form>
+ * <form [dynamic-form]="formConfig" [(value)]="formData" (submitted)="handleSubmit($event)"></form>
  * ```
  */
-declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel extends Record<string, unknown> = InferFormValue$1<TFields> & Record<string, unknown>> implements OnDestroy {
-    private readonly destroyRef;
-    private readonly fieldRegistry;
-    private readonly injector;
-    private readonly eventBus;
-    private readonly rootFormRegistry;
-    private readonly functionRegistry;
-    private readonly schemaRegistry;
-    private readonly logger;
-    private readonly derivationLogConfig;
+declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFieldTypes[], TModel extends Record<string, unknown> = InferFormValue$1<TFields> & Record<string, unknown>> {
     /** Form configuration defining the structure, validation, and behavior. */
-    config: InputSignal<FormConfig<TFields>>;
+    config: _angular_core.InputSignal<FormConfig<TFields, InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown>>;
     /** Runtime form options that override config options when provided. */
-    formOptions: InputSignal<FormOptions | undefined>;
+    formOptions: _angular_core.InputSignal<FormOptions | undefined>;
     /** Form values for two-way data binding. */
     value: _angular_core.ModelSignal<Partial<TModel> | undefined>;
-    private readonly memoizedFlattenFields;
-    private readonly memoizedFlattenFieldsForRendering;
-    private readonly memoizedKeyBy;
-    private readonly memoizedDefaultValues;
-    private readonly rawFieldRegistry;
-    readonly formModeDetection: Signal<FormModeDetectionResult>;
-    private readonly formSetup;
-    readonly pageFieldDefinitions: Signal<PageField<_ng_forge_dynamic_forms.PageAllowedChildren[]>[]>;
-    readonly effectiveFormOptions: Signal<{
+    private destroyRef;
+    private injector;
+    private eventBus;
+    private logger;
+    /**
+     * Connect input signals to the shared deps holder BEFORE injecting FormStateManager.
+     * Field initializers run in declaration order, so this runs after inputs are created
+     * but before stateManager is injected. FormStateManager reads from these signals
+     * in computeds/effects, which are all lazy and evaluated after construction.
+     */
+    private readonly _connectStateDeps;
+    /** State manager that owns all form state. */
+    private stateManager;
+    private componentId;
+    /** The currently active config used for form rendering */
+    activeConfig: Signal<FormConfig<TFields, InferFormValue$1<TFields extends readonly RegisteredFieldTypes[] ? TFields : RegisteredFieldTypes[]>, Record<string, unknown>, unknown> | undefined>;
+    /** Current render phase: 'render' = showing form, 'teardown' = hiding old components */
+    renderPhase: Signal<"teardown" | "render">;
+    /** Computed form mode detection with validation */
+    formModeDetection: Signal<_ng_forge_dynamic_forms.FormModeDetectionResult>;
+    /** Page field definitions for paged forms */
+    pageFieldDefinitions: Signal<_ng_forge_dynamic_forms.PageField<_ng_forge_dynamic_forms.PageAllowedChildren[]>[]>;
+    /** Effective form options (merged from config and input) */
+    effectiveFormOptions: Signal<{
         disabled?: boolean;
         maxDerivationIterations?: number;
         submitButton?: _ng_forge_dynamic_forms.SubmitButtonOptions;
         nextButton?: _ng_forge_dynamic_forms.NextButtonOptions;
+        excludeValueIfHidden?: boolean;
+        excludeValueIfDisabled?: boolean;
+        excludeValueIfReadonly?: boolean;
         emitFormValueOnEvents?: boolean;
     }>;
-    /**
-     * Computed derivation logger based on injected config.
-     *
-     * Uses factory pattern to return no-op logger when logging is disabled,
-     * avoiding any logging overhead in production.
-     */
-    private readonly derivationLogger;
-    readonly fieldSignalContext: Signal<FieldSignalContext<TModel>>;
-    /**
-     * Injector for field components with FIELD_SIGNAL_CONTEXT.
-     * Other form-level tokens (DEFAULT_PROPS, etc.) are provided at component level.
-     */
-    private readonly fieldInjector;
-    readonly defaultValues: _angular_core.WritableSignal<TModel>;
-    private readonly entity;
-    readonly form: Signal<FieldTree<TModel, string | number>>;
-    private readonly componentId;
-    private readonly totalComponentsCount;
-    private readonly fieldsSource;
-    /** Collects errors from async field component loading for error boundary patterns. */
-    readonly fieldLoadingErrors: _angular_core.WritableSignal<{
-        fieldType: string;
-        fieldKey: string;
-        error: Error;
-    }[]>;
-    /** Current form values (reactive). */
-    readonly formValue: Signal<TModel | (TModel extends infer T ? T extends TModel ? T extends _angular_forms.AbstractControl<unknown, infer TValue extends unknown, any> ? TValue : never : never : never)>;
-    /** Whether the form is currently valid. */
-    readonly valid: Signal<boolean>;
-    /** Whether the form is currently invalid. */
-    readonly invalid: Signal<boolean>;
-    /** Whether any form field has been modified. */
-    readonly dirty: Signal<boolean>;
-    /** Whether any form field has been touched (blurred). */
-    readonly touched: Signal<boolean>;
-    /** Current validation errors from all fields. */
-    readonly errors: Signal<_angular_forms_signals.ValidationError.WithField[]>;
-    /** Whether the form is disabled (from options or form state). */
-    readonly disabled: Signal<boolean>;
-    /** Whether the form is currently submitting. */
-    readonly submitting: Signal<boolean>;
-    /**
-     * Configuration for the derivation orchestrator.
-     * Bundles the form-specific signals needed by the orchestrator.
-     *
-     * @internal Used by DERIVATION_ORCHESTRATOR provider.
-     */
-    readonly derivationOrchestratorConfig: DerivationOrchestratorConfig;
-    readonly initialized$: rxjs.Observable<boolean>;
+    /** Field signal context for injection into child components */
+    fieldSignalContext: Signal<_ng_forge_dynamic_forms.FieldSignalContext<TModel>>;
+    /** Default values computed from field definitions */
+    defaultValues: WritableSignal<TModel>;
+    /** The Angular Signal Form instance */
+    form: Signal<FieldTree<TModel, string | number>>;
+    /** Current form values (reactive) */
+    formValue: Signal<TModel | (TModel extends infer T ? T extends TModel ? T extends _angular_forms.AbstractControl<unknown, infer TValue extends unknown, any> ? TValue : never : never : never)>;
+    /** Whether the form is currently valid */
+    valid: Signal<boolean>;
+    /** Whether the form is currently invalid */
+    invalid: Signal<boolean>;
+    /** Whether any form field has been modified */
+    dirty: Signal<boolean>;
+    /** Whether any form field has been touched (blurred) */
+    touched: Signal<boolean>;
+    /** Current validation errors from all fields */
+    errors: Signal<_angular_forms_signals.ValidationError.WithField[]>;
+    /** Whether the form is disabled (from options or form state) */
+    disabled: Signal<boolean>;
+    /** Whether the form is currently submitting */
+    submitting: Signal<boolean>;
+    /** Collects errors from async field component loading for error boundary patterns */
+    fieldLoadingErrors: WritableSignal<FieldLoadingError[]>;
+    /** Whether to render the form template */
+    shouldRender: Signal<boolean>;
+    /** Resolved fields ready for rendering */
+    protected resolvedFields: Signal<ResolvedField[]>;
+    private totalComponentsCount;
+    initialized$: rxjs.Observable<boolean>;
     /** Emits when form validity changes. */
-    readonly validityChange: _angular_core.OutputRef<boolean>;
+    validityChange: _angular_core.OutputRef<boolean>;
     /** Emits when form dirty state changes. */
-    readonly dirtyChange: _angular_core.OutputRef<boolean>;
+    dirtyChange: _angular_core.OutputRef<boolean>;
     /**
      * Emits form values when submitted (via SubmitEvent) and form is valid.
      *
@@ -3183,23 +4396,22 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
      *
      * Note: Does not emit when `submission.action` is configured - use one or the other.
      */
-    readonly submitted: _angular_core.OutputRef<TModel>;
+    submitted: _angular_core.OutputRef<Partial<TModel>>;
     /** Emits when form is reset to default values. */
-    readonly reset: _angular_core.OutputRef<FormResetEvent>;
+    reset: _angular_core.OutputRef<FormResetEvent>;
     /** Emits when form is cleared to empty state. */
-    readonly cleared: _angular_core.OutputRef<FormClearEvent>;
+    cleared: _angular_core.OutputRef<FormClearEvent>;
     /** Emits all form events for custom event handling. */
-    readonly events: _angular_core.OutputRef<_ng_forge_dynamic_forms.FormEvent>;
+    events: _angular_core.OutputRef<_ng_forge_dynamic_forms.FormEvent>;
     /**
      * Emits when all form components are initialized and ready for interaction.
      * Useful for E2E testing to ensure the form is fully rendered before interaction.
      */
-    readonly initialized: _angular_core.OutputRef<boolean>;
+    initialized: _angular_core.OutputRef<boolean>;
     /** Emits when the current page changes in paged forms. */
-    readonly onPageChange: _angular_core.OutputRef<PageChangeEvent>;
+    onPageChange: _angular_core.OutputRef<PageChangeEvent>;
     /** Emits when page navigation state changes (canGoNext, canGoPrevious, etc.). */
-    readonly onPageNavigationStateChange: _angular_core.OutputRef<PageNavigationStateChangeEvent>;
-    protected readonly resolvedFields: Signal<ResolvedField[]>;
+    onPageNavigationStateChange: _angular_core.OutputRef<PageNavigationStateChangeEvent>;
     constructor();
     /**
      * Handles native form submission triggered by:
@@ -3215,12 +4427,6 @@ declare class DynamicForm<TFields extends RegisteredFieldTypes[] = RegisteredFie
     protected onNativeSubmit(event: Event): void;
     private setupEffects;
     private setupEventHandlers;
-    private registerValidatorsFromConfig;
-    private createFormSetupFromConfig;
-    private createEmptyFormSetup;
-    private onFormReset;
-    private onFormClear;
-    ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicForm<any, any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicForm<any, any>, "form[dynamic-form]", never, { "config": { "alias": "dynamic-form"; "required": true; "isSignal": true; }; "formOptions": { "alias": "formOptions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; "reset": "reset"; "cleared": "cleared"; "events": "events"; "initialized": "initialized"; "onPageChange": "onPageChange"; "onPageNavigationStateChange": "onPageNavigationStateChange"; }, never, never, true, never>;
 }
@@ -3239,6 +4445,48 @@ interface DynamicFormFeature<TKind extends string = string> {
     ɵproviders: Provider[];
 }
 
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array)
+ * Container fields have a 'fields' property and don't contribute values directly.
+ * This overload works with RegisteredFieldTypes for full type narrowing.
+ */
+declare function isContainerField(field: RegisteredFieldTypes): field is ContainerFieldTypes;
+/**
+ * Type guard to check if a field is a container field (page, row, group, or array).
+ * This overload works with any FieldDef for looser type checking.
+ */
+declare function isContainerField(field: FieldDef<unknown>): boolean;
+/**
+ * Type guard to check if a field is a leaf field (value or display field)
+ * Leaf fields don't have children and either contribute values or display content
+ */
+declare function isLeafField(field: RegisteredFieldTypes): field is LeafFieldTypes;
+/**
+ * Type guard to check if a field has a value property (value-bearing field)
+ * These fields contribute to the form value output
+ * Note: Using `unknown` in the Extract condition to match any value type
+ */
+declare function isValueBearingField(field: RegisteredFieldTypes): field is Extract<RegisteredFieldTypes, {
+    value: unknown;
+}>;
+/**
+ * Type guard to check if a field is excluded from form values (display-only field)
+ * Currently this includes text fields and any other fields without a value property
+ */
+declare function isDisplayOnlyField(field: RegisteredFieldTypes): boolean;
+
+/**
+ * Helper types for creating type-safe field configurations with proper nesting constraints
+ */
+
+/**
+ * Type helper for accessing nested field paths safely
+ * This allows accessing child paths while maintaining some type safety
+ */
+type FieldPathAccess<TValue> = {
+    [K in keyof TValue]: SchemaPath<TValue[K]> | SchemaPathTree<TValue[K]>;
+};
+
 /**
  * Extract FieldDef type from FieldTypeDefinition
  */
@@ -3509,6 +4757,100 @@ declare class NoopLogger implements Logger {
  */
 declare function withEventFormValue(): DynamicFormFeature<'event-form-value'>;
 
+/**
+ * Configuration for excluding field values from form submission output
+ * based on their reactive state (hidden, disabled, readonly).
+ *
+ * Supports a 3-tier configuration hierarchy: Field > Form > Global.
+ * The most specific level wins for each property.
+ *
+ * @public
+ */
+interface ValueExclusionConfig {
+    /**
+     * Whether to exclude the value of hidden fields from submission output.
+     *
+     * When `true`, fields whose `hidden()` state is `true` will have their
+     * values omitted from the submitted form value.
+     *
+     * @remarks
+     * This does NOT affect HiddenField (`type: 'hidden'`) — those fields
+     * store values without UI and their `hidden()` state is always `false`.
+     */
+    readonly excludeValueIfHidden?: boolean;
+    /**
+     * Whether to exclude the value of disabled fields from submission output.
+     *
+     * When `true`, fields whose `disabled()` state is `true` will have their
+     * values omitted from the submitted form value.
+     */
+    readonly excludeValueIfDisabled?: boolean;
+    /**
+     * Whether to exclude the value of readonly fields from submission output.
+     *
+     * When `true`, fields whose `readonly()` state is `true` will have their
+     * values omitted from the submitted form value.
+     */
+    readonly excludeValueIfReadonly?: boolean;
+}
+/**
+ * Fully resolved exclusion config with all properties required.
+ * Produced by the 3-tier resolution: `field ?? form ?? global`.
+ *
+ * @public
+ */
+type ResolvedValueExclusionConfig = Required<ValueExclusionConfig>;
+
+/**
+ * Configures global value exclusion defaults for form submission output.
+ *
+ * Value exclusion is **enabled by default** — field values are excluded from the
+ * `(submitted)` output based on their reactive state. Use this feature to
+ * override those defaults. This does NOT affect two-way binding (`value` model /
+ * `entity`) — fields retain their values internally.
+ *
+ * @example Default behavior (all exclusions enabled)
+ * ```typescript
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withValueExclusionDefaults()
+ * )
+ * ```
+ *
+ * @example Disable specific exclusions
+ * ```typescript
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withValueExclusionDefaults({ excludeValueIfReadonly: false })
+ * )
+ * ```
+ *
+ * @example Disable all exclusions (restore pre-v1 behavior)
+ * ```typescript
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withValueExclusionDefaults({
+ *     excludeValueIfHidden: false,
+ *     excludeValueIfDisabled: false,
+ *     excludeValueIfReadonly: false,
+ *   })
+ * )
+ * ```
+ *
+ * @remarks
+ * **Precedence rules:**
+ * 1. Per-field `excludeValueIf*` on `FieldDef` — wins for that field
+ * 2. Per-form `excludeValueIf*` on `FormOptions` — wins for all fields in that form
+ * 3. Global `withValueExclusionDefaults()` — baseline default
+ * 4. No global feature — uses token default (all enabled)
+ *
+ * @param config - Partial override of exclusion rules. Unspecified properties default to `true`.
+ * @returns A DynamicFormFeature that configures value exclusion defaults
+ *
+ * @public
+ */
+declare function withValueExclusionDefaults(config?: Partial<ValueExclusionConfig>): DynamicFormFeature<'value-exclusion'>;
+
 interface FieldOption<T = unknown> {
     label: DynamicText;
     value: T;
@@ -3595,127 +4937,53 @@ declare const DEFAULT_PROPS: InjectionToken<Signal<Record<string, unknown> | und
 /**
  * Injection token for form-level default validation messages.
  *
- * Default validation messages act as fallbacks when fields have validation
- * errors but no field-level `validationMessages` defined.
- *
- * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
- * and inherited by all children via Angular's hierarchical injector.
- *
- * The token provides a Signal to enable reactivity - when config changes, mappers
- * that read the signal inside their computed() will automatically update.
- *
- * @example
- * ```typescript
- * // In a mapper or component
- * const defaultMessagesSignal = inject(DEFAULT_VALIDATION_MESSAGES);
- *
- * return computed(() => {
- *   const defaultMessages = defaultMessagesSignal?.();  // Read inside computed for reactivity
- *   const message = defaultMessages?.required ?? 'Field is required';
- *   // ...
- * });
- * ```
- */
-declare const DEFAULT_VALIDATION_MESSAGES: InjectionToken<Signal<ValidationMessages | undefined>>;
-/**
- * Injection token for form-level options.
- *
- * Form options control form-wide behavior including button disabled states.
- * Used by button mappers to determine default disabled behavior.
- *
- * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
- * and inherited by all children via Angular's hierarchical injector.
- *
- * The token provides a Signal to enable reactivity - when config changes, mappers
- * that read the signal inside their computed() will automatically update.
- *
- * @example
- * ```typescript
- * // In a button mapper
- * const formOptionsSignal = inject(FORM_OPTIONS);
- *
- * return computed(() => {
- *   const formOptions = formOptionsSignal?.();  // Read inside computed for reactivity
- *   const disableWhenInvalid = formOptions?.submitButton?.disableWhenInvalid ?? true;
- *   // ...
- * });
- * ```
- */
-declare const FORM_OPTIONS: InjectionToken<Signal<FormOptions | undefined>>;
-
-/**
- * Context for resolving button disabled state.
- *
- * @public
- */
-interface ButtonLogicContext {
-    /** The form's FieldTree instance (supports both string and number keys for array indices) */
-    form: FieldTree<unknown, string | number>;
-    /** Form-level options */
-    formOptions?: FormOptions;
-    /** Field-level logic array (if provided) */
-    fieldLogic?: LogicConfig[];
-    /** Explicit disabled state from field definition */
-    explicitlyDisabled?: boolean;
-    /** Current page validity signal (for paged forms) */
-    currentPageValid?: Signal<boolean>;
-    /** Current form value for evaluating conditional expressions */
-    formValue?: unknown;
-    /** Optional logger for diagnostic output. Falls back to no-op logger if not provided. */
-    logger?: Logger;
-}
-/**
- * Resolves the disabled state for a submit button.
- *
- * The disabled state is determined by (in order of precedence):
- * 1. Explicit `disabled: true` on the field definition
- * 2. Field-level `logic` array (if present, overrides form-level defaults)
- * 3. Form-level `options.submitButton` defaults
+ * Default validation messages act as fallbacks when fields have validation
+ * errors but no field-level `validationMessages` defined.
  *
- * @param ctx - The button logic context
- * @returns A computed signal that returns true when the button should be disabled
+ * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
+ * and inherited by all children via Angular's hierarchical injector.
+ *
+ * The token provides a Signal to enable reactivity - when config changes, mappers
+ * that read the signal inside their computed() will automatically update.
  *
  * @example
  * ```typescript
- * const disabled = resolveSubmitButtonDisabled({
- *   form: formInstance,
- *   formOptions: config.options,
- *   fieldLogic: buttonField.logic,
- *   explicitlyDisabled: buttonField.disabled,
- * });
+ * // In a mapper or component
+ * const defaultMessagesSignal = inject(DEFAULT_VALIDATION_MESSAGES);
  *
- * // Use in template
- * <button [disabled]="disabled()">Submit</button>
+ * return computed(() => {
+ *   const defaultMessages = defaultMessagesSignal?.();  // Read inside computed for reactivity
+ *   const message = defaultMessages?.required ?? 'Field is required';
+ *   // ...
+ * });
  * ```
- *
- * @public
  */
-declare function resolveSubmitButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+declare const DEFAULT_VALIDATION_MESSAGES: InjectionToken<Signal<ValidationMessages | undefined>>;
 /**
- * Resolves the disabled state for a next page button.
+ * Injection token for form-level options.
  *
- * The disabled state is determined by (in order of precedence):
- * 1. Explicit `disabled: true` on the field definition
- * 2. Field-level `logic` array (if present, overrides form-level defaults)
- * 3. Form-level `options.nextButton` defaults
+ * Form options control form-wide behavior including button disabled states.
+ * Used by button mappers to determine default disabled behavior.
  *
- * @param ctx - The button logic context
- * @returns A computed signal that returns true when the button should be disabled
+ * Like DEFAULT_PROPS, this token is provided ONCE at the DynamicForm level
+ * and inherited by all children via Angular's hierarchical injector.
+ *
+ * The token provides a Signal to enable reactivity - when config changes, mappers
+ * that read the signal inside their computed() will automatically update.
  *
  * @example
  * ```typescript
- * const disabled = resolveNextButtonDisabled({
- *   form: formInstance,
- *   formOptions: config.options,
- *   fieldLogic: buttonField.logic,
- *   explicitlyDisabled: buttonField.disabled,
- *   currentPageValid: pageOrchestrator.currentPageValid,
+ * // In a button mapper
+ * const formOptionsSignal = inject(FORM_OPTIONS);
+ *
+ * return computed(() => {
+ *   const formOptions = formOptionsSignal?.();  // Read inside computed for reactivity
+ *   const disableWhenInvalid = formOptions?.submitButton?.disableWhenInvalid ?? true;
+ *   // ...
  * });
  * ```
- *
- * @public
  */
-declare function resolveNextButtonDisabled(ctx: ButtonLogicContext): Signal<boolean>;
+declare const FORM_OPTIONS: InjectionToken<Signal<FormOptions | undefined>>;
 
 interface FieldWithValidation {
     readonly required?: boolean;
@@ -3783,7 +5051,7 @@ interface BaseValueField<TProps, TValue, TMeta extends FieldMeta = FieldMeta> ex
     required?: boolean;
 }
 declare function isValueField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseValueField<TProps, ValueType, TMeta>;
-type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'valueType' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas';
+type ExcludedKeys$1 = 'type' | 'conditionals' | 'value' | 'valueType' | 'disabled' | 'readonly' | 'hidden' | 'col' | 'minValue' | 'maxValue' | 'step' | 'required' | 'email' | 'min' | 'max' | 'minLength' | 'maxLength' | 'pattern' | 'validators' | 'logic' | 'derivation' | 'schemas' | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly';
 type ValueFieldComponent<T extends BaseValueField<Record<string, unknown> | unknown, unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys$1>>>;
 
 interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta> extends FieldDef<TProps, TMeta>, FieldWithValidation {
@@ -3796,7 +5064,7 @@ interface BaseCheckedField<TProps, TMeta extends FieldMeta = FieldMeta> extends
     required?: boolean;
 }
 declare function isCheckedField<TProps, TMeta extends FieldMeta = FieldMeta>(field: FieldDef<TProps, TMeta>): field is BaseCheckedField<TProps, TMeta>;
-type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation;
+type ExcludedKeys = 'type' | 'conditionals' | 'value' | 'disabled' | 'readonly' | 'hidden' | 'col' | keyof FieldWithValidation | 'excludeValueIfHidden' | 'excludeValueIfDisabled' | 'excludeValueIfReadonly';
 type CheckedFieldComponent<T extends BaseCheckedField<Record<string, unknown> | unknown>> = Prettify<WithInputSignals<Omit<T, ExcludedKeys>>>;
 
 declare function applyValidator(config: ValidatorConfig, fieldPath: SchemaPath<any> | SchemaPathTree<any>): void;
@@ -3815,77 +5083,367 @@ declare class PreviousPageEvent implements FormEvent {
 }
 
 /**
- * Event dispatched to add a new item to an array field.
+ * Template type for array items used in events.
+ * Canonical definition lives in {@link ArrayItemDefinition} — this alias
+ * preserves the events-specific naming convention.
+ */
+type ArrayItemDefinitionTemplate = ArrayItemDefinition;
+
+/**
+ * Event dispatched to append a new item at the END of an array field.
+ *
+ * This is the most common array operation - adding items to the end.
+ * For other positions, use {@link PrependArrayItemEvent} or {@link InsertArrayItemEvent}.
+ *
+ * @example
+ * ```typescript
+ * // Object item: append { name, email } object
+ * eventBus.dispatch(arrayEvent('contacts').append([
+ *   { key: 'name', type: 'input', label: 'Name' },
+ *   { key: 'email', type: 'input', label: 'Email' }
+ * ]));
+ *
+ * // Primitive item: append single value
+ * eventBus.dispatch(arrayEvent('tags').append(
+ *   { key: 'tag', type: 'input', label: 'Tag' }
+ * ));
+ * ```
+ *
+ * @typeParam TTemplate - The type of the template (single field or array of fields)
+ */
+declare class AppendArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
+    /** The key of the array field to append an item to */
+    readonly arrayKey: string;
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+     */
+    readonly template: TTemplate;
+    readonly type: "append-array-item";
+    constructor(
+    /** The key of the array field to append an item to */
+    arrayKey: string, 
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+     */
+    template: TTemplate);
+}
+
+/**
+ * Event dispatched to prepend a new item at the BEGINNING of an array field.
  *
- * This event is used to dynamically add items to array fields at runtime.
- * The array field component listens for this event and adds a new item
- * based on the provided field template, or uses the array's own template if not provided.
+ * Use this when new items should appear at the start of the list.
+ * For appending to the end, use {@link AppendArrayItemEvent}.
  *
  * @example
  * ```typescript
- * // Add item using array's own template
- * eventBus.dispatch(AddArrayItemEvent, 'contacts');
+ * // Object item: prepend { name } object
+ * eventBus.dispatch(arrayEvent('contacts').prepend([
+ *   { key: 'name', type: 'input', label: 'Name' }
+ * ]));
+ *
+ * // Primitive item: prepend single value
+ * eventBus.dispatch(arrayEvent('tags').prepend(
+ *   { key: 'tag', type: 'input', label: 'Tag' }
+ * ));
+ * ```
+ *
+ * @typeParam TTemplate - The type of the template (single field or array of fields)
+ */
+declare class PrependArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
+    /** The key of the array field to prepend an item to */
+    readonly arrayKey: string;
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+     */
+    readonly template: TTemplate;
+    readonly type: "prepend-array-item";
+    constructor(
+    /** The key of the array field to prepend an item to */
+    arrayKey: string, 
+    /**
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
+     */
+    template: TTemplate);
+}
+
+/**
+ * Event dispatched to insert a new item at a SPECIFIC INDEX in an array field.
  *
- * // Add item with explicit field template
- * const fieldTemplate = { key: 'email', type: 'input' };
- * eventBus.dispatch(AddArrayItemEvent, 'contacts', fieldTemplate);
+ * Use this when you need precise control over where the new item appears.
+ * For simpler operations, use {@link AppendArrayItemEvent} or {@link PrependArrayItemEvent}.
  *
- * // Add item at specific index
- * eventBus.dispatch(AddArrayItemEvent, 'contacts', fieldTemplate, 2);
+ * @example
+ * ```typescript
+ * // Object item: insert { name } object at index 2
+ * eventBus.dispatch(arrayEvent('contacts').insertAt(2, [
+ *   { key: 'name', type: 'input', label: 'Name' }
+ * ]));
+ *
+ * // Primitive item: insert single value at index 2
+ * eventBus.dispatch(arrayEvent('tags').insertAt(2,
+ *   { key: 'tag', type: 'input', label: 'Tag' }
+ * ));
  * ```
+ *
+ * @typeParam TTemplate - The type of the template (single field or array of fields)
  */
-declare class AddArrayItemEvent implements FormEvent {
-    /** The key of the array field to add an item to */
+declare class InsertArrayItemEvent<TTemplate extends ArrayItemDefinitionTemplate = ArrayItemDefinitionTemplate> implements FormEvent {
+    /** The key of the array field to insert an item into */
     readonly arrayKey: string;
+    /** The index at which to insert the new item */
+    readonly index: number;
     /**
-     * Optional field template definition to render for the new array item.
-     * If not provided, the array field component will use its own template.
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
      */
-    readonly field?: ArrayAllowedChildren | undefined;
-    /** Optional index where to insert the item (defaults to end of array) */
-    readonly index?: number | undefined;
-    readonly type: "add-array-item";
+    readonly template: TTemplate;
+    readonly type: "insert-array-item";
     constructor(
-    /** The key of the array field to add an item to */
+    /** The key of the array field to insert an item into */
     arrayKey: string, 
+    /** The index at which to insert the new item */
+    index: number, 
     /**
-     * Optional field template definition to render for the new array item.
-     * If not provided, the array field component will use its own template.
+     * Template for the new array item. REQUIRED.
+     * - Single field (FieldDef): Creates a primitive item (field's value is extracted directly)
+     * - Array of fields (FieldDef[]): Creates an object item (fields merged into object)
      */
-    field?: ArrayAllowedChildren | undefined, 
-    /** Optional index where to insert the item (defaults to end of array) */
-    index?: number | undefined);
+    template: TTemplate);
+}
+
+/**
+ * Event dispatched to remove the LAST item from an array field.
+ *
+ * Equivalent to JavaScript's `Array.pop()` - removes from the end.
+ * For removing from the beginning, use {@link ShiftArrayItemEvent}.
+ * For removing at a specific index, use {@link RemoveAtIndexEvent}.
+ *
+ * @example
+ * ```typescript
+ * // Use the builder API (recommended)
+ * eventBus.dispatch(arrayEvent('contacts').pop());
+ *
+ * // Or instantiate directly
+ * eventBus.dispatch(new PopArrayItemEvent('contacts'));
+ * ```
+ */
+declare class PopArrayItemEvent implements FormEvent {
+    /** The key of the array field to remove the last item from */
+    readonly arrayKey: string;
+    readonly type: "pop-array-item";
+    constructor(
+    /** The key of the array field to remove the last item from */
+    arrayKey: string);
 }
 
 /**
- * Event dispatched to remove an item from an array field.
+ * Event dispatched to remove the FIRST item from an array field.
  *
- * This event is used to dynamically remove items from array fields at runtime.
- * The array field component listens for this event and removes the item
- * at the specified index.
+ * Equivalent to JavaScript's `Array.shift()` - removes from the beginning.
+ * For removing from the end, use {@link PopArrayItemEvent}.
+ * For removing at a specific index, use {@link RemoveAtIndexEvent}.
  *
  * @example
  * ```typescript
- * // Remove item at index 1 from 'contacts' array
- * eventBus.dispatch(RemoveArrayItemEvent, 'contacts', 1);
+ * // Use the builder API (recommended)
+ * eventBus.dispatch(arrayEvent('contacts').shift());
  *
- * // Remove last item
- * eventBus.dispatch(RemoveArrayItemEvent, 'contacts');
+ * // Or instantiate directly
+ * eventBus.dispatch(new ShiftArrayItemEvent('contacts'));
  * ```
  */
-declare class RemoveArrayItemEvent implements FormEvent {
+declare class ShiftArrayItemEvent implements FormEvent {
+    /** The key of the array field to remove the first item from */
+    readonly arrayKey: string;
+    readonly type: "shift-array-item";
+    constructor(
+    /** The key of the array field to remove the first item from */
+    arrayKey: string);
+}
+
+/**
+ * Event dispatched to remove an item at a SPECIFIC INDEX from an array field.
+ *
+ * Use this when you need precise control over which item to remove.
+ * For simpler operations, use {@link PopArrayItemEvent} or {@link ShiftArrayItemEvent}.
+ *
+ * @example
+ * ```typescript
+ * // Use the builder API (recommended)
+ * eventBus.dispatch(arrayEvent('contacts').removeAt(2));
+ *
+ * // Or instantiate directly
+ * eventBus.dispatch(new RemoveAtIndexEvent('contacts', 2));
+ * ```
+ */
+declare class RemoveAtIndexEvent implements FormEvent {
     /** The key of the array field to remove an item from */
     readonly arrayKey: string;
-    /** Index of the item to remove (defaults to last item) */
-    readonly index?: number | undefined;
-    readonly type: "remove-array-item";
+    /** The index of the item to remove */
+    readonly index: number;
+    readonly type: "remove-at-index";
     constructor(
     /** The key of the array field to remove an item from */
     arrayKey: string, 
-    /** Index of the item to remove (defaults to last item) */
-    index?: number | undefined);
+    /** The index of the item to remove */
+    index: number);
 }
 
+/**
+ * Builder for array manipulation events.
+ *
+ * Provides a fluent, discoverable API for array operations.
+ * Type `arrayEvent('key').` in your IDE to see all available operations.
+ *
+ * **BREAKING CHANGE**: Template is now required for add operations.
+ *
+ * Supports both primitive and object array items:
+ * - Primitive: Pass a single field definition → extracts field value directly
+ * - Object: Pass an array of field definitions → merges fields into object
+ *
+ * @example
+ * ```typescript
+ * import { arrayEvent } from '@ng-forge/dynamic-forms';
+ *
+ * // Object item: append { name, email } object
+ * eventBus.dispatch(arrayEvent('contacts').append([
+ *   { key: 'name', type: 'input', label: 'Name' },
+ *   { key: 'email', type: 'input', label: 'Email' }
+ * ]));
+ *
+ * // Primitive item: append single value
+ * eventBus.dispatch(arrayEvent('tags').append(
+ *   { key: 'tag', type: 'input', label: 'Tag' }
+ * ));
+ *
+ * // Removing items (no template needed)
+ * eventBus.dispatch(arrayEvent('contacts').pop());      // Remove last
+ * eventBus.dispatch(arrayEvent('contacts').shift());    // Remove first
+ * eventBus.dispatch(arrayEvent('contacts').removeAt(2)); // Remove at index
+ * ```
+ *
+ * @param arrayKey - The key of the array field to operate on
+ * @returns An object with methods for all 6 array operations
+ */
+declare function arrayEvent(arrayKey: string): {
+    /**
+     * Append a new item at the END of the array.
+     * This is the most common operation for adding items.
+     *
+     * @param template - Template for the new item (REQUIRED)
+     *   - Single field: Creates a primitive item (field's value is extracted directly)
+     *   - Array of fields: Creates an object item (fields merged into object)
+     * @returns An AppendArrayItemEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * // Object item
+     * eventBus.dispatch(arrayEvent('contacts').append([
+     *   { key: 'name', type: 'input', label: 'Name' }
+     * ]));
+     *
+     * // Primitive item
+     * eventBus.dispatch(arrayEvent('tags').append(
+     *   { key: 'tag', type: 'input', label: 'Tag' }
+     * ));
+     * ```
+     */
+    append: <T extends ArrayItemDefinitionTemplate>(template: T) => AppendArrayItemEvent<T>;
+    /**
+     * Prepend a new item at the BEGINNING of the array.
+     * Use when new items should appear at the start.
+     *
+     * @param template - Template for the new item (REQUIRED)
+     *   - Single field: Creates a primitive item (field's value is extracted directly)
+     *   - Array of fields: Creates an object item (fields merged into object)
+     * @returns A PrependArrayItemEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * // Object item
+     * eventBus.dispatch(arrayEvent('contacts').prepend([
+     *   { key: 'name', type: 'input', label: 'Name' }
+     * ]));
+     *
+     * // Primitive item
+     * eventBus.dispatch(arrayEvent('tags').prepend(
+     *   { key: 'tag', type: 'input', label: 'Tag' }
+     * ));
+     * ```
+     */
+    prepend: <T extends ArrayItemDefinitionTemplate>(template: T) => PrependArrayItemEvent<T>;
+    /**
+     * Insert a new item at a SPECIFIC INDEX in the array.
+     * Use when you need precise control over item placement.
+     *
+     * @param index - The position at which to insert the new item
+     * @param template - Template for the new item (REQUIRED)
+     *   - Single field: Creates a primitive item (field's value is extracted directly)
+     *   - Array of fields: Creates an object item (fields merged into object)
+     * @returns An InsertArrayItemEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * // Object item at index 2
+     * eventBus.dispatch(arrayEvent('contacts').insertAt(2, [
+     *   { key: 'name', type: 'input', label: 'Name' }
+     * ]));
+     *
+     * // Primitive item at index 2
+     * eventBus.dispatch(arrayEvent('tags').insertAt(2,
+     *   { key: 'tag', type: 'input', label: 'Tag' }
+     * ));
+     * ```
+     */
+    insertAt: <T extends ArrayItemDefinitionTemplate>(index: number, template: T) => InsertArrayItemEvent<T>;
+    /**
+     * Remove the LAST item from the array.
+     * Equivalent to JavaScript's `Array.pop()`.
+     *
+     * @returns A PopArrayItemEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * eventBus.dispatch(arrayEvent('contacts').pop());
+     * ```
+     */
+    pop: () => PopArrayItemEvent;
+    /**
+     * Remove the FIRST item from the array.
+     * Equivalent to JavaScript's `Array.shift()`.
+     *
+     * @returns A ShiftArrayItemEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * eventBus.dispatch(arrayEvent('contacts').shift());
+     * ```
+     */
+    shift: () => ShiftArrayItemEvent;
+    /**
+     * Remove an item at a SPECIFIC INDEX from the array.
+     * Use when you need to remove a specific item by position.
+     *
+     * @param index - The position of the item to remove
+     * @returns A RemoveAtIndexEvent to dispatch
+     *
+     * @example
+     * ```typescript
+     * eventBus.dispatch(arrayEvent('contacts').removeAt(2));
+     * ```
+     */
+    removeAt: (index: number) => RemoveAtIndexEvent;
+};
+
 /**
  * Event bus service for form-wide event communication.
  *
@@ -3984,6 +5542,8 @@ interface TokenContext {
     arrayKey?: string;
     /** Current form value for complex indexing */
     formValue?: unknown;
+    /** Template for array item creation */
+    template?: unknown;
 }
 /**
  * Resolves special tokens in event arguments to their actual values
@@ -3992,6 +5552,7 @@ interface TokenContext {
  * - $key: The current field key
  * - $index: The array index (if inside an array field)
  * - $arrayKey: The parent array field key (if inside an array field)
+ * - $template: The template for array item creation
  * - formValue: Reference to the current form value for indexing
  *
  * @param args - Array of arguments that may contain tokens
@@ -4005,6 +5566,10 @@ interface TokenContext {
  * @example
  * resolveTokens(['$key', 'static'], { key: 'myField' })
  * // Returns: ['myField', 'static']
+ *
+ * @example
+ * resolveTokens(['$arrayKey', '$template'], { arrayKey: 'contacts', template: [{ key: 'name', type: 'input' }] })
+ * // Returns: ['contacts', [{ key: 'name', type: 'input' }]]
  */
 declare function resolveTokens(args: readonly (string | number | boolean | null | undefined)[], context: TokenContext): (string | number | boolean | null | undefined | unknown)[];
 
@@ -4177,6 +5742,8 @@ declare function baseFieldMapper(fieldDef: FieldDef<unknown>): Signal<Record<str
  * Row components are layout containers that don't change the form shape.
  * The row component will inject FIELD_SIGNAL_CONTEXT directly.
  *
+ * Supports hidden state resolution via `logic` array or static `hidden` property.
+ *
  * @param fieldDef The row field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
@@ -4189,6 +5756,8 @@ declare function rowFieldMapper(fieldDef: RowField): Signal<Record<string, unkno
  * The group component will inject the parent FIELD_SIGNAL_CONTEXT and create
  * a scoped child injector for its nested fields.
  *
+ * Supports hidden state resolution via `logic` array or static `hidden` property.
+ *
  * @param fieldDef The group field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
@@ -4201,6 +5770,8 @@ declare function groupFieldMapper(fieldDef: GroupField): Signal<Record<string, u
  * The array component will inject the parent FIELD_SIGNAL_CONTEXT and create
  * a scoped child injector for its array item fields.
  *
+ * Supports hidden state resolution via `logic` array or static `hidden` property.
+ *
  * @param fieldDef The array field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
@@ -4212,6 +5783,10 @@ declare function arrayFieldMapper(fieldDef: ArrayField): Signal<Record<string, u
  * Page fields are layout containers that don't modify the form context.
  * The page component will inject FIELD_SIGNAL_CONTEXT directly.
  *
+ * Note: Unlike other container mappers (group, row, array), the page mapper does NOT
+ * resolve hidden logic here. Page visibility is managed by the {@link PageOrchestratorComponent}
+ * which evaluates `ContainerLogicConfig` conditions and controls the `isVisible` input.
+ *
  * @param fieldDef The page field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
  */
@@ -4221,8 +5796,14 @@ declare function pageFieldMapper(fieldDef: PageField): Signal<Record<string, unk
  * Maps a text field definition to component inputs.
  *
  * Text fields are display-only fields that don't participate in the form schema.
- * This mapper handles the `logic` configuration by creating reactive signals
- * that evaluate conditions using the form value from RootFormRegistryService.
+ * This mapper handles the `logic` configuration by using the non-field-hidden resolver
+ * to evaluate conditions against the form value from RootFormRegistryService.
+ *
+ * Hidden state is resolved using the non-field-hidden resolver which considers:
+ * 1. Explicit `hidden: true` on the field definition
+ * 2. Field-level `logic` array with `type: 'hidden'` conditions
+ *
+ * Note: Text fields don't support disabled logic since they are display-only.
  *
  * @param fieldDef The text field definition
  * @returns Signal containing Record of input names to values for ngComponentOutlet
@@ -4318,6 +5899,7 @@ declare class RowFieldComponent {
     field: _angular_core.InputSignal<RowField<readonly _ng_forge_dynamic_forms.RowAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string | undefined>;
+    hidden: _angular_core.InputSignal<boolean>;
     readonly hostClasses: _angular_core.Signal<string>;
     readonly disabled: _angular_core.Signal<boolean>;
     private readonly rawFieldRegistry;
@@ -4326,7 +5908,7 @@ declare class RowFieldComponent {
     constructor();
     private setupEffects;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowFieldComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowFieldComponent, "div[row-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowFieldComponent, "div[row-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -4343,16 +5925,20 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly injector;
     private readonly eventBus;
     private readonly logger;
-    private readonly memoizedFlattenFields;
-    private readonly memoizedKeyBy;
-    private readonly memoizedDefaultValues;
+    private readonly fieldProcessors;
     field: _angular_core.InputSignal<GroupField<readonly _ng_forge_dynamic_forms.GroupAllowedChildren[]>>;
     key: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string | undefined>;
+    hidden: _angular_core.InputSignal<boolean>;
     readonly hostClasses: _angular_core.Signal<string>;
     private readonly rawFieldRegistry;
     private readonly formSetup;
     readonly defaultValues: _angular_core.WritableSignal<Record<string, unknown>>;
+    /**
+     * Entity computed from parent value, group key, and defaults.
+     * Uses deep equality check to prevent unnecessary updates when
+     * object spread creates new references with identical values.
+     */
     private readonly entity;
     private readonly form;
     readonly formValue: _angular_core.Signal<{}>;
@@ -4363,6 +5949,7 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     readonly errors: _angular_core.Signal<_angular_forms_signals.ValidationError.WithField[]>;
     readonly disabled: _angular_core.Signal<boolean>;
     private readonly nestedFieldTree;
+    private readonly groupFieldSignalContext;
     private readonly groupInjector;
     readonly validityChange: _angular_core.OutputRef<boolean>;
     readonly dirtyChange: _angular_core.OutputRef<boolean>;
@@ -4372,17 +5959,13 @@ declare class GroupFieldComponent<TModel extends Record<string, unknown> = Recor
     constructor();
     private setupEffects;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupFieldComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupFieldComponent<any>, "fieldset[group-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupFieldComponent<any>, "fieldset[group-field]", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, { "validityChange": "validityChange"; "dirtyChange": "dirtyChange"; "submitted": "submitted"; }, never, never, true, never>;
 }
 
 /**
- * Resolved array item ready for declarative rendering with ngComponentOutlet.
- * Each item has a stable unique ID and a linkedSignal-based index that
- * automatically updates when items are added/removed.
+ * A single field within a resolved array item.
  */
-interface ResolvedArrayItem {
-    /** Unique identifier for this item (stable across position changes). */
-    id: string;
+interface ResolvedArrayItemField {
     /** The loaded component type. */
     component: Type<unknown>;
     /** Injector providing ARRAY_CONTEXT and FIELD_SIGNAL_CONTEXT. */
@@ -4390,13 +5973,26 @@ interface ResolvedArrayItem {
     /** Inputs signal for ngComponentOutlet - evaluated in template for reactivity. */
     inputs: Signal<Record<string, unknown>>;
 }
+/**
+ * Resolved array item ready for declarative rendering with ngComponentOutlet.
+ * Each item has a stable unique ID and a linkedSignal-based index that
+ * automatically updates when items are added/removed.
+ * Supports multiple fields per array item (e.g., name + email without a wrapper).
+ */
+interface ResolvedArrayItem {
+    /** Unique identifier for this item (stable across position changes). */
+    id: string;
+    /** All fields to render for this array item. */
+    fields: ResolvedArrayItemField[];
+}
 
 /**
  * Container component for rendering dynamic arrays of fields.
  *
- * Supports add/remove operations via AddArrayItemEvent and RemoveArrayItemEvent.
+ * Supports add/remove operations via the arrayEvent() builder API.
  * Uses differential updates to optimize rendering - only recreates items when necessary.
  * Each item gets a scoped injector with ARRAY_CONTEXT for position-aware operations.
+ * Supports multiple sibling fields per array item (e.g., name + email without a wrapper).
  */
 declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Record<string, unknown>> {
     private readonly destroyRef;
@@ -4405,28 +6001,111 @@ declare class ArrayFieldComponent<TModel extends Record<string, unknown> = Recor
     private readonly parentInjector;
     private readonly eventBus;
     private readonly logger;
-    field: _angular_core.InputSignal<ArrayField<readonly _ng_forge_dynamic_forms.ArrayAllowedChildren[]>>;
+    private readonly templateRegistry;
+    private readonly generateItemId;
+    field: _angular_core.InputSignal<ArrayField<readonly ArrayItemDefinition[]>>;
     key: _angular_core.InputSignal<string>;
     className: _angular_core.InputSignal<string | undefined>;
+    hidden: _angular_core.InputSignal<boolean>;
     readonly hostClasses: _angular_core.Signal<string>;
     private readonly rawFieldRegistry;
-    private readonly fieldTemplate;
+    /**
+     * Gets the auto-remove button FieldDef from normalization metadata.
+     * Set by simplified array normalization for primitive arrays with remove buttons.
+     * The button is rendered alongside each item without wrapping in a row,
+     * preserving flat primitive form values.
+     */
+    private readonly autoRemoveButton;
+    /**
+     * For primitive array items, the key of the value field template (e.g., 'value').
+     * Used to wrap the FormControl in the item context so getFieldTree(key) works.
+     * Returns undefined for object arrays (FormGroup items have natural child navigation).
+     *
+     * Detection order:
+     * 1. Normalization metadata (for simplified arrays — always available at normalization time)
+     * 2. Existing item definitions (non-empty full-API arrays)
+     * 3. Dynamically discovered key from handleAddFromEvent (empty full-API arrays)
+     *
+     * Uses linkedSignal: recomputes when field() changes, supports manual set()
+     * for the dynamic discovery case.
+     */
+    private readonly primitiveFieldKey;
+    /**
+     * Gets the item templates (field definitions) for the array.
+     * Each element can be either:
+     * - A single FieldDef (primitive item) - normalized to [FieldDef]
+     * - An array of FieldDefs (object item) - used as-is
+     *
+     * When auto-remove is configured, the remove button is appended to each item's
+     * template list for rendering. This is purely visual — the form schema uses the
+     * original primitive item definition (single FieldDef → FormControl → flat value).
+     *
+     * Returns normalized templates where all items are arrays for consistent handling.
+     */
+    private readonly itemTemplates;
     private readonly arrayFieldTrees;
     private readonly resolvedItemsSignal;
     private readonly updateVersion;
-    private readonly itemOrderSignal;
-    readonly resolvedItems: _angular_core.WritableSignal<ResolvedArrayItem[]>;
+    /**
+     * Map of item IDs to their current positions. O(1) lookup vs O(n) indexOf().
+     * Used by child linkedSignals to reactively track their position in the array.
+     */
+    private readonly itemPositionMap;
+    /** Read-only view of resolved items for template consumption. */
+    readonly resolvedItems: _angular_core.Signal<ResolvedArrayItem[]>;
+    /**
+     * Caches the result of appending the auto-remove button to template arrays.
+     * Keyed by template array reference — cache hits occur during recreate/resolution
+     * operations where stored template references are reused. Add operations via
+     * handleAddFromEvent always create a fresh `[...template]` copy (line ~277),
+     * so each add is a cache miss by design (the spread is needed for mutability).
+     */
+    private readonly autoRemoveCache;
     constructor();
     private setupEffects;
     private setupEventHandlers;
+    /**
+     * Handles add operations from events (append, prepend, insert).
+     * Creates resolved items FIRST, then updates form value.
+     * This ensures prepend/insert work correctly - differential update sees "none"
+     * because resolved items count already matches the new array length.
+     *
+     * Supports both primitive (single FieldDef) and object (FieldDef[]) templates.
+     */
+    private handleAddFromEvent;
     private performDifferentialUpdate;
     private resolveAllItems;
     private appendItems;
+    /**
+     * Creates an observable that resolves a single array item.
+     *
+     * Template resolution order:
+     * 1. Use overrideTemplate if provided (from recreate with stored templates)
+     * 2. Use itemTemplates[index] if within defined templates range
+     * 3. Return undefined (item cannot be resolved without a template)
+     */
     private createResolveItemObservable;
-    private addItem;
+    /**
+     * Appends the auto-remove button to a templates array for rendering.
+     * The button is added for visual rendering only — it doesn't affect the form schema.
+     * Original templates are stored in templateRegistry WITHOUT the remove button,
+     * so this method is called during resolution to add it dynamically.
+     *
+     * Uses a WeakMap cache keyed by template array reference. Cache hits occur
+     * during recreate/resolution paths where stored templates are reused.
+     * Add operations always pass a fresh `[...template]` copy, so they miss
+     * the cache intentionally (the copy is needed for mutable item construction).
+     */
+    private withAutoRemove;
+    /**
+     * Handles remove operations from events (pop, shift, removeAt).
+     * Updates resolvedItems FIRST, then form value - this ensures differential
+     * update sees "none" (lengths match) and avoids unnecessary recreates.
+     * Remaining items' linkedSignal indices auto-update via itemPositionMap.
+     */
     private removeItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayFieldComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFieldComponent<any>, "array-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFieldComponent<any>, "array-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -4501,97 +6180,16 @@ declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): O
 declare function interpolateParams(message: string, error: ValidationError): string;
 
 /**
- * Registry service that maintains references to root form fields.
- * This provides a type-safe way to access root form values from child fields
- * without relying on internal Angular Forms API navigation.
- *
- * This service should be provided at the component level to ensure proper
- * isolation between different form instances.
+ * Registry service that provides access to the root form and its values.
  *
- * IMPORTANT: This registry supports two registration patterns:
- * 1. registerFormValueSignal() - Register the SOURCE signal BEFORE form creation
- *    This allows logic functions to read form values during schema evaluation.
- * 2. registerRootForm() - Register the FieldTree AFTER form creation
- *    This provides access to the full form structure.
- *
- * For cross-field logic to work correctly, registerFormValueSignal() should be
- * called BEFORE the form() call.
+ * Constructed via factory in `provideDynamicFormDI` with signals from
+ * `FormStateManager` — no DI injection, no Maps, no lifecycle.
  */
 declare class RootFormRegistryService {
-    private readonly _rootForms;
-    private readonly _formValueSignals;
-    private readonly formContexts;
-    /**
-     * Registers the form value signal BEFORE form creation.
-     *
-     * This is the recommended pattern for cross-field logic:
-     * 1. Create the formValue signal
-     * 2. Register it with registerFormValueSignal()
-     * 3. Create the form with form(formValue, schema(...))
-     *
-     * This allows logic functions to access form values during schema evaluation.
-     */
-    registerFormValueSignal(valueSignal: Signal<Record<string, unknown>>, formId?: string): void;
-    /**
-     * Gets the registered form value signal by id.
-     *
-     * This allows direct access to the source signal, which can be read
-     * reactively to get form values.
-     */
-    getFormValueSignal(formId?: string): Signal<Record<string, unknown>> | undefined;
-    /**
-     * Registers a root form field with an optional identifier.
-     * If no id is provided, uses 'default' as the key.
-     *
-     * This triggers reactive updates for any computed signals that
-     * depend on getRootForm().
-     */
-    registerRootForm(rootField: FieldTree<unknown>, formId?: string): void;
-    /**
-     * Gets a registered root form field by id.
-     *
-     * IMPORTANT: This method reads from a signal, which means any computed
-     * signal that calls this method will automatically re-evaluate when
-     * the form is registered or updated.
-     */
-    getRootForm(formId?: string): FieldTree<unknown> | undefined;
-    /**
-     * Gets the form value, preferring the direct signal if available.
-     *
-     * This method tries in order:
-     * 1. Form value signal (if registered) - reads directly from source signal
-     * 2. Root form's .value() (if registered) - reads from FieldTree
-     * 3. Returns empty object if nothing is registered
-     *
-     * Reading from signals creates reactive dependencies, so computeds will
-     * re-evaluate when form values change.
-     */
-    getFormValue(formId?: string): Record<string, unknown>;
-    /**
-     * Registers form context (field paths and metadata) for a specific form.
-     * This can be used to store additional context information.
-     */
-    registerFormContext(context: Record<string, unknown>, formId?: string): void;
-    /**
-     * Gets form context by id.
-     */
-    getFormContext(formId?: string): Record<string, unknown>;
-    /**
-     * Unregisters a form and its context.
-     * This should be called when a form component is destroyed to prevent memory leaks.
-     */
-    unregisterForm(formId?: string): void;
-    /**
-     * Gets all registered form IDs.
-     */
-    getRegisteredFormIds(): string[];
-    /**
-     * Clears all registered forms. Useful for testing.
-     */
-    clear(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RootFormRegistryService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RootFormRegistryService>;
+    readonly formValue: Signal<Record<string, unknown>>;
+    readonly rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>;
+    constructor(formValue: Signal<Record<string, unknown>>, rootForm: Signal<FieldTree<Record<string, unknown>> | undefined>);
 }
 
-export { ARRAY_CONTEXT, AddArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, NextPageEvent, NoopLogger, PageChangeEvent, PreviousPageEvent, RemoveArrayItemEvent, RootFormRegistryService, RowFieldComponent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isRowField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig };
-export type { ArrayAllowedChildren, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, AsyncCustomValidator, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCustomValidator, HttpResourceRequest, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, PageAllowedChildren, PageField, Prettify, RegisteredFieldTypes, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };
+export { ARRAY_CONTEXT, AppendArrayItemEvent, ArrayFieldComponent, BUILT_IN_FIELDS, ConsoleLogger, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DynamicForm, DynamicFormError, DynamicFormLogger, DynamicTextPipe, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_OPTIONS, FormClearEvent, FormResetEvent, GroupFieldComponent, InsertArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, RootFormRegistryService, RowFieldComponent, ShiftArrayItemEvent, SubmitEvent, applyMetaToElement, applyValidator, applyValidators, arrayEvent, arrayFieldMapper, baseFieldMapper, buildBaseInputs, createField, dynamicTextToObservable, evaluateNonFieldDisabled, evaluateNonFieldHidden, field, formConfig, getArrayLength, groupFieldMapper, hasFormValue, interpolateParams, isArrayField, isCheckedField, isContainerField, isDisplayOnlyField, isEqual, isFormStateCondition, isGroupField, isLeafField, isPageField, isPropertyDerivationLogicConfig, isRowField, isSimplifiedArrayField, isValueBearingField, isValueField, omit, pageFieldMapper, provideDynamicForm, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, textFieldMapper, withEventFormValue, withLoggerConfig, withValueExclusionDefaults };
+export type { ArrayAllowedChildren, ArrayButtonConfig, ArrayContext, ArrayField, ArrayFieldTree, ArrayItemContext, ArrayItemDefinitionTemplate, ArrayItemTemplate, AsyncCondition, AsyncConditionFunction, AsyncCustomValidator, AsyncDerivationFunction, AsyncValidatorConfig, AvailableFieldTypes, BaseCheckedField, BaseValidatorConfig, BaseValueField, BuiltInValidatorConfig, ButtonLogicContext, CheckedFieldComponent, ConditionalExpression, ContainerFieldTypes, CustomFnConfig, CustomValidator, CustomValidatorConfig, DeclarativeHttpValidatorConfig, DynamicFormFieldRegistry, DynamicText, EvaluationContext, ExtractField, ExtractFieldDefs, ExtractFormValue, FieldComponent, FieldDef, FieldMeta, FieldOption, FieldPathAccess, FieldRegistryContainers, FieldRegistryLeaves, FieldSignalContext, FieldStateContext, FieldStateInfo, FieldTypeDefinition, FieldWithValidation, FormConfig, FormEvent, FormEventConstructor, FormFieldStateMap, FormMode, FormModeDetectionResult, FormOptions, FormStateCondition, GroupAllowedChildren, GroupField, HttpCondition, HttpCustomValidator, HttpRequestConfig, HttpResourceRequest, HttpValidationResponseMapping, HttpValidatorConfig, InferFormValue$1 as InferFormValue, LeafFieldTypes, Logger, LogicConfig, MapperFn, NarrowField, NarrowFields, NextButtonOptions, NonFieldLogicConfig, NonFieldLogicContext, NonFieldLogicType, PageAllowedChildren, PageField, Prettify, PropertyDerivationLogicConfig, RegisteredFieldTypes, ResolvedValueExclusionConfig, RowAllowedChildren, RowField, SchemaApplicationConfig, SchemaDefinition, SimplifiedArrayField, StateLogicConfig, SubmissionActionResult, SubmissionConfig, SubmitButtonOptions, TextElementType, TextField, TextProps, TokenContext, ValidationError, ValidationMessages, ValidatorConfig, ValueExclusionConfig, ValueFieldComponent, ValueHandlingMode, ValueType, WithInputSignals };