@ng-forge/dynamic-forms 0.9.0-next.9 → 0.10.0-next.1

package/fesm2022/{ng-forge-dynamic-forms-ng-forge-dynamic-forms-CfbmSRM_.mjs → ng-forge-dynamic-forms-ng-forge-dynamic-forms--PuL0AKc.mjs}

@@ -1,13 +1,14 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, reflectComponentType, Injector, inject, EnvironmentInjector, DestroyRef, computed, input, ViewContainerRef, signal, Directive, Injectable, isSignal, untracked, linkedSignal, ChangeDetectionStrategy, Component, resourceFromSnapshots, runInInjectionContext, afterNextRender, isWritableSignal, model, makeEnvironmentProviders, Pipe } from '@angular/core';
+import { InjectionToken, inject, reflectComponentType, Injector, EnvironmentInjector, DestroyRef, computed, signal, input, ViewContainerRef, Directive, Injectable, isSignal, untracked, linkedSignal, ChangeDetectionStrategy, Component, resourceFromSnapshots, runInInjectionContext, afterNextRender, isWritableSignal, TemplateRef, model, contentChildren, makeEnvironmentProviders, Pipe } from '@angular/core';
 import { explicitEffect } from 'ngxtension/explicit-effect';
-import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, Subject, filter, TimeoutError, throwError, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, tap, startWith, scan as scan$1, Observable, concatMap, take as take$1, pairwise, takeUntil, combineLatestWith, auditTime, scheduled, queueScheduler, merge, timer } from 'rxjs';
 import { takeUntilDestroyed, toObservable, toSignal, rxResource, outputFromObservable } from '@angular/core/rxjs-interop';
+import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, Subject, filter, TimeoutError, throwError, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, tap, startWith, scan as scan$1, Observable, concatMap, take as take$1, merge, pairwise, combineLatestWith, auditTime, scheduled, queueScheduler, timer } from 'rxjs';
 import { submit, email, min, max, minLength, maxLength, pattern, required, validate, validateAsync, validateHttp, disabled, readonly, hidden, applyEach, applyWhenValue, applyWhen, apply, schema, validateStandardSchema, validateTree, form, provideSignalFormsConfig } from '@angular/forms/signals';
 import { scan, map as map$1, filter as filter$1, take, switchMap as switchMap$1, timeout, catchError as catchError$1, shareReplay } from 'rxjs/operators';
 import { HttpClient } from '@angular/common/http';
 import { isStandardSchemaMarker } from '@ng-forge/dynamic-forms/schema';
 import { NG_STATUS_CLASSES } from '@angular/forms/signals/compat';
+import { NgComponentOutlet, AsyncPipe, NgTemplateOutlet } from '@angular/common';
 
 /**
  * Type guard for WrapperTypeDefinition.
@@ -97,28 +98,39 @@ const DEFAULT_WRAPPERS = new InjectionToken('DEFAULT_WRAPPERS');
  *
  * @example
  * ```typescript
- * // In a mapper function
+ * // In a mapper function — prefer the helper for required access (descriptive error).
  * export function mapValueField(fieldDef: BaseValueField<any, any>): Binding[] {
- *   const context = inject(FIELD_SIGNAL_CONTEXT);
+ *   const context = injectFieldSignalContext();
  *   const form = context.form();
  *   // ... use context
  * }
  *
- * // In a component
- * export class MyFieldComponent {
- *   private context = inject(FIELD_SIGNAL_CONTEXT);
+ * // Optional access — token directly, returns null if not provided.
+ * const ctx = inject(FIELD_SIGNAL_CONTEXT, { optional: true });
+ * if (ctx) {
+ *   // ...
  * }
  * ```
  */
-const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT', {
-    providedIn: null, // Not provided at root - must be provided by DynamicForm
-    factory: () => {
-        throw new DynamicFormError('FIELD_SIGNAL_CONTEXT was not provided. ' +
-            'This token must be provided by DynamicFormComponent or a container field component. ' +
-            'If you are calling a mapper function directly, ensure it runs within runInInjectionContext() ' +
-            'with an injector that provides FIELD_SIGNAL_CONTEXT.');
-    },
-});
+const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT');
+/**
+ * Throwing accessor for {@link FIELD_SIGNAL_CONTEXT}.
+ *
+ * Use when the consumer requires the context — group/array containers and
+ * mappers that depend on form structure. Throws a descriptive
+ * `DynamicFormError` instead of Angular's generic `NullInjectorError` when
+ * the token isn't provided.
+ *
+ * Consumers that may legitimately run outside a `DynamicForm` should keep
+ * using `inject(FIELD_SIGNAL_CONTEXT, { optional: true })`.
+ */
+function injectFieldSignalContext() {
+    const ctx = inject(FIELD_SIGNAL_CONTEXT, { optional: true });
+    if (!ctx) {
+        throw new DynamicFormError('FIELD_SIGNAL_CONTEXT is not provided. This consumer must run inside a <df-dynamic-form> component tree.');
+    }
+    return ctx;
+}
 /**
  * Injection token for providing array context metadata to mappers and components.
  *
@@ -139,6 +151,32 @@ const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT', {
  * ```
  */
 const ARRAY_CONTEXT = new InjectionToken('ARRAY_CONTEXT');
+/**
+ * Injection token for providing group ancestry to mappers and components.
+ *
+ * Re-provided in two places:
+ * 1. `GroupFieldComponent` provides a context whose `groupPath()` is the
+ *    parent path extended by its own key (e.g. `'address'` or `'user.address'`).
+ * 2. `createArrayItemInjector` provides a sentinel with an empty `groupPath`,
+ *    resetting the chain at array boundaries — descendants of an array item
+ *    that re-enter a group compose paths INSIDE the array item, matching the
+ *    property-derivation collector's keying.
+ *
+ * `mapFieldToInputs` reads this to scope DOM IDs and override-store keys so
+ * the same leaf key can appear in different groups without colliding (#401).
+ *
+ * Inject with `{ optional: true }` because top-level fields with no group
+ * ancestor (and no enclosing array) won't have the token provided. The token
+ * IS present for fields inside an array even when no inner group exists — the
+ * array-boundary sentinel makes injection succeed with an empty `groupPath`.
+ */
+// No factory: GROUP_CONTEXT is optional-by-design — `GroupFieldComponent` and
+// `createArrayItemInjector` re-provide it where it makes sense, and consumers
+// inject with `{ optional: true }` to handle the top-level case. Mirrors the
+// ARRAY_CONTEXT pattern. Adding a throwing factory here fires even when
+// injected optionally (Angular still evaluates the tree-shakable factory
+// before honoring `optional`), so non-group fields would crash on every render.
+const GROUP_CONTEXT = new InjectionToken('GROUP_CONTEXT');
 /**
  * Injection token for form-level default props.
  *
@@ -226,65 +264,57 @@ const FORM_OPTIONS = new InjectionToken('FORM_OPTIONS');
  * and inherited by all children via Angular's hierarchical injector.
  */
 const EXTERNAL_DATA = new InjectionToken('EXTERNAL_DATA');
+
 /**
- * Injection token for array-level template registry.
- *
- * This registry tracks which template was used to create each array item,
- * keyed by the item's unique ID. This is essential for "recreate" operations
- * (e.g., after removing items from the middle) where we need to re-resolve
- * items using their original templates, not a fallback.
- *
- * The token is provided by ArrayFieldComponent at its level and shared
- * across all items in that array. Each nested array gets its own registry.
- *
- * @example
- * ```typescript
- * // In ArrayFieldComponent
- * providers: [
- *   { provide: ARRAY_TEMPLATE_REGISTRY, useValue: new Map() }
- * ]
- *
- * // When adding items
- * const registry = inject(ARRAY_TEMPLATE_REGISTRY);
- * registry.set(itemId, templates);
+ * Injection token for the dynamic forms logger.
  *
- * // During recreate, look up original template
- * const originalTemplate = registry.get(existingItemId);
- * ```
+ * Provided by provideDynamicForm() with ConsoleLogger as default.
+ * Override with withLoggerConfig(false) to disable logging.
  */
-const ARRAY_TEMPLATE_REGISTRY = new InjectionToken('ARRAY_TEMPLATE_REGISTRY');
+const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
+
 /**
- * Injection token for array-level item ID generator.
- *
- * Provides a function that generates unique IDs for array items. Each array
- * component instance gets its own generator (via useFactory), ensuring:
- * - SSR hydration compatibility (server and client generate same IDs for same array)
- * - No global state pollution between form instances
- * - Deterministic IDs within each array's lifecycle
- *
- * The token is provided by ArrayFieldComponent at its level with a factory
- * that creates a fresh counter for each array instance.
- *
- * @example
- * ```typescript
- * // In ArrayFieldComponent
- * providers: [
- *   { provide: ARRAY_ITEM_ID_GENERATOR, useFactory: createArrayItemIdGenerator }
- * ]
- *
- * // Usage
- * const generateId = inject(ARRAY_ITEM_ID_GENERATOR);
- * const itemId = generateId(); // 'item-0', 'item-1', etc.
- * ```
+ * Shared empty chain — returned when no wrappers apply so callers get a
+ * stable reference. Freezing makes accidental mutation observable.
  */
-const ARRAY_ITEM_ID_GENERATOR = new InjectionToken('ARRAY_ITEM_ID_GENERATOR');
+const EMPTY_WRAPPERS = Object.freeze([]);
 /**
- * Factory function that creates a new array item ID generator.
- * Each invocation creates an independent counter starting at 0.
+ * Element-wise identity (`===`) comparator for wrapper chains. Used as the
+ * `equal` option on signal memoisation so reconciled `FieldDef`s with the
+ * same chain don't churn downstream — relies on `WrapperConfig` objects
+ * being stable across ticks, which holds for configs declared in
+ * `FormConfig` / `createWrappers(...)`.
  */
-function createArrayItemIdGenerator() {
-    let counter = 0;
-    return () => `item-${counter++}`;
+function isSameWrapperChain(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Resolves the wrapper chain for a field.
+ *
+ * Merge order (outermost → innermost): auto-associations, form defaults,
+ * field-level wrappers. `wrappers: null` skips all three; `skipAutoWrappers` /
+ * `skipDefaultWrappers` on the field opt out of individual layers. Fresh
+ * array per call — downstream memoisation is on the consuming computed.
+ */
+function resolveWrappers(field, defaultWrappers, autoAssociations) {
+    if (field.wrappers === null) {
+        return EMPTY_WRAPPERS;
+    }
+    const autoWrappers = field.skipAutoWrappers ? EMPTY_WRAPPERS : (autoAssociations.get(field.type) ?? EMPTY_WRAPPERS);
+    const defaults = field.skipDefaultWrappers ? EMPTY_WRAPPERS : (defaultWrappers ?? EMPTY_WRAPPERS);
+    const fieldLevel = field.wrappers ?? EMPTY_WRAPPERS;
+    if (autoWrappers.length === 0 && defaults.length === 0 && fieldLevel.length === 0) {
+        return EMPTY_WRAPPERS;
+    }
+    return [...autoWrappers, ...defaults, ...fieldLevel];
 }
 
 /**
@@ -324,8 +354,7 @@ function getDeclaredInputs(componentType) {
  * avoiding the reflection scan on each call is meaningful under heavy typing.
  */
 function setInputIfDeclared(ref, inputName, value) {
-    const declared = getDeclaredInputs(ref.componentType);
-    if (declared.has(inputName)) {
+    if (getDeclaredInputs(ref.componentType).has(inputName)) {
         ref.setInput(inputName, value);
     }
 }
@@ -482,58 +511,6 @@ class WrapperAwareInjector extends Injector {
     }
 }
 
-/**
- * Injection token for the dynamic forms logger.
- *
- * Provided by provideDynamicForm() with ConsoleLogger as default.
- * Override with withLoggerConfig(false) to disable logging.
- */
-const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
-
-/**
- * Shared empty chain — returned when no wrappers apply so callers get a
- * stable reference. Freezing makes accidental mutation observable.
- */
-const EMPTY_WRAPPERS = Object.freeze([]);
-/**
- * Element-wise identity (`===`) comparator for wrapper chains. Used as the
- * `equal` option on signal memoisation so reconciled `FieldDef`s with the
- * same chain don't churn downstream — relies on `WrapperConfig` objects
- * being stable across ticks, which holds for configs declared in
- * `FormConfig` / `createWrappers(...)`.
- */
-function isSameWrapperChain(a, b) {
-    if (a === b)
-        return true;
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-/**
- * Resolves the wrapper chain for a field.
- *
- * Merge order (outermost → innermost): auto-associations, form defaults,
- * field-level wrappers. `wrappers: null` skips all three; `skipAutoWrappers` /
- * `skipDefaultWrappers` on the field opt out of individual layers. Fresh
- * array per call — downstream memoisation is on the consuming computed.
- */
-function resolveWrappers(field, defaultWrappers, autoAssociations) {
-    if (field.wrappers === null) {
-        return EMPTY_WRAPPERS;
-    }
-    const autoWrappers = field.skipAutoWrappers ? EMPTY_WRAPPERS : (autoAssociations.get(field.type) ?? EMPTY_WRAPPERS);
-    const defaults = field.skipDefaultWrappers ? EMPTY_WRAPPERS : (defaultWrappers ?? EMPTY_WRAPPERS);
-    const fieldLevel = field.wrappers ?? EMPTY_WRAPPERS;
-    if (autoWrappers.length === 0 && defaults.length === 0 && fieldLevel.length === 0) {
-        return EMPTY_WRAPPERS;
-    }
-    return [...autoWrappers, ...defaults, ...fieldLevel];
-}
-
 /**
  * Owns the wrapper-chain lifecycle for a field or container: async component
  * loading, switchMap-based cancellation of stale loads, flicker-tolerant
@@ -545,6 +522,9 @@ function createWrapperChainController(opts) {
     const state = createStateSignal(opts);
     const mounted = { value: null };
     let refs = [];
+    // INVARIANT: toObservable schedules emissions as microtasks, so `renderInnermost`
+    // runs outside any parent CD pass. Don't swap for sync signal wiring without
+    // restoring df-field-outlet's detectChanges — NG0950 would re-surface.
     buildEmissionStream(state, deps)
         .pipe(takeUntilDestroyed(deps.destroyRef))
         .subscribe((emission) => {
@@ -691,6 +671,20 @@ function toReadonlyFieldTree(field) {
         errors: state.errors,
     };
 }
+/**
+ * Write a value into a FieldTree's underlying signal. Signal Forms stores
+ * `FieldState.value` as a `WritableSignal`; this helper centralises the cast
+ * and warns if that contract ever changes (vs a silent no-op).
+ */
+function writeToFieldValue(value, next, logger) {
+    const candidate = value;
+    if (typeof candidate.set !== 'function') {
+        logger?.warn('writeToFieldValue: FieldState.value is not a WritableSignal — Signal Forms contract changed.');
+        return false;
+    }
+    candidate.set(next);
+    return true;
+}
 /**
  * DI-scoped cache for `ReadonlyFieldTree` views, keyed on the source FieldTree
  * identity. A fresh WeakMap per root injector keeps renders isolated under SSR —
@@ -721,6 +715,209 @@ function toReadonlyFieldTreeCached(cache, field) {
     return view;
 }
 
+/**
+ * Convert a field's raw mapper outputs into the {@link WrapperFieldInputs}
+ * bag consumed by wrappers and addons.
+ *
+ * The transformation hides write access on the underlying `FieldTree` —
+ * the bag's `field` slot is a {@link ReadonlyFieldTree} view. The raw
+ * `FieldTree` is still pushed to the innermost field component (which
+ * legitimately needs to write); intermediaries (wrappers, addons) are
+ * read-only by contract.
+ *
+ * Pure, dependency-injection-free — caller supplies the cache so the same
+ * `ReadonlyFieldTree` view is returned for the same source `FieldTree`
+ * across renders. Each `<df-dynamic-form>` instance scopes its own cache
+ * (SSR-safe).
+ *
+ * @param rawInputs Mapper outputs (`{ key, label, props, field?: FieldTree, ... }`).
+ * @param cache     `WeakMap<FieldTree, ReadonlyFieldTree>` provided via
+ *                  {@link READONLY_FIELD_TREE_CACHE}.
+ * @param fieldType Optional field-type discriminant. Injected here (rather
+ *                  than via the field mapper) because `type` is the
+ *                  registry key, not a component input — but addons and
+ *                  wrappers legitimately need it.
+ */
+function buildFieldInputs(rawInputs, cache, fieldType) {
+    const fieldTreeCandidate = rawInputs['field'];
+    // FieldTree is callable: `(): FieldState`. Anything else (undefined,
+    // primitive) means the field is rendered before the form is bound.
+    const hasFieldTree = fieldTreeCandidate !== undefined && typeof fieldTreeCandidate === 'function';
+    const readonlyField = hasFieldTree ? toReadonlyFieldTreeCached(cache, fieldTreeCandidate) : undefined;
+    // Lazy writer keyed on the raw FieldTree. Addons (e.g., `prime-button`
+    // presets) call this to mutate the host field. `writeToFieldValue`
+    // centralises the `Signal → WritableSignal` cast and warns at runtime
+    // if Signal Forms ever changes the contract.
+    const setValue = hasFieldTree
+        ? (next) => writeToFieldValue(fieldTreeCandidate().value, next)
+        : undefined;
+    // Shallow spread — relies on the mapper contract (see WrapperFieldInputs)
+    // that rawInputs are emitted as fresh snapshots, not mutated in place.
+    return {
+        ...rawInputs,
+        type: fieldType,
+        field: readonlyField,
+        setValue,
+    };
+}
+
+const EMPTY_STATE = Object.freeze({ phase: 'empty' });
+/**
+ * Encapsulates the imperative `ViewContainerRef` / `ComponentRef` lifecycle
+ * for the innermost field component. Pulled out of `DfFieldOutlet` so the
+ * directive itself stays declarative — signals + constructor wiring — while
+ * the unavoidable mutable bookkeeping (Angular's view container API is
+ * imperative) lives in one place behind a small, focused surface.
+ *
+ * State is held in a single `signal<FieldSlotState>` discriminated union;
+ * every mutation is an explicit `state.set(...)` transition. No nullable
+ * instance fields, no `undefined`-initialized refs — each phase carries
+ * exactly the data it owns.
+ *
+ * Responsibilities:
+ * - Create the component (or reuse the same-class instance across a rebuild,
+ *   preserving its DOM state, focus, and caret).
+ * - Push mapper inputs via `setInput`, dedup'd per-key so dev-mode NG0303
+ *   warnings for undeclared mapper keys don't replay on every emission.
+ * - Detach cleanly before the outer VCR clears, so same-class reuse can
+ *   re-insert the preserved `hostView`.
+ * - Destroy on directive teardown when the host view is still detached.
+ */
+class FieldComponentSlot {
+    state = signal(EMPTY_STATE, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    /**
+     * Per-key cache for `pushInputs`. Lives outside the lifecycle state machine on
+     * purpose — it's a `setInput`-call optimization that changes on every keystroke,
+     * not a phase transition. Keeping it here means the `state` signal only emits
+     * on real `empty ⇄ mounted ⇄ detached` transitions (≈ once per
+     * mount/destroy cycle), not once per input emission.
+     */
+    lastInputs = null;
+    /** Read-only view of the lifecycle phase. Useful for tests and assertions. */
+    phase = () => this.state().phase;
+    /** Read-only view of the full state. Exposed so tests can assert ref stability. */
+    snapshot = () => this.state();
+    /**
+     * Mount the field component into `slot`. Reuses the existing `ComponentRef`
+     * when its component type matches (preserving DOM/focus/caret across a
+     * wrapper-chain rebuild); otherwise discards the old ref and creates a fresh
+     * one.
+     */
+    mountOrReuse(slot, component, fieldInjector, environmentInjector, rawInputs, fieldInputs) {
+        const current = this.state();
+        if (current.phase !== 'empty' && current.ref.componentType === component) {
+            slot.insert(current.ref.hostView);
+            this.lastInputs = null;
+            this.state.set(Object.freeze({ phase: 'mounted', ref: current.ref, slot }));
+            this.pushInputs(rawInputs, fieldInputs);
+            if (current.phase === 'detached')
+                this.replayFocus(current.focusSnapshot);
+            return;
+        }
+        // Different component class — destroy the prior ref (if any) and create
+        // a fresh one. The `empty` transition before `createComponent` ensures a
+        // throw inside the factory doesn't leave a dangling ref the next mount
+        // would try to re-insert.
+        if (current.phase !== 'empty')
+            current.ref.destroy();
+        this.lastInputs = null;
+        this.state.set(EMPTY_STATE);
+        const ref = slot.createComponent(component, {
+            environmentInjector,
+            injector: createWrapperAwareInjector(fieldInjector, slot.injector),
+        });
+        this.state.set(Object.freeze({ phase: 'mounted', ref, slot }));
+        this.pushInputs(rawInputs, fieldInputs);
+    }
+    /**
+     * Push mapper inputs onto the mounted component. Per-key reference compare
+     * skips `setInput` for unchanged values — necessary in dev mode where
+     * `setInput` on unknown keys logs NG0303 per call (Angular 21 is lenient
+     * at runtime but warns); without the cache, every emission would re-warn
+     * for every undeclared mapper key.
+     *
+     * Updates the `lastInputs` cache (a plain field, not part of `state`) so the
+     * `state` signal doesn't churn its reference on every keystroke.
+     *
+     * `reflectComponentType` does NOT include hostDirective-forwarded inputs
+     * (angular/angular#49734), so a declared-input filter here would skip every
+     * value flowing through `NgForgeFieldShell` / `NgForgeField` /
+     * `NgForgeAction`. Mapper-as-contract is enforced by the `*_INPUTS`
+     * lockstep type assertions, not at runtime here.
+     */
+    pushInputs(rawInputs, fieldInputs) {
+        const current = this.state();
+        if (current.phase !== 'mounted')
+            return;
+        const prev = this.lastInputs;
+        if (prev === rawInputs)
+            return;
+        for (const [key, value] of Object.entries(rawInputs)) {
+            if (prev && prev[key] === value)
+                continue;
+            current.ref.setInput(key, value);
+        }
+        // Side-channel forwarding for the `fieldInputs` bag — gated on
+        // `setInputIfDeclared` so leaf fields that don't declare it (most
+        // non-addon-aware components) skip silently rather than triggering
+        // NG0303 in dev. Pushed unconditionally on every emission since the bag
+        // changes identity when `rawInputs` does.
+        if (fieldInputs !== undefined) {
+            setInputIfDeclared(current.ref, 'fieldInputs', fieldInputs);
+        }
+        this.lastInputs = rawInputs;
+    }
+    /**
+     * Detach the host view from its current slot, capturing focus + caret so the
+     * next `mountOrReuse()` can replay them after re-inserting into the new
+     * slot. A stranded `mounted` state with a bad slot index (re-entrancy during
+     * a partial rebuild) is treated like `empty` to avoid leaks.
+     */
+    detach() {
+        const current = this.state();
+        if (current.phase !== 'mounted')
+            return;
+        const focusSnapshot = this.captureFocus(current.ref);
+        const idx = current.slot.indexOf(current.ref.hostView);
+        if (idx >= 0)
+            current.slot.detach(idx);
+        this.lastInputs = null;
+        this.state.set(Object.freeze({ phase: 'detached', ref: current.ref, focusSnapshot }));
+    }
+    /**
+     * Called on directive teardown. Only destroys when the host view is still
+     * detached — otherwise the outer `vcr.clear()` cascade has already destroyed
+     * it (calling `.destroy()` again would throw).
+     */
+    destroyOnTeardown() {
+        const current = this.state();
+        if (current.phase === 'detached')
+            current.ref.destroy();
+        this.lastInputs = null;
+        this.state.set(EMPTY_STATE);
+    }
+    captureFocus(ref) {
+        const hostEl = ref.location.nativeElement;
+        const active = document.activeElement;
+        if (!(active instanceof HTMLElement) || !hostEl.contains(active))
+            return null;
+        const sel = active;
+        return {
+            element: active,
+            selectionStart: typeof sel.selectionStart === 'number' ? sel.selectionStart : null,
+            selectionEnd: typeof sel.selectionEnd === 'number' ? sel.selectionEnd : null,
+        };
+    }
+    replayFocus(snap) {
+        if (!snap || !snap.element.isConnected)
+            return;
+        snap.element.focus();
+        if (snap.selectionStart !== null && snap.selectionEnd !== null && 'setSelectionRange' in snap.element) {
+            snap.element.setSelectionRange(snap.selectionStart, snap.selectionEnd);
+        }
+    }
+}
+
 /**
  * Structural directive that renders a `ResolvedField` with its effective
  * wrapper chain.
@@ -741,12 +938,16 @@ function toReadonlyFieldTreeCached(cache, field) {
  * includes the field's mapper outputs and a `ReadonlyFieldTree` view of its
  * form state.
  *
- * Rendering is gated by `field.renderReady()` — the directive waits until
- * the mapper produces the required inputs before instantiating the component.
- * Once rendered, a transient `renderReady → false` does *not* tear the chain
- * down; the controller keeps the mounted components alive and ignores the
- * flicker. Only a structural change (wrappers or component class) triggers
- * a rebuild.
+ * Rendering is gated by `field.renderReady() && !field.hidden()` — the
+ * directive waits until the mapper produces the required inputs AND the
+ * field isn't hidden before instantiating the component. Once rendered, a
+ * transient `renderReady → false` does *not* tear the chain down; the
+ * controller keeps the mounted components alive and ignores the flicker.
+ * Only a structural change (wrappers or component class) triggers a rebuild.
+ *
+ * Imperative `ComponentRef` / `ViewContainerRef` lifecycle is encapsulated
+ * in `FieldComponentSlot` — the directive itself is signal definitions
+ * plus three method calls (`mountOrReuse`, `detach`, `destroyOnTeardown`).
  *
  * @example
  * ```html
@@ -766,25 +967,16 @@ class DfFieldOutlet {
     wrapperAutoAssociations = inject(WRAPPER_AUTO_ASSOCIATIONS);
     defaultWrappersSignal = inject(DEFAULT_WRAPPERS, { optional: true });
     readonlyFieldCache = inject(READONLY_FIELD_TREE_CACHE);
-    fieldRef;
-    /**
-     * VCR the `fieldRef`'s host view is currently inserted into (either the outer
-     * VCR when there are no wrappers, or the innermost wrapper's `#fieldComponent`
-     * slot). Tracked so `beforeRebuild` can detach the view before the outer VCR
-     * cascade-destroys it.
-     */
-    fieldSlot;
-    /** Focus + caret captured during detach, replayed after re-insert. */
-    focusSnapshot;
+    /** Encapsulates Angular's imperative ComponentRef / ViewContainerRef lifecycle. */
+    fieldComponent = new FieldComponentSlot();
+    componentIdentity = computed(() => this.dfFieldOutlet().component, ...(ngDevMode ? [{ debugName: "componentIdentity" }] : /* istanbul ignore next */ []));
     /**
-     * Last rawInputs reference pushed to the innermost field. Used to dedupe the
-     * rawInputs effect when the same snapshot was already applied as part of the
-     * initial render — keeps per-keystroke input updates O(changed-keys) instead
-     * of re-walking the whole input bag.
+     * Gate for the wrapper chain controller: true only when required inputs are populated AND the
+     * field isn't hidden. Combining the two prevents an initial-mount race where the chain mounts
+     * during the brief window between `renderReady` flipping true and `hidden()` settling — that
+     * window is exactly where Angular Signal Forms' `[formField]` directive emits NG01916.
      */
-    lastPushedInputs;
-    componentIdentity = computed(() => this.dfFieldOutlet().component, ...(ngDevMode ? [{ debugName: "componentIdentity" }] : /* istanbul ignore next */ []));
-    renderReady = computed(() => this.dfFieldOutlet().renderReady(), ...(ngDevMode ? [{ debugName: "renderReady" }] : /* istanbul ignore next */ []));
+    renderReady = computed(() => this.dfFieldOutlet().renderReady() && !this.dfFieldOutlet().hidden(), ...(ngDevMode ? [{ debugName: "renderReady" }] : /* istanbul ignore next */ []));
     rawInputs = computed(() => this.dfFieldOutlet().inputs(), ...(ngDevMode ? [{ debugName: "rawInputs" }] : /* istanbul ignore next */ []));
     /**
      * Effective wrapper chain. Element-wise identity comparison keeps the signal
@@ -793,11 +985,13 @@ class DfFieldOutlet {
      */
     wrappers = computed(() => resolveWrappers(this.dfFieldOutlet().fieldDef, this.defaultWrappersSignal?.(), this.wrapperAutoAssociations), { ...(ngDevMode ? { debugName: "wrappers" } : /* istanbul ignore next */ {}), equal: isSameWrapperChain });
     /**
-     * `fieldInputs` bag handed to every wrapper in the chain. Memoised on
-     * `rawInputs` identity so repeated emissions with the same underlying object
-     * return the same view and don't cascade OnPush re-evaluations.
+     * `fieldInputs` bag handed to every wrapper in the chain AND forwarded to
+     * the innermost field component (when it declares `fieldInputs` as an
+     * input). Memoised on `rawInputs` identity so repeated emissions with the
+     * same underlying object return the same view and don't cascade OnPush
+     * re-evaluations.
      */
-    fieldInputs = computed(() => this.buildFieldInputs(this.rawInputs()), ...(ngDevMode ? [{ debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+    fieldInputs = computed(() => buildFieldInputs(this.rawInputs(), this.readonlyFieldCache, this.dfFieldOutlet().fieldDef.type), ...(ngDevMode ? [{ debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
     defaultEnvInjector = inject(EnvironmentInjector);
     /** Environment injector for the innermost field component — `[environmentInjector]` input takes precedence over the directive's own DI. */
     fieldEnvInjector = computed(() => this.dfFieldOutletEnvironmentInjector() ?? this.defaultEnvInjector, ...(ngDevMode ? [{ debugName: "fieldEnvInjector" }] : /* istanbul ignore next */ []));
@@ -811,126 +1005,23 @@ class DfFieldOutlet {
             rebuildKey: this.componentIdentity,
             fieldInputs: this.fieldInputs,
             fieldInjector: this.fieldInjector,
-            beforeRebuild: () => this.detachFieldRef(),
+            beforeRebuild: () => this.fieldComponent.detach(),
             renderInnermost: (slot) => {
                 const resolved = this.dfFieldOutlet();
-                if (this.fieldRef && this.fieldRef.componentType === resolved.component) {
-                    // Same component class — re-insert the preserved hostView. Browser
-                    // loses focus on detach, so we replay the snapshot captured in
-                    // detachFieldRef. Input value persists on the DOM node itself.
-                    slot.insert(this.fieldRef.hostView);
-                    this.fieldSlot = slot;
-                    this.pushRawInputs(this.fieldRef, this.rawInputs());
-                    this.restoreFocusSnapshot();
-                    return;
-                }
-                // Different component class — discard the old ref and create fresh.
-                // Merge field + element injectors so the field can inject ancestor
-                // wrappers AND form-context tokens (ARRAY_CONTEXT etc.).
-                // Clear state before createComponent — if it throws (bad provider,
-                // invalid class) we don't want to leak a reference to a destroyed ref
-                // that the same-component branch would later try to re-insert.
-                this.focusSnapshot = undefined;
-                this.lastPushedInputs = undefined;
-                const previousRef = this.fieldRef;
-                this.fieldRef = undefined;
-                this.fieldSlot = undefined;
-                previousRef?.destroy();
-                this.fieldRef = slot.createComponent(resolved.component, {
-                    environmentInjector: this.fieldEnvInjector(),
-                    injector: createWrapperAwareInjector(resolved.injector, slot.injector),
-                });
-                this.fieldSlot = slot;
-                this.pushRawInputs(this.fieldRef, this.rawInputs());
+                this.fieldComponent.mountOrReuse(slot, resolved.component, resolved.injector, this.fieldEnvInjector(), this.rawInputs(), this.fieldInputs());
             },
         });
-        // Push rawInputs to the innermost field. Safe mid-rebuild — renderInnermost
-        // re-reads rawInputs synchronously on mount, so skipping here loses nothing.
-        explicitEffect([this.rawInputs], ([rawInputs]) => {
-            if (!this.fieldRef)
-                return;
-            if (this.lastPushedInputs === rawInputs)
-                return;
-            this.pushRawInputs(this.fieldRef, rawInputs);
-        });
-        this.destroyRef.onDestroy(() => {
-            // Only destroy when detached — vcr.clear() cascades otherwise.
-            if (this.fieldRef && !this.fieldSlot)
-                this.fieldRef.destroy();
-            this.fieldRef = undefined;
-            this.fieldSlot = undefined;
-            this.lastPushedInputs = undefined;
-        });
-    }
-    detachFieldRef() {
-        if (!this.fieldRef)
-            return;
-        if (!this.fieldSlot) {
-            // Stranded fieldRef — destroy to prevent a leak.
-            this.fieldRef.destroy();
-            this.fieldRef = undefined;
-            return;
-        }
-        this.captureFocusSnapshot();
-        const idx = this.fieldSlot.indexOf(this.fieldRef.hostView);
-        if (idx >= 0)
-            this.fieldSlot.detach(idx);
-        this.fieldSlot = undefined;
-    }
-    /** Capture active element + selection before the hostView is detached from DOM. */
-    captureFocusSnapshot() {
-        if (!this.fieldRef)
-            return;
-        const hostEl = this.fieldRef.location.nativeElement;
-        const active = document.activeElement;
-        if (!(active instanceof HTMLElement) || !hostEl.contains(active))
-            return;
-        const sel = active;
-        this.focusSnapshot = {
-            element: active,
-            selectionStart: typeof sel.selectionStart === 'number' ? sel.selectionStart : null,
-            selectionEnd: typeof sel.selectionEnd === 'number' ? sel.selectionEnd : null,
-        };
-    }
-    /** Re-apply the pre-detach focus + caret after the hostView is back in the DOM. */
-    restoreFocusSnapshot() {
-        const snap = this.focusSnapshot;
-        this.focusSnapshot = undefined;
-        if (!snap || !snap.element.isConnected)
-            return;
-        snap.element.focus();
-        if (snap.selectionStart !== null && snap.selectionEnd !== null && 'setSelectionRange' in snap.element) {
-            snap.element.setSelectionRange(snap.selectionStart, snap.selectionEnd);
-        }
-    }
-    pushRawInputs(ref, rawInputs) {
-        // Ref-identity dedupe per key — mappers must emit immutable snapshots.
-        const last = this.lastPushedInputs;
-        for (const [key, value] of Object.entries(rawInputs)) {
-            if (last && last[key] === value)
-                continue;
-            setInputIfDeclared(ref, key, value);
-        }
-        this.lastPushedInputs = rawInputs;
-    }
-    buildFieldInputs(rawInputs) {
-        const fieldTreeCandidate = rawInputs['field'];
-        // A FieldTree is a callable (() => FieldState). We expose it to wrappers via a narrow
-        // read-only view; raw FieldTree is still pushed to the innermost component for writes.
-        const readonlyField = fieldTreeCandidate && typeof fieldTreeCandidate === 'function'
-            ? toReadonlyFieldTreeCached(this.readonlyFieldCache, fieldTreeCandidate)
-            : undefined;
-        // Shallow spread — relies on the mapper contract (see WrapperFieldInputs)
-        // that rawInputs are emitted as fresh snapshots, not mutated in place.
-        return {
-            ...rawInputs,
-            field: readonlyField,
-        };
+        // Push rawInputs (plus the wrapper-style fieldInputs bag) to the innermost
+        // field on every change. The slot dedupes per-key, so the initial render's
+        // synchronous push from `renderInnermost` and the effect's first fire
+        // converge cleanly with no double-pushing.
+        explicitEffect([this.rawInputs, this.fieldInputs], ([rawInputs, fieldInputs]) => this.fieldComponent.pushInputs(rawInputs, fieldInputs));
+        this.destroyRef.onDestroy(() => this.fieldComponent.destroyOnTeardown());
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DfFieldOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.8", type: DfFieldOutlet, isStandalone: true, selector: "[dfFieldOutlet]", inputs: { dfFieldOutlet: { classPropertyName: "dfFieldOutlet", publicName: "dfFieldOutlet", isSignal: true, isRequired: true, transformFunction: null }, dfFieldOutletEnvironmentInjector: { classPropertyName: "dfFieldOutletEnvironmentInjector", publicName: "dfFieldOutletEnvironmentInjector", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfFieldOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.14", type: DfFieldOutlet, isStandalone: true, selector: "[dfFieldOutlet]", inputs: { dfFieldOutlet: { classPropertyName: "dfFieldOutlet", publicName: "dfFieldOutlet", isSignal: true, isRequired: true, transformFunction: null }, dfFieldOutletEnvironmentInjector: { classPropertyName: "dfFieldOutletEnvironmentInjector", publicName: "dfFieldOutletEnvironmentInjector", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DfFieldOutlet, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfFieldOutlet, decorators: [{
             type: Directive,
             args: [{
                     selector: '[dfFieldOutlet]',
@@ -1230,10 +1321,10 @@ class EventBus {
         }
         return this.pipeline$.pipe(filter((event) => event.type === eventType));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventBus });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventBus, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventBus, decorators: [{
             type: Injectable
         }] });
 
@@ -1919,10 +2010,16 @@ var TokenType;
     // Punctuation
     TokenType["DOT"] = "DOT";
     TokenType["COMMA"] = "COMMA";
+    TokenType["COLON"] = "COLON";
     TokenType["LPAREN"] = "LPAREN";
     TokenType["RPAREN"] = "RPAREN";
     TokenType["LBRACKET"] = "LBRACKET";
     TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["ARROW"] = "ARROW";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["OPTIONAL_DOT"] = "OPTIONAL_DOT";
     // Special
     TokenType["EOF"] = "EOF";
 })(TokenType || (TokenType = {}));
@@ -2102,6 +2199,12 @@ class Tokenizer {
             case '||':
                 this.position += 2;
                 return { type: TokenType.OR, value: '||', position: start };
+            case '=>':
+                this.position += 2;
+                return { type: TokenType.ARROW, value: '=>', position: start };
+            case '?.':
+                this.position += 2;
+                return { type: TokenType.OPTIONAL_DOT, value: '?.', position: start };
         }
         // Single-character operators and punctuation
         this.position++;
@@ -2126,6 +2229,8 @@ class Tokenizer {
                 return { type: TokenType.DOT, value: '.', position: start };
             case ',':
                 return { type: TokenType.COMMA, value: ',', position: start };
+            case ':':
+                return { type: TokenType.COLON, value: ':', position: start };
             case '(':
                 return { type: TokenType.LPAREN, value: '(', position: start };
             case ')':
@@ -2134,6 +2239,12 @@ class Tokenizer {
                 return { type: TokenType.LBRACKET, value: '[', position: start };
             case ']':
                 return { type: TokenType.RBRACKET, value: ']', position: start };
+            case '{':
+                return { type: TokenType.LBRACE, value: '{', position: start };
+            case '}':
+                return { type: TokenType.RBRACE, value: '}', position: start };
+            case '?':
+                return { type: TokenType.QUESTION, value: '?', position: start };
             default:
                 throw new ExpressionParserError(`Unexpected character: ${char}`, start, this.expression);
         }
@@ -2169,7 +2280,88 @@ class Parser {
         return result;
     }
     parseExpression() {
-        return this.parseLogicalOr();
+        // Try arrow function first — it has the lowest precedence and would otherwise
+        // be ambiguous with grouped expressions / bare identifiers.
+        const arrow = this.tryParseArrowFunction();
+        if (arrow)
+            return arrow;
+        return this.parseConditional();
+    }
+    /**
+     * Ternary `test ? consequent : alternate` — right-associative, sits between
+     * the arrow-function check and logical-or in precedence.
+     */
+    parseConditional() {
+        const test = this.parseLogicalOr();
+        if (!this.match(TokenType.QUESTION))
+            return test;
+        const consequent = this.parseExpression();
+        this.consume(TokenType.COLON, 'Expected ":" between ternary branches');
+        const alternate = this.parseExpression();
+        return { type: 'Conditional', test, consequent, alternate };
+    }
+    /**
+     * Attempts to parse an arrow function. Returns null and leaves position
+     * unchanged if the next tokens don't form an arrow function head.
+     *
+     * Supported shapes:
+     *   x => body
+     *   () => body
+     *   (x) => body
+     *   (x, y, ...) => body
+     *
+     * Body returning an object literal must be wrapped in parens: `d => ({...})`.
+     */
+    tryParseArrowFunction() {
+        const savedPos = this.current;
+        // Single unparenthesized param: IDENTIFIER =>
+        if (this.check(TokenType.IDENTIFIER) && this.checkAt(this.current + 1, TokenType.ARROW)) {
+            const param = this.advance().value;
+            this.advance(); // consume =>
+            const body = this.parseExpression();
+            return { type: 'ArrowFunction', params: [param], body };
+        }
+        // Parenthesized params: ( ) => or ( id (, id)* ) =>
+        if (this.check(TokenType.LPAREN)) {
+            this.advance(); // tentatively consume (
+            const params = [];
+            if (this.check(TokenType.RPAREN)) {
+                this.advance(); // )
+            }
+            else if (this.check(TokenType.IDENTIFIER)) {
+                params.push(this.advance().value);
+                while (this.check(TokenType.COMMA)) {
+                    this.advance(); // ,
+                    if (!this.check(TokenType.IDENTIFIER)) {
+                        this.current = savedPos;
+                        return null;
+                    }
+                    params.push(this.advance().value);
+                }
+                if (!this.check(TokenType.RPAREN)) {
+                    this.current = savedPos;
+                    return null;
+                }
+                this.advance(); // )
+            }
+            else {
+                this.current = savedPos;
+                return null;
+            }
+            if (!this.check(TokenType.ARROW)) {
+                this.current = savedPos;
+                return null;
+            }
+            this.advance(); // =>
+            const body = this.parseExpression();
+            return { type: 'ArrowFunction', params, body };
+        }
+        return null;
+    }
+    checkAt(index, type) {
+        if (index < 0 || index >= this.tokens.length)
+            return false;
+        return this.tokens[index].type === type;
     }
     parseLogicalOr() {
         let node = this.parseLogicalAnd();
@@ -2244,6 +2436,32 @@ class Parser {
                 const property = this.advance().value;
                 node = { type: 'MemberAccess', object: node, property };
             }
+            else if (this.match(TokenType.OPTIONAL_DOT)) {
+                // Optional chain — supports `?.prop`, `?.[expr]`, and `?.(args)`.
+                if (this.match(TokenType.LBRACKET)) {
+                    const property = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                    node = { type: 'ComputedMemberAccess', object: node, property, optional: true };
+                }
+                else if (this.match(TokenType.LPAREN)) {
+                    const args = this.parseArgumentList();
+                    this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
+                    node = { type: 'CallExpression', callee: node, arguments: args, optional: true };
+                }
+                else if (this.check(TokenType.IDENTIFIER)) {
+                    const property = this.advance().value;
+                    node = { type: 'MemberAccess', object: node, property, optional: true };
+                }
+                else {
+                    throw new ExpressionParserError('Expected property name, "[", or "(" after "?."', this.peek().position, this.expression);
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                // Computed member access: obj[expr]
+                const property = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                node = { type: 'ComputedMemberAccess', object: node, property };
+            }
             else if (this.match(TokenType.LPAREN)) {
                 // Function call: func()
                 const args = this.parseArgumentList();
@@ -2282,6 +2500,12 @@ class Parser {
             this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
             return { type: 'ArrayLiteral', elements };
         }
+        // Object literal
+        if (this.match(TokenType.LBRACE)) {
+            const properties = this.parseObjectProperties();
+            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
+            return { type: 'ObjectLiteral', properties };
+        }
         // Identifier
         if (this.match(TokenType.IDENTIFIER)) {
             return { type: 'Identifier', name: this.previous().value };
@@ -2312,6 +2536,28 @@ class Parser {
         }
         return elements;
     }
+    parseObjectProperties() {
+        const properties = [];
+        if (this.check(TokenType.RBRACE)) {
+            return properties;
+        }
+        do {
+            // Trailing comma support: `{ a: 1, }`
+            if (this.check(TokenType.RBRACE))
+                break;
+            let key;
+            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
+                key = this.advance().value;
+            }
+            else {
+                throw new ExpressionParserError(`Expected property name (identifier or string) in object literal, got '${this.peek().value}'`, this.peek().position, this.expression);
+            }
+            this.consume(TokenType.COLON, 'Expected ":" after property name in object literal');
+            const value = this.parseExpression();
+            properties.push({ key, value });
+        } while (this.match(TokenType.COMMA));
+        return properties;
+    }
     match(...types) {
         for (const type of types) {
             if (this.check(type)) {
@@ -2486,14 +2732,22 @@ class Evaluator {
                 return this.evaluateIdentifier(node.name);
             case 'MemberAccess':
                 return this.evaluateMemberAccess(node);
+            case 'ComputedMemberAccess':
+                return this.evaluateComputedMemberAccess(node);
             case 'BinaryOp':
                 return this.evaluateBinaryOp(node);
             case 'UnaryOp':
                 return this.evaluateUnaryOp(node);
             case 'CallExpression':
                 return this.evaluateCallExpression(node);
+            case 'Conditional':
+                return this.evaluate(node.test) ? this.evaluate(node.consequent) : this.evaluate(node.alternate);
             case 'ArrayLiteral':
                 return this.evaluateArrayLiteral(node);
+            case 'ObjectLiteral':
+                return this.evaluateObjectLiteral(node);
+            case 'ArrowFunction':
+                return this.evaluateArrowFunction(node);
             default:
                 throw new ExpressionParserError(`Unknown node type: ${node.type}`, 0, this.expression);
         }
@@ -2519,6 +2773,27 @@ class Evaluator {
         }
         return undefined;
     }
+    evaluateComputedMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+            // Both `obj?.[expr]` and `obj[expr]` short-circuit on null/undefined —
+            // matches the safe-access behavior of dotted member access above.
+            return undefined;
+        }
+        const rawKey = this.evaluate(node.property);
+        if (rawKey === null || rawKey === undefined)
+            return undefined;
+        const key = String(rawKey);
+        // Same blocklist as dotted access — `obj['__proto__']` must be rejected
+        // even though the property name was computed.
+        if (BLOCKED_PROPERTIES.has(key)) {
+            throw new ExpressionParserError(`Property "${key}" is not accessible for security reasons`, 0, this.expression);
+        }
+        if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[key];
+        }
+        return undefined;
+    }
     evaluateBinaryOp(node) {
         // Handle short-circuit evaluation for logical operators
         if (node.operator === '&&') {
@@ -2583,11 +2858,21 @@ class Evaluator {
         }
     }
     evaluateCallExpression(node) {
-        // Only allow method calls (member access), not arbitrary function calls
+        // Only allow method calls (member access). Computed access (`obj['method']()`)
+        // is also rejected — the security model whitelists method names statically.
         if (node.callee.type !== 'MemberAccess') {
             throw new ExpressionParserError('Only method calls are allowed, not arbitrary function calls', 0, this.expression);
         }
         const obj = this.evaluate(node.callee.object);
+        // Calling a method on a nullish receiver silently returns undefined —
+        // consistent with how dotted member access (`obj.prop`) treats nullish
+        // receivers above. This means `a?.b()`, `a?.b.c()`, and `nullable.method()`
+        // all short-circuit to undefined rather than tripping the whitelist check
+        // with a misleading "method not allowed" error. The whitelist still
+        // enforces strictly on non-nullish receivers.
+        if (obj === null || obj === undefined) {
+            return undefined;
+        }
         const methodName = node.callee.property;
         // Block access to dangerous properties (must check before method call)
         if (BLOCKED_PROPERTIES.has(methodName)) {
@@ -2610,6 +2895,28 @@ class Evaluator {
     evaluateArrayLiteral(node) {
         return node.elements.map((element) => this.evaluate(element));
     }
+    evaluateObjectLiteral(node) {
+        const result = {};
+        for (const { key, value } of node.properties) {
+            if (BLOCKED_PROPERTIES.has(key)) {
+                throw new ExpressionParserError(`Property "${key}" is not allowed in object literals for security reasons`, 0, this.expression);
+            }
+            result[key] = this.evaluate(value);
+        }
+        return result;
+    }
+    evaluateArrowFunction(node) {
+        const parentScope = this.scope;
+        const expression = this.expression;
+        return (...args) => {
+            const childScope = { ...parentScope };
+            for (let i = 0; i < node.params.length; i++) {
+                childScope[node.params[i]] = args[i];
+            }
+            const childEvaluator = new Evaluator(childScope, expression);
+            return childEvaluator.evaluate(node.body);
+        };
+    }
     isMethodSafe(obj, methodName) {
         if (obj === null || obj === undefined) {
             return false;
@@ -2744,16 +3051,25 @@ function evaluateCondition(expression, context) {
         case 'javascript':
             return evaluateJavaScriptExpression(expression, context);
         case 'custom': {
-            const customFn = context.customFunctions?.[expression.functionName];
+            // Read both keys via cast — the XOR type narrows to `never` when both
+            // would be truthy, but JSON-loaded configs can produce that state at
+            // runtime. We accept it here, warn, and let inline win.
+            const bothSet = expression;
+            const inlineFn = bothSet.fn;
+            const registeredName = bothSet.functionName;
+            if (inlineFn && registeredName) {
+                context.logger.warn('Both "fn" and "functionName" are set on custom condition. Inline "fn" takes precedence; "functionName" is ignored.');
+            }
+            const customFn = inlineFn ?? (registeredName ? context.customFunctions?.[registeredName] : undefined);
             if (!customFn) {
-                context.logger.error('Custom function not found:', expression.functionName);
+                context.logger.error('Custom function not found:', registeredName);
                 return false;
             }
             try {
                 return !!customFn(context);
             }
             catch (error) {
-                context.logger.error('Error executing custom function:', expression.functionName, error);
+                context.logger.error('Error executing custom function:', registeredName ?? '<inline>', error);
                 return false;
             }
         }
@@ -2762,7 +3078,7 @@ function evaluateCondition(expression, context) {
         case 'or':
             return evaluateOrCondition(expression, context);
         case 'http':
-            context.logger.warn('[Dynamic Forms] HTTP conditions are resolved asynchronously via createHttpConditionLogicFunction(). ' +
+            context.logger.warn('HTTP conditions are resolved asynchronously via createHttpConditionLogicFunction(). ' +
                 'When used inside and/or composites, the HTTP result is not available synchronously. Returning false.');
             return false;
         case 'async':
@@ -3298,10 +3614,10 @@ class FunctionRegistryService {
         this.clearAsyncValidators();
         this.clearHttpValidators();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FunctionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FunctionRegistryService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FunctionRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FunctionRegistryService, decorators: [{
             type: Injectable
         }] });
 
@@ -3752,10 +4068,10 @@ class FieldContextRegistryService {
             },
         };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FieldContextRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FieldContextRegistryService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FieldContextRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldContextRegistryService, decorators: [{
             type: Injectable
         }] });
 
@@ -4110,8 +4426,8 @@ class PageOrchestratorComponent {
         }
         return false;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: PageOrchestratorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.8", type: PageOrchestratorComponent, isStandalone: true, selector: "div[page-orchestrator]", inputs: { pageFields: { classPropertyName: "pageFields", publicName: "pageFields", isSignal: true, isRequired: true, transformFunction: null }, form: { classPropertyName: "form", publicName: "form", isSignal: true, isRequired: true, transformFunction: null }, fieldSignalContext: { classPropertyName: "fieldSignalContext", publicName: "fieldSignalContext", isSignal: true, isRequired: true, transformFunction: null } }, host: { properties: { "attr.data-current-page": "state().currentPageIndex", "attr.data-total-pages": "state().totalPages" }, classAttribute: "df-page-orchestrator" }, providers: [
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: PageOrchestratorComponent, isStandalone: true, selector: "div[page-orchestrator]", inputs: { pageFields: { classPropertyName: "pageFields", publicName: "pageFields", isSignal: true, isRequired: true, transformFunction: null }, form: { classPropertyName: "form", publicName: "form", isSignal: true, isRequired: true, transformFunction: null }, fieldSignalContext: { classPropertyName: "fieldSignalContext", publicName: "fieldSignalContext", isSignal: true, isRequired: true, transformFunction: null } }, host: { properties: { "attr.data-current-page": "state().currentPageIndex", "attr.data-total-pages": "state().totalPages" }, classAttribute: "df-page-orchestrator" }, providers: [
             {
                 provide: FIELD_SIGNAL_CONTEXT,
                 useFactory: (orchestrator) => orchestrator.extendedFieldSignalContext(),
@@ -4141,9 +4457,9 @@ class PageOrchestratorComponent {
         }
       }
     }
-  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-DqWAcwhG.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-DqWAcwhG.mjs').then(m => m.default)]] });
+  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs').then(m => m.default)]] });
 }
-i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.8", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-DqWAcwhG.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
+i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
                 type: Component,
                 args: [{ selector: 'div[page-orchestrator]', imports: [PageFieldComponent], template: `
     @for (pageField of pageFields(); track pageField.key; let i = $index) {
@@ -4575,6 +4891,85 @@ function isValidNonPagedForm(fields) {
     return result.mode === 'non-paged' && result.isValid;
 }
 
+function createSlot() {
+    let counter = 0;
+    const templates = new Map();
+    const itemOrder = [];
+    const primitiveFieldKey = signal(undefined, ...(ngDevMode ? [{ debugName: "primitiveFieldKey" }] : /* istanbul ignore next */ []));
+    return {
+        templates,
+        itemOrder,
+        primitiveFieldKey,
+        nextId: () => `item-${counter++}`,
+        setTemplate(itemId, t) {
+            templates.set(itemId, t);
+        },
+        getTemplate(itemId) {
+            return templates.get(itemId);
+        },
+        hasTemplate(itemId) {
+            return templates.has(itemId);
+        },
+        setIdAt(index, itemId) {
+            itemOrder[index] = itemId;
+        },
+        removeAt(index) {
+            const [removed] = itemOrder.splice(index, 1);
+            if (removed !== undefined)
+                templates.delete(removed);
+        },
+        moveItem(fromIndex, toIndex) {
+            const [id] = itemOrder.splice(fromIndex, 1);
+            if (id !== undefined)
+                itemOrder.splice(toIndex, 0, id);
+        },
+        truncate(length) {
+            const removed = itemOrder.splice(length);
+            for (const id of removed)
+                templates.delete(id);
+        },
+        clear() {
+            templates.clear();
+            itemOrder.length = 0;
+            counter = 0;
+            primitiveFieldKey.set(undefined);
+        },
+    };
+}
+/**
+ * Form-scoped registry of per-array durable state. One slot per array path
+ * (e.g. 'members', 'team.members', 'orders.lineItems'). Survives
+ * `ArrayFieldComponent` lifecycle, dies with the `DynamicForm`. Cleared on
+ * schema swap by the `formSetup` effect in `FormStateManager`.
+ *
+ * `ArrayFieldComponent` injects this service and obtains its slot via
+ * `slotFor(arrayPath)` on mount. Replaces the prior per-component
+ * `ARRAY_TEMPLATE_REGISTRY` + `ARRAY_ITEM_ID_GENERATOR` providers.
+ */
+class ArrayItemRegistryService {
+    slots = new Map();
+    /** Get-or-create a slot for the array at the given path. */
+    slotFor(arrayPath) {
+        let slot = this.slots.get(arrayPath);
+        if (!slot) {
+            slot = createSlot();
+            this.slots.set(arrayPath, slot);
+        }
+        return slot;
+    }
+    /** Drop all slots — called from the `formSetup` effect on schema change. */
+    clearAll() {
+        for (const slot of this.slots.values())
+            slot.clear();
+        this.slots.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ArrayItemRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ArrayItemRegistryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ArrayItemRegistryService, decorators: [{
+            type: Injectable
+        }] });
+
 class SchemaRegistryService {
     registeredSchemas = new Map();
     /**
@@ -4610,10 +5005,10 @@ class SchemaRegistryService {
         }
         return schema;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: SchemaRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: SchemaRegistryService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SchemaRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SchemaRegistryService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: SchemaRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SchemaRegistryService, decorators: [{
             type: Injectable
         }] });
 
@@ -4624,7 +5019,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
  * Use this guard when you need type-safe access to `FunctionHttpValidatorConfig` properties.
  */
 function isFunctionHttpValidator(config) {
-    return 'functionName' in config && !!config.functionName;
+    const c = config;
+    return typeof c.functionName === 'string' || (c.fn !== null && typeof c.fn === 'object');
 }
 
 /**
@@ -4820,8 +5216,6 @@ class HttpConditionFunctionCacheService {
  * );
  * // user.value() keeps the old user data during loading transitions
  * ```
- *
- * @experimental Uses Angular's experimental resource composition APIs.
  */
 function withPreviousValue(input) {
     const derived = linkedSignal({ ...(ngDevMode ? { debugName: "derived" } : /* istanbul ignore next */ {}), source: input.snapshot,
@@ -5043,11 +5437,18 @@ function createAsyncConditionLogicFunction(condition) {
     const cacheService = inject(AsyncConditionFunctionCacheService);
     const pendingValue = condition.pendingValue ?? false;
     const debounceMs = condition.debounceMs ?? 300;
-    // Check function cache
-    const cacheKey = stableStringify(condition);
-    const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
-    if (cached) {
-        return cached;
+    if (condition.asyncFn && condition.asyncFunctionName) {
+        logger.warn('Both "asyncFn" and "asyncFunctionName" are set on async condition. Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.');
+    }
+    // Skip cross-condition caching when an inline function is used: stableStringify
+    // cannot distinguish two different inline functions, which would cause cache hits
+    // to wrongly reuse a LogicFn closing over a different function reference.
+    const cacheKey = condition.asyncFn ? undefined : stableStringify(condition);
+    if (cacheKey !== undefined) {
+        const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
     }
     // Each condition needs its own per-field signal store.
     const perFunctionSignalStore = new Map();
@@ -5072,8 +5473,10 @@ function createAsyncConditionLogicFunction(condition) {
                 const asyncResource = rxResource({
                     params: () => debouncedTrigger() ?? undefined,
                     stream: ({ params: triggerKey }) => {
-                        // Look up the async function at call time (fresh reference)
-                        const asyncFn = functionRegistry.getAsyncConditionFunction(condition.asyncFunctionName);
+                        // Inline `asyncFn` wins; otherwise look up the registered function at call time
+                        // (fresh reference, in case the registry was updated after LogicFn creation).
+                        const asyncFn = condition.asyncFn ??
+                            (condition.asyncFunctionName ? functionRegistry.getAsyncConditionFunction(condition.asyncFunctionName) : undefined);
                         if (!asyncFn) {
                             logger.warn(`Async Condition - function '${condition.asyncFunctionName}' not found. ` +
                                 `Register it in customFnConfig.asyncConditions.`);
@@ -5125,7 +5528,9 @@ function createAsyncConditionLogicFunction(condition) {
         });
         return resultResource.value();
     };
-    cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    if (cacheKey !== undefined) {
+        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    }
     return fn;
 }
 
@@ -5760,12 +6165,12 @@ function applyCustomValidator(config, fieldPath) {
     if (config.expression) {
         validatorFn = createExpressionValidator(config);
     }
-    else if (config.functionName) {
+    else if (config.fn || config.functionName) {
         validatorFn = createFunctionValidator(config);
     }
     else {
         const logger = inject(DynamicFormLogger);
-        logger.warn('Custom validator must have either "expression" or "functionName"');
+        logger.warn('Custom validator must have one of "expression", "functionName", or "fn"');
         return;
     }
     const whenLogic = createConditionalLogic(config.when);
@@ -5777,6 +6182,13 @@ function applyCustomValidator(config, fieldPath) {
 }
 function createFunctionValidator(config) {
     const logger = inject(DynamicFormLogger);
+    if (config.fn && config.functionName) {
+        logger.warn('Both "fn" and "functionName" are set on custom validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    if (config.fn) {
+        const inlineFn = config.fn;
+        return (ctx) => inlineFn(ctx, config.params);
+    }
     const functionName = config.functionName;
     if (!functionName) {
         logger.warn('Custom validator missing functionName');
@@ -5837,10 +6249,24 @@ function createExpressionValidator(config) {
  * - onError: Optional handler for resource errors
  */
 function applyAsyncValidator(config, fieldPath) {
-    const registry = inject(FunctionRegistryService);
-    const validatorConfig = registry.getAsyncValidator(config.functionName);
-    if (!validatorConfig) {
-        throw new DynamicFormError(`Async validator "${config.functionName}" not found. Register it with customFnConfig.asyncValidators.`);
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on async validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let validatorConfig;
+    if (config.fn) {
+        validatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        validatorConfig = registry.getAsyncValidator(config.functionName);
+        if (!validatorConfig) {
+            throw new DynamicFormError(`Async validator "${config.functionName}" not found. Register it with customFnConfig.asyncValidators.`);
+        }
+    }
+    else {
+        // XOR type rejects this at compile time; JSON-loaded configs can still reach here at runtime.
+        throw new DynamicFormError('Async validator requires one of "functionName" or "fn".');
     }
     const whenLogic = createConditionalLogic(config.when);
     const asyncOptions = {
@@ -5862,10 +6288,16 @@ function applyAsyncValidator(config, fieldPath) {
 function applyUnifiedHttpValidator(config, fieldPath) {
     if (isFunctionHttpValidator(config)) {
         applyFunctionHttpValidator(config, fieldPath);
+        return;
     }
-    else {
-        applyDeclarativeHttpValidator(config, fieldPath);
+    // Declarative path requires both `http` and `responseMapping` — reject early
+    // for JSON-loaded configs that have neither side fully populated. The
+    // discriminated union forbids this at compile time.
+    const declarative = config;
+    if (!declarative.http || !declarative.responseMapping) {
+        throw new DynamicFormError('HTTP validator requires one of "functionName" / "fn" (function-based) or "http" + "responseMapping" (declarative).');
     }
+    applyDeclarativeHttpValidator(config, fieldPath);
 }
 /**
  * Apply function-based HTTP validator to field path using Angular's public validateHttp() API.
@@ -5876,10 +6308,24 @@ function applyUnifiedHttpValidator(config, fieldPath) {
  * - onError: Optional handler for HTTP errors
  */
 function applyFunctionHttpValidator(config, fieldPath) {
-    const registry = inject(FunctionRegistryService);
-    const httpValidatorConfig = registry.getHttpValidator(config.functionName);
-    if (!httpValidatorConfig) {
-        throw new DynamicFormError(`HTTP validator "${config.functionName}" not found. Register it with customFnConfig.httpValidators.`);
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on HTTP validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let httpValidatorConfig;
+    if (config.fn) {
+        httpValidatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        httpValidatorConfig = registry.getHttpValidator(config.functionName);
+        if (!httpValidatorConfig) {
+            throw new DynamicFormError(`HTTP validator "${config.functionName}" not found. Register it with customFnConfig.httpValidators.`);
+        }
+    }
+    else {
+        // XOR type rejects this at compile time; JSON-loaded configs can still reach here at runtime.
+        throw new DynamicFormError('HTTP validator requires one of "functionName" or "fn".');
     }
     const whenLogic = createConditionalLogic(config.when);
     const httpOptions = {
@@ -8232,9 +8678,13 @@ function buildClassName(fieldDef) {
  * @returns Record of input names to values
  */
 function buildBaseInputs(fieldDef, defaultProps) {
-    const { key, label, className, tabIndex, props, meta } = fieldDef;
+    const { key, label, className, tabIndex, props, meta, addons } = fieldDef;
     const inputs = {};
-    // Always include key - required by components for accessibility and identification
+    // Always include key — required by components for accessibility and identification.
+    // `type` is intentionally NOT propagated to the field component (it's the
+    // registry discriminant, not a component input); wrappers and addons read it
+    // from `WrapperFieldInputs.type` which is injected at the buildFieldInputs()
+    // boundary by `DfFieldOutlet`.
     inputs['key'] = key;
     if (label !== undefined) {
         inputs['label'] = label;
@@ -8264,6 +8714,13 @@ function buildBaseInputs(fieldDef, defaultProps) {
     if (meta !== undefined) {
         inputs['meta'] = meta;
     }
+    // Forward addons. Field components that don't declare an `addons` input
+    // signal (Tier 3 — toggle, checkbox, radio, slider) ignore this key via
+    // Angular's `setInput` no-op-on-unknown behaviour, so it's safe to forward
+    // unconditionally.
+    if (addons !== undefined) {
+        inputs['addons'] = addons;
+    }
     return inputs;
 }
 /**
@@ -8463,22 +8920,31 @@ const PLACEHOLDER_INDEX = '$';
 /**
  * Builds a property override store key for a field.
  *
- * For non-array fields, the key is just the field's key.
- * For array item fields, the key includes the array path and either a concrete
- * index (e.g., `contacts.0.email`) or the `$` placeholder (e.g., `contacts.$.email`).
+ * For non-array fields, the key is the dot-joined group ancestors plus the
+ * field's leaf key (e.g., `address.street` for `street` inside `address`).
+ * For array item fields, the key includes the array path, either a concrete
+ * index or the `$` placeholder, and any group ancestors INSIDE the array
+ * item (e.g., `contacts.0.email`, `contacts.$.email`, or
+ * `contacts.0.profile.email` for a group nested under each contact).
+ *
+ * `groupPath` matches the form-value path of nested groups (collector resets
+ * it at array boundaries — see `property-derivation-collector.ts`), so the
+ * resulting key always mirrors the field's location in `formValue`.
  *
  * @param arrayKey - The array field key (e.g., 'contacts'), or undefined for non-array fields
  * @param index - The array item index, `PLACEHOLDER_INDEX` for the wildcard format, or undefined for non-array fields
  * @param fieldKey - The leaf field key (e.g., 'email')
- * @returns The store key (e.g., 'email', 'contacts.0.email', or 'contacts.$.email')
+ * @param groupPath - Dot-joined group ancestors scoped to the current array item (or top-level), or undefined when not inside any group
+ * @returns The store key (e.g., 'email', 'address.street', 'contacts.0.email', 'contacts.$.profile.email')
  *
  * @public
  */
-function buildPropertyOverrideKey(arrayKey, index, fieldKey) {
+function buildPropertyOverrideKey(arrayKey, index, fieldKey, groupPath) {
+    const leafScope = groupPath ? `${groupPath}.${fieldKey}` : fieldKey;
     if (arrayKey != null && index != null) {
-        return `${arrayKey}.${index}.${fieldKey}`;
+        return `${arrayKey}.${index}.${leafScope}`;
     }
-    return fieldKey;
+    return leafScope;
 }
 
 /**
@@ -8559,6 +9025,25 @@ function applyIndexSuffix(inputs, index) {
         key: `${key}_${index}`,
     };
 }
+/**
+ * Prefixes the key with the underscored group ancestor path so that the same
+ * leaf key inside different groups produces distinct DOM IDs (issue #401).
+ * Form-schema keys remain clean — only the rendered `key` input is rewritten.
+ *
+ * Dots in the group path become underscores, then the original leaf key is
+ * appended: `(groupPath='user.address', inputs.key='street')` →
+ * `inputs.key = 'user_address_street'`.
+ */
+function applyGroupPrefix(inputs, groupPath) {
+    const key = inputs['key'];
+    if (typeof key !== 'string' || groupPath.length === 0) {
+        return inputs;
+    }
+    return {
+        ...inputs,
+        key: `${groupPath.replace(/\./g, '_')}_${key}`,
+    };
+}
 /**
  * Main field mapper function that uses the field registry to get the appropriate mapper
  * based on the field's type property.
@@ -8595,6 +9080,10 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // Check if we're inside an array item context - if so, we need to suffix keys
     // Optional because ARRAY_CONTEXT is only provided inside array item injectors
     const arrayContext = inject(ARRAY_CONTEXT, { optional: true });
+    // Check if we're inside a group context - if so, prefix the key with the group path
+    // so overlapping leaf keys across groups produce distinct DOM IDs (issue #401).
+    // Optional because GROUP_CONTEXT is only provided by GroupFieldComponent.
+    const groupContext = inject(GROUP_CONTEXT, { optional: true });
     // Inject the property override store for property derivation overrides
     // Always available — provided at the DynamicForm component level via provideDynamicFormDI
     const store = inject(PROPERTY_OVERRIDE_STORE);
@@ -8605,6 +9094,7 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // Check that arrayContext exists and has a valid index signal (guards against mock injectors)
     const indexSignal = arrayContext?.index;
     const hasArrayContext = indexSignal !== undefined && isSignal(indexSignal);
+    const hasGroupContext = groupContext != null;
     // Fast-path check for property overrides: only fields whose definition declares
     // a property-derivation enter the computed() wrapper. We inspect the FieldDef
     // directly rather than asking the store, because the store's registration
@@ -8613,7 +9103,7 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // collector apply the same inclusion rule, so the answers always agree.
     const hasOverrides = fieldHasPropertyDerivations(fieldDef);
     // Fast path: no transformations needed
-    if (!hasPropsForwarding && !hasArrayContext && !hasOverrides) {
+    if (!hasPropsForwarding && !hasArrayContext && !hasGroupContext && !hasOverrides) {
         return mapperResult;
     }
     // Wrap in computed to apply transformations
@@ -8623,18 +9113,34 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
         if (hasPropsForwarding) {
             inputs = mergeForwardedPropsToMeta(inputs, propsToMeta);
         }
+        // Apply group prefix BEFORE array suffix so the resulting key reads as
+        // `{groupPath}_{key}_{index}` (e.g. `address_street_0`) — matching the
+        // form-value path order: group → leaf → array index.
+        if (hasGroupContext) {
+            // Non-null after the hasGroupContext guard.
+            inputs = applyGroupPrefix(inputs, groupContext.groupPath());
+        }
         // Apply index suffix for array items
         if (hasArrayContext) {
             const index = indexSignal();
             inputs = applyIndexSuffix(inputs, index);
         }
-        // Apply property overrides from the store (AFTER all static transformations)
+        // Apply property overrides from the store (AFTER all static transformations).
+        //
+        // INVARIANT: the store key MUST be built from `fieldDef.key` + the group/array
+        // ancestry (via buildPropertyOverrideKey) — NEVER from the DOM-scoped
+        // `inputs['key']` produced by applyGroupPrefix/applyIndexSuffix above. The
+        // collector (property-derivation-collector.ts) registers using the same
+        // shape; if these drift, overrides silently miss their target.
         if (hasOverrides) {
-            // Build the store key inside computed() so index signal read establishes reactive dependency
-            // Safe to access arrayContext/indexSignal directly — hasArrayContext already confirmed they exist
+            // Build inside computed() so the index/group signals establish reactive deps.
+            // GROUP_CONTEXT resets at array boundaries (see create-array-item-injector.ts),
+            // so groupPath() represents ancestors inside the current array item (or
+            // top-level groups when not in an array) — matching the collector.
+            const groupPath = hasGroupContext ? groupContext.groupPath() : undefined;
             const key = hasArrayContext
-                ? buildPropertyOverrideKey(arrayContext.arrayKey, indexSignal(), fieldDef.key)
-                : fieldDef.key;
+                ? buildPropertyOverrideKey(arrayContext.arrayKey, indexSignal(), fieldDef.key, groupPath || undefined)
+                : buildPropertyOverrideKey(undefined, undefined, fieldDef.key, groupPath || undefined);
             const overrides = store.getOverrides(key)();
             inputs = applyPropertyOverrides(inputs, overrides);
         }
@@ -8653,6 +9159,40 @@ function createRenderReadySignal(inputs, definition) {
         return requiredInputs.every((inputName) => currentInputs[inputName] !== undefined);
     });
 }
+/**
+ * Reads the current hidden state from mapper inputs. Uniform across all field
+ * types — value-bearing leaves source from the `FieldTree`'s `state.hidden()`
+ * (where Angular Signal Forms cascades `hidden(path, …)`), and non-field outputs
+ * (button/text/containers) source from the mapper's explicit `inputs.hidden`.
+ *
+ * The `@if (!field.hidden())` gate at every `*dfFieldOutlet` consumption site uses
+ * this signal, removing hidden fields from the DOM. That's required to silence
+ * Angular's `NG01916: Field 'X' is hidden but is being rendered` warning — and
+ * is the prescribed pattern from the
+ * [`hidden` API docs](https://angular.dev/api/forms/signals/hidden).
+ *
+ * Container internal state (e.g. an `ArrayFieldComponent`'s items + dynamic
+ * templates + id counter) survives this destroy/recreate via the form-scoped
+ * `ArrayItemRegistryService` keyed by array path.
+ */
+function createHiddenSignal(inputs) {
+    return computed(() => {
+        const currentInputs = inputs();
+        const fieldCandidate = currentInputs['field'];
+        // Value-bearing leaves expose `field` as a callable `FieldTree` whose invocation returns a
+        // `FieldState` with a `hidden` accessor. `isSignal()` doesn't recognise the Proxy-wrapped
+        // FieldTree (no SIGNAL symbol), so we duck-type the shape and call `state.hidden()` directly.
+        if (typeof fieldCandidate === 'function') {
+            const state = fieldCandidate();
+            if (state && typeof state.hidden === 'function') {
+                return state.hidden() === true;
+            }
+        }
+        // Non-value fields (button, text, containers) carry an explicit `hidden` input set by
+        // `applyHiddenLogic` based on the mapper-side evaluation.
+        return currentInputs['hidden'] === true;
+    });
+}
 /**
  * Resolves a single field definition to a ResolvedField using RxJS.
  * Loads the component asynchronously and maps inputs in the injection context.
@@ -8689,6 +9229,7 @@ function resolveField(fieldDef, context) {
             injector: context.injector,
             inputs,
             renderReady: createRenderReadySignal(inputs, definition),
+            hidden: createHiddenSignal(inputs),
         };
     }), catchError((error) => {
         // Only call onError if component is not destroyed to avoid accessing cleaned-up state
@@ -8725,6 +9266,7 @@ function resolveFieldSync(fieldDef, context) {
         injector: context.injector,
         inputs,
         renderReady: createRenderReadySignal(inputs, definition),
+        hidden: createHiddenSignal(inputs),
     };
 }
 /**
@@ -8751,13 +9293,14 @@ function reconcileFields(prev, curr) {
             }
             // Same component instance + injector, but the field definition changed.
             // Preserve component identity (so ngComponentOutlet keeps the same instance)
-            // while swapping in the freshly-mapped inputs/renderReady signals so prop
-            // updates (e.g. select options) reach the component.
+            // while swapping in the freshly-mapped inputs/renderReady/hidden signals
+            // so prop updates (e.g. select options) reach the component.
             return {
                 ...existing,
                 fieldDef: field.fieldDef,
                 inputs: field.inputs,
                 renderReady: field.renderReady,
+                hidden: field.hidden,
             };
         }
         // New field, type changed, or context changed (new injector) - use new field
@@ -9075,15 +9618,32 @@ function injectFieldRegistry() {
  * Collects all field keys, types, and validates regex patterns from a field tree
  * by recursively traversing containers (page, row, group, array).
  *
- * @param collectKeys - Whether to add field keys to data.keys for duplicate detection.
- *   Set to false when inside an array container: array item fields share template keys
- *   across items by design (e.g. every item has 'name', 'email'), so they must not
- *   participate in global duplicate-key checking.
+ * Keys are scoped by their group ancestors (e.g. `address.city` instead of `city`),
+ * so the same leaf key can appear inside different groups without conflict. Page and
+ * row containers do not contribute to the path because they flatten their children
+ * into the parent scope. Array items are excluded entirely from key collection
+ * because they share template keys across items by design.
+ *
+ * Fields whose registered `valueHandling` is anything other than `include` (e.g.
+ * buttons with `exclude`, page/row with `flatten`) are not collected: they don't
+ * bind to a form-value path, so duplicate-key uniqueness isn't meaningful for them.
+ *
+ * @param collectKeys - When false, the entire subtree skips key collection (used
+ *   when descending into an array container).
  */
-function collectFieldData(fields, data, collectKeys = true) {
+function collectFieldData(fields, data, registry, pathPrefix, collectKeys = true) {
     for (const field of fields) {
-        if (collectKeys && field.key) {
-            data.keys.push(field.key);
+        // Defensively skip only known non-include modes — unexpected/missing
+        // valueHandling defaults back to participating in duplicate detection so a
+        // mis-registered field type doesn't silently drop from collision checks.
+        const valueHandling = field.type ? getFieldValueHandling(field.type, registry) : 'include';
+        const participatesInValue = valueHandling !== 'exclude' && valueHandling !== 'flatten';
+        if (collectKeys && field.key && participatesInValue) {
+            const scopedKey = pathPrefix ? `${pathPrefix}.${field.key}` : field.key;
+            data.keys.push(scopedKey);
+            // Project to the DOM-ID format (dots → underscores) so we can detect
+            // collisions like top-level `'foo_bar'` vs group `'foo'` + leaf `'bar'`.
+            data.domIds.push(scopedKey.replace(/\./g, '_'));
         }
         if (field.type) {
             data.types.add(field.type);
@@ -9103,13 +9663,16 @@ function collectFieldData(fields, data, collectKeys = true) {
             // Array item fields share template keys across items by design — stop collecting keys
             // once inside an array. Types and regex patterns are still validated.
             const childCollectKeys = collectKeys && field.type !== 'array';
+            // Only group containers extend the scoping path — page/row flatten into the parent
+            // scope, and array items use dynamic indices that aren't statically knowable.
+            const childPrefix = isGroupField(field) && field.key ? (pathPrefix ? `${pathPrefix}.${field.key}` : field.key) : pathPrefix;
             const children = normalizeFieldsArray(field.fields);
             for (const child of children) {
                 if (Array.isArray(child)) {
-                    collectFieldData(child, data, childCollectKeys);
+                    collectFieldData(child, data, registry, childPrefix, childCollectKeys);
                 }
                 else {
-                    collectFieldData([child], data, childCollectKeys);
+                    collectFieldData([child], data, registry, childPrefix, childCollectKeys);
                 }
             }
         }
@@ -9145,7 +9708,38 @@ function validateNoDuplicateKeys(allKeys) {
         const duplicateList = Array.from(duplicates)
             .map((k) => `'${k}'`)
             .join(', ');
-        throw new DynamicFormError(`Duplicate field keys detected: ${duplicateList}. Each field key must be unique within a form config.`);
+        throw new DynamicFormError(`Duplicate field keys detected: ${duplicateList}. Field keys must be unique within their group scope (the same key may appear inside different groups).`);
+    }
+}
+/**
+ * Validates that the underscore-projected DOM-ID namespace has no collisions.
+ *
+ * DOM IDs are built by underscore-joining the group ancestor path with the
+ * leaf key (e.g. `address_street`). Two scoped paths can land on the same
+ * DOM ID even when their form-value paths differ — e.g. a top-level key
+ * `'foo_bar'` and a leaf `'bar'` inside group `'foo'` both render as
+ * `id="foo_bar"`. The form-value-path check accepts this (paths are
+ * `'foo_bar'` vs `'foo.bar'` — distinct) but the rendered DOM would have
+ * duplicate IDs, breaking aria associations and CSS selectors.
+ *
+ * @throws {DynamicFormError} When two scoped paths project to the same DOM ID
+ */
+function validateNoDomIdCollisions(domIds) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const id of domIds) {
+        if (seen.has(id)) {
+            duplicates.add(id);
+        }
+        seen.add(id);
+    }
+    if (duplicates.size > 0) {
+        const duplicateList = Array.from(duplicates)
+            .map((k) => `'${k}'`)
+            .join(', ');
+        throw new DynamicFormError(`DOM id collision detected for: ${duplicateList}. Group-nested keys are joined with '_' to form DOM ids ` +
+            `(e.g. group 'foo' + leaf 'bar' renders as id='foo_bar'). A separate top-level key like 'foo_bar' or a different ` +
+            `group/leaf pair that underscores to the same string will produce duplicate ids. Rename one of the colliding keys.`);
     }
 }
 /**
@@ -9183,11 +9777,13 @@ function validateFieldTypesRegistered(allTypes, registry, logger) {
 function validateFormConfig(fields, registry, logger) {
     const data = {
         keys: [],
+        domIds: [],
         types: new Set(),
         regexErrors: [],
     };
-    collectFieldData(fields, data);
+    collectFieldData(fields, data, registry, '');
     validateNoDuplicateKeys(data.keys);
+    validateNoDomIdCollisions(data.domIds);
     validateFieldTypesRegistered(data.types, registry, logger);
     if (data.regexErrors.length > 0) {
         throw new DynamicFormError(data.regexErrors.length === 1
@@ -9196,6 +9792,272 @@ function validateFormConfig(fields, registry, logger) {
     }
 }
 
+/**
+ * Walk a field's addons; return the survivors plus a list of warnings for
+ * anything dropped.
+ *
+ * Pure: receives the registries as arguments (so the function is reusable
+ * outside Angular's DI — tests, server-side validation, etc.).
+ *
+ * @param field        The field to validate.
+ * @param fieldRegistry Snapshot of `FIELD_REGISTRY` map.
+ * @param kindRegistry  Snapshot of `ADDON_KIND_REGISTRY` map.
+ * @param source       Whether the config originated from JSON (lenient drop
+ *                      of code-only kinds) or inline TypeScript.
+ */
+function validateFieldAddons(field, fieldRegistry, kindRegistry, source) {
+    const warnings = [];
+    const incoming = field.addons;
+    if (!incoming?.length) {
+        return { addons: [], warnings };
+    }
+    const fieldType = field.type;
+    const fieldDef = fieldRegistry.get(fieldType);
+    if (!fieldDef) {
+        warnings.push({ type: 'unknown-field-type', fieldKey: field.key, fieldType });
+        return { addons: [], warnings };
+    }
+    const addonSupport = fieldDef.addons;
+    if (!addonSupport) {
+        warnings.push({ type: 'field-type-no-addon-support', fieldKey: field.key, fieldType });
+        return { addons: [], warnings };
+    }
+    const allowedSlots = addonSupport.slots;
+    const allowedKinds = addonSupport.allowedKinds;
+    const registeredKinds = Array.from(kindRegistry.keys());
+    const survivors = [];
+    for (const addon of incoming) {
+        // Slot allowed?
+        if (!allowedSlots.includes(addon.slot)) {
+            warnings.push({
+                type: 'unknown-slot',
+                fieldKey: field.key,
+                fieldType,
+                slot: String(addon.slot),
+                allowedSlots,
+            });
+            continue;
+        }
+        // Kind registered? `AnyAddon.kind` is already a string-literal union via
+        // DynamicFormAddonRegistry; no need to cast.
+        const kindDef = kindRegistry.get(addon.kind);
+        if (!kindDef) {
+            warnings.push({
+                type: 'unknown-kind',
+                fieldKey: field.key,
+                kind: addon.kind,
+                registeredKinds,
+            });
+            continue;
+        }
+        // Kind whitelisted (if `allowedKinds` was set)?
+        if (allowedKinds && !allowedKinds.includes(kindDef.kind)) {
+            warnings.push({
+                type: 'kind-not-allowed',
+                fieldKey: field.key,
+                fieldType,
+                kind: kindDef.kind,
+                allowedKinds,
+            });
+            continue;
+        }
+        // Code-only kind dropped from JSON-source configs. A kind opts out of
+        // JSON-safety via `AddonKindDefinition.jsonSafe: false` (defaults to true).
+        if (source === 'json' && kindDef.jsonSafe === false) {
+            warnings.push({
+                type: 'code-only-kind-in-json',
+                fieldKey: field.key,
+                kind: kindDef.kind,
+            });
+            continue;
+        }
+        // Multi-set XOR + JSON-source function stripping. Both runs operate on
+        // a working copy via `ensureCopy()` so the original config isn't
+        // mutated — the survivor pushed at the bottom is either the original
+        // addon (no strips) or the sanitized copy.
+        let sanitized = addon;
+        let stripped = false;
+        const ensureCopy = () => {
+            if (!stripped)
+                sanitized = { ...sanitized };
+            stripped = true;
+        };
+        // Snapshot which click variants the original config declared BEFORE
+        // any stripping. Computing variants AFTER function-strip would
+        // underreport the multi-variant warning (`action` would silently
+        // vanish from the reported list).
+        const declaredVariants = ['preset', 'actionRef', 'action'].filter((k) => sanitized[k] !== undefined);
+        // JSON-source function strip — inline `action`/`hidden`/`disabled`/
+        // `loading` functions can't round-trip through serialization, so they
+        // get dropped here with a warning. Inline-source configs keep them.
+        if (source === 'json') {
+            const dropReactiveFn = (key) => {
+                if (typeof sanitized[key] === 'function') {
+                    ensureCopy();
+                    delete sanitized[key];
+                    warnings.push({
+                        type: 'code-only-action-in-json',
+                        fieldKey: field.key,
+                        reason: `function '${key}' on kind '${kindDef.kind}' (use a signal/observable in code, or omit in JSON)`,
+                    });
+                }
+            };
+            if (typeof sanitized.action === 'function') {
+                ensureCopy();
+                delete sanitized.action;
+                warnings.push({
+                    type: 'code-only-action-in-json',
+                    fieldKey: field.key,
+                    reason: `inline 'action' function on kind '${kindDef.kind}'`,
+                });
+            }
+            dropReactiveFn('hidden');
+            dropReactiveFn('disabled');
+            dropReactiveFn('loading');
+        }
+        // Multi-set XOR — applies to BOTH inline and JSON sources. TypeScript
+        // discriminated unions already reject multi-set at compile time, but
+        // configs that bypass type-checking (loose `any`, runtime composition,
+        // JSON parsing) still need defence-in-depth. Keep the first variant,
+        // strip the rest; mirrors the runtime precedence
+        // (preset > actionRef > action) so the chosen handler matches what
+        // the dispatcher would have picked.
+        if (declaredVariants.length > 1) {
+            ensureCopy();
+            for (const k of declaredVariants.slice(1))
+                delete sanitized[k];
+            warnings.push({
+                type: 'code-only-action-in-json',
+                fieldKey: field.key,
+                reason: `multiple click variants on kind '${kindDef.kind}' (${declaredVariants.join(', ')}); kept '${declaredVariants[0]}'`,
+            });
+        }
+        if (stripped) {
+            survivors.push(sanitized);
+            continue;
+        }
+        // Per-kind shape validator (throws on violation).
+        if (kindDef.validate) {
+            try {
+                kindDef.validate(addon, field.key);
+            }
+            catch (error) {
+                warnings.push({
+                    type: 'shape-violation',
+                    fieldKey: field.key,
+                    kind: kindDef.kind,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+                continue;
+            }
+        }
+        survivors.push(addon);
+    }
+    return { addons: survivors, warnings };
+}
+/**
+ * Recursively walk a field tree, validating each field's addons. Returns a
+ * sanitized copy of the input field array plus accumulated warnings.
+ */
+function walkAndValidateAddons(fields, fieldRegistry, kindRegistry, source) {
+    const allWarnings = [];
+    const sanitized = fields.map((field) => {
+        let next = field;
+        if (field.addons?.length) {
+            const { addons, warnings } = validateFieldAddons(field, fieldRegistry, kindRegistry, source);
+            allWarnings.push(...warnings);
+            next = { ...next, addons };
+        }
+        // Recurse into containers — every container field type carries its
+        // children on a `fields` array.
+        const children = next.fields;
+        if (Array.isArray(children)) {
+            const { fields: visited, warnings } = walkAndValidateAddons(children, fieldRegistry, kindRegistry, source);
+            allWarnings.push(...warnings);
+            next = { ...next, fields: visited };
+        }
+        return next;
+    });
+    return { fields: sanitized, warnings: allWarnings };
+}
+
+/**
+ * Stable structural fingerprint for an `AddonWarning`, used by the
+ * FormStateManager dedup cache. Includes every distinguishing field
+ * (`type`, `fieldKey`, `kind`/`slot`/`reason` as relevant) so warnings
+ * for different fields or different kinds never collapse to one log
+ * line — independent of the human-readable format which may change.
+ */
+function addonWarningKey(w) {
+    switch (w.type) {
+        case 'unknown-field-type':
+            return `${w.type}|${w.fieldKey}|${w.fieldType}`;
+        case 'field-type-no-addon-support':
+            return `${w.type}|${w.fieldKey}|${w.fieldType}`;
+        case 'unknown-slot':
+            return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.slot}`;
+        case 'unknown-kind':
+            return `${w.type}|${w.fieldKey}|${w.kind}`;
+        case 'kind-not-allowed':
+            return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.kind}`;
+        case 'shape-violation':
+            return `${w.type}|${w.fieldKey}|${w.kind}|${w.reason}`;
+        case 'code-only-kind-in-json':
+            return `${w.type}|${w.fieldKey}|${w.kind}`;
+        case 'code-only-action-in-json':
+            return `${w.type}|${w.fieldKey}|${w.reason}`;
+    }
+}
+/**
+ * Render an `AddonWarning` to a developer-friendly message.
+ *
+ * Returns the bare message — the `[Dynamic Forms]` prefix is added by the
+ * library's logger (`ConsoleLogger`) and by `DynamicFormError`. Pass the
+ * result of this function directly into `logger.warn(...)` to get the
+ * standard prefixed line; use `logAddonWarnings()` for direct
+ * `console.warn` output (which prefixes manually).
+ *
+ * Messages are designed to be actionable: they enumerate the relevant set
+ * (registered kinds, allowed slots) and suggest a likely fix.
+ */
+function formatAddonWarning(w) {
+    switch (w.type) {
+        case 'unknown-field-type':
+            return `Field '${w.fieldKey}': unknown field type '${w.fieldType}'. Addons dropped.`;
+        case 'field-type-no-addon-support':
+            return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): this field type does not declare addon support. Addons dropped. ` +
+                `If this is incorrect, add 'addons: { slots: [...] }' to the field type registration.`);
+        case 'unknown-slot':
+            return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): slot '${w.slot}' is not supported. ` +
+                `Allowed: ${w.allowedSlots.join(', ')}. Addon dropped.`);
+        case 'unknown-kind':
+            return (`Field '${w.fieldKey}': addon kind '${w.kind}' is not registered. ` +
+                `Did you forget withCustomAddon({ kind: '${w.kind}', ... })? ` +
+                `Currently registered: ${w.registeredKinds.join(', ') || '(none)'}. Addon dropped.`);
+        case 'kind-not-allowed':
+            return (`Field '${w.fieldKey}' (type: '${w.fieldType}'): addon kind '${w.kind}' is not in the allowed list. ` +
+                `Allowed: ${w.allowedKinds.join(', ')}. Addon dropped.`);
+        case 'shape-violation':
+            return `Field '${w.fieldKey}': addon kind '${w.kind}' shape invalid: ${w.reason}. Addon dropped.`;
+        case 'code-only-kind-in-json':
+            return `Field '${w.fieldKey}': addon kind '${w.kind}' is code-only and cannot be used with JSON-derived configs. Addon dropped.`;
+        case 'code-only-action-in-json':
+            return `Field '${w.fieldKey}': ${w.reason}. Use 'preset' or 'actionRef' instead. Addon dropped.`;
+    }
+}
+
+/**
+ * Global registry of addon kinds.
+ *
+ * Populated by `withCustomAddon(...)` features and adapter feature helpers
+ * (e.g., `withPrimeNGAddons()`). Read by `<df-addon-slot>` to resolve a
+ * kind discriminant to its renderer component.
+ */
+const ADDON_KIND_REGISTRY = new InjectionToken('ADDON_KIND_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+
 /**
  * Injection token for global value exclusion defaults.
  *
@@ -9889,6 +10751,12 @@ class FormStateManager {
     eventBus = inject(EventBus);
     functionRegistry = inject(FunctionRegistryService);
     schemaRegistry = inject(SchemaRegistryService);
+    // Optional so unit-test setups that drive FormStateManager directly without provideDynamicFormDI()
+    // (e.g. mocked RootFormRegistryService specs) don't have to manually wire the registry. Real
+    // DynamicForm usage always provides it via coreProviders; if you hit the dev warning below in
+    // your own setup, you're using DynamicForm without provideDynamicFormDI() — fix the providers
+    // chain rather than ignoring it.
+    arrayItemRegistry = inject(ArrayItemRegistryService, { optional: true });
     /** Host component dependencies (config, formOptions, value). */
     deps = (() => {
         const raw = inject(FORM_STATE_DEPS);
@@ -9897,12 +10765,28 @@ class FormStateManager {
                 'Ensure DynamicForm assigns its input signals to FORM_STATE_DEPS.');
         }
         // Safe cast: DynamicForm populates FormStateDeps with its concrete signals.
+        // `source` is optional — `DynamicForm` always populates it, but other
+        // callers of `FormStateManager` (e.g., specs) may omit it.
         return raw;
     })();
     /** Global value exclusion defaults. */
     valueExclusionDefaults = inject(VALUE_EXCLUSION_DEFAULTS);
     /** Field registry for loading components. */
     fieldRegistry = injectFieldRegistry();
+    /** Addon-kind registry — feeds the addon validator at config-setup time. */
+    addonKindRegistry = inject(ADDON_KIND_REGISTRY);
+    /**
+     * Fingerprints of addon warnings emitted by the last config setup.
+     * Used to skip re-logging warnings that already fired for the previous
+     * config — avoids spam when the form swaps config repeatedly but the
+     * addon issues haven't changed.
+     *
+     * Scoping: per-FormStateManager (i.e., per `<df-dynamic-form>` component
+     * instance). Replaced wholesale on every config setup — bounded by the
+     * current config's warning count, never grows unbounded across swaps.
+     * A warning that disappears and later returns re-logs as expected.
+     */
+    lastAddonWarningKeys = new Set();
     // ─────────────────────────────────────────────────────────────────────────────
     // State Machine
     // ─────────────────────────────────────────────────────────────────────────────
@@ -10515,12 +11399,24 @@ class FormStateManager {
             }
         });
         // Schema change resets the saved store + transition tracker so values from a stale schema
-        // can't leak into the new one.
+        // can't leak into the new one. Also drops every per-array slot in the registry so a fresh
+        // schema starts with an empty template/itemOrder/id-counter state.
+        let warnedAboutMissingArrayRegistry = false;
         explicitEffect([this.formSetup], () => {
             this.prevFieldStateSnapshot.set({});
             if (Object.keys(this.excludedValueStore()).length > 0) {
                 this.excludedValueStore.set({});
             }
+            if (this.arrayItemRegistry) {
+                this.arrayItemRegistry.clearAll();
+            }
+            else if (DEV_MODE && !warnedAboutMissingArrayRegistry) {
+                warnedAboutMissingArrayRegistry = true;
+                this.logger.warn('ArrayItemRegistryService was not provided to FormStateManager. ' +
+                    'Array fields will lose dynamically-added item templates across hide/show cycles. ' +
+                    'This usually means DynamicForm was bootstrapped without provideDynamicFormDI() — ' +
+                    'check your providers chain.');
+            }
         });
         // Outward sync uses boundFormValue (honors only explicit excludeValueIf* opt-ins) so
         // global defaults that target submission output don't reshape the host's bound model.
@@ -10578,11 +11474,35 @@ class FormStateManager {
     }
     createFormSetupFromConfig(fields, mode, registry) {
         const normalizedFields = normalizeSimplifiedArrays(fields);
-        // Validate after normalization so simplified array templates are already expanded
-        // into full ArrayField.fields and are reachable during traversal.
+        // Two validation passes run after normalization so simplified array templates
+        // are already expanded into full ArrayField.fields and reachable during traversal:
+        // 1. Structural — duplicate keys, unknown field types, invalid regex patterns.
+        // 2. Addon pass below — strips invalid/unsupported addons with lenient warnings.
         validateFormConfig(normalizedFields, registry, this.logger);
-        const flattenedFields = this.fieldProcessors.memoizedFlattenFields(normalizedFields, registry);
-        const flattenedFieldsForRendering = this.fieldProcessors.memoizedFlattenFieldsForRendering(normalizedFields, registry);
+        // Addon pass — strip invalid / unsupported addon entries and log a warning
+        // for each one dropped. Lenient by design: the form keeps rendering even
+        // when a JSON-source config ships an addon the FE doesn't understand.
+        //
+        // Warnings are deduped across consecutive config setups: a warning that
+        // already fired for the previous config is skipped, so swapping config
+        // back and forth doesn't spam the console.
+        const source = this.deps.source?.() ?? 'inline';
+        const { fields: sanitizedFields, warnings: addonWarnings } = walkAndValidateAddons(normalizedFields, registry, this.addonKindRegistry, source);
+        const nextKeys = new Set();
+        for (const w of addonWarnings) {
+            // Dedup uses a structural fingerprint so different fields with the
+            // same warning category never collide; the rendered message is what
+            // we log.
+            const key = addonWarningKey(w);
+            nextKeys.add(key);
+            if (!this.lastAddonWarningKeys.has(key)) {
+                this.logger.warn(formatAddonWarning(w));
+            }
+        }
+        this.lastAddonWarningKeys = nextKeys;
+        const validatedFields = sanitizedFields;
+        const flattenedFields = this.fieldProcessors.memoizedFlattenFields(validatedFields, registry);
+        const flattenedFieldsForRendering = this.fieldProcessors.memoizedFlattenFieldsForRendering(validatedFields, registry);
         const fieldsById = this.fieldProcessors.memoizedKeyBy(flattenedFields);
         const defaultValues = this.fieldProcessors.memoizedDefaultValues(fieldsById, registry);
         const fieldsToRender = mode === 'paged' ? [] : flattenedFieldsForRendering;
@@ -10610,10 +11530,10 @@ class FormStateManager {
     ngOnDestroy() {
         this.machine.dispatch({ type: Action.Destroy });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FormStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FormStateManager });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FormStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FormStateManager });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: FormStateManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FormStateManager, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
@@ -11032,15 +11952,18 @@ function computeValueFromEntry(entry, evalContext, options) {
     if (entry.expression) {
         return ExpressionParser.evaluate(entry.expression, evalContext);
     }
-    if (entry.functionName) {
-        const fn = options.derivationFunctions?.[entry.functionName];
+    if (entry.fn || entry.functionName) {
+        if (entry.fn && entry.functionName) {
+            evalContext.logger.warn(`Both "fn" and "functionName" are set on derivation for '${options.subject}'. Inline "fn" takes precedence; "functionName" is ignored.`);
+        }
+        const fn = entry.fn ?? (entry.functionName ? options.derivationFunctions?.[entry.functionName] : undefined);
         if (!fn) {
             const kind = options.functionKind ?? 'Derivation function';
             throw new DynamicFormError(`${kind} '${entry.functionName}' not found in customFnConfig.derivations`);
         }
         return fn(evalContext);
     }
-    throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', or 'functionName'.`);
+    throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', 'functionName', or 'fn'.`);
 }
 
 /**
@@ -11443,7 +12366,7 @@ function getEntriesForChangedFields$1(entries, changedFields) {
 function tryApplyDerivation(entry, context, chainContext) {
     const { derivationLogger } = context;
     // HTTP and async entries are processed asynchronously in their own streams — skip in sync loop
-    if (entry.http || entry.asyncFunctionName) {
+    if (entry.http || entry.asyncFunctionName || entry.asyncFn) {
         return { applied: false, fieldKey: entry.fieldKey };
     }
     // Check if this is an array field derivation (has '$' placeholder)
@@ -11750,9 +12673,11 @@ function formatDerivationError(entry, phase, message) {
         ? `expression: "${entry.expression.substring(0, 50)}${entry.expression.length > 50 ? '...' : ''}"`
         : entry.functionName
             ? `function: "${entry.functionName}"`
-            : entry.value !== undefined
-                ? 'static value'
-                : 'unknown source';
+            : entry.fn
+                ? 'inline fn'
+                : entry.value !== undefined
+                    ? 'static value'
+                    : 'unknown source';
     return `${ERROR_PREFIX$1} Failed to ${phase} derivation (field: ${entry.fieldKey}, ${source}): ${message}`;
 }
 /**
@@ -11821,7 +12746,7 @@ function shouldSkipForUserOverride(entry, resolvedFieldKey, context, chainContex
 function applyDerivationsForTrigger(collection, trigger, context, changedFields) {
     // Filter entries by trigger type, excluding HTTP and async entries (processed in async streams)
     const filteredEntries = collection.entries.filter((entry) => {
-        if (entry.http || entry.asyncFunctionName)
+        if (entry.http || entry.asyncFunctionName || entry.asyncFn)
             return false;
         if (trigger === 'onChange') {
             return !entry.trigger || entry.trigger === 'onChange';
@@ -11990,7 +12915,7 @@ function topologicalSort(entries) {
  * Combines:
  * - Explicit `dependsOn` (when provided, it takes precedence over auto-detection)
  * - Expression-detected dependencies (only used when `dependsOn` is empty)
- * - `'*'` wildcard for `functionName` (only when `dependsOn` is empty)
+ * - `'*'` wildcard for `functionName` / inline `fn` (only when `dependsOn` is empty)
  * - Condition expression dependencies (always included)
  *
  * @internal
@@ -12004,7 +12929,9 @@ function extractDependenciesFromConfig(config) {
         if (config.expression) {
             extractStringDependencies(config.expression).forEach((dep) => deps.add(dep));
         }
-        if (config.functionName) {
+        // Inline `fn` mirrors `functionName` semantics: without explicit dependsOn,
+        // assume the function may depend on anything in the form.
+        if (config.functionName || config.fn) {
             deps.add('*');
         }
     }
@@ -12014,6 +12941,32 @@ function extractDependenciesFromConfig(config) {
     return Array.from(deps);
 }
 
+/**
+ * Reads the optional inline `fn` property off a derivation config.
+ *
+ * `fn` only appears on the function-mode branch of the discriminated union, so
+ * call sites that need to copy it through unconditionally must widen via cast.
+ * This helper centralises the cast and keeps it read-only — no widening, no
+ * mutation. Returns `undefined` for any non-function-mode variant.
+ *
+ * @internal
+ */
+function extractInlineFn(config) {
+    return config.fn;
+}
+/**
+ * Reads the optional inline `asyncFn` property off a derivation config.
+ *
+ * Same rationale as {@link extractInlineFn}: `asyncFn` only appears on the
+ * `source: 'asyncFunction'` branch, so collectors that copy it through need a
+ * cast. Read-only access, no widening.
+ *
+ * @internal
+ */
+function extractInlineAsyncFn(config) {
+    return config.asyncFn;
+}
+
 /**
  * Recursively walks a field-definition tree, invoking `visitor` for each field.
  *
@@ -12356,9 +13309,11 @@ function createLogicEntry(fieldKey, config, context) {
         value: config.value,
         expression: config.expression,
         functionName: config.functionName,
+        fn: extractInlineFn(config),
         http: config.http,
         responseExpression: config.responseExpression,
         asyncFunctionName: config.asyncFunctionName,
+        asyncFn: extractInlineAsyncFn(config),
         trigger,
         debounceMs,
         isShorthand: false,
@@ -12674,21 +13629,67 @@ function validateNoCycles(collection, logger) {
 }
 
 /**
- * Creates a staleness guard for HTTP/async derivation streams.
+ * Compares two entry lists as multisets of content signatures. Order-insensitive
+ * — entries reordered with the same content compare equal, so topological-sort
+ * reorderings triggered by unrelated entries don't churn downstream stream
+ * lifecycles.
+ *
+ * Multiset (not set) semantics: two distinct entries with identical signatures
+ * are counted separately, so `[A, B]` does NOT equal `[A, A]` even though both
+ * have length 2 and both contain `A` as a signature.
  *
- * - Call `invalidate()` when tearing down the current generation of streams.
- * - Pipe HTTP requests through `takeUntil(guard$)` to automatically discard
- *   in-flight responses that arrive after the generation has been invalidated.
+ * Used by the value-derivation and property-derivation orchestrators to gate
+ * `distinctUntilChanged` over HTTP- and async-function-entry sets.
+ *
+ * @internal
  */
-function createStreamGuard() {
-    const subject = new Subject();
-    return {
-        invalidate: () => subject.next(),
-        guard$: subject.asObservable().pipe(take$1(1)),
-    };
+function entrySetsEqual(prev, next, sig) {
+    if (prev.length !== next.length)
+        return false;
+    const counts = new Map();
+    for (const item of prev) {
+        const key = sig(item);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    for (const item of next) {
+        const key = sig(item);
+        const remaining = counts.get(key);
+        if (!remaining)
+            return false;
+        if (remaining === 1)
+            counts.delete(key);
+        else
+            counts.set(key, remaining - 1);
+    }
+    return counts.size === 0;
 }
-const LOG_PREFIX$1 = 'HTTP Derivation -';
-const DEFAULT_HTTP_DEBOUNCE_MS = 300;
+/**
+ * Declarative pipeline shared by both derivation orchestrators:
+ *
+ * 1. Project the collection down to a typed entry list.
+ * 2. Skip rebuilds when the entry set hasn't changed (multiset comparison).
+ * 3. `switchMap` cancels the previous merged inner streams and creates fresh
+ *    ones from the new entries; in-flight HTTP / async work is cancelled via
+ *    ordinary RxJS unsubscribe semantics.
+ *
+ * No mutable subscription bookkeeping; the caller pipes through
+ * `takeUntilDestroyed` for unmount cleanup.
+ *
+ * @internal
+ */
+function buildEntryStreamPipeline(config) {
+    return config.collection$.pipe(map((collection) => config.selectEntries(collection)), distinctUntilChanged((prev, next) => entrySetsEqual(prev, next, config.entrySignature)), switchMap((entries) => {
+        if (entries.length === 0)
+            return EMPTY;
+        const streams = entries.map((entry) => config.createStream(entry)).filter((stream) => stream !== null);
+        if (streams.length === 0)
+            return EMPTY;
+        return merge(...streams);
+    }));
+}
+
+const LOG_PREFIX$3 = 'HTTP Derivation -';
+const DEFAULT_HTTP_DEBOUNCE_MS$1 = 300;
 /**
  * Creates an RxJS Observable stream that processes an HTTP derivation entry.
  *
@@ -12712,7 +13713,7 @@ const DEFAULT_HTTP_DEBOUNCE_MS = 300;
 function createHttpDerivationStream(entry, formValue$, context) {
     // Guard: no array support for HTTP derivations
     if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX$1} HTTP derivation for array field '${entry.fieldKey}' is not supported. ` +
+        context.logger.warn(`${LOG_PREFIX$3} HTTP derivation for array field '${entry.fieldKey}' is not supported. ` +
             `Array HTTP derivations will be supported in a future release.`);
         return EMPTY;
     }
@@ -12721,7 +13722,7 @@ function createHttpDerivationStream(entry, formValue$, context) {
     }
     // Capture after the guard — TS narrows this to `string` here
     const responseExpression = entry.responseExpression;
-    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS;
+    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS$1;
     return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
         current: current,
         changedFields: getChangedKeys(previous, current),
@@ -12815,15 +13816,16 @@ function createHttpDerivationStream(entry, formValue$, context) {
                 subscriber.complete();
                 return;
             }
-            // Make the HTTP request. takeUntil(guard$) automatically discards responses
-            // that arrive after the config has changed and the guard has been invalidated.
+            // Cancellation is handled declaratively by the orchestrator's outer
+            // switchMap: when the entry set changes, the outer stream unsubscribes
+            // from this inner observable, the cleanup callback below runs, and
+            // the in-flight HTTP request is cancelled.
             const method = (resolvedRequest.method ?? 'GET').toUpperCase();
             const httpSub = context.httpClient
                 .request(method, resolvedRequest.url, {
                 body: resolvedRequest.body,
                 headers: resolvedRequest.headers,
             })
-                .pipe(takeUntil(context.guard$))
                 .subscribe({
                 next: (response) => {
                     try {
@@ -12858,13 +13860,13 @@ function createHttpDerivationStream(entry, formValue$, context) {
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX$1} Failed to process response for '${entry.fieldKey}': ${message}`);
+                        context.logger.warn(`${LOG_PREFIX$3} Failed to process response for '${entry.fieldKey}': ${message}`);
                         subscriber.complete();
                     }
                 },
                 error: (error) => {
                     const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX$1} HTTP request failed for '${entry.fieldKey}': ${message}`);
+                    context.logger.warn(`${LOG_PREFIX$3} HTTP request failed for '${entry.fieldKey}': ${message}`);
                     subscriber.complete();
                 },
             });
@@ -12878,13 +13880,13 @@ function createHttpDerivationStream(entry, formValue$, context) {
     }), catchError$1((error) => {
         // Safety net — should not normally be reached since inner errors are caught
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}': ${message}`);
+        context.logger.warn(`${LOG_PREFIX$3} Unexpected stream error for '${entry.fieldKey}': ${message}`);
         return EMPTY;
     }));
 }
 
-const LOG_PREFIX = 'Async Derivation -';
-const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
+const LOG_PREFIX$2 = 'Async Derivation -';
+const DEFAULT_ASYNC_DEBOUNCE_MS$1 = 300;
 /**
  * Creates an RxJS Observable stream that processes an async derivation entry.
  *
@@ -12903,15 +13905,22 @@ const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
 function createAsyncDerivationStream(entry, formValue$, context) {
     // Guard: no array support for async derivations
     if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX} Async derivation for array field '${entry.fieldKey}' is not supported. ` +
+        context.logger.warn(`${LOG_PREFIX$2} Async derivation for array field '${entry.fieldKey}' is not supported. ` +
             `Array async derivations will be supported in a future release.`);
         return EMPTY;
     }
-    if (!entry.asyncFunctionName) {
+    if (!entry.asyncFunctionName && !entry.asyncFn) {
+        context.logger.warn(`${LOG_PREFIX$2} Derivation for '${entry.fieldKey}' has neither "asyncFunctionName" nor "asyncFn". ` +
+            `One of the two is required for source: 'asyncFunction'.`);
         return EMPTY;
     }
+    if (entry.asyncFn && entry.asyncFunctionName) {
+        context.logger.warn(`${LOG_PREFIX$2} Both "asyncFn" and "asyncFunctionName" are set on derivation for '${entry.fieldKey}'. ` +
+            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
+    }
+    const inlineAsyncFn = entry.asyncFn;
     const asyncFunctionName = entry.asyncFunctionName;
-    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
+    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS$1;
     // startWith(null) → pairwise() causes all fields to appear "changed" on the
     // first emission (null vs actual form value), so every dependsOn field matches.
     // This intentionally fires the async derivation on initial form load — same
@@ -12955,10 +13964,10 @@ function createAsyncDerivationStream(entry, formValue$, context) {
             const customFunctions = context.customFunctions?.();
             const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
             const externalData = context.externalData?.();
-            // Look up the async function
-            const asyncFn = asyncDerivationFunctions?.[asyncFunctionName];
+            // Inline `asyncFn` wins; otherwise look up the registered function.
+            const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
             if (!asyncFn) {
-                context.logger.warn(`${LOG_PREFIX} Async derivation function '${asyncFunctionName}' not found for field '${entry.fieldKey}'. ` +
+                context.logger.warn(`${LOG_PREFIX$2} Async derivation function '${asyncFunctionName}' not found for field '${entry.fieldKey}'. ` +
                     `Register it in customFnConfig.asyncDerivations.`);
                 subscriber.complete();
                 return;
@@ -13026,13 +14035,13 @@ function createAsyncDerivationStream(entry, formValue$, context) {
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}': ${message}`);
+                        context.logger.warn(`${LOG_PREFIX$2} Failed to process result for '${entry.fieldKey}': ${message}`);
                         subscriber.complete();
                     }
                 },
                 error: (error) => {
                     const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}': ${message}`);
+                    context.logger.warn(`${LOG_PREFIX$2} Async function failed for '${entry.fieldKey}': ${message}`);
                     subscriber.complete();
                 },
                 complete: () => {
@@ -13049,7 +14058,7 @@ function createAsyncDerivationStream(entry, formValue$, context) {
     }), catchError$1((error) => {
         // Safety net — should not normally be reached since inner errors are caught
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}': ${message}`);
+        context.logger.warn(`${LOG_PREFIX$2} Unexpected stream error for '${entry.fieldKey}': ${message}`);
         return EMPTY;
     }));
 }
@@ -13127,20 +14136,6 @@ class DerivationOrchestrator {
     functionRegistry = inject(FunctionRegistryService);
     formOptions = inject(FORM_OPTIONS);
     httpClient = inject(HttpClient, { optional: true });
-    /** Active HTTP derivation stream subscriptions */
-    httpSubscriptions = [];
-    /** Identity keys of current HTTP entries for smart teardown comparison */
-    lastHttpEntryKeys = null;
-    /** Active async function derivation stream subscriptions */
-    asyncFunctionSubscriptions = [];
-    /** Identity keys of current async entries for smart teardown comparison */
-    lastAsyncEntryKeys = null;
-    /**
-     * Guard for detecting stale HTTP responses. Call `invalidate()` on teardown to cancel
-     * in-flight requests from the previous generation. Each HTTP stream subscribes via
-     * `takeUntil(guard$)` — when `invalidate()` fires, all in-flight requests are discarded.
-     */
-    streamGuard = createStreamGuard();
     /**
      * Computed signal containing the collected and validated derivations.
      * Returns null if no derivations are defined.
@@ -13296,36 +14291,33 @@ class DerivationOrchestrator {
         }
     }
     /**
-     * Sets up reactive HTTP derivation streams that react to collection changes.
+     * Builds a declarative stream that reacts to changes in the set of HTTP
+     * derivation entries and emits per-entry streams merged together.
+     *
+     * - `distinctUntilChanged` over the set of entry signatures skips rebuilds
+     *   when the HTTP entries haven't actually changed. The comparison is
+     *   order-insensitive — `topologicalSort` in the collector can reorder
+     *   existing entries when unrelated entries are added/removed, and we
+     *   don't want to tear down healthy streams in that case.
+     * - `switchMap` cancels the previous merged stream when entries change,
+     *   which propagates into each `createHttpDerivationStream` and cancels
+     *   any in-flight HTTP requests via ordinary RxJS unsubscribe semantics.
      *
-     * Subscribes to derivationCollection changes and creates per-entry HTTP streams.
-     * Uses smart teardown: only recreates streams when HTTP entries actually change.
+     * No mutable subscription bookkeeping or stream guard — `takeUntilDestroyed`
+     * on the outer subscription handles unmount.
      */
     setupHttpStreams() {
-        toObservable(this.derivationCollection, { injector: this.injector })
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe((collection) => {
-            const httpEntries = collection?.entries.filter((entry) => entry.http) ?? [];
-            if (httpEntries.length === 0) {
-                this.teardownHttpStreams();
-                this.lastHttpEntryKeys = null;
-                return;
-            }
-            // Smart teardown: compare entry identity keys to avoid redundant stream recreation
-            const newKeys = this.computeHttpEntryKeys(httpEntries);
-            if (this.lastHttpEntryKeys && this.setsEqual(this.lastHttpEntryKeys, newKeys)) {
-                return; // No change in HTTP entries — keep existing streams
-            }
-            // Validate HttpClient availability
-            if (!this.httpClient) {
-                this.logger.error('HTTP Derivation: HttpClient is not available. ' + 'Ensure provideHttpClient() is included in your application providers.');
-                return;
-            }
-            // Tear down previous streams and create new ones
-            this.teardownHttpStreams();
-            this.lastHttpEntryKeys = newKeys;
-            const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-            for (const entry of httpEntries) {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.derivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
+            entrySignature: httpEntrySignature$1,
+            createStream: (entry) => {
+                if (!this.httpClient) {
+                    this.logger.error('HTTP Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
+                    return null;
+                }
                 const context = {
                     formValue: this.config.formValue,
                     form: this.config.form,
@@ -13335,114 +14327,77 @@ class DerivationOrchestrator {
                     customFunctions: () => this.functionRegistry.getCustomFunctions(),
                     externalData: () => resolveExternalData(this.config.externalData),
                     warningTracker: this.warningTracker,
-                    guard$: this.streamGuard.guard$,
                 };
-                const stream = createHttpDerivationStream(entry, formValue$, context).pipe(takeUntilDestroyed(this.destroyRef));
-                this.httpSubscriptions.push(stream.subscribe({
-                    error: (err) => this.logger.error(`HTTP Derivation: Stream error for '${entry.fieldKey}'`, err),
-                }));
-            }
-        });
-    }
-    /**
-     * Tears down all active HTTP derivation streams. Invalidating the stream guard
-     * cancels any in-flight HTTP responses from the old generation via `takeUntil`.
-     */
-    teardownHttpStreams() {
-        this.streamGuard.invalidate();
-        for (const sub of this.httpSubscriptions) {
-            sub.unsubscribe();
-        }
-        this.httpSubscriptions = [];
-    }
-    /**
-     * Computes a set of identity keys for HTTP entries.
-     * Used for smart teardown comparison.
-     */
-    computeHttpEntryKeys(entries) {
-        return new Set(entries.map((entry) => `${entry.fieldKey}:${JSON.stringify(entry.http, Object.keys(entry.http ?? {}).sort())}`));
-    }
-    /**
-     * Compares two sets for equality.
-     */
-    setsEqual(a, b) {
-        if (a.size !== b.size)
-            return false;
-        for (const item of a) {
-            if (!b.has(item))
-                return false;
-        }
-        return true;
+                return createHttpDerivationStream(entry, formValue$, context);
+            },
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('HTTP Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
     }
-    /**
-     * Sets up reactive async function derivation streams that react to collection changes.
-     *
-     * Subscribes to derivationCollection changes and creates per-entry async streams.
-     * Uses smart teardown: only recreates streams when async entries actually change.
-     */
     setupAsyncFunctionStreams() {
-        toObservable(this.derivationCollection, { injector: this.injector })
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe((collection) => {
-            const asyncEntries = collection?.entries.filter((entry) => entry.asyncFunctionName) ?? [];
-            if (asyncEntries.length === 0) {
-                this.teardownAsyncFunctionStreams();
-                this.lastAsyncEntryKeys = null;
-                return;
-            }
-            // Smart teardown: compare entry identity keys to avoid redundant stream recreation
-            const newKeys = this.computeAsyncEntryKeys(asyncEntries);
-            if (this.lastAsyncEntryKeys && this.setsEqual(this.lastAsyncEntryKeys, newKeys)) {
-                return; // No change in async entries — keep existing streams
-            }
-            // Tear down previous streams and create new ones
-            this.teardownAsyncFunctionStreams();
-            this.lastAsyncEntryKeys = newKeys;
-            const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-            for (const entry of asyncEntries) {
-                const context = {
-                    formValue: this.config.formValue,
-                    form: this.config.form,
-                    logger: this.logger,
-                    derivationLogger: this.config.derivationLogger,
-                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                    asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
-                    externalData: () => resolveExternalData(this.config.externalData),
-                    warningTracker: this.warningTracker,
-                };
-                const stream = createAsyncDerivationStream(entry, formValue$, context).pipe(takeUntilDestroyed(this.destroyRef));
-                this.asyncFunctionSubscriptions.push(stream.subscribe({
-                    error: (err) => this.logger.error(`Async Derivation: Stream error for '${entry.fieldKey}'`, err),
-                }));
-            }
-        });
-    }
-    /**
-     * Tears down all active async function derivation streams.
-     */
-    teardownAsyncFunctionStreams() {
-        for (const sub of this.asyncFunctionSubscriptions) {
-            sub.unsubscribe();
-        }
-        this.asyncFunctionSubscriptions = [];
-    }
-    /**
-     * Computes a set of identity keys for async entries.
-     * Used for smart teardown comparison.
-     */
-    computeAsyncEntryKeys(entries) {
-        return new Set(entries.map((entry) => {
-            const config = {
-                asyncFunctionName: entry.asyncFunctionName,
-                dependsOn: entry.dependsOn,
-                debounceMs: entry.debounceMs,
-                stopOnUserOverride: entry.stopOnUserOverride,
-                reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
-            };
-            return `${entry.fieldKey}:${JSON.stringify(config, Object.keys(config).sort())}`;
-        }));
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.derivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
+            entrySignature: asyncEntrySignature$1,
+            createStream: (entry) => createAsyncDerivationStream(entry, formValue$, {
+                formValue: this.config.formValue,
+                form: this.config.form,
+                logger: this.logger,
+                derivationLogger: this.config.derivationLogger,
+                customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
+                externalData: () => resolveExternalData(this.config.externalData),
+                warningTracker: this.warningTracker,
+            }),
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('Async Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
     }
 }
+/**
+ * Identity signature for an HTTP derivation entry. Includes every field that
+ * drives the inner stream's behavior — changing any of them must tear down
+ * and rebuild the stream. Stable across topological reorderings because the
+ * consumer ({@link entrySetsEqual}) compares as a multiset.
+ */
+function httpEntrySignature$1(entry) {
+    const config = {
+        http: entry.http,
+        responseExpression: entry.responseExpression,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+        stopOnUserOverride: entry.stopOnUserOverride,
+        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
+    };
+    return `${entry.fieldKey}:${JSON.stringify(config)}`;
+}
+function asyncEntrySignature$1(entry) {
+    // For inline `asyncFn` entries we tag the signature with the field path (the
+    // real identity, since derivations are self-targeting) rather than the array
+    // index. Index-based tagging churned identities whenever topologicalSort
+    // reordered entries, causing unnecessary teardown + re-subscribe.
+    const config = {
+        asyncFunctionName: entry.asyncFunctionName,
+        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}` : undefined,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+        stopOnUserOverride: entry.stopOnUserOverride,
+        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
+    };
+    return `${entry.fieldKey}:${JSON.stringify(config)}`;
+}
 /**
  * Creates a DerivationOrchestrator for a dynamic form.
  * Must be called within an injection context.
@@ -13482,10 +14437,11 @@ function warnAboutWildcardDependencies$1(logger, entries, fieldCount) {
     // HTTP and async entries require explicit dependsOn (validated at collection time)
     const implicitWildcards = wildcardEntries.filter((entry) => !entry.http &&
         !entry.asyncFunctionName &&
-        entry.functionName &&
+        !entry.asyncFn &&
+        (entry.functionName || entry.fn) &&
         (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
     if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey} (${e.functionName})`);
+        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey} (${e.functionName ?? '<inline fn>'})`);
         logger.warn('Derivation: custom functions without explicit dependsOn detected. ' +
             `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
             'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
@@ -13649,7 +14605,11 @@ function isDynamicFormFeature(value) {
         Array.isArray(value.ɵproviders));
 }
 /**
- * Helper to create a feature with proper typing
+ * Helper to create a feature with proper typing.
+ *
+ * `kind` is the discriminant compared by string equality at the
+ * provider-resolution site (and in feature-specific type guards). Each
+ * feature module owns its own kind literal — no central registry.
  */
 function createFeature(kind, providers) {
     return {
@@ -13745,6 +14705,27 @@ function withLoggerConfig(config = true) {
     return createFeature('logger', providers);
 }
 
+/**
+ * Creates an empty property derivation collection.
+ *
+ * @returns Empty collection
+ *
+ * @internal
+ */
+function createEmptyPropertyDerivationCollection() {
+    return { entries: [] };
+}
+/**
+ * Returns true when the entry's value source is async (HTTP or async function)
+ * and therefore must be processed by a dedicated stream subscription rather
+ * than the synchronous applicator pipeline.
+ *
+ * @internal
+ */
+function isAsyncPropertyDerivationEntry(entry) {
+    return Boolean(entry.http) || Boolean(entry.asyncFunctionName) || Boolean(entry.asyncFn);
+}
+
 /** @internal */
 const ERROR_PREFIX = '[PropertyDerivation]';
 /**
@@ -13765,7 +14746,10 @@ function applyPropertyDerivations(collection, context, changedFields) {
     let appliedCount = 0;
     let skippedCount = 0;
     let errorCount = 0;
-    const entriesToProcess = changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries;
+    const baseEntries = changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries;
+    // Async entries (HTTP / asyncFn / asyncFunctionName) are processed by dedicated
+    // stream subscriptions in the orchestrator, not by this synchronous applicator.
+    const entriesToProcess = baseEntries.filter((entry) => !isAsyncPropertyDerivationEntry(entry));
     for (const entry of entriesToProcess) {
         try {
             const applied = tryApplyPropertyDerivation(entry, context);
@@ -13968,8 +14952,16 @@ function collectPropertyDerivations(fields, logger, tracker) {
     const entries = [];
     const context = { logger, tracker };
     traverseFieldsWithContext(fields, context, (field, ctx) => collectFromField(field, entries, ctx), {
-        onArrayChild: (_, field) => ({ arrayPath: field.key }),
-        // Group and layout containers do not affect property-derivation paths.
+        // Array boundary: each item is its own model root. Reset groupPath so
+        // ancestor groups OUTSIDE the array don't bleed into per-item keys.
+        onArrayChild: (_, field) => ({ arrayPath: field.key, groupPath: undefined }),
+        onGroupChild: (parent, field) => {
+            // Keyless groups (rare) act like layout containers — pass through.
+            if (!field.key)
+                return {};
+            return { groupPath: parent.groupPath ? `${parent.groupPath}.${field.key}` : field.key };
+        },
+        // Layout containers (page, row, container) leave context unchanged.
     });
     return { entries };
 }
@@ -14001,7 +14993,79 @@ function collectFromField(field, entries, context) {
  * @internal
  */
 function createPropertyDerivationEntryFromDerivation(fieldKey, config, context) {
-    const effectiveFieldKey = buildPropertyOverrideKey(context.arrayPath, context.arrayPath ? PLACEHOLDER_INDEX : undefined, fieldKey);
+    const effectiveFieldKey = buildPropertyOverrideKey(context.arrayPath, context.arrayPath ? PLACEHOLDER_INDEX : undefined, fieldKey, context.groupPath);
+    // HTTP and async function property derivations require explicit, non-wildcard
+    // dependencies — mirrors the same guards on value-derivation HTTP/async sources.
+    //
+    // Type-level discriminants require these fields, but JSON-loaded configs can
+    // bypass that — so we defensively guard against missing arrays and missing
+    // HTTP fields here to fail fast with `DynamicFormError` instead of throwing
+    // an opaque `TypeError` later.
+    //
+    // `targetProperty` is captured up front and `untypedConfig` is used inside
+    // the source-narrowed blocks because TypeScript narrows `config` to `never`
+    // once we negate a discriminant-required field (e.g. `!config.http` when
+    // `source: 'http'` requires `http`).
+    const errorLocation = `'${effectiveFieldKey}.${config.targetProperty}'`;
+    const untypedConfig = config;
+    // Reject configs that mix value-source fields with an explicit async source.
+    // TypeScript's discriminated union already enforces this XOR for inline
+    // configs; the runtime check guards JSON-loaded configs (API/OpenAPI/MCP)
+    // where the wrong combination would silently degrade — async entries are
+    // routed to the stream pipeline while sync fields would be ignored.
+    if (untypedConfig.source === 'http' || untypedConfig.source === 'asyncFunction') {
+        const conflictingSyncSources = [];
+        if (untypedConfig.value !== undefined)
+            conflictingSyncSources.push('value');
+        if (untypedConfig.expression !== undefined)
+            conflictingSyncSources.push('expression');
+        if (untypedConfig.functionName !== undefined)
+            conflictingSyncSources.push('functionName');
+        if (untypedConfig.fn !== undefined)
+            conflictingSyncSources.push('fn');
+        if (conflictingSyncSources.length > 0) {
+            throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: ${JSON.stringify(untypedConfig.source)}' alongside ` +
+                `sync value source(s) [${conflictingSyncSources.join(', ')}]. These are mutually exclusive — remove either ` +
+                `the sync fields or the async source.`);
+        }
+    }
+    // Reject HTTP + asyncFunction-field combinations as well (TS already
+    // enforces this; runtime guard for JSON-loaded configs).
+    if (untypedConfig.source === 'http' && (untypedConfig.asyncFunctionName !== undefined || untypedConfig.asyncFn !== undefined)) {
+        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "http"' alongside an async function — these are mutually exclusive.`);
+    }
+    if (untypedConfig.source === 'asyncFunction' && (untypedConfig.http !== undefined || untypedConfig.responseExpression !== undefined)) {
+        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "asyncFunction"' alongside HTTP fields — these are mutually exclusive.`);
+    }
+    if (untypedConfig.source === 'http') {
+        if (!untypedConfig.http) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires an 'http' config object.`);
+        }
+        if (typeof untypedConfig.responseExpression !== 'string' || untypedConfig.responseExpression.trim() === '') {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires a non-empty 'responseExpression'.`);
+        }
+        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
+                `Wildcard dependencies would trigger HTTP requests on every form change.`);
+        }
+        if (untypedConfig.dependsOn.includes('*')) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
+                `Wildcards would trigger HTTP requests on every form change. Specify explicit field dependencies instead.`);
+        }
+    }
+    if (untypedConfig.source === 'asyncFunction') {
+        if (!untypedConfig.asyncFunctionName && !untypedConfig.asyncFn) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires either 'asyncFunctionName' or 'asyncFn'.`);
+        }
+        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
+                `Wildcard dependencies would trigger async functions on every form change.`);
+        }
+        if (untypedConfig.dependsOn.includes('*')) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
+                `Wildcards would trigger async functions on every form change. Specify explicit field dependencies instead.`);
+        }
+    }
     const dependsOn = extractDependenciesFromConfig(config);
     const condition = config.condition ?? true;
     const trigger = config.trigger ?? 'onChange';
@@ -14014,6 +15078,11 @@ function createPropertyDerivationEntryFromDerivation(fieldKey, config, context)
         value: config.value,
         expression: config.expression,
         functionName: config.functionName,
+        fn: extractInlineFn(config),
+        http: config.http,
+        responseExpression: config.responseExpression,
+        asyncFunctionName: config.asyncFunctionName,
+        asyncFn: extractInlineAsyncFn(config),
         trigger,
         debounceMs,
         debugName: config.debugName,
@@ -14021,6 +15090,204 @@ function createPropertyDerivationEntryFromDerivation(fieldKey, config, context)
     };
 }
 
+const LOG_PREFIX$1 = 'HTTP Property Derivation -';
+const DEFAULT_HTTP_DEBOUNCE_MS = 300;
+/**
+ * Creates an RxJS Observable stream that processes an HTTP property-derivation entry.
+ *
+ * Mirrors `createHttpDerivationStream` (value pipeline) but writes the result via
+ * `store.setOverride(fieldKey, targetProperty, value)` instead of patching the form.
+ *
+ * The stream uses `startWith(null) → pairwise()` so the first emission fires a
+ * request for all `dependsOn` fields, populating the derived property on initial
+ * form load. Subsequent emissions only fire when a `dependsOn` field changes.
+ *
+ * @internal
+ */
+function createHttpPropertyDerivationStream(entry, formValue$, context) {
+    // Guard: no array support yet for HTTP property derivations (mirrors value pipeline).
+    if (isArrayPlaceholderPath(entry.fieldKey)) {
+        context.logger.warn(`${LOG_PREFIX$1} HTTP property derivation for array field '${entry.fieldKey}' is not supported. ` +
+            `Array HTTP property derivations will be supported in a future release.`);
+        return EMPTY;
+    }
+    if (!entry.http || !entry.responseExpression) {
+        return EMPTY;
+    }
+    const responseExpression = entry.responseExpression;
+    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS;
+    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
+        current: current,
+        changedFields: getChangedKeys(previous, current),
+    })), filter(({ changedFields }) => {
+        if (changedFields.size === 0)
+            return false;
+        return entry.dependsOn.some((dep) => changedFields.has(dep));
+    }), debounceTime(debounceMs), switchMap(({ current }) => {
+        return new Observable((subscriber) => {
+            const customFunctions = context.customFunctions?.();
+            const externalData = context.externalData?.();
+            const fieldValue = getNestedValue(current, entry.fieldKey);
+            const evalContext = {
+                fieldValue,
+                formValue: current,
+                fieldPath: entry.fieldKey,
+                customFunctions,
+                externalData,
+                logger: context.logger,
+            };
+            // Evaluate condition — skip if false
+            if (entry.condition !== true) {
+                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
+                if (!conditionMet) {
+                    subscriber.complete();
+                    return;
+                }
+            }
+            // Returns null when a path param is undefined — suppress the request
+            const resolvedRequest = resolveHttpRequest(entry.http, evalContext);
+            if (!resolvedRequest) {
+                subscriber.complete();
+                return;
+            }
+            const method = (resolvedRequest.method ?? 'GET').toUpperCase();
+            // Inner cancellation is handled declaratively by the orchestrator's
+            // outer switchMap: when the entry set changes, the outer stream
+            // unsubscribes from this inner observable, which triggers the
+            // cleanup callback below and cancels the in-flight HTTP request.
+            const httpSub = context.httpClient
+                .request(method, resolvedRequest.url, {
+                body: resolvedRequest.body,
+                headers: resolvedRequest.headers,
+            })
+                .subscribe({
+                next: (response) => {
+                    try {
+                        const newValue = ExpressionParser.evaluate(responseExpression, { response });
+                        // `setOverride` performs its own deep-equality check, so we don't need to
+                        // compare with the current store value here.
+                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
+                        subscriber.complete();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        context.logger.warn(`${LOG_PREFIX$1} Failed to process response for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                        subscriber.complete();
+                    }
+                },
+                error: (error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    context.logger.warn(`${LOG_PREFIX$1} HTTP request failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                httpSub.unsubscribe();
+            };
+        });
+    }), catchError$1((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+        return EMPTY;
+    }));
+}
+
+const LOG_PREFIX = 'Async Property Derivation -';
+const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
+/**
+ * Creates an RxJS Observable stream that processes an async-function property-derivation entry.
+ *
+ * Mirrors `createAsyncDerivationStream` (value pipeline) but writes the result via
+ * `store.setOverride(fieldKey, targetProperty, value)` instead of patching the form.
+ *
+ * @internal
+ */
+function createAsyncPropertyDerivationStream(entry, formValue$, context) {
+    if (isArrayPlaceholderPath(entry.fieldKey)) {
+        context.logger.warn(`${LOG_PREFIX} Async property derivation for array field '${entry.fieldKey}' is not supported. ` +
+            `Array async property derivations will be supported in a future release.`);
+        return EMPTY;
+    }
+    if (!entry.asyncFunctionName && !entry.asyncFn) {
+        context.logger.warn(`${LOG_PREFIX} Property derivation for '${entry.fieldKey}.${entry.targetProperty}' has neither "asyncFunctionName" nor "asyncFn". ` +
+            `One of the two is required for source: 'asyncFunction'.`);
+        return EMPTY;
+    }
+    if (entry.asyncFn && entry.asyncFunctionName) {
+        context.logger.warn(`${LOG_PREFIX} Both "asyncFn" and "asyncFunctionName" are set on property derivation for '${entry.fieldKey}.${entry.targetProperty}'. ` +
+            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
+    }
+    const inlineAsyncFn = entry.asyncFn;
+    const asyncFunctionName = entry.asyncFunctionName;
+    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
+    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
+        current: current,
+        changedFields: getChangedKeys(previous, current),
+    })), filter(({ changedFields }) => {
+        if (changedFields.size === 0)
+            return false;
+        return entry.dependsOn.some((dep) => changedFields.has(dep));
+    }), debounceTime(debounceMs), switchMap(({ current }) => {
+        return new Observable((subscriber) => {
+            const customFunctions = context.customFunctions?.();
+            const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
+            const externalData = context.externalData?.();
+            const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
+            if (!asyncFn) {
+                context.logger.warn(`${LOG_PREFIX} Async derivation function '${asyncFunctionName}' not found for '${entry.fieldKey}.${entry.targetProperty}'. ` +
+                    `Register it in customFnConfig.asyncDerivations.`);
+                subscriber.complete();
+                return;
+            }
+            const fieldValue = getNestedValue(current, entry.fieldKey);
+            const evalContext = {
+                fieldValue,
+                formValue: current,
+                fieldPath: entry.fieldKey,
+                customFunctions,
+                externalData,
+                logger: context.logger,
+            };
+            if (entry.condition !== true) {
+                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
+                if (!conditionMet) {
+                    subscriber.complete();
+                    return;
+                }
+            }
+            const result$ = from(asyncFn(evalContext));
+            const asyncSub = result$.subscribe({
+                next: (newValue) => {
+                    try {
+                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
+                        subscriber.complete();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                        subscriber.complete();
+                    }
+                },
+                error: (error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                    subscriber.complete();
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                asyncSub.unsubscribe();
+            };
+        });
+    }), catchError$1((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+        return EMPTY;
+    }));
+}
+
 /**
  * Orchestrates property derivation processing for a dynamic form.
  *
@@ -14040,6 +15307,7 @@ class PropertyDerivationOrchestrator {
     deprecationTracker = inject(DEPRECATION_WARNING_TRACKER);
     functionRegistry = inject(FunctionRegistryService);
     formOptions = inject(FORM_OPTIONS);
+    httpClient = inject(HttpClient, { optional: true });
     /**
      * Computed signal containing the collected property derivations.
      * Returns null if no property derivations are defined.
@@ -14075,6 +15343,8 @@ class PropertyDerivationOrchestrator {
         });
         this.setupOnChangeStream();
         this.setupDebouncedStream();
+        this.setupHttpStreams();
+        this.setupAsyncFunctionStreams();
     }
     setupOnChangeStream() {
         const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
@@ -14144,40 +15414,161 @@ class PropertyDerivationOrchestrator {
         };
         applyPropertyDerivationsForTrigger(filteredCollection, 'debounced', applicatorContext, changedFields);
     }
-}
-/**
- * Creates a PropertyDerivationOrchestrator for a dynamic form.
- * Must be called within an injection context.
- *
- * @param config - Form-specific signals configuration
- * @returns The created PropertyDerivationOrchestrator
- *
- * @public
- */
-function createPropertyDerivationOrchestrator(config) {
-    return new PropertyDerivationOrchestrator(config);
-}
-/**
- * Injection token for the PropertyDerivationOrchestrator.
- *
- * @public
- */
-const PROPERTY_DERIVATION_ORCHESTRATOR = new InjectionToken('PROPERTY_DERIVATION_ORCHESTRATOR');
-// ─────────────────────────────────────────────────────────────────────────────
-// Dev-mode diagnostics (tree-shaken in prod via DEV_MODE gate at call site)
-// ─────────────────────────────────────────────────────────────────────────────
-function warnAboutWildcardDependencies(logger, entries, fieldCount) {
-    const implicitWildcards = entries.filter((entry) => entry.dependsOn.includes('*') &&
-        entry.functionName &&
-        (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
-    if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey}.${e.targetProperty} (${e.functionName})`);
-        logger.warn('PropertyDerivation: custom functions without explicit dependsOn detected. ' +
-            `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
+    /**
+     * Declarative pipeline for HTTP property-derivation entries. Delegates the
+     * collection-watching / dedup / cancellation plumbing to
+     * {@link buildEntryStreamPipeline} so both orchestrators share one
+     * implementation.
+     *
+     * Errors inside `createStream` invocations are isolated via the inner
+     * stream's own `catchError`; we additionally wrap the outer pipeline so a
+     * synchronous throw during stream construction (e.g., evaluation of a
+     * `condition`) doesn't tear the whole pipeline down for the lifetime of
+     * the form.
+     */
+    setupHttpStreams() {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
+            entrySignature: httpEntrySignature,
+            createStream: (entry) => {
+                if (!this.httpClient) {
+                    this.logger.error('HTTP Property Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
+                    return null;
+                }
+                return createHttpPropertyDerivationStream(entry, formValue$, {
+                    formValue: this.config.formValue,
+                    store: this.config.store,
+                    httpClient: this.httpClient,
+                    logger: this.logger,
+                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                    externalData: () => resolveExternalData(this.config.externalData),
+                });
+            },
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('HTTP Property Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    setupAsyncFunctionStreams() {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
+            entrySignature: asyncEntrySignature,
+            createStream: (entry) => createAsyncPropertyDerivationStream(entry, formValue$, {
+                formValue: this.config.formValue,
+                store: this.config.store,
+                logger: this.logger,
+                customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
+                externalData: () => resolveExternalData(this.config.externalData),
+            }),
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('Async Property Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+}
+/**
+ * Identity signature for an HTTP property-derivation entry. Includes every
+ * field that drives the inner stream's behavior — changing any of them must
+ * tear down and rebuild the stream. Stable across topological reorderings
+ * because the consumer ({@link entrySetsEqual}) compares as a multiset.
+ */
+function httpEntrySignature(entry) {
+    const config = {
+        http: entry.http,
+        responseExpression: entry.responseExpression,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+    };
+    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
+}
+/**
+ * Identity signature for an async-function property-derivation entry. Same
+ * principle as {@link httpEntrySignature}: include every field the inner
+ * stream closes over so changes force a rebuild. Inline `asyncFn`s use the
+ * `fieldKey.targetProperty` path as a stable identifier — function identity
+ * isn't JSON-serializable.
+ */
+function asyncEntrySignature(entry) {
+    const config = {
+        asyncFunctionName: entry.asyncFunctionName,
+        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}.${entry.targetProperty}` : undefined,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+    };
+    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
+}
+/**
+ * Creates a PropertyDerivationOrchestrator for a dynamic form.
+ * Must be called within an injection context.
+ *
+ * @param config - Form-specific signals configuration
+ * @returns The created PropertyDerivationOrchestrator
+ *
+ * @public
+ */
+function createPropertyDerivationOrchestrator(config) {
+    return new PropertyDerivationOrchestrator(config);
+}
+/**
+ * Injection token for the PropertyDerivationOrchestrator.
+ *
+ * @public
+ */
+const PROPERTY_DERIVATION_ORCHESTRATOR = new InjectionToken('PROPERTY_DERIVATION_ORCHESTRATOR');
+// ─────────────────────────────────────────────────────────────────────────────
+// Dev-mode diagnostics (tree-shaken in prod via DEV_MODE gate at call site)
+// ─────────────────────────────────────────────────────────────────────────────
+function warnAboutWildcardDependencies(logger, entries, fieldCount) {
+    const implicitWildcards = entries.filter((entry) => entry.dependsOn.includes('*') &&
+        (entry.functionName || entry.fn) &&
+        (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
+    if (implicitWildcards.length > 0) {
+        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey}.${e.targetProperty} (${e.functionName ?? '<inline fn>'})`);
+        logger.warn('PropertyDerivation: custom functions without explicit dependsOn detected. ' +
+            `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
             'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
     }
 }
 
+/**
+ * Multi-provider token populated by `provideAddonActions({...})` calls.
+ * `ADDON_ACTION_REGISTRY` aggregates these into a single name → handler map.
+ *
+ * @internal
+ */
+const ADDON_ACTION_HANDLERS = new InjectionToken('ADDON_ACTION_HANDLERS');
+/**
+ * Form-scoped name → handler map. Read by adapter button kinds at click
+ * time for `actionRef: 'name'` lookups. Provided at form scope (not root)
+ * because `ADDON_ACTION_HANDLERS` is form-scoped via `provideAddonActions`.
+ */
+const ADDON_ACTION_REGISTRY = new InjectionToken('ADDON_ACTION_REGISTRY');
+function createAddonActionRegistry() {
+    const sources = inject(ADDON_ACTION_HANDLERS, { optional: true }) ?? [];
+    const map = new Map();
+    for (const handlers of sources) {
+        for (const [name, fn] of Object.entries(handlers)) {
+            map.set(name, fn);
+        }
+    }
+    return map;
+}
+
 /**
  * Always-on providers for any DynamicForm: state machine, registries, signal-context tokens.
  * Pure form bootstrap — no derivation, HTTP, or async machinery.
@@ -14192,7 +15583,7 @@ function coreProviders() {
         FunctionRegistryService,
         {
             provide: FORM_STATE_DEPS,
-            useFactory: () => ({ config: null, formOptions: null, value: null }),
+            useFactory: () => ({ config: null, formOptions: null, value: null, source: null }),
         },
         FormStateManager,
         {
@@ -14201,6 +15592,7 @@ function coreProviders() {
             deps: [FormStateManager],
         },
         FieldContextRegistryService,
+        ArrayItemRegistryService,
         {
             provide: DEFAULT_PROPS,
             useFactory: (stateManager) => computed(() => stateManager.activeConfig()?.defaultProps),
@@ -14227,6 +15619,11 @@ function coreProviders() {
             deps: [FormStateManager],
         },
         { provide: DEPRECATION_WARNING_TRACKER, useFactory: createWarningTracker },
+        // ADDON_ACTION_REGISTRY must live at form scope (not root) because the
+        // multi-provider source `ADDON_ACTION_HANDLERS` is contributed by
+        // `provideAddonActions(...)` features passed to `provideDynamicForm(...)`
+        // — those entries are only visible inside the form's own injector tree.
+        { provide: ADDON_ACTION_REGISTRY, useFactory: createAddonActionRegistry },
     ];
 }
 /**
@@ -14418,13 +15815,90 @@ class EventDispatcher {
     disconnect() {
         this.bus = undefined;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventDispatcher });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventDispatcher });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: EventDispatcher, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Marks an `<ng-template>` projected into `<df-dynamic-form>` content as
+ * available to template addons by name.
+ *
+ * The host form collects all `DfTemplate` instances via `contentChildren`
+ * and exposes them through {@link DF_FIELD_TEMPLATES}, where the template
+ * addon kind looks them up by `templateKey` at render time.
+ *
+ * @example
+ * ```html
+ * <df-dynamic-form [config]="config">
+ *   <ng-template dfTemplate="searchIcon" let-field>
+ *     <my-icon [field]="field" />
+ *   </ng-template>
+ * </df-dynamic-form>
+ * ```
+ *
+ * In the field config:
+ * ```ts
+ * { slot: 'prefix', kind: 'template', templateKey: 'searchIcon' }
+ * ```
+ */
+class DfTemplate {
+    /** Name this template registers under — referenced from `TemplateAddon.templateKey`. */
+    dfTemplate = input.required(...(ngDevMode ? [{ debugName: "dfTemplate" }] : /* istanbul ignore next */ []));
+    /** The wrapped template, captured for registration and `NgTemplateOutlet` rendering. */
+    templateRef = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfTemplate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.14", type: DfTemplate, isStandalone: true, selector: "ng-template[dfTemplate]", inputs: { dfTemplate: { classPropertyName: "dfTemplate", publicName: "dfTemplate", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["dfTemplate"], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: EventDispatcher, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfTemplate, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[dfTemplate]',
+                    exportAs: 'dfTemplate',
+                }]
+        }], propDecorators: { dfTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "dfTemplate", required: true }] }] } });
+/**
+ * Holder service published at the `<df-dynamic-form>` component scope.
+ * `DynamicForm` collects projected `<ng-template dfTemplate="...">` via
+ * `contentChildren(DfTemplate)` and pushes the resulting map through
+ * `DfFieldTemplateRegistry.set(...)`. The {@link DF_FIELD_TEMPLATES}
+ * injection token is provided as a factory that returns this service's
+ * `map` signal, so template-addon components can resolve `templateKey`
+ * without coupling to the host form's generic class.
+ */
+class DfFieldTemplateRegistry {
+    _map = signal(new Map(), ...(ngDevMode ? [{ debugName: "_map" }] : /* istanbul ignore next */ []));
+    /** Reactive view consumed by the `template` addon kind via DI. */
+    map = this._map.asReadonly();
+    /** Replace the registry contents — called from `DynamicForm` when projected templates change. */
+    set(value) {
+        this._map.set(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfFieldTemplateRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfFieldTemplateRegistry });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfFieldTemplateRegistry, decorators: [{
             type: Injectable
         }] });
 
+/**
+ * Map of named `TemplateRef`s collected by `<df-dynamic-form>` from
+ * `<ng-template dfTemplate="...">` children projected into its content.
+ * The directive selector is `dfTemplate` (see `DfTemplate`); the input
+ * value is the name addons reference via `templateKey`.
+ *
+ * The `template` addon kind looks up its `templateKey` in this map at
+ * render time. Exposed as a `Signal` so projections can be added or
+ * removed reactively (e.g., when the host conditionally projects).
+ *
+ * Provided at the form-component level (not root) so multiple
+ * `<df-dynamic-form>` instances on the same page have independent
+ * template scopes.
+ */
+const DF_FIELD_TEMPLATES = new InjectionToken('DF_FIELD_TEMPLATES');
+
 /**
  * Dynamic form component — renders a form based on configuration.
  * Delegates state management to `FormStateManager`.
@@ -14444,6 +15918,13 @@ class DynamicForm {
     formOptions = input(undefined, ...(ngDevMode ? [{ debugName: "formOptions" }] : /* istanbul ignore next */ []));
     /** Form values for two-way data binding. */
     value = model(undefined, ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    /**
+     * How lenient the addon validator is on `config.fields[...].addons`.
+     * `'inline'` (default) keeps everything; `'json'` drops code-only kinds
+     * with a warning. Read at form init and on every config swap — change
+     * `source` AND the config to force re-validation mid-flight.
+     */
+    source = input('inline', ...(ngDevMode ? [{ debugName: "source" }] : /* istanbul ignore next */ []));
     // ─────────────────────────────────────────────────────────────────────────────
     // Dependencies
     // ─────────────────────────────────────────────────────────────────────────────
@@ -14453,6 +15934,12 @@ class DynamicForm {
     eventBus = inject(EventBus);
     logger = inject(DynamicFormLogger);
     dispatcher = inject(EventDispatcher, { optional: true });
+    templateRegistry = inject(DfFieldTemplateRegistry);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Projected templates — collected for the `template` addon kind via DI.
+    // ─────────────────────────────────────────────────────────────────────────────
+    /** All `<ng-template dfTemplate="...">` instances projected into this form. */
+    _projectedTemplates = contentChildren(DfTemplate, ...(ngDevMode ? [{ debugName: "_projectedTemplates" }] : /* istanbul ignore next */ []));
     /** State manager that owns all form state. Initialized via connectDeps() to guarantee
      * FORM_STATE_DEPS is populated before FormStateManager is injected. */
     stateManager = this.connectDeps();
@@ -14605,6 +16092,15 @@ class DynamicForm {
                 }, { injector: this.injector });
             }
         });
+        // Mirror projected `<ng-template dfTemplate="...">` into the template
+        // registry so `template` addons can resolve `templateKey` via DI.
+        explicitEffect([this._projectedTemplates], ([templates]) => {
+            const map = new Map();
+            for (const t of templates) {
+                map.set(t.dfTemplate(), t.templateRef);
+            }
+            this.templateRegistry.set(map);
+        });
     }
     /**
      * Populates FORM_STATE_DEPS with this component's input signals, then injects
@@ -14617,6 +16113,7 @@ class DynamicForm {
         deps.config = this.config;
         deps.formOptions = this.formOptions;
         deps.value = this.value;
+        deps.source = this.source;
         return inject((FormStateManager));
     }
     setupEventHandlers() {
@@ -14632,8 +16129,12 @@ class DynamicForm {
             error: (err) => this.logger.error('Submission handler error', err),
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DynamicForm, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.8", type: DynamicForm, isStandalone: true, selector: "form[dynamic-form]", inputs: { config: { classPropertyName: "config", publicName: "dynamic-form", isSignal: true, isRequired: true, transformFunction: null }, formOptions: { classPropertyName: "formOptions", publicName: "formOptions", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", validityChange: "validityChange", dirtyChange: "dirtyChange", submitted: "submitted", reset: "reset", cleared: "cleared", events: "events", initialized: "initialized", onPageChange: "onPageChange", onPageNavigationStateChange: "onPageNavigationStateChange" }, host: { attributes: { "novalidate": "" }, listeners: { "submit": "onNativeSubmit($event)" }, properties: { "class.disabled": "disabled()", "class.df-form-paged": "formModeDetection().mode === \"paged\"", "class.df-form-non-paged": "formModeDetection().mode === \"non-paged\"", "attr.data-form-mode": "formModeDetection().mode" }, classAttribute: "df-dynamic-form df-form" }, providers: [provideDynamicFormDI()], ngImport: i0, template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicForm, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: DynamicForm, isStandalone: true, selector: "form[dynamic-form]", inputs: { config: { classPropertyName: "config", publicName: "dynamic-form", isSignal: true, isRequired: true, transformFunction: null }, formOptions: { classPropertyName: "formOptions", publicName: "formOptions", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, source: { classPropertyName: "source", publicName: "source", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", validityChange: "validityChange", dirtyChange: "dirtyChange", submitted: "submitted", reset: "reset", cleared: "cleared", events: "events", initialized: "initialized", onPageChange: "onPageChange", onPageNavigationStateChange: "onPageNavigationStateChange" }, host: { attributes: { "novalidate": "" }, listeners: { "submit": "onNativeSubmit($event)" }, properties: { "class.disabled": "disabled()", "class.df-form-paged": "formModeDetection().mode === \"paged\"", "class.df-form-non-paged": "formModeDetection().mode === \"non-paged\"", "attr.data-form-mode": "formModeDetection().mode" }, classAttribute: "df-dynamic-form df-form" }, providers: [
+            provideDynamicFormDI(),
+            DfFieldTemplateRegistry,
+            { provide: DF_FIELD_TEMPLATES, useFactory: () => inject(DfFieldTemplateRegistry).map },
+        ], queries: [{ propertyName: "_projectedTemplates", predicate: DfTemplate, isSignal: true }], ngImport: i0, template: `
     @if (shouldRender()) {
       @switch (formModeDetection().mode) {
         @case ('paged') {
@@ -14641,7 +16142,13 @@ class DynamicForm {
         }
         @case ('non-paged') {
           @for (field of resolvedFields(); track field.key) {
-            <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            <!-- @if + DfFieldOutlet's own renderReady-&-!hidden gate together silence NG01916:
+                 the template @if removes the host from the DOM (Angular's prescribed pattern), and
+                 the directive's gate stops a same-CD-pass mount before [formField] can warn.
+                 Don't dedupe one without the other — see DfFieldOutlet.renderReady. -->
+            @if (!field.hidden()) {
+              <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            }
           }
         }
         @default {
@@ -14649,9 +16156,9 @@ class DynamicForm {
         }
       }
     }
-  `, isInline: true, styles: [":host,.df-form{--df-grid-columns: 12;--df-grid-gap: .5rem;--df-grid-row-gap: .5rem;--df-breakpoint-sm: 576px;--df-breakpoint-md: 768px;--df-breakpoint-lg: 992px;--df-breakpoint-xl: 1200px;--df-grid-gap-sm: .5rem;--df-grid-gap-md: .5rem;--df-grid-gap-lg: .5rem;--df-grid-gap-xl: .5rem;--df-grid-row-gap-sm: .5rem;--df-grid-row-gap-md: .5rem;--df-grid-row-gap-lg: .5rem;--df-grid-row-gap-xl: .5rem;--df-array-item-gap: var(--df-grid-row-gap);--df-group-gap: var(--df-grid-gap);--df-group-padding: var(--df-grid-gap)}.df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm);--df-grid-row-gap: var(--df-grid-row-gap-sm)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md);--df-grid-row-gap: var(--df-grid-row-gap-md)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg);--df-grid-row-gap: var(--df-grid-row-gap-lg)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl);--df-grid-row-gap: var(--df-grid-row-gap-xl)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{--df-grid-row-gap: 0}\n"], dependencies: [{ kind: "directive", type: DfFieldOutlet, selector: "[dfFieldOutlet]", inputs: ["dfFieldOutlet", "dfFieldOutletEnvironmentInjector"] }, { kind: "component", type: PageOrchestratorComponent, selector: "div[page-orchestrator]", inputs: ["pageFields", "form", "fieldSignalContext"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [".df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap, .5rem);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-sm, .5rem)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns, 12),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-md, .5rem)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-lg, .5rem)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-xl, .5rem)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--df-form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{gap:0}\n"], dependencies: [{ kind: "directive", type: DfFieldOutlet, selector: "[dfFieldOutlet]", inputs: ["dfFieldOutlet", "dfFieldOutletEnvironmentInjector"] }, { kind: "component", type: PageOrchestratorComponent, selector: "div[page-orchestrator]", inputs: ["pageFields", "form", "fieldSignalContext"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DynamicForm, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicForm, decorators: [{
             type: Component,
             args: [{ selector: 'form[dynamic-form]', imports: [DfFieldOutlet, PageOrchestratorComponent], template: `
     @if (shouldRender()) {
@@ -14661,7 +16168,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
         }
         @case ('non-paged') {
           @for (field of resolvedFields(); track field.key) {
-            <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            <!-- @if + DfFieldOutlet's own renderReady-&-!hidden gate together silence NG01916:
+                 the template @if removes the host from the DOM (Angular's prescribed pattern), and
+                 the directive's gate stops a same-CD-pass mount before [formField] can warn.
+                 Don't dedupe one without the other — see DfFieldOutlet.renderReady. -->
+            @if (!field.hidden()) {
+              <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            }
           }
         }
         @default {
@@ -14669,7 +16182,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
         }
       }
     }
-  `, providers: [provideDynamicFormDI()], host: {
+  `, providers: [
+                        provideDynamicFormDI(),
+                        DfFieldTemplateRegistry,
+                        { provide: DF_FIELD_TEMPLATES, useFactory: () => inject(DfFieldTemplateRegistry).map },
+                    ], host: {
                         class: 'df-dynamic-form df-form',
                         novalidate: '', // Disable browser validation - Angular Signal Forms handles validation
                         '[class.disabled]': 'disabled()',
@@ -14677,8 +16194,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
                         '[class.df-form-non-paged]': 'formModeDetection().mode === "non-paged"',
                         '[attr.data-form-mode]': 'formModeDetection().mode',
                         '(submit)': 'onNativeSubmit($event)',
-                    }, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host,.df-form{--df-grid-columns: 12;--df-grid-gap: .5rem;--df-grid-row-gap: .5rem;--df-breakpoint-sm: 576px;--df-breakpoint-md: 768px;--df-breakpoint-lg: 992px;--df-breakpoint-xl: 1200px;--df-grid-gap-sm: .5rem;--df-grid-gap-md: .5rem;--df-grid-gap-lg: .5rem;--df-grid-gap-xl: .5rem;--df-grid-row-gap-sm: .5rem;--df-grid-row-gap-md: .5rem;--df-grid-row-gap-lg: .5rem;--df-grid-row-gap-xl: .5rem;--df-array-item-gap: var(--df-grid-row-gap);--df-group-gap: var(--df-grid-gap);--df-group-padding: var(--df-grid-gap)}.df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm);--df-grid-row-gap: var(--df-grid-row-gap-sm)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md);--df-grid-row-gap: var(--df-grid-row-gap-md)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg);--df-grid-row-gap: var(--df-grid-row-gap-lg)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl);--df-grid-row-gap: var(--df-grid-row-gap-xl)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{--df-grid-row-gap: 0}\n"] }]
-        }], ctorParameters: () => [], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "dynamic-form", required: true }] }], formOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "formOptions", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], validityChange: [{ type: i0.Output, args: ["validityChange"] }], dirtyChange: [{ type: i0.Output, args: ["dirtyChange"] }], submitted: [{ type: i0.Output, args: ["submitted"] }], reset: [{ type: i0.Output, args: ["reset"] }], cleared: [{ type: i0.Output, args: ["cleared"] }], events: [{ type: i0.Output, args: ["events"] }], initialized: [{ type: i0.Output, args: ["initialized"] }], onPageChange: [{ type: i0.Output, args: ["onPageChange"] }], onPageNavigationStateChange: [{ type: i0.Output, args: ["onPageNavigationStateChange"] }] } });
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap, .5rem);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-sm, .5rem)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns, 12),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-md, .5rem)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-lg, .5rem)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-xl, .5rem)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--df-form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{gap:0}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "dynamic-form", required: true }] }], formOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "formOptions", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], source: [{ type: i0.Input, args: [{ isSignal: true, alias: "source", required: false }] }], _projectedTemplates: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => DfTemplate), { isSignal: true }] }], validityChange: [{ type: i0.Output, args: ["validityChange"] }], dirtyChange: [{ type: i0.Output, args: ["dirtyChange"] }], submitted: [{ type: i0.Output, args: ["submitted"] }], reset: [{ type: i0.Output, args: ["reset"] }], cleared: [{ type: i0.Output, args: ["cleared"] }], events: [{ type: i0.Output, args: ["events"] }], initialized: [{ type: i0.Output, args: ["initialized"] }], onPageChange: [{ type: i0.Output, args: ["onPageChange"] }], onPageNavigationStateChange: [{ type: i0.Output, args: ["onPageNavigationStateChange"] }] } });
 /**
  * Recursively counts container fields (page, row, group, array, wrapper) in a field tree.
  * Descends into container children including array item templates to ensure
@@ -14708,6 +16225,147 @@ function countContainersRecursive(fields) {
     return count;
 }
 
+/**
+ * Cache for resolved addon-kind components.
+ *
+ * Provided per-form by `provideDynamicFormDI()` so two `<df-dynamic-form>`
+ * instances with conflicting `loadComponent` factories for the same kind
+ * never share a stale entry. Has no `providedIn: 'root'` factory — the
+ * registry consumer is always inside a form scope, and a root fallback
+ * would only hide misconfiguration (an SSR cross-request hit if a future
+ * code path forgot to provide it locally).
+ *
+ * Mirrors `COMPONENT_CACHE` (field types) and `WRAPPER_COMPONENT_CACHE`
+ * (wrappers).
+ *
+ * @internal
+ */
+const ADDON_KIND_COMPONENT_CACHE = new InjectionToken('ADDON_KIND_COMPONENT_CACHE');
+/**
+ * Injection function for accessing the addon kind registry.
+ *
+ * Usage parallels {@link injectFieldRegistry}: lookup, lazy load, cache.
+ * Must be called within an injection context.
+ *
+ * @example
+ * ```typescript
+ * const addonKinds = injectAddonKindRegistry();
+ * const Component = await addonKinds.loadKindComponent('prime-icon');
+ * ```
+ */
+function injectAddonKindRegistry() {
+    const registry = inject(ADDON_KIND_REGISTRY);
+    const componentCache = inject(ADDON_KIND_COMPONENT_CACHE);
+    return {
+        /** Look up a kind definition by its discriminant. */
+        getKind(kind) {
+            return registry.get(kind);
+        },
+        /** Whether a kind is currently registered. */
+        hasKind(kind) {
+            return registry.has(kind);
+        },
+        /** All registered kind names — useful for actionable validator warnings. */
+        getKindNames() {
+            return Array.from(registry.keys());
+        },
+        /**
+         * Resolve a kind to its renderer component. Caches on first resolution.
+         *
+         * @throws DynamicFormError when the kind is not registered.
+         */
+        async loadKindComponent(kind) {
+            const definition = registry.get(kind);
+            if (!definition) {
+                const known = Array.from(registry.keys()).join(', ') || '(none)';
+                throw new DynamicFormError(`Addon kind '${kind}' is not registered. Currently registered kinds: ${known}.`);
+            }
+            const cached = componentCache.get(kind);
+            if (cached) {
+                return cached;
+            }
+            try {
+                const component = resolveDefaultExport(await definition.loadComponent());
+                if (component) {
+                    componentCache.set(kind, component);
+                    return component;
+                }
+                throw new DynamicFormError(`Addon kind '${kind}' loadComponent resolved to null.`);
+            }
+            catch (error) {
+                if (error instanceof DynamicFormError)
+                    throw error;
+                throw new DynamicFormError(`Failed to load component for addon kind '${kind}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        /**
+         * Synchronous lookup of an already-loaded kind component, or undefined.
+         * Returns `undefined` when the kind isn't registered in this scope even
+         * if a prior scope cached a component under the same name — prevents
+         * cross-form cache hits when registrations diverge.
+         */
+        getLoadedKindComponent(kind) {
+            if (!registry.has(kind))
+                return undefined;
+            return componentCache.get(kind);
+        },
+        /** Direct read-only access to the registry map. */
+        get raw() {
+            return registry;
+        },
+    };
+}
+
+/**
+ * Built-in addon kinds shipped by core.
+ *
+ * Universally adapter-independent: `text`, `template`, `component`. Adapters
+ * register their own kinds (e.g., `prime-icon`, `prime-button`) via
+ * `withCustomAddon(...)` features.
+ */
+const BUILT_IN_ADDON_KINDS = [
+    {
+        kind: 'text',
+        loadComponent: () => Promise.resolve().then(function () { return textAddon_component; }).then((m) => m.TextAddonComponent),
+        validate: (addon, fieldKey) => {
+            const text = addon.text;
+            // Validates structural presence: rejects missing / null / non-string-non-callable,
+            // and rejects literal empty strings. DynamicText values that resolve to empty
+            // at runtime (signal/observable yielding '') are NOT caught here — they're
+            // legal as far as the config is concerned, just render an empty span.
+            if (text === undefined || text === null) {
+                throw new DynamicFormError(`Addon kind 'text' requires a 'text' field (field: '${fieldKey}').`);
+            }
+            if (typeof text === 'string' && text.length === 0) {
+                throw new DynamicFormError(`Addon kind 'text' requires a non-empty 'text' string (field: '${fieldKey}').`);
+            }
+        },
+    },
+    {
+        kind: 'template',
+        loadComponent: () => Promise.resolve().then(function () { return templateAddon_component; }).then((m) => m.TemplateAddonComponent),
+        validate: (addon, fieldKey) => {
+            const key = addon.templateKey;
+            if (typeof key !== 'string' || key.length === 0) {
+                throw new DynamicFormError(`Addon kind 'template' requires a non-empty 'templateKey' string (field: '${fieldKey}').`);
+            }
+        },
+    },
+    {
+        kind: 'component',
+        // The shape carries a function loader — not serialisable; dropped by the
+        // validator when the form config originated from JSON.
+        jsonSafe: false,
+        loadComponent: () => Promise.resolve().then(function () { return componentAddon_component; }).then((m) => m.ComponentAddonComponent),
+        validate: (addon, fieldKey) => {
+            const loader = addon.component;
+            if (typeof loader !== 'function') {
+                throw new DynamicFormError(`Addon kind 'component' requires a 'component' loader function (field: '${fieldKey}').`);
+            }
+        },
+    },
+];
+
 /**
  * No-op logger for when no logger is provided.
  * Used as fallback in button logic evaluation to avoid breaking downstream packages.
@@ -15244,8 +16902,14 @@ function containerFieldMapper(fieldDef) {
  * ```
  */
 /**
- * Base field type definitions for fields that don't use the `field` input.
- * Used by display-only fields like `text` that render immediately without
+ * Base for container field types that consume the mapper-emitted `field` input
+ * (row, group, array, page, container).
+ */
+const CONTAINER_FIELD_TYPES_BASE = {
+    renderReadyWhen: ['field'],
+};
+/**
+ * Base for display-only fields (`text`) that render immediately without
  * waiting for form value integration.
  */
 const DISPLAY_FIELD_TYPES_BASE = {
@@ -15264,31 +16928,35 @@ const BUILT_IN_FIELDS = [
         // `row` is a virtual field type: it maps to ContainerFieldComponent, and
         // the rowFieldMapper injects a `{ type: 'row' }` wrapper so the container
         // renders the flex/grid layout via RowWrapperComponent.
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BCIQ6_Mm.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-C554hOxN.mjs'),
         mapper: rowFieldMapper,
         valueHandling: 'flatten',
+        ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'group',
-        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-DKcoco0G.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-BJ8j7Sh0.mjs'),
         mapper: groupFieldMapper,
         valueHandling: 'include',
+        ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'array',
-        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-us7mQtVQ.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-GiaVHO9N.mjs'),
         mapper: arrayFieldMapper,
         valueHandling: 'include',
+        ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'page',
-        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-DqWAcwhG.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs'),
         mapper: pageFieldMapper,
         valueHandling: 'flatten',
+        ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'text',
-        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-8C1-oyU_.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-BGw6T-4h.mjs'),
         mapper: textFieldMapper,
         valueHandling: 'exclude',
         ...DISPLAY_FIELD_TYPES_BASE,
@@ -15300,22 +16968,32 @@ const BUILT_IN_FIELDS = [
     },
     {
         name: 'container',
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BCIQ6_Mm.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-C554hOxN.mjs'),
         mapper: containerFieldMapper,
         valueHandling: 'flatten',
+        ...CONTAINER_FIELD_TYPES_BASE,
     },
 ];
 const BUILT_IN_WRAPPERS = [
     {
         wrapperName: 'css',
-        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-Dhlf6UxN.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-CnJgFWLB.mjs'),
     },
     {
         wrapperName: 'row',
-        loadComponent: () => import('./ng-forge-dynamic-forms-row-wrapper.component-BIvEUoia.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-row-wrapper.component-CFtnatYj.mjs'),
     },
 ];
 
+/**
+ * Multi-provider token used by `withCustomAddon(...)` features to contribute
+ * addon kind definitions. `provideDynamicForm` aggregates all values into
+ * the form-scoped `ADDON_KIND_REGISTRY` map.
+ *
+ * @internal
+ */
+const ADDON_KIND_DEFINITIONS = new InjectionToken('ADDON_KIND_DEFINITIONS');
+
 /**
  * Bundle wrapper registrations into a single object that can be passed to
  * `provideDynamicForm(...)`.
@@ -15432,8 +17110,6 @@ function provideDynamicForm(...items) {
     const defaultLoggerProvider = hasLoggerFeature ? [] : [{ provide: DynamicFormLogger, useValue: new ConsoleLogger() }];
     return makeEnvironmentProviders([
         ...defaultLoggerProvider,
-        // Always provide default Signal Forms classes (ng-touched, ng-invalid, etc.)
-        provideSignalFormsConfig({ classes: NG_STATUS_CLASSES }),
         {
             provide: FIELD_REGISTRY,
             useFactory: () => {
@@ -15484,6 +17160,31 @@ function provideDynamicForm(...items) {
                 return autoMap;
             },
         },
+        // Form-scoped addon kind registry. Built from BUILT_IN_ADDON_KINDS plus
+        // every kind contributed by `withCustomAddon(...)` features (via the
+        // ADDON_KIND_DEFINITIONS multi-provider). Overrides the empty
+        // `providedIn: 'root'` default so contributions from form-scoped
+        // providers are visible.
+        {
+            provide: ADDON_KIND_REGISTRY,
+            useFactory: () => {
+                const logger = inject(DynamicFormLogger);
+                const contributed = inject(ADDON_KIND_DEFINITIONS, { optional: true }) ?? [];
+                const registry = new Map();
+                for (const def of BUILT_IN_ADDON_KINDS) {
+                    registry.set(def.kind, def);
+                }
+                for (const def of contributed) {
+                    if (registry.has(def.kind)) {
+                        logger.warn(`Addon kind "${def.kind}" is already registered. Overwriting.`);
+                    }
+                    registry.set(def.kind, def);
+                }
+                return registry;
+            },
+        },
+        // Per-form addon-component cache (no root fallback — isolated by form scope).
+        { provide: ADDON_KIND_COMPONENT_CACHE, useFactory: () => new Map() },
         ...featureProviders,
     ]);
 }
@@ -15660,6 +17361,35 @@ function withValidationExecutionDefaults(config) {
     return createFeature('validation-execution', [{ provide: VALIDATION_EXECUTION_DEFAULTS, useValue: resolved }]);
 }
 
+/**
+ * Opt into Angular Signal Forms' legacy `.ng-touched` / `.ng-invalid` /
+ * `.ng-dirty` / `.ng-pristine` / `.ng-untouched` / `.ng-pending` /
+ * `.ng-valid` CSS classes on form-bound elements.
+ *
+ * Wires Angular's `@angular/forms/signals/compat` `NG_STATUS_CLASSES` strategy
+ * via `provideSignalFormsConfig`. Without this feature the modern Signal Forms
+ * class strategy is active, which omits the legacy `ng-*` classes.
+ *
+ * @example Opt in once at the application root
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDynamicForm(
+ *       ...withMaterialFields(),
+ *       withLegacyStatusClasses()
+ *     )
+ *   ]
+ * });
+ * ```
+ *
+ * @returns A DynamicFormFeature that enables the legacy `ng-*` class strategy
+ *
+ * @public
+ */
+function withLegacyStatusClasses() {
+    return createFeature('legacy-status-classes', [...provideSignalFormsConfig({ classes: NG_STATUS_CLASSES })]);
+}
+
 /**
  * Zero-cost type carrier used in wrapper registrations.
  *
@@ -15687,6 +17417,713 @@ function wrapperProps() {
     return undefined;
 }
 
+/** Type guard narrowing {@link AddonActionContext} to its field-bound variant. */
+function isFieldBoundContext(ctx) {
+    return ctx.form !== null;
+}
+
+/**
+ * Normalises a {@link DynamicValue} into a `Signal<T>`.
+ *
+ * Accepts a static value, a `Signal<T>`, or an `Observable<T>`. The result
+ * is a `Signal<T>` that reactively reflects the current value, suitable
+ * for direct use in Angular templates.
+ *
+ * Static values yield a `computed` that always returns the same constant —
+ * preferable to wrapping in `signal()` because the computed never causes
+ * change-detection invalidation.
+ *
+ * Pass an `injector` when calling outside an Angular injection context
+ * (e.g., from inside a `computed`). `toSignal` needs a `DestroyRef` to
+ * unsubscribe — without an injector it falls back to `inject(DestroyRef)`,
+ * which throws when called outside injection context.
+ *
+ * @example
+ * ```typescript
+ * const isHidden = resolveDynamicValue(addon().hidden, false);
+ * // template: \@if (isHidden()) { ... }
+ * ```
+ */
+function resolveDynamicValue(value, fallback, injector) {
+    if (value === undefined) {
+        return computed(() => fallback);
+    }
+    if (isSignal(value)) {
+        return value;
+    }
+    if (isObservable(value)) {
+        return toSignal(value, { initialValue: fallback, injector });
+    }
+    // Static value
+    return computed(() => value);
+}
+
+/**
+ * Dispatcher component that renders an addon by looking up its `kind` in
+ * `ADDON_KIND_REGISTRY` and instantiating the registered component.
+ *
+ * Used by every adapter's field component to render slot content:
+ *
+ * ```html
+ * \@for (a of addonsAt('prefix'); track $index) {
+ *   <df-addon-slot [addon]="a" />
+ * }
+ * ```
+ *
+ * Behaviour:
+ * - Resolves and caches the kind's component asynchronously on first render.
+ * - Forwards the `slot` HTML attribute on the host so Ionic shadow-DOM
+ *   projection works (`<ion-input>` projects children with `slot="start"`
+ *   into its native start slot).
+ * - Honours the addon's reactive `hidden` flag — when `true`, the host is
+ *   `display: none` so it occupies no layout but stays in DOM (cheaper than
+ *   tearing down the component).
+ * - Forwards `className` to the host element.
+ * - ARIA semantics are owned by individual kind components — decorative
+ *   kinds (icons, text) set `aria-hidden="true"` on themselves; interactive
+ *   kinds (buttons) handle their own `aria-label`.
+ *
+ * If the kind cannot be resolved (registry miss, load failure), the
+ * dispatcher logs a warning and renders nothing — never throws. The
+ * runtime addon validator should have caught unknown kinds at config init,
+ * but this provides a defence-in-depth fallback for misconfigured registries.
+ */
+class DfAddonSlot {
+    registry = injectAddonKindRegistry();
+    logger = inject(DynamicFormLogger);
+    hostInjector = inject(Injector);
+    addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
+    /**
+     * Optional read-only view of the host field's mapped inputs — same shape
+     * wrappers receive (`field?: ReadonlyFieldTree`, `key`, `props`, etc.).
+     * Forwarded to kind components so they can read field state without
+     * re-injecting `FIELD_SIGNAL_CONTEXT` and rebuilding context themselves.
+     *
+     * `undefined` when the addon is rendered outside a field (rare).
+     */
+    fieldInputs = input(...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+    /**
+     * Pre-resolved `hidden` signal supplied by the host field. When provided,
+     * the dispatcher reads this instead of re-resolving `addon.hidden` —
+     * lets the host (e.g., `prime-input`) share a single subscription per
+     * Observable-typed `hidden` between its own visibility filter and the
+     * slot's `[style.display]` binding.
+     */
+    hidden = input(undefined, ...(ngDevMode ? [{ debugName: "hidden" }] : /* istanbul ignore next */ []));
+    /** `slot` HTML attribute forwarded to host — needed for Ionic shadow projection. */
+    slotAttr = computed(() => this.addon().slot, ...(ngDevMode ? [{ debugName: "slotAttr" }] : /* istanbul ignore next */ []));
+    className = computed(() => this.addon().className ?? null, ...(ngDevMode ? [{ debugName: "className" }] : /* istanbul ignore next */ []));
+    /**
+     * Locally-resolved `hidden` signal — always reflects `addon.hidden`
+     * regardless of whether the host supplied a pre-resolved signal.
+     * Populated via `explicitEffect` so `resolveDynamicValue` (which may call
+     * `toSignal` for Observable-typed values) does NOT run inside a reactive
+     * context (NG0602). The WeakMap caches per `hidden`-value identity, so
+     * swapping `addon` inputs that share the same Observable reuses the
+     * subscription instead of leaking a fresh one per swap.
+     *
+     * Resolved unconditionally (not gated on host `hidden()` presence) so a
+     * transition from `host hidden = Signal` → `undefined` doesn't expose a
+     * brief window where neither value is current — the upstream effect
+     * re-runs eventually, but the computed read can happen in between.
+     */
+    _hiddenByValue = new WeakMap();
+    _resolvedHidden = signal(undefined, ...(ngDevMode ? [{ debugName: "_resolvedHidden" }] : /* istanbul ignore next */ []));
+    /**
+     * `hidden` resolved from `DynamicValue<boolean>` to a flat `Signal<boolean>`.
+     * Prefers the host-supplied signal when present (avoids duplicate `toSignal`
+     * subscriptions for Observable-typed `hidden`); falls back to the locally-
+     * resolved signal, which is always populated by the addon-tracking effect.
+     */
+    isHidden = computed(() => {
+        const pre = this.hidden();
+        if (pre)
+            return pre();
+        const local = this._resolvedHidden();
+        return local ? local() : false;
+    }, ...(ngDevMode ? [{ debugName: "isHidden" }] : /* istanbul ignore next */ []));
+    /**
+     * Latest async-loaded `{ kind, component }` pair. Tagging the result with
+     * its kind lets `resolvedComponent` filter stale loads structurally — no
+     * monotonic token needed. When `addon.kind` changes mid-load, the prior
+     * load still completes and writes here, but the computed ignores it
+     * because the recorded kind no longer matches the current one.
+     */
+    asyncLoaded = signal(undefined, ...(ngDevMode ? [{ debugName: "asyncLoaded" }] : /* istanbul ignore next */ []));
+    /**
+     * Resolved kind component — composed declaratively from two sources of
+     * truth: the registry's synchronous cache (warm hits, e.g., a second
+     * `<df-addon-slot>` for an already-loaded kind) and the kind-tagged async
+     * loader result. Reading `addon().kind` first makes the computed react to
+     * addon swaps and naturally invalidate stale async-load results.
+     */
+    resolvedComponent = computed(() => {
+        const kind = this.addon().kind;
+        const cached = this.registry.getLoadedKindComponent(kind);
+        if (cached)
+            return cached;
+        const loaded = this.asyncLoaded();
+        return loaded?.kind === kind ? loaded.component : undefined;
+    }, ...(ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []));
+    /** Inputs passed to the kind component — addon plus the wrapper-style host bag. */
+    kindInputs = computed(() => ({
+        addon: this.addon(),
+        fieldInputs: this.fieldInputs(),
+    }), ...(ngDevMode ? [{ debugName: "kindInputs" }] : /* istanbul ignore next */ []));
+    constructor() {
+        // Resolve `addon.hidden` outside any reactive context AND unconditionally —
+        // the host-supplied signal is a perf hint, not a precondition. Keeping
+        // `_resolvedHidden` always-fresh closes a race where `isHidden` could
+        // return `false` between a host-`hidden` clear and the effect re-running.
+        explicitEffect([this.addon], ([addon]) => {
+            const h = addon.hidden;
+            const valueKey = typeof h === 'object' && h !== null ? h : null;
+            let resolved = valueKey ? this._hiddenByValue.get(valueKey) : undefined;
+            if (!resolved) {
+                resolved = resolveDynamicValue(addon.hidden, false, this.hostInjector);
+                if (valueKey)
+                    this._hiddenByValue.set(valueKey, resolved);
+            }
+            this._resolvedHidden.set(resolved);
+        });
+        // Kick off async loads on cache miss. `resolvedComponent` filters stale
+        // results by kind identity, so this effect is a pure side-effect dispatcher.
+        explicitEffect([this.addon], ([addon]) => {
+            const kind = addon.kind;
+            if (this.registry.getLoadedKindComponent(kind))
+                return; // sync path; computed picks it up
+            this.registry
+                .loadKindComponent(kind)
+                .then((component) => this.asyncLoaded.set({ kind, component }))
+                .catch((error) => {
+                this.logger.warn(`Failed to load addon kind '${kind}': ${error instanceof Error ? error.message : String(error)}. ` +
+                    `Registered kinds: ${this.registry.getKindNames().join(', ') || '(none)'}.`);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfAddonSlot, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: DfAddonSlot, isStandalone: true, selector: "df-addon-slot", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.slot": "slotAttr()", "class": "className()", "style.display": "isHidden() ? \"none\" : null" } }, ngImport: i0, template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: kindInputs()" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DfAddonSlot, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-addon-slot',
+                    imports: [NgComponentOutlet],
+                    template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: kindInputs()" />
+    }
+  `,
+                    host: {
+                        '[attr.slot]': 'slotAttr()',
+                        '[class]': 'className()',
+                        '[style.display]': 'isHidden() ? "none" : null',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }], hidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "hidden", required: false }] }] } });
+
+/**
+ * Pipe that handles dynamic text resolution with support for static strings,
+ * Observables, and Signals.
+ *
+ * Supports:
+ * - Static strings (pass-through)
+ * - Observables (subscribed internally)
+ * - Signals (converted to Observable using toObservable for reactivity)
+ *
+ * @example
+ * ```html
+ * <!-- Static string -->
+ * {{ 'Hello World' | dynamicText | async }}
+ *
+ * <!-- Observable -->
+ * {{ transloco.selectTranslate('key') | dynamicText | async }}
+ *
+ * <!-- Signal -->
+ * {{ myTextSignal | dynamicText | async }}
+ * ```
+ *
+ * @public
+ */
+class DynamicTextPipe {
+    injector = inject(Injector);
+    /**
+     * Transforms dynamic text input into a resolved string value
+     *
+     * @param value - The dynamic text value to resolve
+     * @returns The resolved string value as an Observable
+     */
+    transform(value) {
+        if (isObservable(value)) {
+            return value;
+        }
+        if (isSignal(value)) {
+            return toObservable(value, { injector: this.injector });
+        }
+        return of(value || '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, isStandalone: true, name: "dynamicText" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: DynamicTextPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dynamicText',
+                }]
+        }] });
+
+/**
+ * Renderer for the universal `text` addon kind.
+ *
+ * Renders the addon's `text` (a `DynamicText`) inside a span. Decorative —
+ * sets `aria-hidden="true"` on the host so screen readers skip it; users
+ * who need announcement should use a `*-button` kind with `ariaLabel` instead.
+ */
+class TextAddonComponent {
+    addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
+    /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
+    fieldInputs = input(...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: TextAddonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.14", type: TextAddonComponent, isStandalone: true, selector: "df-text-addon", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.aria-hidden": "\"true\"" } }, ngImport: i0, template: `<span>{{ addon().text | dynamicText | async }}</span>`, isInline: true, dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "pipe", type: DynamicTextPipe, name: "dynamicText" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: TextAddonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-text-addon',
+                    imports: [AsyncPipe, DynamicTextPipe],
+                    template: `<span>{{ addon().text | dynamicText | async }}</span>`,
+                    host: {
+                        '[attr.aria-hidden]': '"true"',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }] } });
+
+var textAddon_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    TextAddonComponent: TextAddonComponent
+});
+
+/**
+ * Renderer for the universal `template` addon kind.
+ *
+ * Resolves the addon's `templateKey` against {@link DF_FIELD_TEMPLATES}
+ * (populated by `<df-dynamic-form>` from `<ng-template dfTemplate="...">`
+ * children) and renders via `NgTemplateOutlet`. The wrapper-style host bag
+ * (`fieldInputs`) is forwarded as the template's implicit context — author
+ * the template as `<ng-template dfTemplate="..." let-fi>{{ fi.key }}</ng-template>`.
+ *
+ * If the key is unresolved, logs a warning and renders nothing — keeps the
+ * form alive when a backend references a template the FE has not registered.
+ */
+class TemplateAddonComponent {
+    templates = inject(DF_FIELD_TEMPLATES, { optional: true });
+    logger = inject(DynamicFormLogger);
+    addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
+    /** Forwarded by `df-addon-slot`; surfaced to the template as its implicit `$implicit` context. */
+    fieldInputs = input(...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+    // Pure computed: pure lookup, no side effects. Unresolved → null; the
+    // `@if` in the template skips the outlet and renders nothing.
+    template = computed(() => {
+        const map = this.templates?.();
+        const key = this.addon().templateKey;
+        return map?.get(key) ?? null;
+    }, ...(ngDevMode ? [{ debugName: "template" }] : /* istanbul ignore next */ []));
+    /** Implicit context payload — template authors bind via `let-fi`. */
+    outletContext = computed(() => ({ $implicit: this.fieldInputs() }), ...(ngDevMode ? [{ debugName: "outletContext" }] : /* istanbul ignore next */ []));
+    constructor() {
+        // Logging side effect lives in an effect, not the computed — keeps
+        // the computed pure so signal-graph evaluations don't duplicate warnings.
+        explicitEffect([this.template, this.addon], ([tpl, addon]) => {
+            if (!tpl) {
+                this.logger.warn(`Template addon: no <ng-template dfTemplate="${addon.templateKey}"> found. Did you project it as a child of <df-dynamic-form>?`);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: TemplateAddonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: TemplateAddonComponent, isStandalone: true, selector: "df-template-addon", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    @if (template(); as tpl) {
+      <ng-container *ngTemplateOutlet="tpl; context: outletContext()" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: TemplateAddonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-template-addon',
+                    imports: [NgTemplateOutlet],
+                    template: `
+    @if (template(); as tpl) {
+      <ng-container *ngTemplateOutlet="tpl; context: outletContext()" />
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }] } });
+
+var templateAddon_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    TemplateAddonComponent: TemplateAddonComponent
+});
+
+/**
+ * Renderer for the universal `component` addon kind.
+ *
+ * Loads the user-supplied component lazily (`addon.component()`) and renders
+ * it via `NgComponentOutlet` with `addon.inputs` forwarded as input bindings.
+ * The wrapper-style `fieldInputs` bag is not propagated — user components
+ * receive only what `addon.inputs` declares. Authors that need field state
+ * should switch to the `template` kind or build a wrapper.
+ *
+ * @codeOnly The `component` loader is a function; this kind is dropped in
+ * lenient validation when the config originated from JSON.
+ */
+class ComponentAddonComponent {
+    logger = inject(DynamicFormLogger);
+    addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
+    /** Accepted for contract uniformity — `NgComponentOutlet` setInput is strict; every kind must declare it. */
+    fieldInputs = input(...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+    inputs = computed(() => (this.addon().inputs ?? {}), ...(ngDevMode ? [{ debugName: "inputs" }] : /* istanbul ignore next */ []));
+    /**
+     * Latest async-loaded `{ addon, component }` pair. Tagging the result with
+     * its source addon lets `resolvedComponent` filter stale loads structurally
+     * — same kind-tagging pattern `DfAddonSlot` uses. When `addon` swaps
+     * mid-load, the prior loader still completes and writes here, but the
+     * computed ignores it because the recorded addon no longer matches the
+     * current one.
+     */
+    asyncLoaded = signal(undefined, ...(ngDevMode ? [{ debugName: "asyncLoaded" }] : /* istanbul ignore next */ []));
+    resolvedComponent = computed(() => {
+        const current = this.addon();
+        const loaded = this.asyncLoaded();
+        return loaded?.addon === current ? loaded.component : undefined;
+    }, ...(ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []));
+    constructor() {
+        explicitEffect([this.addon], ([addon]) => {
+            Promise.resolve(addon.component())
+                .then((mod) => {
+                const component = resolveDefaultExport(mod);
+                if (component)
+                    this.asyncLoaded.set({ addon, component });
+            })
+                .catch((error) => {
+                this.logger.warn(`Failed to load component addon (slot: '${addon.slot}'): ${error instanceof Error ? error.message : String(error)}`);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ComponentAddonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.14", type: ComponentAddonComponent, isStandalone: true, selector: "df-component-addon", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: inputs()" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ComponentAddonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-component-addon',
+                    imports: [NgComponentOutlet],
+                    template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: inputs()" />
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }] } });
+
+var componentAddon_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ComponentAddonComponent: ComponentAddonComponent
+});
+
+/**
+ * Apply a built-in preset action against the addon's host field. Shared
+ * across all adapters — each adapter's `ADDON_PRESET_HANDLER` provider
+ * delegates here.
+ *
+ * Presets that require adapter-specific UI mechanics (clipboard, type
+ * override) are best-effort — they no-op with a warning when the necessary
+ * collaborator isn't available (e.g., toggle-password-visibility outside an
+ * input field).
+ *
+ * @param adapterLabel Used in warnings — `'Material'` / `'Bootstrap'` / etc.
+ * @param fieldLabel   Used in warnings — `'mat-input'` / `'bs-input'` / etc.
+ */
+async function runPresetAction(preset, ctx, collaborators, adapterLabel, fieldLabel) {
+    // Guard against orphan dispatches — none of the built-in presets do
+    // anything useful without a host field, except `copy` and `paste` which
+    // only need the clipboard API. The canonical discriminant per the
+    // `AddonActionContext` discriminated union is `ctx.form` — non-null on
+    // the field-bound variant, null on the orphan variant. `field.key` was
+    // unreliable for nested-array scenarios where keys can legitimately be
+    // empty strings.
+    if (ctx.form === null && preset !== 'copy' && preset !== 'paste') {
+        collaborators.logger.warn(`preset '${String(preset)}' fired without a host field context — ignoring.`);
+        return;
+    }
+    switch (preset) {
+        case 'clear': {
+            // Preserve type semantics: strings clear to `''` (browser-friendly for
+            // input.value), everything else clears to `undefined` (numeric / object
+            // / date fields would otherwise become a string and break their type).
+            const next = typeof ctx.value === 'string' ? '' : undefined;
+            collaborators.fieldValueSetter?.(next);
+            return;
+        }
+        case 'reset': {
+            const defaultValue = collaborators.fieldDefaultValueGetter?.();
+            collaborators.fieldValueSetter?.(defaultValue !== undefined ? defaultValue : typeof ctx.value === 'string' ? '' : undefined);
+            return;
+        }
+        case 'paste': {
+            if (typeof navigator === 'undefined' || !navigator.clipboard) {
+                collaborators.logger.warn(`preset 'paste' requires a browser clipboard API (not available in this environment).`);
+                return;
+            }
+            try {
+                const text = await navigator.clipboard.readText();
+                collaborators.fieldValueSetter?.(text);
+            }
+            catch (error) {
+                collaborators.logger.warn(`preset 'paste' clipboard read failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        case 'copy': {
+            if (typeof navigator === 'undefined' || !navigator.clipboard) {
+                collaborators.logger.warn(`preset 'copy' requires a browser clipboard API (not available in this environment).`);
+                return;
+            }
+            try {
+                // Explicit null check — `String(null) === 'null'` would write the
+                // literal string "null" to the clipboard.
+                const v = ctx.value;
+                await navigator.clipboard.writeText(v == null ? '' : String(v));
+            }
+            catch (error) {
+                collaborators.logger.warn(`preset 'copy' clipboard write failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        case 'toggle-password-visibility': {
+            const override = collaborators.typeOverride;
+            if (!override) {
+                collaborators.logger.warn(`preset 'toggle-password-visibility' has no effect outside a '${fieldLabel}' field.`);
+                return;
+            }
+            // Refuse to flip non-password inputs. Re-check on EVERY dispatch (not
+            // just when override is undefined) because `props().type` can change
+            // reactively after the first toggle — e.g., 'password' → 'email'. Once
+            // the override is touched, only the override is canonical for the
+            // current visible/hidden state; the baseline still gates whether
+            // toggling makes semantic sense for this field.
+            const baseline = collaborators.baselineType?.();
+            if (baseline !== undefined && baseline !== 'password') {
+                collaborators.logger.warn(`preset 'toggle-password-visibility' refused: host '${fieldLabel}' has type '${baseline}', not 'password'.`);
+                return;
+            }
+            const current = override();
+            override.set(current === 'text' ? 'password' : 'text');
+            return;
+        }
+        default:
+            collaborators.logger.warn(`preset '${String(preset)}' is not implemented in the ${adapterLabel} adapter.`);
+    }
+}
+
+/**
+ * Walk `FIELD_REGISTRY` and return every field type that opted into addons
+ * (i.e., declared `addons` on its `FieldTypeDefinition`).
+ *
+ * Useful for tooling — admin UIs surfacing "which fields can carry addons?",
+ * docs generators, MCP server cross-checks. Field types without an `addons`
+ * registration ("Tier 3" — toggle, checkbox, radio, slider) are excluded.
+ *
+ * Must be called within an injection context.
+ *
+ * @example
+ * ```typescript
+ * @Component({ ... })
+ * class FormBuilder {
+ *   protected readonly addonable = injectFieldsSupportingAddons();
+ *
+ *   constructor() {
+ *     // -> [{ name: 'prime-input', slots: ['prefix', 'suffix'], allowedKinds: [...] }, ...]
+ *   }
+ * }
+ * ```
+ */
+function injectFieldsSupportingAddons() {
+    const registry = inject(FIELD_REGISTRY);
+    const entries = [];
+    for (const [name, def] of registry.entries()) {
+        if (def.addons === undefined)
+            continue;
+        entries.push({ name, slots: def.addons.slots, allowedKinds: def.addons.allowedKinds });
+    }
+    return entries;
+}
+
+/**
+ * Register a custom addon kind with the form.
+ *
+ * The provided definition is added to `ADDON_KIND_REGISTRY` at form
+ * initialisation, alongside the built-in `text` / `template` / `component`
+ * kinds and any kinds contributed by adapter feature helpers
+ * (`withPrimeNGAddons()` etc.).
+ *
+ * @example
+ * ```typescript
+ * provideDynamicForm(
+ *   ...withMaterialFields(),
+ *   withCustomAddon({
+ *     kind: 'lucide-icon',
+ *     // Match how field types register: a default-exported component lets
+ *     // `loadComponent` return the import promise directly.
+ *     loadComponent: () => import('./lucide-icon-addon.component'),
+ *     validate: (addon) => {
+ *       if (typeof addon.icon !== 'string') {
+ *         throw new Error('lucide-icon: icon string is required');
+ *       }
+ *     },
+ *   }),
+ * );
+ * ```
+ *
+ * Multiple `withCustomAddon(...)` calls are supported; later registrations
+ * for the same kind override earlier ones (with a warning logged).
+ */
+function withCustomAddon(definition) {
+    return createFeature('addons', [
+        {
+            provide: ADDON_KIND_DEFINITIONS,
+            useValue: definition,
+            multi: true,
+        },
+    ]);
+}
+
+/**
+ * Register named action handlers reachable via JSON-driven addon configs.
+ *
+ * Once registered, a backend can ship
+ * `{ kind: 'prime-button', actionRef: 'openProfile' }` and the FE will invoke
+ * the corresponding handler at click time.
+ *
+ * Define handlers once and augment the registry from the same object:
+ *
+ * ```typescript
+ * export const appActions = provideAddonActions({
+ *   openProfile: (ctx) => modalService.open(ProfileModal, { data: ctx.value }),
+ *   runWorkflow: (ctx) => workflowService.run(ctx.field.key, ctx.value),
+ * });
+ *
+ * declare module '@ng-forge/dynamic-forms' {
+ *   // Pulls the keys straight off `appActions` — no manual list to keep in sync.
+ *   interface DynamicFormActionRegistry extends Record<NonNullable<typeof appActions['__handlerKeys']>, true> {}
+ * }
+ *
+ * // Then in your bootstrap:
+ * provideDynamicForm(...withPrimeNGFields(), appActions);
+ * ```
+ *
+ * Multiple `provideAddonActions(...)` calls are merged; later names override
+ * earlier ones for the same key.
+ */
+function provideAddonActions(handlers) {
+    return createFeature('addon-actions', [
+        {
+            provide: ADDON_ACTION_HANDLERS,
+            useValue: handlers,
+            multi: true,
+        },
+    ]);
+}
+
+/**
+ * Walk a `FormConfig`, validate every field's addons against the active
+ * `FIELD_REGISTRY` and `ADDON_KIND_REGISTRY`, and return a sanitized copy
+ * plus a list of dropped-addon warnings.
+ *
+ * Distinct from the INTERNAL `validateFormConfig` in
+ * `utils/config-validation/config-validator.ts` (which throws on
+ * structural errors like duplicate keys / unknown field types). This
+ * helper is the PUBLIC, lenient addon-shape pass — renamed to
+ * `sanitizeFormConfig` to avoid the name collision.
+ *
+ * Lenient by design: invalid addons are dropped (with warnings) rather than
+ * thrown. The form keeps rendering even when the backend ships an addon the
+ * FE doesn't understand.
+ *
+ * `<df-dynamic-form>` already runs this internally at form init — calling
+ * the public helper AND passing the original config to the form will
+ * double-emit warnings. Use this entry point only when you need the
+ * sanitized config or warning list outside the form (e.g., admin-UI
+ * diagnostics, build-time lints).
+ *
+ * Must be called within an Angular injection context — typically inside
+ * an admin-UI component or a `runInInjectionContext()` block on the server.
+ *
+ * @example
+ * ```typescript
+ * @Component({ ... })
+ * class AdminFormBuilder {
+ *   private readonly check = (cfg: FormConfig) => {
+ *     const { sanitized, warnings } = sanitizeFormConfig(cfg, { source: 'json' });
+ *     if (warnings.length > 0) {
+ *       this.diagnostics.set(warnings);
+ *     }
+ *     return sanitized;
+ *   };
+ * }
+ * ```
+ */
+function sanitizeFormConfig(config, options = {}) {
+    const fieldRegistry = inject(FIELD_REGISTRY);
+    const kindRegistry = inject(ADDON_KIND_REGISTRY);
+    const source = options.source ?? 'inline';
+    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, kindRegistry, source);
+    return {
+        sanitized: { ...config, fields: fields },
+        warnings,
+    };
+}
+/**
+ * Default warning sink. Pass a `DynamicFormLogger` to route through the
+ * form's configured logger (respects `NoopLogger` opt-out); omit it to
+ * fall back to `console.warn` for build-time / admin-UI use cases that
+ * run outside an Angular injection context.
+ */
+function logAddonWarnings(warnings, logger) {
+    for (const w of warnings) {
+        if (logger) {
+            logger.warn(formatAddonWarning(w));
+        }
+        else {
+            console.warn('[Dynamic Forms]', formatAddonWarning(w));
+        }
+    }
+}
+/**
+ * DI-free variant of {@link sanitizeFormConfig} for tooling that lives
+ * outside Angular's injector — build-time linters, MCP-side checks, CLI
+ * scripts.
+ *
+ * Caller passes the registries explicitly; the result has the same shape
+ * as the DI-bound version.
+ */
+function sanitizeFormConfigPure(config, fieldRegistry, kindRegistry, options = {}) {
+    const source = options.source ?? 'inline';
+    const { fields, warnings } = walkAndValidateAddons((config.fields ?? []), fieldRegistry, kindRegistry, source);
+    return { sanitized: { ...config, fields: fields }, warnings };
+}
+
 function isValueField(field) {
     // `nullable: true` without an explicit `value` is still a value-bearing declaration:
     // the field resolves to `null` at runtime. Treating it as a value field keeps
@@ -15695,7 +18132,7 @@ function isValueField(field) {
 }
 
 function isCheckedField(field) {
-    return field.type === 'checkbox';
+    return field.type === 'checkbox' || field.type === 'toggle';
 }
 
 /**
@@ -16201,56 +18638,6 @@ function applyMetaToElement(element, meta, previouslyApplied) {
     return newApplied;
 }
 
-/**
- * Pipe that handles dynamic text resolution with support for static strings,
- * Observables, and Signals.
- *
- * Supports:
- * - Static strings (pass-through)
- * - Observables (subscribed internally)
- * - Signals (converted to Observable using toObservable for reactivity)
- *
- * @example
- * ```html
- * <!-- Static string -->
- * {{ 'Hello World' | dynamicText | async }}
- *
- * <!-- Observable -->
- * {{ transloco.selectTranslate('key') | dynamicText | async }}
- *
- * <!-- Signal -->
- * {{ myTextSignal | dynamicText | async }}
- * ```
- *
- * @public
- */
-class DynamicTextPipe {
-    injector = inject(Injector);
-    /**
-     * Transforms dynamic text input into a resolved string value
-     *
-     * @param value - The dynamic text value to resolve
-     * @returns The resolved string value as an Observable
-     */
-    transform(value) {
-        if (isObservable(value)) {
-            return value;
-        }
-        if (isSignal(value)) {
-            return toObservable(value, { injector: this.injector });
-        }
-        return of(value || '');
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DynamicTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.8", ngImport: i0, type: DynamicTextPipe, isStandalone: true, name: "dynamicText" });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: DynamicTextPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'dynamicText',
-                }]
-        }] });
-
 /**
  * Interpolates {{param}} placeholders in message with error values
  *
@@ -16382,5 +18769,5 @@ function extractErrorParams(error) {
  * Generated bundle index. Do not edit.
  */
 
-export { SubmitEvent as $, ARRAY_CONTEXT as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DynamicFormLogger as D, EventBus as E, FIELD_SIGNAL_CONTEXT as F, DEFAULT_VALIDATION_MESSAGES as G, DynamicForm as H, DynamicFormError as I, EventDispatcher as J, FIELD_REGISTRY as K, FORM_OPTIONS as L, FormClearEvent as M, FormResetEvent as N, INITIALIZATION_TIMEOUT_MS as O, InsertArrayItemEvent as P, MoveArrayItemEvent as Q, RootFormRegistryService as R, NextPageEvent as S, NoopLogger as T, PageChangeEvent as U, PopArrayItemEvent as V, WRAPPER_AUTO_ASSOCIATIONS as W, PrependArrayItemEvent as X, PreviousPageEvent as Y, RemoveAtIndexEvent as Z, ShiftArrayItemEvent as _, DEFAULT_WRAPPERS as a, WRAPPER_REGISTRY as a0, applyMetaToElement as a1, applyValidator as a2, applyValidators as a3, arrayEvent as a4, arrayFieldMapper as a5, baseFieldMapper as a6, buildBaseInputs as a7, containerFieldMapper as a8, createField as a9, resolveNextButtonDisabled as aA, resolveNonFieldDisabled as aB, resolveNonFieldHidden as aC, resolveSubmitButtonDisabled as aD, resolveTokens as aE, rowFieldMapper as aF, textFieldMapper as aG, toReadonlyFieldTree as aH, withEventFormValue as aI, withLoggerConfig as aJ, withPreviousValue as aK, withValidationExecutionDefaults as aL, withValueExclusionDefaults as aM, wrapperProps as aN, createWrappers as aa, evaluateNonFieldDisabled as ab, evaluateNonFieldHidden as ac, field as ad, formConfig as ae, getArrayLength as af, groupFieldMapper as ag, hasFormValue as ah, interpolateParams as ai, isArrayField as aj, isCheckedField as ak, isContainerField as al, isContainerTypedField as am, isDisplayOnlyField as an, isFormStateCondition as ao, isLeafField as ap, isPageField as aq, isRowField as ar, isSimplifiedArrayField as as, isValueBearingField as at, isValueField as au, isWrapperTypeDefinition as av, isWrappersBundle as aw, omit as ax, pageFieldMapper as ay, provideDynamicForm as az, isSameWrapperChain as b, createFieldResolutionPipe as c, derivedFromDeferred as d, createWrapperChainController as e, DfFieldOutlet as f, isEqual as g, createSchemaFromFields as h, injectFieldRegistry as i, createRenderReadySignal as j, ARRAY_TEMPLATE_REGISTRY as k, ARRAY_ITEM_ID_GENERATOR as l, mapFieldToInputs as m, getNormalizedArrayMetadata as n, getFieldValueHandling as o, getFieldDefaultValue as p, isGroupField as q, resolveWrappers as r, createArrayItemIdGenerator as s, ComponentInitializedEvent as t, DynamicTextPipe as u, validatePageNesting as v, dynamicTextToObservable as w, AppendArrayItemEvent as x, ConsoleLogger as y, DEFAULT_PROPS as z };
-//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-CfbmSRM_.mjs.map
+export { arrayFieldMapper as $, ADDON_ACTION_HANDLERS as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DEFAULT_PROPS as D, EventBus as E, FIELD_REGISTRY as F, GROUP_CONTEXT as G, NoopLogger as H, INITIALIZATION_TIMEOUT_MS as I, PopArrayItemEvent as J, PrependArrayItemEvent as K, PreviousPageEvent as L, MoveArrayItemEvent as M, NextPageEvent as N, RootFormRegistryService as O, PageChangeEvent as P, SubmitEvent as Q, RemoveAtIndexEvent as R, ShiftArrayItemEvent as S, TemplateAddonComponent as T, TextAddonComponent as U, WRAPPER_REGISTRY as V, WRAPPER_AUTO_ASSOCIATIONS as W, applyMetaToElement as X, applyValidator as Y, applyValidators as Z, arrayEvent as _, ADDON_ACTION_REGISTRY as a, textFieldMapper as a$, baseFieldMapper as a0, buildBaseInputs as a1, containerFieldMapper as a2, createField as a3, createFieldResolutionPipe as a4, createHiddenSignal as a5, createRenderReadySignal as a6, createSchemaFromFields as a7, createWrapperChainController as a8, createWrappers as a9, isGroupField as aA, isLeafField as aB, isPageField as aC, isRowField as aD, isSameWrapperChain as aE, isSimplifiedArrayField as aF, isValueBearingField as aG, isValueField as aH, isWrapperTypeDefinition as aI, isWrappersBundle as aJ, logAddonWarnings as aK, mapFieldToInputs as aL, omit as aM, pageFieldMapper as aN, provideAddonActions as aO, provideDynamicForm as aP, resolveDynamicValue as aQ, resolveNextButtonDisabled as aR, resolveNonFieldDisabled as aS, resolveNonFieldHidden as aT, resolveSubmitButtonDisabled as aU, resolveTokens as aV, resolveWrappers as aW, rowFieldMapper as aX, runPresetAction as aY, sanitizeFormConfig as aZ, sanitizeFormConfigPure as a_, derivedFromDeferred as aa, dynamicTextToObservable as ab, evaluateNonFieldDisabled as ac, evaluateNonFieldHidden as ad, field as ae, formConfig as af, formatAddonWarning as ag, getArrayLength as ah, getFieldDefaultValue as ai, getFieldValueHandling as aj, getNormalizedArrayMetadata as ak, groupFieldMapper as al, hasFormValue as am, injectAddonKindRegistry as an, injectFieldRegistry as ao, injectFieldSignalContext as ap, injectFieldsSupportingAddons as aq, interpolateParams as ar, isArrayField as as, isCheckedField as at, isContainerField as au, isContainerTypedField as av, isDisplayOnlyField as aw, isEqual as ax, isFieldBoundContext as ay, isFormStateCondition as az, ADDON_KIND_COMPONENT_CACHE as b, toReadonlyFieldTree as b0, validateFieldAddons as b1, validatePageNesting as b2, walkAndValidateAddons as b3, withCustomAddon as b4, withEventFormValue as b5, withLegacyStatusClasses as b6, withLoggerConfig as b7, withPreviousValue as b8, withValidationExecutionDefaults as b9, withValueExclusionDefaults as ba, wrapperProps as bb, writeToFieldValue as bc, ADDON_KIND_DEFINITIONS as c, ADDON_KIND_REGISTRY as d, ARRAY_CONTEXT as e, AppendArrayItemEvent as f, ArrayItemRegistryService as g, ComponentAddonComponent as h, ComponentInitializedEvent as i, ConsoleLogger as j, DEFAULT_VALIDATION_MESSAGES as k, DEFAULT_WRAPPERS as l, DF_FIELD_TEMPLATES as m, DfAddonSlot as n, DfFieldOutlet as o, DfTemplate as p, DynamicForm as q, DynamicFormError as r, DynamicFormLogger as s, DynamicTextPipe as t, EventDispatcher as u, FIELD_SIGNAL_CONTEXT as v, FORM_OPTIONS as w, FormClearEvent as x, FormResetEvent as y, InsertArrayItemEvent as z };
+//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms--PuL0AKc.mjs.map