@ng-forge/dynamic-forms 0.10.0-next.3 → 0.10.0-next.4

package/fesm2022/{ng-forge-dynamic-forms-ng-forge-dynamic-forms-CPkVjU_N.mjs → ng-forge-dynamic-forms-ng-forge-dynamic-forms-CNc4a_Xv.mjs}

@@ -1,58 +1,16 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, reflectComponentType, Injector, EnvironmentInjector, DestroyRef, computed, signal, input, ViewContainerRef, Directive, Injectable, isSignal, untracked, linkedSignal, ChangeDetectionStrategy, Component, resourceFromSnapshots, runInInjectionContext, afterNextRender, ElementRef, PLATFORM_ID, isDevMode, isWritableSignal, TemplateRef, model, contentChildren, makeEnvironmentProviders, Pipe } from '@angular/core';
+import { reflectComponentType, Injector, inject, EnvironmentInjector, DestroyRef, computed, signal, input, ViewContainerRef, Directive, linkedSignal, ChangeDetectionStrategy, Component, InjectionToken, Injectable, isSignal, runInInjectionContext, afterNextRender, untracked, ElementRef, PLATFORM_ID, isDevMode, isWritableSignal, TemplateRef, model, contentChildren, makeEnvironmentProviders } from '@angular/core';
 import { explicitEffect } from 'ngxtension/explicit-effect';
-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, pairwise, merge, 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 { DynamicFormLogger, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, toReadonlyFieldTreeCached, writeToFieldValue, WRAPPER_AUTO_ASSOCIATIONS, DEFAULT_WRAPPERS, READONLY_FIELD_TREE_CACHE, EventBus, FieldContextRegistryService, FunctionRegistryService, FORM_OPTIONS, evaluateCondition, FIELD_SIGNAL_CONTEXT, isRowField, isContainerField, isArrayField, hasChildFields, isSimplifiedArrayField, DynamicFormError, isStateLogicConfig, isDerivationLogicConfig, createDebouncedLogicFunction, createLogicFunction, ExpressionParser, applyValidator, isPageField, isContainerTypedField, isGroupField, getFieldValueHandling, normalizeFieldsArray, getNestedValue, isCrossFieldValidator, extractStringDependencies, isCrossFieldBuiltInValidator, hasCrossFieldWhenCondition, extractExpressionDependencies, isCrossFieldStateLogic, isCrossFieldSchema, keyBy, mapValues, isEqual, hasTargetProperty, ARRAY_CONTEXT, GROUP_CONTEXT, FORM_ID_PREFIX, baseFieldMapper, detectFormMode, validatePageNesting, FIELD_REGISTRY, assertNever, ADDON_KIND_REGISTRY, deepMergeDefaults, derivedFromDeferred, createWarningTracker, createFormFieldStateMap, readFieldStateInfo, getChangedKeys, resolveHttpRequest, createDefaultDerivationLogConfig, shouldLog, NoopLogger, RootFormRegistryService, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, EXTERNAL_DATA, DEPRECATION_WARNING_TRACKER, HttpConditionCache, HTTP_CONDITION_CACHE, HttpConditionFunctionCacheService, AsyncConditionFunctionCacheService, DynamicValueFunctionCacheService, LogicFunctionCacheService, setupInitializationTracking, ComponentInitializedEvent, DF_FIELD_TEMPLATES, rowFieldMapper, groupFieldMapper, arrayFieldMapper, pageFieldMapper, textFieldMapper, containerFieldMapper, isWrapperTypeDefinition, EMIT_FORM_VALUE_ON_EVENTS, resolveDynamicValue, DynamicTextPipe } from '@ng-forge/dynamic-forms/internal';
+import { takeUntilDestroyed, toObservable, toSignal, outputFromObservable } from '@angular/core/rxjs-interop';
+import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, debounceTime, distinctUntilChanged, tap, pipe, scan, Observable, Subject, concatMap, filter, take, startWith, pairwise, merge, combineLatestWith, auditTime, scheduled, queueScheduler, timer } from 'rxjs';
+import { submit, required, disabled, readonly, hidden, applyEach, applyWhenValue, applyWhen, apply, email, minLength, maxLength, pattern, min, max, schema, validateStandardSchema, validateTree, form, provideSignalFormsConfig } from '@angular/forms/signals';
 import { isStandardSchemaMarker } from '@ng-forge/dynamic-forms/schema';
 import { isPlatformBrowser, NgComponentOutlet, AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { catchError as catchError$1 } from 'rxjs/operators';
 import { NG_STATUS_CLASSES } from '@angular/forms/signals/compat';
 
-function isWrapperTypeDefinition(value) {
-    return typeof value === 'object' && value !== null && 'wrapperName' in value;
-}
-const WRAPPER_REGISTRY = new InjectionToken('WRAPPER_REGISTRY', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-const WRAPPER_COMPONENT_CACHE = new InjectionToken('WRAPPER_COMPONENT_CACHE', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-const WRAPPER_AUTO_ASSOCIATIONS = new InjectionToken('WRAPPER_AUTO_ASSOCIATIONS', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-
-class DynamicFormError extends Error {
-    static PREFIX = '[Dynamic Forms]';
-    constructor(message) {
-        super(`${DynamicFormError.PREFIX} ${message}`);
-        this.name = 'DynamicFormError';
-    }
-}
-
-const DEFAULT_WRAPPERS = new InjectionToken('DEFAULT_WRAPPERS');
-const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT');
-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;
-}
-const ARRAY_CONTEXT = new InjectionToken('ARRAY_CONTEXT');
-const GROUP_CONTEXT = new InjectionToken('GROUP_CONTEXT');
-const DEFAULT_PROPS = new InjectionToken('DEFAULT_PROPS');
-const DEFAULT_VALIDATION_MESSAGES = new InjectionToken('DEFAULT_VALIDATION_MESSAGES');
-const FORM_OPTIONS = new InjectionToken('FORM_OPTIONS');
-const EXTERNAL_DATA = new InjectionToken('EXTERNAL_DATA');
-const FORM_ID_PREFIX = new InjectionToken('FORM_ID_PREFIX');
-
-const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
-
 const EMPTY_WRAPPERS = Object.freeze([]);
 function isSameWrapperChain(a, b) {
     if (a === b)
@@ -283,47 +241,6 @@ function pushFieldInputsOnChange(opts, getRefs) {
     });
 }
 
-function getArrayLength(arrayFieldTree) {
-    const value = arrayFieldTree().value();
-    return Array.isArray(value) ? value.length : 0;
-}
-function toReadonlyFieldTree(field) {
-    const state = field();
-    return {
-        value: state.value,
-        valid: state.valid,
-        invalid: state.invalid,
-        touched: state.touched,
-        dirty: state.dirty,
-        required: state.required,
-        disabled: state.disabled,
-        hidden: state.hidden,
-        errors: state.errors,
-    };
-}
-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;
-}
-const READONLY_FIELD_TREE_CACHE = new InjectionToken('READONLY_FIELD_TREE_CACHE', {
-    providedIn: 'root',
-    factory: () => new WeakMap(),
-});
-function toReadonlyFieldTreeCached(cache, field) {
-    const key = field;
-    const cached = cache.get(key);
-    if (cached)
-        return cached;
-    const view = toReadonlyFieldTree(field);
-    cache.set(key, view);
-    return view;
-}
-
 function buildFieldInputs(rawInputs, cache, fieldType) {
     const fieldTreeCandidate = rawInputs['field'];
             const hasFieldTree = fieldTreeCandidate !== undefined && typeof fieldTreeCandidate === 'function';
@@ -498,212 +415,10 @@ function createSubmissionHandler(options) {
     }));
 }
 
-const EMIT_FORM_VALUE_ON_EVENTS = new InjectionToken('EMIT_FORM_VALUE_ON_EVENTS', {
-    providedIn: 'root',
-    factory: () => false,
-});
-
-class RootFormRegistryService {
-    formValue;
-    rootForm;
-    constructor(formValue, rootForm) {
-        this.formValue = formValue;
-        this.rootForm = rootForm;
-    }
-}
-
-class NoopLogger {
-    debug() {
-            }
-    info() {
-            }
-    warn() {
-            }
-    error() {
-            }
-}
-
-function safeInjectToken(token, defaultValue) {
-    try {
-        return inject(token, { optional: true }) ?? defaultValue;
-    }
-    catch {
-        return defaultValue;
-    }
-}
-function safeInjectClass(token, defaultValue) {
-    try {
-        return inject(token, { optional: true }) ?? defaultValue;
-    }
-    catch {
-        return defaultValue;
-    }
-}
-function attachFormValue(event, formValue) {
-    const prototype = Object.getPrototypeOf(event);
-    return Object.assign(Object.create(prototype), event, { formValue });
-}
-const FALLBACK_LOGGER = new NoopLogger();
-class EventBus {
-    pipeline$ = new Subject();
-    globalEmitFormValue = safeInjectToken(EMIT_FORM_VALUE_ON_EVENTS, false);
-    rootFormRegistry = safeInjectClass(RootFormRegistryService, null);
-    formOptions = safeInjectToken(FORM_OPTIONS, null);
-    logger = safeInjectToken(DynamicFormLogger, FALLBACK_LOGGER);
-    events$ = this.pipeline$.asObservable();
-    dispatch(eventOrConstructor, ...args) {
-        if (typeof eventOrConstructor !== 'function' && 'type' in eventOrConstructor) {
-            this.emit(eventOrConstructor);
-        }
-        else {
-            this.emit(new eventOrConstructor(...args));
-        }
-    }
-        emitInstance(event) {
-        this.emit(event);
-    }
-        emit(event) {
-        if (this.shouldEmitFormValue()) {
-            const formValue = this.rootFormRegistry?.formValue();
-                                    if (formValue && Object.keys(formValue).length > 0) {
-                this.safeEmit(attachFormValue(event, formValue));
-                return;
-            }
-        }
-        this.safeEmit(event);
-    }
-        safeEmit(event) {
-        try {
-            this.pipeline$.next(event);
-        }
-        catch (err) {
-            this.logger.error('Exception in EventBus subscriber during dispatch', err);
-        }
-    }
-        shouldEmitFormValue() {
-        const formLevelSetting = this.formOptions?.()?.emitFormValueOnEvents;
-        return formLevelSetting ?? this.globalEmitFormValue;
-    }
-        on(eventType) {
-        if (Array.isArray(eventType)) {
-            return this.pipeline$.pipe(filter((event) => eventType.includes(event.type)));
-        }
-        return this.pipeline$.pipe(filter((event) => event.type === eventType));
-    }
-    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.14", ngImport: i0, type: EventBus, decorators: [{
-            type: Injectable
-        }] });
-
 class SubmitEvent {
     type = 'submit';
 }
 
-class ComponentInitializedEvent {
-    componentType;
-    componentId;
-    type = 'component-initialized';
-    constructor(componentType, componentId) {
-        this.componentType = componentType;
-        this.componentId = componentId;
-    }
-}
-
-const INITIALIZATION_TIMEOUT_MS = new InjectionToken('INITIALIZATION_TIMEOUT_MS', {
-    providedIn: 'root',
-    factory: () => 10_000,
-});
-function createInitializationTracker(eventBus, expectedCount) {
-    return eventBus.on('component-initialized').pipe(scan((count) => count + 1, 0), map$1((currentCount) => currentCount >= expectedCount), filter$1((isComplete) => isComplete));
-}
-function setupInitializationTracking(options) {
-    const { eventBus, totalComponentsCount, injector, componentId } = options;
-    const timeoutMs = injector.get(INITIALIZATION_TIMEOUT_MS);
-    const logger = injector.get(DynamicFormLogger);
-    return toObservable(totalComponentsCount, { injector }).pipe(take(1), switchMap$1((count) => {
-        const tracking$ = count === 1
-            ?                 eventBus.on('component-initialized').pipe(filter$1((event) => event.componentType === 'dynamic-form' && event.componentId === componentId), map$1(() => true), take(1))
-            : createInitializationTracker(eventBus, count);
-                return tracking$.pipe(timeout(timeoutMs), catchError$1((error) => {
-            if (error instanceof TimeoutError) {
-                logger.warn(`Initialization timed out after ${timeoutMs}ms. ` +
-                    `Expected ${count} component(s) to initialize but not all reported in time. ` +
-                    'This may indicate a container component threw during initialization. ' +
-                    'Emitting (initialized) as best-effort.');
-                                return of(true);
-            }
-            return throwError(() => error);
-        }));
-    }), shareReplay({ bufferSize: 1, refCount: false }));
-}
-
-function isRowField(field) {
-    return field.type === 'row' && 'fields' in field && Array.isArray(field.fields);
-}
-
-function isGroupField(field) {
-    return field.type === 'group' && 'fields' in field;
-}
-
-function isContainerTypedField(field) {
-    return (field.type === 'container' &&
-        'wrappers' in field &&
-        'fields' in field &&
-        Array.isArray(field.wrappers) &&
-        Array.isArray(field.fields));
-}
-
-function isPageField(field) {
-    return field.type === 'page' && 'fields' in field && Array.isArray(field.fields);
-}
-function validatePageNesting(pageField) {
-    return !hasNestedPages(pageField.fields);
-}
-function isContainerWithFields$1(field) {
-    return ((isRowField(field) || isGroupField(field) || isContainerTypedField(field)) &&
-        'fields' in field &&
-        Array.isArray(field.fields));
-}
-function hasNestedPages(fields) {
-    for (const field of fields) {
-        if (isPageField(field)) {
-            return true;
-        }
-                if (isContainerWithFields$1(field)) {
-            if (hasNestedPages(field.fields)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-function isArrayField(field) {
-    return field.type === 'array' && 'fields' in field && Array.isArray(field.fields);
-}
-function isSimplifiedArrayField(field) {
-    return field.type === 'array' && 'template' in field;
-}
-
-function hasChildFields(field) {
-    return 'fields' in field && field.fields != null;
-}
-const CONTAINER_TYPES$1 = new Set(['page', 'row', 'group', 'array', 'container']);
-function isContainerField(field) {
-    return CONTAINER_TYPES$1.has(field.type);
-}
-function isLeafField(field) {
-    return !isContainerField(field);
-}
-function isValueBearingField(field) {
-    return 'value' in field;
-}
-function isDisplayOnlyField(field) {
-    return field.type === 'text' || isContainerField(field);
-}
-
 class NextPageEvent {
     type = 'next-page';
 }
@@ -827,2941 +542,561 @@ class PageNavigationStateChangeEvent {
     }
 }
 
-function compareValues(actual, expected, operator) {
-    switch (operator) {
-        case 'equals':
-            return actual === expected;
-        case 'notEquals':
-            return actual !== expected;
-        case 'greater':
-            return Number(actual) > Number(expected);
-        case 'less':
-            return Number(actual) < Number(expected);
-        case 'greaterOrEqual':
-            return Number(actual) >= Number(expected);
-        case 'lessOrEqual':
-            return Number(actual) <= Number(expected);
-        case 'contains':
-            return String(actual).includes(String(expected));
-        case 'startsWith':
-            return String(actual).startsWith(String(expected));
-        case 'endsWith':
-            return String(actual).endsWith(String(expected));
-        case 'matches':
-            try {
-                return new RegExp(String(expected)).test(String(actual));
-            }
-            catch {
-                return false;
-            }
-        default:
-            return false;
-    }
-}
-function getNestedValue(obj, path) {
-    return path.split('.').reduce((current, key) => {
-        return current && typeof current === 'object' ? current[key] : undefined;
-    }, obj);
-}
-function hasNestedProperty(obj, path) {
-    const keys = path.split('.');
-    let current = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
-        if (!current || typeof current !== 'object')
-            return false;
-        current = current[keys[i]];
-    }
-    if (!current || typeof current !== 'object')
-        return false;
-    return keys[keys.length - 1] in current;
-}
-
-var TokenType;
-(function (TokenType) {
-        TokenType["NUMBER"] = "NUMBER";
-    TokenType["STRING"] = "STRING";
-    TokenType["TRUE"] = "TRUE";
-    TokenType["FALSE"] = "FALSE";
-    TokenType["NULL"] = "NULL";
-    TokenType["UNDEFINED"] = "UNDEFINED";
-        TokenType["IDENTIFIER"] = "IDENTIFIER";
-        TokenType["PLUS"] = "PLUS";
-    TokenType["MINUS"] = "MINUS";
-    TokenType["MULTIPLY"] = "MULTIPLY";
-    TokenType["DIVIDE"] = "DIVIDE";
-    TokenType["MODULO"] = "MODULO";
-        TokenType["EQUAL"] = "EQUAL";
-    TokenType["NOT_EQUAL"] = "NOT_EQUAL";
-    TokenType["GREATER"] = "GREATER";
-    TokenType["LESS"] = "LESS";
-    TokenType["GREATER_EQUAL"] = "GREATER_EQUAL";
-    TokenType["LESS_EQUAL"] = "LESS_EQUAL";
-        TokenType["AND"] = "AND";
-    TokenType["OR"] = "OR";
-    TokenType["NOT"] = "NOT";
-        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";
-        TokenType["EOF"] = "EOF";
-})(TokenType || (TokenType = {}));
-class ExpressionParserError extends DynamicFormError {
-    position;
-    expression;
-    constructor(message, position, expression) {
-        super(`${message} at position ${position} in expression: ${expression}`);
-        this.position = position;
-        this.expression = expression;
-        this.name = 'ExpressionParserError';
-    }
-}
-
-class Tokenizer {
-    position = 0;
-    expression;
-    constructor(expression) {
-        this.expression = expression;
-    }
-        tokenize() {
-        const tokens = [];
-        while (this.position < this.expression.length) {
-            this.skipWhitespace();
-            if (this.position >= this.expression.length) {
-                break;
-            }
-            const token = this.nextToken();
-            tokens.push(token);
-        }
-        tokens.push({ type: TokenType.EOF, value: '', position: this.position });
-        return tokens;
-    }
-    skipWhitespace() {
-        while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
-            this.position++;
-        }
-    }
-    nextToken() {
-        const char = this.expression[this.position];
-                if (char === '"' || char === "'") {
-            return this.readString(char);
-        }
-                if (/[0-9]/.test(char)) {
-            return this.readNumber();
-        }
-                if (/[a-zA-Z_$]/.test(char)) {
-            return this.readIdentifierOrKeyword();
-        }
-                return this.readOperatorOrPunctuation();
-    }
-    readString(quote) {
-        const start = this.position;
-        this.position++;         let value = '';
-        while (this.position < this.expression.length) {
-            const char = this.expression[this.position];
-            if (char === quote) {
-                this.position++;                 return { type: TokenType.STRING, value, position: start };
-            }
-            if (char === '\\' && this.position + 1 < this.expression.length) {
-                                this.position++;
-                const nextChar = this.expression[this.position];
-                switch (nextChar) {
-                    case 'n':
-                        value += '\n';
-                        break;
-                    case 't':
-                        value += '\t';
-                        break;
-                    case 'r':
-                        value += '\r';
-                        break;
-                    case '\\':
-                        value += '\\';
-                        break;
-                    case quote:
-                        value += quote;
-                        break;
-                    default:
-                        value += nextChar;
+class PageOrchestratorComponent {
+    eventBus = inject(EventBus);
+    fieldContextRegistry = inject(FieldContextRegistryService);
+    functionRegistry = inject(FunctionRegistryService);
+    formOptions = inject(FORM_OPTIONS, { optional: true });
+        pageFields = input.required(...(ngDevMode ? [{ debugName: "pageFields" }] : /* istanbul ignore next */ []));
+        form = input.required(...(ngDevMode ? [{ debugName: "form" }] : /* istanbul ignore next */ []));
+            fieldSignalContext = input.required(...(ngDevMode ? [{ debugName: "fieldSignalContext" }] : /* istanbul ignore next */ []));
+        pageHiddenStates = computed(() => {
+        const pages = this.pageFields();
+        return pages.map((page) => this.evaluatePageHidden(page));
+    }, ...(ngDevMode ? [{ debugName: "pageHiddenStates" }] : /* istanbul ignore next */ []));
+        visiblePageIndices = computed(() => {
+        const hiddenStates = this.pageHiddenStates();
+        return hiddenStates
+            .map((hidden, index) => ({ index, hidden }))
+            .filter((item) => !item.hidden)
+            .map((item) => item.index);
+    }, ...(ngDevMode ? [{ debugName: "visiblePageIndices" }] : /* istanbul ignore next */ []));
+        currentPageIndex = linkedSignal(() => {
+        const totalPages = this.pageFields().length;
+        if (totalPages === 0)
+            return 0;
+                return 0;
+    }, ...(ngDevMode ? [{ debugName: "currentPageIndex" }] : /* istanbul ignore next */ []));
+        state = computed(() => {
+        const currentIndex = this.currentPageIndex();
+        const totalPages = this.pageFields().length;
+        const visibleIndices = this.visiblePageIndices();
+                const currentVisiblePosition = visibleIndices.indexOf(currentIndex);
+        const isFirstVisiblePage = currentVisiblePosition === 0 || currentVisiblePosition === -1;
+        const isLastVisiblePage = currentVisiblePosition >= visibleIndices.length - 1;
+        return {
+            currentPageIndex: currentIndex,
+            totalPages,
+            isFirstPage: isFirstVisiblePage,
+            isLastPage: isLastVisiblePage,
+            navigationDisabled: false,
+        };
+    }, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+        currentPageValid = computed(() => {
+        const currentIndex = this.currentPageIndex();
+        const pages = this.pageFields();
+        const form = this.form();
+                if (pages.length === 0 || currentIndex >= pages.length) {
+            return true;
+        }
+        const currentPage = pages[currentIndex];
+        const pageFields = currentPage.fields || [];
+                const leafKeys = collectLeafFieldKeys(pageFields);
+                        for (const fieldKey of leafKeys) {
+            const field = form[fieldKey];
+            if (field && typeof field === 'function') {
+                const fieldState = field();
+                if (fieldState && typeof fieldState.valid === 'function' && !fieldState.valid()) {
+                    return false;
                 }
-                this.position++;
             }
-            else {
-                value += char;
-                this.position++;
-            }
-        }
-        throw new ExpressionParserError('Unterminated string literal', start, this.expression);
-    }
-    readNumber() {
-        const start = this.position;
-        let value = '';
-        while (this.position < this.expression.length && /[0-9.]/.test(this.expression[this.position])) {
-            value += this.expression[this.position];
-            this.position++;
-        }
-        if (!/^\d+(\.\d+)?$/.test(value)) {
-            throw new ExpressionParserError(`Invalid number: ${value}`, start, this.expression);
-        }
-        return { type: TokenType.NUMBER, value, position: start };
-    }
-    readIdentifierOrKeyword() {
-        const start = this.position;
-        let value = '';
-        while (this.position < this.expression.length && /[a-zA-Z0-9_$]/.test(this.expression[this.position])) {
-            value += this.expression[this.position];
-            this.position++;
-        }
-                const type = this.getKeywordType(value);
-        return { type, value, position: start };
-    }
-    getKeywordType(value) {
-        switch (value) {
-            case 'true':
-                return TokenType.TRUE;
-            case 'false':
-                return TokenType.FALSE;
-            case 'null':
-                return TokenType.NULL;
-            case 'undefined':
-                return TokenType.UNDEFINED;
-            default:
-                return TokenType.IDENTIFIER;
-        }
-    }
-    readOperatorOrPunctuation() {
-        const start = this.position;
-        const char = this.expression[this.position];
-        const nextChar = this.position + 1 < this.expression.length ? this.expression[this.position + 1] : '';
-        const thirdChar = this.position + 2 < this.expression.length ? this.expression[this.position + 2] : '';
-                const threeChar = char + nextChar + thirdChar;
-        if (threeChar === '===') {
-            this.position += 3;
-            return { type: TokenType.EQUAL, value: '===', position: start };
-        }
-        if (threeChar === '!==') {
-            this.position += 3;
-            return { type: TokenType.NOT_EQUAL, value: '!==', position: start };
-        }
-                const twoChar = char + nextChar;
-        switch (twoChar) {
-            case '==':
-                this.position += 2;
-                return { type: TokenType.EQUAL, value: '==', position: start };
-            case '!=':
-                this.position += 2;
-                return { type: TokenType.NOT_EQUAL, value: '!=', position: start };
-            case '>=':
-                this.position += 2;
-                return { type: TokenType.GREATER_EQUAL, value: '>=', position: start };
-            case '<=':
-                this.position += 2;
-                return { type: TokenType.LESS_EQUAL, value: '<=', position: start };
-            case '&&':
-                this.position += 2;
-                return { type: TokenType.AND, value: '&&', position: start };
-            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 };
-        }
-                this.position++;
-        switch (char) {
-            case '+':
-                return { type: TokenType.PLUS, value: '+', position: start };
-            case '-':
-                return { type: TokenType.MINUS, value: '-', position: start };
-            case '*':
-                return { type: TokenType.MULTIPLY, value: '*', position: start };
-            case '/':
-                return { type: TokenType.DIVIDE, value: '/', position: start };
-            case '%':
-                return { type: TokenType.MODULO, value: '%', position: start };
-            case '>':
-                return { type: TokenType.GREATER, value: '>', position: start };
-            case '<':
-                return { type: TokenType.LESS, value: '<', position: start };
-            case '!':
-                return { type: TokenType.NOT, value: '!', position: start };
-            case '.':
-                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 ')':
-                return { type: TokenType.RPAREN, value: ')', position: start };
-            case '[':
-                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);
-        }
-    }
-}
-
-class Parser {
-    tokens = [];
-    current = 0;
-    expression;
-    constructor(expression) {
-        this.expression = expression;
-    }
-        parse() {
-        const tokenizer = new Tokenizer(this.expression);
-        this.tokens = tokenizer.tokenize();
-        this.current = 0;
-        if (this.isAtEnd()) {
-            throw new ExpressionParserError('Empty expression', 0, this.expression);
-        }
-        const result = this.parseExpression();
-        if (!this.isAtEnd()) {
-            const token = this.peek();
-            throw new ExpressionParserError(`Unexpected token '${token.value}' at position ${token.position} — expression has trailing content`, token.position, this.expression);
         }
-        return result;
-    }
-    parseExpression() {
-                        const arrow = this.tryParseArrowFunction();
-        if (arrow)
-            return arrow;
-        return this.parseConditional();
-    }
-        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 };
-    }
-        tryParseArrowFunction() {
-        const savedPos = this.current;
-                if (this.check(TokenType.IDENTIFIER) && this.checkAt(this.current + 1, TokenType.ARROW)) {
-            const param = this.advance().value;
-            this.advance();             const body = this.parseExpression();
-            return { type: 'ArrowFunction', params: [param], body };
-        }
-                if (this.check(TokenType.LPAREN)) {
-            this.advance();             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;
+        return true;
+    }, ...(ngDevMode ? [{ debugName: "currentPageValid" }] : /* istanbul ignore next */ []));
+        extendedFieldSignalContext = computed(() => ({
+        ...this.fieldSignalContext(),
+        currentPageValid: this.currentPageValid,
+    }), ...(ngDevMode ? [{ debugName: "extendedFieldSignalContext" }] : /* istanbul ignore next */ []));
+    constructor() {
+                this.setupEventListeners();
+                explicitEffect([this.state, this.visiblePageIndices], ([state, visibleIndices]) => {
+            const currentVisiblePosition = visibleIndices.indexOf(state.currentPageIndex);
+            if (currentVisiblePosition === -1 && visibleIndices.length > 0) {
+                                const nearest = this.findNearestVisiblePage(state.currentPageIndex, visibleIndices);
+                if (nearest !== -1) {
+                    this.navigateToPage(nearest);
                 }
-                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();
-        while (this.match(TokenType.OR)) {
-            const operator = this.previous().value;
-            const right = this.parseLogicalAnd();
-            node = { type: 'BinaryOp', operator, left: node, right };
-        }
-        return node;
-    }
-    parseLogicalAnd() {
-        let node = this.parseEquality();
-        while (this.match(TokenType.AND)) {
-            const operator = this.previous().value;
-            const right = this.parseEquality();
-            node = { type: 'BinaryOp', operator, left: node, right };
-        }
-        return node;
+        });
     }
-    parseEquality() {
-        let node = this.parseComparison();
-        while (this.match(TokenType.EQUAL, TokenType.NOT_EQUAL)) {
-            const operator = this.previous().value;
-            const right = this.parseComparison();
-            node = { type: 'BinaryOp', operator, left: node, right };
+        navigateToNextPage() {
+                        const disableWhenPageInvalid = this.formOptions?.()?.nextButton?.disableWhenPageInvalid ?? true;
+        if (disableWhenPageInvalid && !this.currentPageValid()) {
+            return {
+                success: false,
+                newPageIndex: this.state().currentPageIndex,
+                error: 'Current page has invalid fields',
+            };
         }
-        return node;
-    }
-    parseComparison() {
-        let node = this.parseAddition();
-        while (this.match(TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL)) {
-            const operator = this.previous().value;
-            const right = this.parseAddition();
-            node = { type: 'BinaryOp', operator, left: node, right };
+        const currentState = this.state();
+        const visibleIndices = this.visiblePageIndices();
+        if (currentState.isLastPage) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'Already on the last visible page',
+            };
         }
-        return node;
-    }
-    parseAddition() {
-        let node = this.parseMultiplication();
-        while (this.match(TokenType.PLUS, TokenType.MINUS)) {
-            const operator = this.previous().value;
-            const right = this.parseMultiplication();
-            node = { type: 'BinaryOp', operator, left: node, right };
+        if (currentState.navigationDisabled) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'Navigation is currently disabled',
+            };
         }
-        return node;
-    }
-    parseMultiplication() {
-        let node = this.parseUnary();
-        while (this.match(TokenType.MULTIPLY, TokenType.DIVIDE, TokenType.MODULO)) {
-            const operator = this.previous().value;
-            const right = this.parseUnary();
-            node = { type: 'BinaryOp', operator, left: node, right };
-        }
-        return node;
-    }
-    parseUnary() {
-        if (this.match(TokenType.NOT, TokenType.MINUS, TokenType.PLUS)) {
-            const operator = this.previous().value;
-            const operand = this.parseUnary();
-            return { type: 'UnaryOp', operator, operand };
-        }
-        return this.parsePostfix();
-    }
-    parsePostfix() {
-        let node = this.parsePrimary();
-        while (true) {
-            if (this.match(TokenType.DOT)) {
-                                if (!this.check(TokenType.IDENTIFIER)) {
-                    throw new ExpressionParserError('Expected property name after "."', this.peek().position, this.expression);
-                }
-                const property = this.advance().value;
-                node = { type: 'MemberAccess', object: node, property };
-            }
-            else if (this.match(TokenType.OPTIONAL_DOT)) {
-                                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)) {
-                                const property = this.parseExpression();
-                this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
-                node = { type: 'ComputedMemberAccess', object: node, property };
-            }
-            else if (this.match(TokenType.LPAREN)) {
-                                const args = this.parseArgumentList();
-                this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
-                node = { type: 'CallExpression', callee: node, arguments: args };
-            }
-            else {
-                break;
-            }
+                const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
+        if (currentVisiblePosition === -1 || currentVisiblePosition >= visibleIndices.length - 1) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'No next visible page available',
+            };
         }
-        return node;
+        const nextVisiblePageIndex = visibleIndices[currentVisiblePosition + 1];
+        return this.navigateToPage(nextVisiblePageIndex);
     }
-    parsePrimary() {
-                if (this.match(TokenType.TRUE)) {
-            return { type: 'Literal', value: true };
-        }
-        if (this.match(TokenType.FALSE)) {
-            return { type: 'Literal', value: false };
-        }
-        if (this.match(TokenType.NULL)) {
-            return { type: 'Literal', value: null };
-        }
-        if (this.match(TokenType.UNDEFINED)) {
-            return { type: 'Literal', value: undefined };
-        }
-        if (this.match(TokenType.NUMBER)) {
-            return { type: 'Literal', value: parseFloat(this.previous().value) };
+        navigateToPreviousPage() {
+        const currentState = this.state();
+        const visibleIndices = this.visiblePageIndices();
+        if (currentState.isFirstPage) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'Already on the first visible page',
+            };
         }
-        if (this.match(TokenType.STRING)) {
-            return { type: 'Literal', value: this.previous().value };
+        if (currentState.navigationDisabled) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'Navigation is currently disabled',
+            };
         }
-                if (this.match(TokenType.LBRACKET)) {
-            const elements = this.parseArrayElements();
-            this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
-            return { type: 'ArrayLiteral', elements };
+                const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
+        if (currentVisiblePosition <= 0) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: 'No previous visible page available',
+            };
         }
-                if (this.match(TokenType.LBRACE)) {
-            const properties = this.parseObjectProperties();
-            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
-            return { type: 'ObjectLiteral', properties };
+        const prevVisiblePageIndex = visibleIndices[currentVisiblePosition - 1];
+        return this.navigateToPage(prevVisiblePageIndex);
+    }
+        navigateToPage(pageIndex) {
+        const currentState = this.state();
+        const totalPages = currentState.totalPages;
+                if (pageIndex < 0 || pageIndex >= totalPages) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: `Invalid page index: ${pageIndex}. Valid range is 0 to ${totalPages - 1}`,
+            };
         }
-                if (this.match(TokenType.IDENTIFIER)) {
-            return { type: 'Identifier', name: this.previous().value };
+                const visibleIndices = this.visiblePageIndices();
+        if (!visibleIndices.includes(pageIndex)) {
+            return {
+                success: false,
+                newPageIndex: currentState.currentPageIndex,
+                error: `Cannot navigate to hidden page at index ${pageIndex}. Visible pages: [${visibleIndices.join(', ')}]`,
+            };
         }
-                if (this.match(TokenType.LPAREN)) {
-            const expr = this.parseExpression();
-            this.consume(TokenType.RPAREN, 'Expected ")" after expression');
-            return expr;
+                if (pageIndex === currentState.currentPageIndex) {
+            return {
+                success: true,
+                newPageIndex: pageIndex,
+            };
         }
-        throw new ExpressionParserError(`Unexpected token: ${this.peek().value}`, this.peek().position, this.expression);
+                const previousIndex = currentState.currentPageIndex;
+        this.currentPageIndex.set(pageIndex);
+                this.eventBus.dispatch(PageChangeEvent, pageIndex, totalPages, previousIndex);
+        return {
+            success: true,
+            newPageIndex: pageIndex,
+        };
     }
-    parseArgumentList() {
-        const args = [];
-        if (!this.check(TokenType.RPAREN)) {
-            do {
-                args.push(this.parseExpression());
-            } while (this.match(TokenType.COMMA));
+        findNearestVisiblePage(currentIndex, visibleIndices) {
+        let nearest = -1;
+        let minDistance = Infinity;
+        for (const idx of visibleIndices) {
+            const distance = Math.abs(idx - currentIndex);
+                        if (distance < minDistance || (distance === minDistance && idx > nearest)) {
+                minDistance = distance;
+                nearest = idx;
+            }
         }
-        return args;
+        return nearest;
     }
-    parseArrayElements() {
-        const elements = [];
-        if (!this.check(TokenType.RBRACKET)) {
-            do {
-                elements.push(this.parseExpression());
-            } while (this.match(TokenType.COMMA));
-        }
-        return elements;
+        setupEventListeners() {
+                this.eventBus
+            .on('next-page')
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => {
+            this.navigateToNextPage();
+        });
+                this.eventBus
+            .on('previous-page')
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => {
+            this.navigateToPreviousPage();
+        });
+        explicitEffect([this.state], ([state]) => this.eventBus.dispatch(PageNavigationStateChangeEvent, state));
     }
-    parseObjectProperties() {
-        const properties = [];
-        if (this.check(TokenType.RBRACE)) {
-            return properties;
+        evaluatePageHidden(page) {
+                if (!page.logic || page.logic.length === 0) {
+            return false;
         }
-        do {
-                        if (this.check(TokenType.RBRACE))
-                break;
-            let key;
-            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
-                key = this.advance().value;
+                const hiddenLogic = page.logic.filter((l) => l.type === 'hidden');
+                if (hiddenLogic.length === 0) {
+            return false;
+        }
+                for (const logic of hiddenLogic) {
+                        if (typeof logic.condition === 'boolean') {
+                if (logic.condition) {
+                    return true;
+                }
+                continue;
             }
-            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)) {
-                this.advance();
+                        const condition = logic.condition;
+            const context = this.fieldContextRegistry.createDisplayOnlyContext(page.key || '', this.functionRegistry.getCustomFunctions());
+            if (evaluateCondition(condition, context)) {
                 return true;
             }
         }
         return false;
     }
-    check(type) {
-        if (this.isAtEnd())
-            return false;
-        return this.peek().type === type;
-    }
-    advance() {
-        if (!this.isAtEnd())
-            this.current++;
-        return this.previous();
-    }
-    isAtEnd() {
-        return this.peek().type === TokenType.EOF;
-    }
-    peek() {
-        return this.tokens[this.current];
-    }
-    previous() {
-        return this.tokens[this.current - 1];
-    }
-    consume(type, message) {
-        if (this.check(type))
-            return this.advance();
-        throw new ExpressionParserError(message, this.peek().position, this.expression);
+    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(),
+                deps: [PageOrchestratorComponent],
+            },
+        ], ngImport: i0, template: `
+    @for (pageField of pageFields(); track pageField.key; let i = $index) {
+      <!--
+        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
+        derives schema/value/validators from config (not from mounted components),
+        so unmounting a hidden page has no effect on form state — only on render +
+        CD cost. This is the page-level equivalent of the existing field-level
+        \`@if (!field.hidden())\` gate in page-field.component.ts.
+      -->
+      @if (!pageHiddenStates()[i]) {
+        @if (i === state().currentPageIndex || i === state().currentPageIndex + 1 || i === state().currentPageIndex - 1) {
+          <!-- Current and adjacent pages (±1): render immediately for flicker-free navigation -->
+          @defer (on immediate) {
+            <section
+              page-field
+              [field]="pageField"
+              [key]="pageField.key"
+              [pageIndex]="i"
+              [isVisible]="i === state().currentPageIndex"
+            ></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
+          }
+        } @else {
+          <!-- Distant pages: defer until browser is idle for memory savings -->
+          @defer (on idle) {
+            <section page-field [field]="pageField" [key]="pageField.key" [pageIndex]="i" [isVisible]="false"></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
+          }
+        }
+      }
     }
+  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-BJRNnoz-.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-BJRNnoz-.mjs').then(m => m.default)]] });
 }
-
-const STRING_SAFE_METHODS = [
-    'charAt',
-    'charCodeAt',
-    'concat',
-    'endsWith',
-    'includes',
-    'indexOf',
-    'lastIndexOf',
-    'match',
-    'padEnd',
-    'padStart',
-    'repeat',
-    'replace',
-    'search',
-    'slice',
-    'split',
-    'startsWith',
-    'substring',
-    'toLowerCase',
-    'toUpperCase',
-    'trim',
-    'trimEnd',
-    'trimStart',
-    'toString',
-];
-const NUMBER_SAFE_METHODS = ['toExponential', 'toFixed', 'toPrecision', 'toString'];
-const ARRAY_SAFE_METHODS = [
-    'concat',
-    'every',
-    'filter',
-    'find',
-    'findIndex',
-    'flat',
-    'flatMap',
-    'includes',
-    'indexOf',
-    'join',
-    'lastIndexOf',
-    'map',
-    'reduce',
-    'reduceRight',
-    'slice',
-    'some',
-    'toString',
-    'entries',
-    'keys',
-    'values',
-];
-const DATE_SAFE_METHODS = [
-    'getDate',
-    'getDay',
-    'getFullYear',
-    'getHours',
-    'getMilliseconds',
-    'getMinutes',
-    'getMonth',
-    'getSeconds',
-    'getTime',
-    'getTimezoneOffset',
-    'getUTCDate',
-    'getUTCDay',
-    'getUTCFullYear',
-    'getUTCHours',
-    'getUTCMilliseconds',
-    'getUTCMinutes',
-    'getUTCMonth',
-    'getUTCSeconds',
-    'toDateString',
-    'toISOString',
-    'toJSON',
-    'toString',
-    'toTimeString',
-    'toUTCString',
-];
-const SAFE_METHODS = {
-    string: new Set(STRING_SAFE_METHODS),
-    number: new Set(NUMBER_SAFE_METHODS),
-    array: new Set(ARRAY_SAFE_METHODS),
-    date: new Set(DATE_SAFE_METHODS),
-};
-const BLOCKED_PROPERTIES = new Set([
-    'constructor',
-    '__proto__',
-    'prototype',
-    '__defineGetter__',
-    '__defineSetter__',
-    '__lookupGetter__',
-    '__lookupSetter__',
-]);
-class Evaluator {
-    scope;
-    expression;
-    constructor(scope, expression) {
-        this.scope = scope;
-        this.expression = expression;
-    }
-        evaluate(node) {
-        switch (node.type) {
-            case 'Literal':
-                return node.value;
-            case 'Identifier':
-                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);
+i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-BJRNnoz-.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) {
+      <!--
+        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
+        derives schema/value/validators from config (not from mounted components),
+        so unmounting a hidden page has no effect on form state — only on render +
+        CD cost. This is the page-level equivalent of the existing field-level
+        \`@if (!field.hidden())\` gate in page-field.component.ts.
+      -->
+      @if (!pageHiddenStates()[i]) {
+        @if (i === state().currentPageIndex || i === state().currentPageIndex + 1 || i === state().currentPageIndex - 1) {
+          <!-- Current and adjacent pages (±1): render immediately for flicker-free navigation -->
+          @defer (on immediate) {
+            <section
+              page-field
+              [field]="pageField"
+              [key]="pageField.key"
+              [pageIndex]="i"
+              [isVisible]="i === state().currentPageIndex"
+            ></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
+          }
+        } @else {
+          <!-- Distant pages: defer until browser is idle for memory savings -->
+          @defer (on idle) {
+            <section page-field [field]="pageField" [key]="pageField.key" [pageIndex]="i" [isVisible]="false"></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
+          }
         }
+      }
     }
-    evaluateIdentifier(name) {
-        if (name in this.scope) {
-            return this.scope[name];
+  `, host: {
+                            class: 'df-page-orchestrator',
+                            '[attr.data-current-page]': 'state().currentPageIndex',
+                            '[attr.data-total-pages]': 'state().totalPages',
+                        }, providers: [
+                            {
+                                provide: FIELD_SIGNAL_CONTEXT,
+                                useFactory: (orchestrator) => orchestrator.extendedFieldSignalContext(),
+                                deps: [PageOrchestratorComponent],
+                            },
+                        ], changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;position:relative;width:100%}\n"] }]
+            }], ctorParameters: () => [], propDecorators: { pageFields: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageFields", required: true }] }], form: [{ type: i0.Input, args: [{ isSignal: true, alias: "form", required: true }] }], fieldSignalContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldSignalContext", required: true }] }] } }) });
+function collectLeafFieldKeys(fields) {
+    const keys = [];
+    for (const field of fields) {
+        if (isRowField(field)) {
+                        keys.push(...collectLeafFieldKeys(field.fields));
+        }
+        else if (field.key) {
+            keys.push(field.key);
         }
-        return undefined;
     }
-    evaluateMemberAccess(node) {
-        const obj = this.evaluate(node.object);
-        if (obj === null || obj === undefined) {
-            return undefined;
+    return keys;
+}
+
+const FORM_INITIALIZER = new InjectionToken('FORM_INITIALIZER');
+
+const NORMALIZED_ARRAY_METADATA = Symbol('normalizedArrayMetadata');
+function setNormalizedArrayMetadata(arrayField, metadata) {
+    arrayField[NORMALIZED_ARRAY_METADATA] = metadata;
+}
+function getNormalizedArrayMetadata(arrayField) {
+    return arrayField[NORMALIZED_ARRAY_METADATA];
+}
+
+function normalizeSimplifiedArrays(fields) {
+    return fields.flatMap((field) => {
+                if (isContainerField(field) && !isArrayField(field) && hasChildFields(field)) {
+            return [{ ...field, fields: normalizeSimplifiedArrays(field.fields) }];
         }
-                if (BLOCKED_PROPERTIES.has(node.property)) {
-            throw new ExpressionParserError(`Property "${node.property}" is not accessible for security reasons`, 0, this.expression);
+                if (isArrayField(field) && !isSimplifiedArrayField(field)) {
+            const normalizedItems = field.fields.map((item) => Array.isArray(item) ? normalizeSimplifiedArrays(item) : item);
+            return [{ ...field, fields: normalizedItems }];
         }
-                if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
-            return obj[node.property];
+                if (isSimplifiedArrayField(field)) {
+            const { arrayField, addButton } = expandSimplifiedArray(field);
+            return addButton ? [arrayField, addButton] : [arrayField];
         }
-        return undefined;
-    }
-    evaluateComputedMemberAccess(node) {
-        const obj = this.evaluate(node.object);
-        if (obj === null || obj === undefined) {
-                                    return undefined;
-        }
-        const rawKey = this.evaluate(node.property);
-        if (rawKey === null || rawKey === undefined)
-            return undefined;
-        const key = String(rawKey);
-                        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) {
-                if (node.operator === '&&') {
-            const left = this.evaluate(node.left);
-            return left ? this.evaluate(node.right) : left;
-        }
-        if (node.operator === '||') {
-            const left = this.evaluate(node.left);
-            return left ? left : this.evaluate(node.right);
-        }
-                const left = this.evaluate(node.left);
-        const right = this.evaluate(node.right);
-        switch (node.operator) {
-                        case '+':
-                return left + right;
-            case '-':
-                return left - right;
-            case '*':
-                return left * right;
-            case '/':
-                if (right === 0)
-                    return null;
-                return left / right;
-            case '%':
-                if (right === 0)
-                    return null;
-                return left % right;
-                        case '==':
-                return left == right;
-            case '===':
-                return left === right;
-            case '!=':
-                return left != right;
-            case '!==':
-                return left !== right;
-            case '>':
-                return left > right;
-            case '<':
-                return left < right;
-            case '>=':
-                return left >= right;
-            case '<=':
-                return left <= right;
-            default:
-                throw new ExpressionParserError(`Unknown binary operator: ${node.operator}`, 0, this.expression);
-        }
-    }
-    evaluateUnaryOp(node) {
-        const operand = this.evaluate(node.operand);
-        switch (node.operator) {
-            case '!':
-                return !operand;
-            case '-':
-                return -operand;
-            case '+':
-                return +operand;
-            default:
-                throw new ExpressionParserError(`Unknown unary operator: ${node.operator}`, 0, this.expression);
-        }
-    }
-    evaluateCallExpression(node) {
-                        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);
-                                                        if (obj === null || obj === undefined) {
-            return undefined;
-        }
-        const methodName = node.callee.property;
-                if (BLOCKED_PROPERTIES.has(methodName)) {
-            throw new ExpressionParserError(`Property "${methodName}" is not accessible for security reasons`, 0, this.expression);
-        }
-                if (!this.isMethodSafe(obj, methodName)) {
-            throw new ExpressionParserError(`Method "${methodName}" is not allowed for security reasons`, 0, this.expression);
-        }
-                const args = node.arguments.map((arg) => this.evaluate(arg));
-                const method = obj[methodName];
-        if (typeof method === 'function') {
-                        return method.call(obj, ...args);
-        }
-        return undefined;
-    }
-    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;
-        }
-        const type = Array.isArray(obj) ? 'array' : obj instanceof Date ? 'date' : typeof obj;
-        const safeMethods = SAFE_METHODS[type];
-        if (!safeMethods) {
-            return false;
-        }
-        return safeMethods.has(methodName);
-    }
-}
-
-const MAX_AST_CACHE_SIZE$1 = 1000;
-class LRUCache {
-    cache = new Map();
-    maxSize;
-    constructor(maxSize) {
-        this.maxSize = maxSize;
-    }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-                        this.cache.delete(key);
-            this.cache.set(key, value);
-        }
-        return value;
-    }
-    set(key, value) {
-                if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-                this.cache.set(key, value);
-                if (this.cache.size > this.maxSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey);
-            }
-        }
-    }
-    clear() {
-        this.cache.clear();
-    }
-    get size() {
-        return this.cache.size;
-    }
-}
-const astCache = new LRUCache(MAX_AST_CACHE_SIZE$1);
-class ExpressionParser {
-        static parse(expression) {
-                const cached = astCache.get(expression);
-        if (cached) {
-            return cached;
-        }
-                const parser = new Parser(expression);
-        const ast = parser.parse();
-                astCache.set(expression, ast);
-        return ast;
-    }
-        static evaluate(expression, scope) {
-        try {
-            const ast = this.parse(expression);
-            const evaluator = new Evaluator(scope, expression);
-            return evaluator.evaluate(ast);
-        }
-        catch (error) {
-            if (error instanceof ExpressionParserError) {
-                throw error;
-            }
-                        throw new ExpressionParserError(`Error evaluating expression: ${error instanceof Error ? error.message : String(error)}`, 0, expression);
-        }
-    }
-        static clearCache() {
-        astCache.clear();
-    }
-        static getCacheStats() {
-        return {
-            size: astCache.size,
-            maxSize: MAX_AST_CACHE_SIZE$1,
-        };
-    }
-}
-
-function evaluateCondition(expression, context) {
-    switch (expression.type) {
-        case 'fieldValue':
-            return evaluateFieldValueCondition(expression, context);
-        case 'javascript':
-            return evaluateJavaScriptExpression(expression, context);
-        case 'custom': {
-                                                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:', registeredName);
-                return false;
-            }
-            try {
-                return !!customFn(context);
-            }
-            catch (error) {
-                context.logger.error('Error executing custom function:', registeredName ?? '<inline>', error);
-                return false;
-            }
-        }
-        case 'and':
-            return evaluateAndCondition(expression, context);
-        case 'or':
-            return evaluateOrCondition(expression, context);
-        case 'http':
-            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':
-            context.logger.warn('Async Condition - resolved asynchronously via createAsyncConditionLogicFunction(). ' +
-                'When used inside and/or composites, the async result is not available synchronously. Returning false.');
-            return false;
-        default:
-            return false;
-    }
-}
-function evaluateFieldValueCondition(expression, context) {
-        if (!expression.fieldPath)
-        return false;
-                        const fieldValue = hasNestedProperty(context.formValue, expression.fieldPath)
-        ? getNestedValue(context.formValue, expression.fieldPath)
-        : context.rootFormValue
-            ? getNestedValue(context.rootFormValue, expression.fieldPath)
-            : undefined;
-    return compareValues(fieldValue, expression.value, expression.operator);
-}
-function evaluateJavaScriptExpression(expression, context) {
-    try {
-                const result = ExpressionParser.evaluate(expression.expression, context);
-        return !!result;
-    }
-    catch (error) {
-        context.logger.error('Error evaluating JavaScript expression:', expression.expression, error);
-        return false;
-    }
-}
-function evaluateAndCondition(expression, context) {
-    if (expression.conditions.length === 0)
-        return false;
-        return expression.conditions.every((condition) => evaluateCondition(condition, context));
-}
-function evaluateOrCondition(expression, context) {
-    if (expression.conditions.length === 0)
-        return false;
-        return expression.conditions.some((condition) => evaluateCondition(condition, context));
-}
-
-class FunctionRegistryService {
-    customFunctions = new Map();
-    customFunctionScopes = new Map();
-    derivationFunctions = new Map();
-    asyncDerivationFunctions = new Map();
-    asyncConditionFunctions = new Map();
-    validators = new Map();
-    asyncValidators = new Map();
-    httpValidators = new Map();
-        registerCustomFunction(name, fn, options) {
-        this.customFunctions.set(name, fn);
-                this.customFunctionScopes.set(name, options?.scope ?? 'form');
-    }
-        getCustomFunctionScope(name) {
-        return this.customFunctionScopes.get(name);
-    }
-        isFieldScopedFunction(name) {
-        return this.customFunctionScopes.get(name) === 'field';
-    }
-        getCustomFunctions() {
-        return Object.fromEntries(this.customFunctions);
-    }
-        clearCustomFunctions() {
-        this.customFunctions.clear();
-        this.customFunctionScopes.clear();
-    }
-                    registerDerivationFunction(name, fn) {
-        this.derivationFunctions.set(name, fn);
-    }
-        getDerivationFunction(name) {
-        return this.derivationFunctions.get(name);
-    }
-        getDerivationFunctions() {
-        return Object.fromEntries(this.derivationFunctions);
-    }
-        setDerivationFunctions(derivations) {
-        this.setRegistryIfChanged(this.derivationFunctions, derivations);
-    }
-        clearDerivationFunctions() {
-        this.derivationFunctions.clear();
-    }
-                    registerAsyncDerivationFunction(name, fn) {
-        this.asyncDerivationFunctions.set(name, fn);
-    }
-        getAsyncDerivationFunction(name) {
-        return this.asyncDerivationFunctions.get(name);
-    }
-        getAsyncDerivationFunctions() {
-        return Object.fromEntries(this.asyncDerivationFunctions);
-    }
-        setAsyncDerivationFunctions(fns) {
-        this.setRegistryIfChanged(this.asyncDerivationFunctions, fns);
-    }
-        clearAsyncDerivationFunctions() {
-        this.asyncDerivationFunctions.clear();
-    }
-                    registerAsyncConditionFunction(name, fn) {
-        this.asyncConditionFunctions.set(name, fn);
-    }
-        getAsyncConditionFunction(name) {
-        return this.asyncConditionFunctions.get(name);
-    }
-        getAsyncConditionFunctions() {
-        return Object.fromEntries(this.asyncConditionFunctions);
-    }
-        setAsyncConditionFunctions(fns) {
-        this.setRegistryIfChanged(this.asyncConditionFunctions, fns);
-    }
-        clearAsyncConditionFunctions() {
-        this.asyncConditionFunctions.clear();
-    }
-        registerValidator(name, fn) {
-        this.validators.set(name, fn);
-    }
-        getValidator(name) {
-        return this.validators.get(name);
-    }
-        clearValidators() {
-        this.validators.clear();
-    }
-        registerAsyncValidator(name, fn) {
-        this.asyncValidators.set(name, fn);
-    }
-        getAsyncValidator(name) {
-        return this.asyncValidators.get(name);
-    }
-        clearAsyncValidators() {
-        this.asyncValidators.clear();
-    }
-        registerHttpValidator(name, config) {
-        this.httpValidators.set(name, config);
-    }
-        getHttpValidator(name) {
-        return this.httpValidators.get(name);
-    }
-        clearHttpValidators() {
-        this.httpValidators.clear();
-    }
-        setRegistryIfChanged(registry, values) {
-        if (!values)
-            return;
-        const entries = Object.entries(values);
-        const hasChanges = entries.some(([name, value]) => registry.get(name) !== value);
-        if (hasChanges) {
-            entries.forEach(([name, value]) => registry.set(name, value));
-        }
-    }
-        setValidators(validators) {
-        this.setRegistryIfChanged(this.validators, validators);
-    }
-        setAsyncValidators(asyncValidators) {
-        this.setRegistryIfChanged(this.asyncValidators, asyncValidators);
-    }
-        setHttpValidators(httpValidators) {
-        this.setRegistryIfChanged(this.httpValidators, httpValidators);
-    }
-        clearAll() {
-        this.clearCustomFunctions();
-        this.clearDerivationFunctions();
-        this.clearAsyncDerivationFunctions();
-        this.clearAsyncConditionFunctions();
-        this.clearValidators();
-        this.clearAsyncValidators();
-        this.clearHttpValidators();
-    }
-    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.14", ngImport: i0, type: FunctionRegistryService, decorators: [{
-            type: Injectable
-        }] });
-
-const DEPRECATION_WARNING_TRACKER = new InjectionToken('DeprecationWarningTracker');
-
-const STATE_PROPERTIES = ['touched', 'dirty', 'valid', 'invalid', 'pending', 'hidden', 'readonly', 'disabled'];
-function readStateSignal(fieldState, prop, reactive) {
-    const signalFn = fieldState[prop];
-    if (!signalFn || !isSignal(signalFn))
-        return false;
-    return reactive ? !!signalFn() : !!untracked(signalFn);
-}
-function resolveFieldState(fieldSource, reactive) {
-    if (!fieldSource)
-        return undefined;
-        if (typeof fieldSource === 'function') {
-        return reactive ? fieldSource() : untracked(fieldSource);
-    }
-        if (typeof fieldSource === 'object') {
-        return fieldSource;
-    }
-    return undefined;
-}
-function readFieldStateInfo(fieldSource, reactive) {
-    const state = resolveFieldState(fieldSource, reactive);
-    if (!state || typeof state !== 'object')
-        return undefined;
-    const knownProperties = new Set([...STATE_PROPERTIES, 'pristine']);
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (prop === 'pristine') {
-                return !readStateSignal(state, 'dirty', reactive);
-            }
-            if (STATE_PROPERTIES.includes(prop)) {
-                return readStateSignal(state, prop, reactive);
-            }
-            return false;
-        },
-        has(_target, prop) {
-            return knownProperties.has(prop);
-        },
-    });
-}
-function createFormFieldStateMap(rootForm, reactive) {
-    const cache = new Map();
-    return new Proxy({}, {
-        get(_target, key) {
-            if (cache.has(key)) {
-                return cache.get(key);
-            }
-            const fieldAccessor = navigateToFieldAccessor(rootForm, key);
-            const snapshot = readFieldStateInfo(fieldAccessor, reactive);
-            cache.set(key, snapshot);
-            return snapshot;
-        },
-        has(_target, key) {
-            return navigateToFieldAccessor(rootForm, key) !== undefined;
-        },
-    });
-}
-function navigateToFieldAccessor(rootForm, keyPath) {
-    if (!keyPath)
-        return undefined;
-    const parts = keyPath.split('.');
-            let current = rootForm;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const next = current[parts[i]];
-        if (!next)
-            return undefined;
-        current = next;
-    }
-    return current[parts[parts.length - 1]];
-}
-
-function safeReadPathKeys(fieldContext) {
-    if (!('pathKeys' in fieldContext) || typeof fieldContext.pathKeys !== 'function') {
-        return [];
-    }
-    return untracked(() => fieldContext.pathKeys());
-}
-
-function isChildFieldContext(context) {
-    return 'key' in context && isSignal(context.key);
-}
-function extractFieldState(fieldContext) {
-    return untracked(() => {
-        if (!fieldContext || !('state' in fieldContext))
-            return undefined;
-        return fieldContext.state;
-    });
-}
-function detectArrayScope(pathKeys) {
-        if (pathKeys.length < 3)
-        return undefined;
-                for (let i = pathKeys.length - 2; i >= 1; i--) {
-        const maybeIndex = Number(pathKeys[i]);
-        if (Number.isInteger(maybeIndex) && maybeIndex >= 0) {
-            return {
-                arrayKey: pathKeys.slice(0, i).join('.'),
-                index: maybeIndex,
-                localKey: pathKeys[pathKeys.length - 1],
-            };
-        }
-    }
-    return undefined;
-}
-class FieldContextRegistryService {
-    rootFormRegistry = inject(RootFormRegistryService);
-    logger = inject(DynamicFormLogger);
-    deprecationTracker = inject(DEPRECATION_WARNING_TRACKER, { optional: true });
-    externalDataSignal = inject(EXTERNAL_DATA, { optional: true });
-        createEvaluationContext(fieldContext, customFunctions) {
-                        const fieldValue = untracked(() => fieldContext.value());
-                                const rootFormValue = untracked(() => this.rootFormRegistry.formValue());
-        const localKey = this.extractFieldPath(fieldContext);
-        const pathKeys = safeReadPathKeys(fieldContext);
-        const arrayScope = detectArrayScope(pathKeys);
-        if (arrayScope) {
-            return this.buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, false, fieldContext);
-        }
-                                        const rootFormSignal = this.rootFormRegistry.rootForm;
-        return {
-            fieldValue,
-            formValue: rootFormValue,
-            fieldPath: localKey,
-            customFunctions: customFunctions || {},
-            externalData: this.resolveExternalData(false),
-            logger: this.logger,
-            deprecationTracker: this.deprecationTracker ?? undefined,
-            get fieldState() {
-                return readFieldStateInfo(extractFieldState(fieldContext), false);
-            },
-            get formFieldState() {
-                return createFormFieldStateMap(untracked(rootFormSignal), false);
-            },
-        };
-    }
-        extractFieldPath(fieldContext) {
-        if (isChildFieldContext(fieldContext)) {
-            try {
-                return String(fieldContext.key());
-            }
-            catch (error) {
-                this.logger.warn('Unable to extract field key:', error);
-            }
-        }
-                return '';
-    }
-        buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, reactive, fieldContext) {
-        const { arrayKey, index, localKey } = arrayScope;
-                const arrayData = getNestedValue(rootFormValue, arrayKey);
-        let scopedFormValue;
-        if (Array.isArray(arrayData) && index >= 0 && index < arrayData.length) {
-            const item = arrayData[index];
-            if (item != null && typeof item === 'object') {
-                scopedFormValue = item;
-            }
-        }
-                                const rootFormSignal = this.rootFormRegistry.rootForm;
-        const fieldStateGetter = fieldContext ? () => readFieldStateInfo(extractFieldState(fieldContext), reactive) : () => undefined;
-        const formFieldStateGetter = () => createFormFieldStateMap((reactive ? rootFormSignal() : untracked(rootFormSignal)), reactive);
-                if (!scopedFormValue) {
-            return {
-                fieldValue,
-                formValue: rootFormValue,
-                fieldPath: localKey,
-                customFunctions: customFunctions || {},
-                externalData: this.resolveExternalData(reactive),
-                logger: this.logger,
-                deprecationTracker: this.deprecationTracker ?? undefined,
-                get fieldState() {
-                    return fieldStateGetter();
-                },
-                get formFieldState() {
-                    return formFieldStateGetter();
-                },
-            };
-        }
-        return {
-            fieldValue,
-            formValue: scopedFormValue,
-            rootFormValue,
-            arrayIndex: index,
-            arrayPath: arrayKey,
-            fieldPath: `${arrayKey}.${index}.${localKey}`,
-            customFunctions: customFunctions || {},
-            externalData: this.resolveExternalData(reactive),
-            logger: this.logger,
-            deprecationTracker: this.deprecationTracker ?? undefined,
-            get fieldState() {
-                return fieldStateGetter();
-            },
-            get formFieldState() {
-                return formFieldStateGetter();
-            },
-        };
-    }
-        resolveExternalData(reactive) {
-        const externalDataSignal = this.externalDataSignal;
-        if (!externalDataSignal)
-            return undefined;
-        const externalDataRecord = reactive ? externalDataSignal() : untracked(() => externalDataSignal());
-        if (!externalDataRecord) {
-            return undefined;
-        }
-        const resolved = {};
-        for (const [key, value] of Object.entries(externalDataRecord)) {
-            if (!isSignal(value)) {
-                throw new DynamicFormError(`externalData["${key}"] must be a Signal. Got: ${typeof value}. Wrap it with signal(yourValue).`);
-            }
-            resolved[key] = reactive ? value() : untracked(() => value());
-        }
-        return resolved;
-    }
-        createReactiveEvaluationContext(fieldContext, customFunctions) {
-        const fieldValue = fieldContext.value();
-        const rootFormValue = this.rootFormRegistry.formValue();
-        const pathKeys = safeReadPathKeys(fieldContext);
-        const arrayScope = detectArrayScope(pathKeys);
-        if (arrayScope) {
-            return this.buildArrayScopedContext(rootFormValue, arrayScope, fieldValue, customFunctions, true, fieldContext);
-        }
-        const localKey = this.extractFieldPath(fieldContext);
-        const rootFormSignal = this.rootFormRegistry.rootForm;
-        return {
-            fieldValue,
-            formValue: rootFormValue,
-            fieldPath: localKey,
-            customFunctions: customFunctions || {},
-            externalData: this.resolveExternalData(true),
-            logger: this.logger,
-            deprecationTracker: this.deprecationTracker ?? undefined,
-            get fieldState() {
-                return readFieldStateInfo(extractFieldState(fieldContext), true);
-            },
-            get formFieldState() {
-                return createFormFieldStateMap(rootFormSignal(), true);
-            },
-        };
-    }
-        createDisplayOnlyContext(fieldPath, customFunctions) {
-        const formValue = this.rootFormRegistry.formValue();
-        const rootFormSignal = this.rootFormRegistry.rootForm;
-        return {
-            fieldValue: undefined,
-            formValue,
-            fieldPath,
-            customFunctions: customFunctions || {},
-            externalData: this.resolveExternalData(true),
-            logger: this.logger,
-            deprecationTracker: this.deprecationTracker ?? undefined,
-            get formFieldState() {
-                return createFormFieldStateMap(rootFormSignal(), true);
-            },
-        };
-    }
-    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.14", ngImport: i0, type: FieldContextRegistryService, decorators: [{
-            type: Injectable
-        }] });
-
-class PageOrchestratorComponent {
-    eventBus = inject(EventBus);
-    fieldContextRegistry = inject(FieldContextRegistryService);
-    functionRegistry = inject(FunctionRegistryService);
-    formOptions = inject(FORM_OPTIONS, { optional: true });
-        pageFields = input.required(...(ngDevMode ? [{ debugName: "pageFields" }] : /* istanbul ignore next */ []));
-        form = input.required(...(ngDevMode ? [{ debugName: "form" }] : /* istanbul ignore next */ []));
-            fieldSignalContext = input.required(...(ngDevMode ? [{ debugName: "fieldSignalContext" }] : /* istanbul ignore next */ []));
-        pageHiddenStates = computed(() => {
-        const pages = this.pageFields();
-        return pages.map((page) => this.evaluatePageHidden(page));
-    }, ...(ngDevMode ? [{ debugName: "pageHiddenStates" }] : /* istanbul ignore next */ []));
-        visiblePageIndices = computed(() => {
-        const hiddenStates = this.pageHiddenStates();
-        return hiddenStates
-            .map((hidden, index) => ({ index, hidden }))
-            .filter((item) => !item.hidden)
-            .map((item) => item.index);
-    }, ...(ngDevMode ? [{ debugName: "visiblePageIndices" }] : /* istanbul ignore next */ []));
-        currentPageIndex = linkedSignal(() => {
-        const totalPages = this.pageFields().length;
-        if (totalPages === 0)
-            return 0;
-                return 0;
-    }, ...(ngDevMode ? [{ debugName: "currentPageIndex" }] : /* istanbul ignore next */ []));
-        state = computed(() => {
-        const currentIndex = this.currentPageIndex();
-        const totalPages = this.pageFields().length;
-        const visibleIndices = this.visiblePageIndices();
-                const currentVisiblePosition = visibleIndices.indexOf(currentIndex);
-        const isFirstVisiblePage = currentVisiblePosition === 0 || currentVisiblePosition === -1;
-        const isLastVisiblePage = currentVisiblePosition >= visibleIndices.length - 1;
-        return {
-            currentPageIndex: currentIndex,
-            totalPages,
-            isFirstPage: isFirstVisiblePage,
-            isLastPage: isLastVisiblePage,
-            navigationDisabled: false,
-        };
-    }, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
-        currentPageValid = computed(() => {
-        const currentIndex = this.currentPageIndex();
-        const pages = this.pageFields();
-        const form = this.form();
-                if (pages.length === 0 || currentIndex >= pages.length) {
-            return true;
-        }
-        const currentPage = pages[currentIndex];
-        const pageFields = currentPage.fields || [];
-                const leafKeys = collectLeafFieldKeys(pageFields);
-                        for (const fieldKey of leafKeys) {
-            const field = form[fieldKey];
-            if (field && typeof field === 'function') {
-                const fieldState = field();
-                if (fieldState && typeof fieldState.valid === 'function' && !fieldState.valid()) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }, ...(ngDevMode ? [{ debugName: "currentPageValid" }] : /* istanbul ignore next */ []));
-        extendedFieldSignalContext = computed(() => ({
-        ...this.fieldSignalContext(),
-        currentPageValid: this.currentPageValid,
-    }), ...(ngDevMode ? [{ debugName: "extendedFieldSignalContext" }] : /* istanbul ignore next */ []));
-    constructor() {
-                this.setupEventListeners();
-                explicitEffect([this.state, this.visiblePageIndices], ([state, visibleIndices]) => {
-            const currentVisiblePosition = visibleIndices.indexOf(state.currentPageIndex);
-            if (currentVisiblePosition === -1 && visibleIndices.length > 0) {
-                                const nearest = this.findNearestVisiblePage(state.currentPageIndex, visibleIndices);
-                if (nearest !== -1) {
-                    this.navigateToPage(nearest);
-                }
-            }
-        });
-    }
-        navigateToNextPage() {
-                        const disableWhenPageInvalid = this.formOptions?.()?.nextButton?.disableWhenPageInvalid ?? true;
-        if (disableWhenPageInvalid && !this.currentPageValid()) {
-            return {
-                success: false,
-                newPageIndex: this.state().currentPageIndex,
-                error: 'Current page has invalid fields',
-            };
-        }
-        const currentState = this.state();
-        const visibleIndices = this.visiblePageIndices();
-        if (currentState.isLastPage) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'Already on the last visible page',
-            };
-        }
-        if (currentState.navigationDisabled) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'Navigation is currently disabled',
-            };
-        }
-                const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
-        if (currentVisiblePosition === -1 || currentVisiblePosition >= visibleIndices.length - 1) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'No next visible page available',
-            };
-        }
-        const nextVisiblePageIndex = visibleIndices[currentVisiblePosition + 1];
-        return this.navigateToPage(nextVisiblePageIndex);
-    }
-        navigateToPreviousPage() {
-        const currentState = this.state();
-        const visibleIndices = this.visiblePageIndices();
-        if (currentState.isFirstPage) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'Already on the first visible page',
-            };
-        }
-        if (currentState.navigationDisabled) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'Navigation is currently disabled',
-            };
-        }
-                const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
-        if (currentVisiblePosition <= 0) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: 'No previous visible page available',
-            };
-        }
-        const prevVisiblePageIndex = visibleIndices[currentVisiblePosition - 1];
-        return this.navigateToPage(prevVisiblePageIndex);
-    }
-        navigateToPage(pageIndex) {
-        const currentState = this.state();
-        const totalPages = currentState.totalPages;
-                if (pageIndex < 0 || pageIndex >= totalPages) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: `Invalid page index: ${pageIndex}. Valid range is 0 to ${totalPages - 1}`,
-            };
-        }
-                const visibleIndices = this.visiblePageIndices();
-        if (!visibleIndices.includes(pageIndex)) {
-            return {
-                success: false,
-                newPageIndex: currentState.currentPageIndex,
-                error: `Cannot navigate to hidden page at index ${pageIndex}. Visible pages: [${visibleIndices.join(', ')}]`,
-            };
-        }
-                if (pageIndex === currentState.currentPageIndex) {
-            return {
-                success: true,
-                newPageIndex: pageIndex,
-            };
-        }
-                const previousIndex = currentState.currentPageIndex;
-        this.currentPageIndex.set(pageIndex);
-                this.eventBus.dispatch(PageChangeEvent, pageIndex, totalPages, previousIndex);
-        return {
-            success: true,
-            newPageIndex: pageIndex,
-        };
-    }
-        findNearestVisiblePage(currentIndex, visibleIndices) {
-        let nearest = -1;
-        let minDistance = Infinity;
-        for (const idx of visibleIndices) {
-            const distance = Math.abs(idx - currentIndex);
-                        if (distance < minDistance || (distance === minDistance && idx > nearest)) {
-                minDistance = distance;
-                nearest = idx;
-            }
-        }
-        return nearest;
-    }
-        setupEventListeners() {
-                this.eventBus
-            .on('next-page')
-            .pipe(takeUntilDestroyed())
-            .subscribe(() => {
-            this.navigateToNextPage();
-        });
-                this.eventBus
-            .on('previous-page')
-            .pipe(takeUntilDestroyed())
-            .subscribe(() => {
-            this.navigateToPreviousPage();
-        });
-        explicitEffect([this.state], ([state]) => this.eventBus.dispatch(PageNavigationStateChangeEvent, state));
-    }
-        evaluatePageHidden(page) {
-                if (!page.logic || page.logic.length === 0) {
-            return false;
-        }
-                const hiddenLogic = page.logic.filter((l) => l.type === 'hidden');
-                if (hiddenLogic.length === 0) {
-            return false;
-        }
-                for (const logic of hiddenLogic) {
-                        if (typeof logic.condition === 'boolean') {
-                if (logic.condition) {
-                    return true;
-                }
-                continue;
-            }
-                        const condition = logic.condition;
-            const context = this.fieldContextRegistry.createDisplayOnlyContext(page.key || '', this.functionRegistry.getCustomFunctions());
-            if (evaluateCondition(condition, context)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    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(),
-                deps: [PageOrchestratorComponent],
-            },
-        ], ngImport: i0, template: `
-    @for (pageField of pageFields(); track pageField.key; let i = $index) {
-      <!--
-        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
-        derives schema/value/validators from config (not from mounted components),
-        so unmounting a hidden page has no effect on form state — only on render +
-        CD cost. This is the page-level equivalent of the existing field-level
-        \`@if (!field.hidden())\` gate in page-field.component.ts.
-      -->
-      @if (!pageHiddenStates()[i]) {
-        @if (i === state().currentPageIndex || i === state().currentPageIndex + 1 || i === state().currentPageIndex - 1) {
-          <!-- Current and adjacent pages (±1): render immediately for flicker-free navigation -->
-          @defer (on immediate) {
-            <section
-              page-field
-              [field]="pageField"
-              [key]="pageField.key"
-              [pageIndex]="i"
-              [isVisible]="i === state().currentPageIndex"
-            ></section>
-          } @placeholder {
-            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
-          }
-        } @else {
-          <!-- Distant pages: defer until browser is idle for memory savings -->
-          @defer (on idle) {
-            <section page-field [field]="pageField" [key]="pageField.key" [pageIndex]="i" [isVisible]="false"></section>
-          } @placeholder {
-            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
-          }
-        }
-      }
-    }
-  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-zF-vEv5V.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-zF-vEv5V.mjs').then(m => m.default)]] });
-}
-i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-zF-vEv5V.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) {
-      <!--
-        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
-        derives schema/value/validators from config (not from mounted components),
-        so unmounting a hidden page has no effect on form state — only on render +
-        CD cost. This is the page-level equivalent of the existing field-level
-        \`@if (!field.hidden())\` gate in page-field.component.ts.
-      -->
-      @if (!pageHiddenStates()[i]) {
-        @if (i === state().currentPageIndex || i === state().currentPageIndex + 1 || i === state().currentPageIndex - 1) {
-          <!-- Current and adjacent pages (±1): render immediately for flicker-free navigation -->
-          @defer (on immediate) {
-            <section
-              page-field
-              [field]="pageField"
-              [key]="pageField.key"
-              [pageIndex]="i"
-              [isVisible]="i === state().currentPageIndex"
-            ></section>
-          } @placeholder {
-            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
-          }
-        } @else {
-          <!-- Distant pages: defer until browser is idle for memory savings -->
-          @defer (on idle) {
-            <section page-field [field]="pageField" [key]="pageField.key" [pageIndex]="i" [isVisible]="false"></section>
-          } @placeholder {
-            <div class="df-page-placeholder" [attr.data-page-index]="i" [attr.data-page-key]="pageField.key"></div>
-          }
-        }
-      }
-    }
-  `, host: {
-                            class: 'df-page-orchestrator',
-                            '[attr.data-current-page]': 'state().currentPageIndex',
-                            '[attr.data-total-pages]': 'state().totalPages',
-                        }, providers: [
-                            {
-                                provide: FIELD_SIGNAL_CONTEXT,
-                                useFactory: (orchestrator) => orchestrator.extendedFieldSignalContext(),
-                                deps: [PageOrchestratorComponent],
-                            },
-                        ], changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;position:relative;width:100%}\n"] }]
-            }], ctorParameters: () => [], propDecorators: { pageFields: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageFields", required: true }] }], form: [{ type: i0.Input, args: [{ isSignal: true, alias: "form", required: true }] }], fieldSignalContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldSignalContext", required: true }] }] } }) });
-function collectLeafFieldKeys(fields) {
-    const keys = [];
-    for (const field of fields) {
-        if (isRowField(field)) {
-                        keys.push(...collectLeafFieldKeys(field.fields));
-        }
-        else if (field.key) {
-            keys.push(field.key);
-        }
-    }
-    return keys;
-}
-
-const FORM_INITIALIZER = new InjectionToken('FORM_INITIALIZER');
-
-const NORMALIZED_ARRAY_METADATA = Symbol('normalizedArrayMetadata');
-function setNormalizedArrayMetadata(arrayField, metadata) {
-    arrayField[NORMALIZED_ARRAY_METADATA] = metadata;
-}
-function getNormalizedArrayMetadata(arrayField) {
-    return arrayField[NORMALIZED_ARRAY_METADATA];
-}
-
-function normalizeSimplifiedArrays(fields) {
-    return fields.flatMap((field) => {
-                if (isContainerField(field) && !isArrayField(field) && hasChildFields(field)) {
-            return [{ ...field, fields: normalizeSimplifiedArrays(field.fields) }];
-        }
-                if (isArrayField(field) && !isSimplifiedArrayField(field)) {
-            const normalizedItems = field.fields.map((item) => Array.isArray(item) ? normalizeSimplifiedArrays(item) : item);
-            return [{ ...field, fields: normalizedItems }];
-        }
-                if (isSimplifiedArrayField(field)) {
-            const { arrayField, addButton } = expandSimplifiedArray(field);
-            return addButton ? [arrayField, addButton] : [arrayField];
-        }
-                return [field];
-    });
-}
-const INVALID_ARRAY_CHILD_TYPES = new Set(['page', 'array']);
-function validateSimplifiedTemplate(field) {
-    const { template, key } = field;
-    const isObjectTemplate = Array.isArray(template);
-    if (isObjectTemplate) {
-        const templateFields = template;
-        for (const tmpl of templateFields) {
-                                    if (INVALID_ARRAY_CHILD_TYPES.has(tmpl.type)) {
-                throw new DynamicFormError(`Simplified array "${key}" template contains a '${tmpl.type}' field (key: '${tmpl.key}'). ` +
-                    `Only leaf fields, rows, and groups are allowed as array children.`);
-            }
-        }
-    }
-    else {
-        const singleTemplate = template;
-        if (INVALID_ARRAY_CHILD_TYPES.has(singleTemplate.type)) {
-            throw new DynamicFormError(`Simplified array "${key}" template has type '${singleTemplate.type}'. ` +
-                `Only leaf fields, rows, and groups are allowed as array children.`);
-        }
-    }
-}
-function expandSimplifiedArray(field) {
-    const { template, value = [], addButton, removeButton, key, logic, minLength, maxLength, wrappers, skipAutoWrappers, skipDefaultWrappers, } = field;
-    const isObjectTemplate = Array.isArray(template);
-    const values = value;
-        validateSimplifiedTemplate(field);
-        const items = values.map((v) => {
-        if (isObjectTemplate) {
-            return buildObjectItem(template, v, removeButton);
-        }
-        return buildPrimitiveItem(template, v);
-    });
-                const addTemplate = isObjectTemplate
-        ? buildObjectItemTemplate(template, removeButton)
-        : template;
-                const hasAutoRemove = !isObjectTemplate && removeButton !== false;
-        const arrayFieldObj = {
-        key,
-        type: 'array',
-        fields: items,
-    };
-    if (logic) {
-        arrayFieldObj['logic'] = logic;
-    }
-    if (minLength !== undefined) {
-        arrayFieldObj['minLength'] = minLength;
-    }
-    if (maxLength !== undefined) {
-        arrayFieldObj['maxLength'] = maxLength;
-    }
-    if (wrappers !== undefined) {
-        arrayFieldObj['wrappers'] = wrappers;
-    }
-    if (skipAutoWrappers !== undefined) {
-        arrayFieldObj['skipAutoWrappers'] = skipAutoWrappers;
-    }
-    if (skipDefaultWrappers !== undefined) {
-        arrayFieldObj['skipDefaultWrappers'] = skipDefaultWrappers;
-    }
-        const arrayField = arrayFieldObj;
-                                                const primitiveFieldKey = !isObjectTemplate ? template.key : undefined;
-    const metadataTemplate = isObjectTemplate ? buildObjectItemTemplate(template, removeButton) : template;
-    setNormalizedArrayMetadata(arrayFieldObj, {
-        ...(hasAutoRemove && { autoRemoveButton: buildRemoveButton(removeButton) }),
-        ...(primitiveFieldKey && { primitiveFieldKey }),
-        template: metadataTemplate,
-    });
-        let addButtonField;
-    if (addButton !== false) {
-        const buttonConfig = (typeof addButton === 'object' ? addButton : {});
-                addButtonField = {
-            key: `${key}__add`,
-            type: 'addArrayItem',
-            label: buttonConfig.label ?? 'Add',
-            arrayKey: key,
-            template: addTemplate,
-            ...(buttonConfig.props && { props: buttonConfig.props }),
-                                    ...(logic && { logic }),
-        };
-    }
-    return { arrayField, addButton: addButtonField };
-}
-function buildPrimitiveItem(template, value) {
-    return { ...template, value };
-}
-function buildObjectItem(template, valueObj, removeButton) {
-    const fieldsWithValues = template.map((templateField) => ({
-        ...templateField,
-        ...(Object.hasOwn(valueObj, templateField.key) && { value: valueObj[templateField.key] }),
-    }));
-    if (removeButton === false) {
-        return fieldsWithValues;
-    }
-    return [...fieldsWithValues, buildRemoveButton(removeButton)];
-}
-function buildObjectItemTemplate(template, removeButton) {
-    if (removeButton === false) {
-        return template;
-    }
-    return [...template, buildRemoveButton(removeButton)];
-}
-function buildRemoveButton(config) {
-    const buttonConfig = (typeof config === 'object' ? config : {});
-        return {
-        key: '__remove',
-        type: 'removeArrayItem',
-        label: buttonConfig.label ?? 'Remove',
-        ...(buttonConfig.props && { props: buttonConfig.props }),
-    };
-}
-
-function isContainerWithFields(field) {
-    return ((field.type === 'row' || field.type === 'group' || field.type === 'page' || field.type === 'container') &&
-        'fields' in field &&
-        Array.isArray(field.fields));
-}
-function isPagedForm(fields) {
-    if (!fields || fields.length === 0) {
-        return false;
-    }
-    return fields.every((field) => isPageField(field));
-}
-function isNonPagedForm(fields) {
-    if (!fields || fields.length === 0) {
-        return true;     }
-    return !hasAnyPageFields(fields);
-}
-function detectFormMode(fields) {
-    if (!fields || fields.length === 0) {
-        return {
-            mode: 'non-paged',
-            isValid: true,
-            errors: [],
-        };
-    }
-    const hasPageFields = fields.some((field) => isPageField(field));
-    const allPagesAtRoot = fields.every((field) => isPageField(field));
-    const hasNestedPages = hasNestedPageFields(fields);
-        if (hasPageFields) {
-        const errors = [];
-                if (!allPagesAtRoot) {
-            errors.push('Mixed page and non-page fields at root level. In paged forms, ALL root-level fields must be of type "page".');
-        }
-                if (hasNestedPages) {
-            errors.push('Page fields cannot contain nested page fields at any level.');
-        }
-        return {
-            mode: 'paged',
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-    else {
-                const errors = [];
-                if (hasAnyPageFields(fields)) {
-            errors.push('Page fields are not allowed in non-paged forms.');
-        }
-        return {
-            mode: 'non-paged',
-            isValid: errors.length === 0,
-            errors,
-        };
-    }
-}
-function hasAnyPageFields(fields) {
-    for (const field of fields) {
-        if (isPageField(field)) {
-            return true;
-        }
-                if (!isPageField(field) && isContainerWithFields(field)) {
-            if (hasAnyPageFields(field.fields)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function hasNestedPageFields(fields) {
-    for (const field of fields) {
-                if (isPageField(field) && isContainerWithFields(field)) {
-            if (hasAnyPageFields(field.fields)) {
-                return true;
-            }
-        }
-                if (!isPageField(field) && isContainerWithFields(field)) {
-            if (hasNestedPageFields(field.fields)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function isValidPagedForm(fields) {
-    const result = detectFormMode(fields);
-    return result.mode === 'paged' && result.isValid;
-}
-function isValidNonPagedForm(fields) {
-    const result = detectFormMode(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);
-        },
-    };
-}
-class ArrayItemRegistryService {
-    slots = new Map();
-        slotFor(arrayPath) {
-        let slot = this.slots.get(arrayPath);
-        if (!slot) {
-            slot = createSlot();
-            this.slots.set(arrayPath, slot);
-        }
-        return slot;
-    }
-        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();
-        registerSchema(schema) {
-        this.registeredSchemas.set(schema.name, schema);
-    }
-        getSchema(name) {
-        return this.registeredSchemas.get(name);
-    }
-        getAllSchemas() {
-        return new Map(this.registeredSchemas);
-    }
-        clearSchemas() {
-        this.registeredSchemas.clear();
-    }
-        resolveSchema(schema) {
-        if (typeof schema === 'string') {
-            return this.getSchema(schema) || null;
-        }
-        return schema;
-    }
-    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.14", ngImport: i0, type: SchemaRegistryService, decorators: [{
-            type: Injectable
-        }] });
-
-function isFunctionHttpValidator(config) {
-    const c = config;
-    return typeof c.functionName === 'string' || (c.fn !== null && typeof c.fn === 'object');
-}
-
-function resolveHttpRequest(config, context) {
-    let url = config.url;
-    if (config.params) {
-        for (const [key, expression] of Object.entries(config.params)) {
-            const value = ExpressionParser.evaluate(expression, context);
-            if (value == null) {
-                context.logger.debug(`HTTP request suppressed: path param '${key}' resolved to ${String(value)} ` +
-                    `(expression: '${expression}'). The request will not be sent.`);
-                return null;
-            }
-            url = url.replace(`:${key}`, encodeURIComponent(String(value)));
-        }
-    }
-    if (config.queryParams) {
-        const params = new URLSearchParams();
-        for (const [key, expression] of Object.entries(config.queryParams)) {
-            const value = ExpressionParser.evaluate(expression, context);
-            params.set(key, value != null ? String(value) : '');
-        }
-        const queryString = params.toString();
-        if (queryString) {
-            url += (url.includes('?') ? '&' : '?') + queryString;
-        }
-    }
-    const request = {
-        url,
-        method: config.method,
-    };
-    if (config.body) {
-        if (config.evaluateBodyExpressions) {
-            const resolvedBody = {};
-            for (const [key, value] of Object.entries(config.body)) {
-                if (typeof value === 'string') {
-                    resolvedBody[key] = ExpressionParser.evaluate(value, context);
-                }
-                else {
-                    resolvedBody[key] = value;
-                }
-            }
-            request.body = resolvedBody;
-        }
-        else {
-            request.body = config.body;
-        }
-    }
-    if (config.headers) {
-        request.headers = config.headers;
-    }
-    return request;
-}
-
-function evaluateHttpValidationResponse(response, mapping, logger) {
-    const scope = { response };
-    try {
-        const result = ExpressionParser.evaluate(mapping.validWhen, scope);
-        if (typeof result !== 'boolean') {
-            logger.warn(`validWhen expression "${mapping.validWhen}" returned non-boolean value:`, result, 'Expected true or false.');
-        }
-        if (result === true) {
-            return null;
-        }
-        const error = { kind: mapping.errorKind };
-        if (mapping.errorParams) {
-            for (const [key, expression] of Object.entries(mapping.errorParams)) {
-                try {
-                    error[key] = ExpressionParser.evaluate(expression, scope);
-                }
-                catch (err) {
-                    logger.warn(`Error evaluating errorParam "${key}":`, expression, err);
-                }
-            }
-        }
-        return error;
-    }
-    catch (err) {
-        logger.warn('Error evaluating validWhen expression:', mapping.validWhen, err);
-        return { kind: mapping.errorKind };
-    }
-}
-
-function stableStringify(value) {
-    if (value === null || value === undefined) {
-        return String(value);
-    }
-    if (typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return '[' + value.map(stableStringify).join(',') + ']';
-    }
-    const obj = value;
-    const sortedKeys = Object.keys(obj).sort();
-    const pairs = sortedKeys.map((key) => JSON.stringify(key) + ':' + stableStringify(obj[key]));
-    return '{' + pairs.join(',') + '}';
+                return [field];
+    });
 }
-
-class HttpConditionCache {
-    cache = new Map();
-    maxEntries;
-    constructor(maxEntries = 100) {
-        this.maxEntries = Math.max(1, maxEntries);
-    }
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return undefined;
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return undefined;
-        }
-        return entry.value;
-    }
-    set(key, value, ttlMs) {
-                while (this.cache.size >= this.maxEntries && !this.cache.has(key)) {
-            const oldestKey = this.cache.keys().next().value;
-            if (oldestKey !== undefined) {
-                this.cache.delete(oldestKey);
+const INVALID_ARRAY_CHILD_TYPES = new Set(['page', 'array']);
+function validateSimplifiedTemplate(field) {
+    const { template, key } = field;
+    const isObjectTemplate = Array.isArray(template);
+    if (isObjectTemplate) {
+        const templateFields = template;
+        for (const tmpl of templateFields) {
+                                    if (INVALID_ARRAY_CHILD_TYPES.has(tmpl.type)) {
+                throw new DynamicFormError(`Simplified array "${key}" template contains a '${tmpl.type}' field (key: '${tmpl.key}'). ` +
+                    `Only leaf fields, rows, and groups are allowed as array children.`);
             }
         }
-        this.cache.set(key, { value, expiresAt: Date.now() + ttlMs });
-    }
-    clear() {
-        this.cache.clear();
     }
-}
-const HTTP_CONDITION_CACHE = new InjectionToken('HttpConditionCache');
-
-class HttpConditionFunctionCacheService {
-        httpConditionFunctionCache = new Map();
-}
-
-function isSignalArray(value) {
-    return Array.isArray(value) && value.every((item) => isSignal(item));
-}
-function isSignalRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.values(value).every((item) => isSignal(item));
-}
-function derivedFromDeferred(source, operator, options) {
-    const deferred$ = defer(() => {
-                if (isSignal(source)) {
-            return toObservable(source, { injector: options.injector });
-        }
-                if (isSignalArray(source)) {
-            const observables = source.map((s) => toObservable(s, { injector: options.injector }));
-            return combineLatest(observables);
-        }
-                if (isSignalRecord(source)) {
-            const keys = Object.keys(source);
-            const observables = keys.map((key) => toObservable(source[key], { injector: options.injector }));
-            return combineLatest(observables, (...values) => {
-                const result = {};
-                keys.forEach((key, index) => {
-                    result[key] = values[index];
-                });
-                return result;
-            });
-        }
-                throw new Error('Invalid source type. Expected a Signal, array of Signals, or object of Signals.');
-    }).pipe(operator);
-    return toSignal(deferred$, { initialValue: options.initialValue, injector: options.injector });
-}
-
-function withPreviousValue(input) {
-    const derived = linkedSignal({ ...(ngDevMode ? { debugName: "derived" } : /* istanbul ignore next */ {}), source: input.snapshot,
-        computation: (snapshot, previous) => {
-                                    if ((snapshot.status === 'loading' || snapshot.status === 'reloading') &&
-                previous !== undefined &&
-                previous.value.status !== 'error') {
-                return { status: snapshot.status, value: previous.value.value };
-            }
-            return snapshot;
-        } });
-    return resourceFromSnapshots(derived);
-}
-
-function createDebouncedResourceLogicFn(config) {
-    const perFunctionSignalStore = new Map();
-    return (ctx) => {
-        const contextKey = safeReadPathKeys(ctx).join('.');
-        let handle = perFunctionSignalStore.get(contextKey);
-        if (!handle) {
-            const trigger = signal(undefined, ...(ngDevMode ? [{ debugName: "trigger" }] : /* istanbul ignore next */ []));
-                                                            const resultResource = untracked(() => {
-                const debouncedTrigger = derivedFromDeferred(trigger, pipe(debounceTime(config.debounceMs), 
-                                                distinctUntilChanged((a, b) => a?.key === b?.key)), { initialValue: undefined, injector: config.injector });
-                const resource = rxResource({
-                    params: () => debouncedTrigger(),
-                                        stream: ({ params }) => config.buildStream(params.payload),
-                    defaultValue: config.pendingValue,
-                    injector: config.injector,
-                });
-                return withPreviousValue(resource);
-            });
-            handle = { trigger, resultResource, refetchVersion: 0 };
-            perFunctionSignalStore.set(contextKey, handle);
-        }
-        const resolved = config.resolve(ctx);
-        if (resolved.kind === 'returnEarly') {
-            handle.refetchVersion++;
-            return resolved.value;
-        }
-        if (resolved.kind === 'holdPrevious') {
-            return handle.resultResource.value();
-        }
-        const dedupKey = `${resolved.key}::${handle.refetchVersion}`;
-        const newTrigger = { key: dedupKey, payload: resolved.payload };
-        untracked(() => {
-            const current = handle.trigger();
-                        if (current?.key !== newTrigger.key) {
-                handle.trigger.set(newTrigger);
-            }
-        });
-        return handle.resultResource.value();
-    };
-}
-
-function extractBoolean(response, responseExpression, pendingValue, logger) {
-    if (responseExpression) {
-        try {
-            const result = ExpressionParser.evaluate(responseExpression, { response });
-            if (typeof result !== 'boolean') {
-                logger.warn(`responseExpression "${responseExpression}" returned non-boolean value:`, result, 'Consider returning a boolean explicitly.');
-            }
-            return !!result;
-        }
-        catch (error) {
-            logger.warn(`Failed to evaluate responseExpression '${responseExpression}':`, error);
-            return pendingValue;
+    else {
+        const singleTemplate = template;
+        if (INVALID_ARRAY_CHILD_TYPES.has(singleTemplate.type)) {
+            throw new DynamicFormError(`Simplified array "${key}" template has type '${singleTemplate.type}'. ` +
+                `Only leaf fields, rows, and groups are allowed as array children.`);
         }
     }
-    return !!response;
-}
-function createHttpConditionLogicFunction(condition) {
-    const httpClient = inject(HttpClient, { optional: true });
-    if (!httpClient) {
-        throw new DynamicFormError('HttpClient is required for HTTP conditions. Add provideHttpClient() to your providers.');
-    }
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const functionRegistry = inject(FunctionRegistryService);
-    const injector = inject(Injector);
-    const cache = inject(HTTP_CONDITION_CACHE);
-    const logger = inject(DynamicFormLogger);
-    const cacheService = inject(HttpConditionFunctionCacheService);
-    const pendingValue = condition.pendingValue ?? false;
-    const cacheDurationMs = condition.cacheDurationMs ?? 30000;
-    const debounceMs = condition.debounceMs ?? 300;
-        const cacheKey = stableStringify(condition);
-    const cached = cacheService.httpConditionFunctionCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const fn = createDebouncedResourceLogicFn({
-        pendingValue,
-        debounceMs,
-        injector,
-        resolve: (ctx) => {
-            const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-            const resolved = resolveHttpRequest(condition.http, evaluationContext);
-                                    if (!resolved)
-                return { kind: 'holdPrevious' };
-            const requestKey = stableStringify(resolved);
-            const cachedResult = cache.get(requestKey);
-            if (cachedResult !== undefined)
-                return { kind: 'returnEarly', value: cachedResult };
-            return { kind: 'trigger', key: requestKey, payload: resolved };
-        },
-        buildStream: (request) => {
-            const method = request.method ?? 'GET';
-            const options = {};
-            if (request.body !== undefined)
-                options['body'] = request.body;
-            if (request.headers)
-                options['headers'] = request.headers;
-            return httpClient.request(method, request.url, options).pipe(map((response) => extractBoolean(response, condition.responseExpression, pendingValue, logger)), tap((value) => {
-                const requestKey = stableStringify(request);
-                cache.set(requestKey, value, cacheDurationMs);
-            }), catchError((error) => {
-                logger.warn('HTTP condition request failed:', error);
-                return of(pendingValue);
-            }));
-        },
-    });
-    cacheService.httpConditionFunctionCache.set(cacheKey, fn);
-    return fn;
 }
-
-class AsyncConditionFunctionCacheService {
-        asyncConditionFunctionCache = new Map();
-}
-
-function createAsyncConditionLogicFunction(condition) {
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const functionRegistry = inject(FunctionRegistryService);
-    const injector = inject(Injector);
-    const logger = inject(DynamicFormLogger);
-    const cacheService = inject(AsyncConditionFunctionCacheService);
-    const pendingValue = condition.pendingValue ?? false;
-    const debounceMs = condition.debounceMs ?? 300;
-    if (condition.asyncFn && condition.asyncFunctionName) {
-        logger.warn('Both "asyncFn" and "asyncFunctionName" are set on async condition. Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.');
-    }
-                const cacheKey = condition.asyncFn ? undefined : stableStringify(condition);
-    if (cacheKey !== undefined) {
-        const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
-        if (cached) {
-            return cached;
+function expandSimplifiedArray(field) {
+    const { template, value = [], addButton, removeButton, key, logic, minLength, maxLength, wrappers, skipAutoWrappers, skipDefaultWrappers, } = field;
+    const isObjectTemplate = Array.isArray(template);
+    const values = value;
+        validateSimplifiedTemplate(field);
+        const items = values.map((v) => {
+        if (isObjectTemplate) {
+            return buildObjectItem(template, v, removeButton);
         }
-    }
-    const fn = createDebouncedResourceLogicFn({
-        pendingValue,
-        debounceMs,
-        injector,
-        resolve: (ctx) => {
-                                                const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-            const key = stableStringify({
-                formValue: evaluationContext.formValue,
-                fieldValue: evaluationContext.fieldValue,
-                externalData: evaluationContext.externalData,
-            });
-            return { kind: 'trigger', key, payload: ctx };
-        },
-        buildStream: (capturedCtx) => {
-                                    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.`);
-                return of(pendingValue);
-            }
-            const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(capturedCtx, functionRegistry.getCustomFunctions());
-                                    return from(asyncFn(evaluationContext)).pipe(map((result) => !!result), catchError((error) => {
-                logger.warn('Async Condition - function failed:', error);
-                return of(pendingValue);
-            }));
-        },
+        return buildPrimitiveItem(template, v);
     });
-    if (cacheKey !== undefined) {
-        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
-    }
-    return fn;
-}
-
-class LogicFunctionCacheService {
-        logicFunctionCache = new Map();
-        debouncedLogicFunctionCache = new Map();
-        debouncedSignalStore = new Map();
-}
-
-function validateNoNestedHttpConditions(expression) {
-    if (expression.type === 'and' || expression.type === 'or') {
-        for (const sub of expression.conditions) {
-            if (sub.type === 'http' || sub.type === 'async') {
-                const label = sub.type === 'http' ? 'HTTP' : 'Async';
-                throw new DynamicFormError(`${label} conditions cannot be nested inside '${expression.type}' composites. ` +
-                    `Move the ${label} condition to a separate logic entry on the field.`);
-            }
-            validateNoNestedHttpConditions(sub);
-        }
-    }
-}
-function createLogicFunction(expression) {
-        if (expression?.type === 'async') {
-        return createAsyncConditionLogicFunction(expression);
-    }
-        if (expression?.type === 'http') {
-        return createHttpConditionLogicFunction(expression);
-    }
-        if (expression) {
-        validateNoNestedHttpConditions(expression);
-    }
-        const functionRegistry = inject(FunctionRegistryService);
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const cacheService = inject(LogicFunctionCacheService);
-        const cacheKey = stableStringify(expression);
-        const cached = cacheService.logicFunctionCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const fn = (ctx) => {
-                        const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-        return evaluateCondition(expression, evaluationContext);
-    };
-        cacheService.logicFunctionCache.set(cacheKey, fn);
-    return fn;
-}
-function createDebouncedLogicFunction(expression, debounceMs) {
-        if (expression?.type === 'async') {
-        return createAsyncConditionLogicFunction(expression);
-    }
-        if (expression?.type === 'http') {
-        return createHttpConditionLogicFunction(expression);
-    }
-        if (expression) {
-        validateNoNestedHttpConditions(expression);
-    }
-        const functionRegistry = inject(FunctionRegistryService);
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const injector = inject(Injector);
-    const cacheService = inject(LogicFunctionCacheService);
-        const cacheKey = `${stableStringify(expression)}:${debounceMs}`;
-        const cached = cacheService.debouncedLogicFunctionCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const fn = (ctx) => {
-        const contextKey = safeReadPathKeys(ctx).join('.');
-        let signalPair = cacheService.debouncedSignalStore.get(contextKey);
-        if (!signalPair) {
-                        const immediateValue = signal(false, ...(ngDevMode ? [{ debugName: "immediateValue" }] : /* istanbul ignore next */ []));
-                                                const debouncedValue = untracked(() => {
-                const immediateValue$ = toObservable(immediateValue, { injector }).pipe(debounceTime(debounceMs), distinctUntilChanged(), startWith(false));
-                return toSignal(immediateValue$, { injector, initialValue: false });
-            });
-            signalPair = { immediateValue, debouncedValue };
-            cacheService.debouncedSignalStore.set(contextKey, signalPair);
-        }
-                const evaluationContext = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-                const result = evaluateCondition(expression, evaluationContext);
-                        const { immediateValue, debouncedValue } = signalPair;
-        untracked(() => {
-            if (immediateValue() !== result) {
-                immediateValue.set(result);
-            }
-        });
-                return debouncedValue() ?? false;
-    };
-        cacheService.debouncedLogicFunctionCache.set(cacheKey, fn);
-    return fn;
-}
-
-class DynamicValueFunctionCacheService {
-        dynamicValueFunctionCache = new Map();
-}
-
-function createDynamicValueFunction(expression) {
-            const fieldContextRegistry = inject(FieldContextRegistryService);
-    const logger = inject(DynamicFormLogger);
-    const cacheService = inject(DynamicValueFunctionCacheService);
-        const cached = cacheService.dynamicValueFunctionCache.get(expression);
-    if (cached) {
-        return cached;
-    }
-    const fn = (ctx) => {
-                const evaluationContext = fieldContextRegistry.createEvaluationContext(ctx);
-        try {
-                        return ExpressionParser.evaluate(expression, evaluationContext);
-        }
-        catch (error) {
-            logger.error('Error evaluating dynamic expression:', expression, error);
-            return undefined;
-        }
-    };
-        cacheService.dynamicValueFunctionCache.set(expression, fn);
-    return fn;
-}
-
-function createDefaultDerivationLogConfig() {
-    return {
-        level: 'none',
+                const addTemplate = isObjectTemplate
+        ? buildObjectItemTemplate(template, removeButton)
+        : template;
+                const hasAutoRemove = !isObjectTemplate && removeButton !== false;
+        const arrayFieldObj = {
+        key,
+        type: 'array',
+        fields: items,
     };
-}
-function shouldLog(config, minLevel) {
-    if (config.level === 'none')
-        return false;
-    if (minLevel === 'summary')
-        return config.level === 'summary' || config.level === 'verbose';
-    return config.level === 'verbose';
-}
-function isFormStateCondition(condition) {
-    return typeof condition === 'string' && ['formInvalid', 'formSubmitting', 'pageInvalid'].includes(condition);
-}
-function isStateLogicConfig(config) {
-    return config.type === 'hidden' || config.type === 'readonly' || config.type === 'disabled' || config.type === 'required';
-}
-function isDerivationLogicConfig(config) {
-    return config.type === 'derivation';
-}
-function hasTargetProperty(config) {
-    return 'targetProperty' in config && typeof config.targetProperty === 'string' && config.targetProperty.length > 0;
-}
-
-const FORM_VALUE_ACCESS_PATTERN = /\bformValue\s*(?:\.|\[)/;
-const FORM_VALUE_PATTERN = /\bformValue\s*(?:\.([\w.]+)|\[\s*'([\w.-]+)'\s*\]|\[\s*"([\w.-]+)"\s*\])/g;
-function isCrossFieldExpression(expr, context) {
-        if (expr === undefined || typeof expr === 'boolean' || isFormStateCondition(expr)) {
-        return false;
-    }
-    switch (expr.type) {
-        case 'fieldValue':
-                        return !!expr.fieldPath;
-        case 'javascript':
-                        return FORM_VALUE_ACCESS_PATTERN.test(expr.expression || '');
-        case 'custom': {
-                                    const functionName = expr.functionName;
-            if (context?.getFunctionScope && functionName) {
-                const scope = context.getFunctionScope(functionName);
-                if (scope === 'field') {
-                                        return false;
-                }
-                            }
-                        return true;
-        }
-        case 'async':
-                                    return false;
-        case 'and':
-        case 'or':
-                        return (expr.conditions || []).some((c) => isCrossFieldExpression(c, context));
-        default:
-            return false;
-    }
-}
-function extractExpressionDependencies(expr) {
-    if (expr === undefined || typeof expr === 'boolean') {
-        return [];
-    }
-    const deps = new Set();
-    switch (expr.type) {
-        case 'fieldValue':
-            if (expr.fieldPath) {
-                                deps.add(expr.fieldPath.split('.')[0]);
-            }
-            break;
-        case 'javascript':
-                        extractFromExpressionString(expr.expression || '', deps);
-            break;
-        case 'custom':
-                        deps.add('*');
-            break;
-        case 'async':
-                        break;
-        case 'and':
-        case 'or':
-                        for (const condition of expr.conditions || []) {
-                extractExpressionDependencies(condition).forEach((d) => deps.add(d));
-            }
-            break;
-    }
-    return Array.from(deps);
-}
-function extractStringDependencies(expression) {
-    const deps = new Set();
-    extractFromExpressionString(expression, deps);
-    return Array.from(deps);
-}
-function extractFromExpressionString(expression, deps) {
-    for (const match of expression.matchAll(FORM_VALUE_PATTERN)) {
-        const fullPath = match[1] ?? match[2] ?? match[3];
-        if (!fullPath)
-            continue;
-                const rootField = fullPath.split('.')[0];
-        deps.add(rootField);
-                if (fullPath.includes('.')) {
-            deps.add(fullPath);
-        }
-    }
-}
-function isCrossFieldValidator(config) {
-    if (!config.expression) {
-        return false;
-    }
-    return FORM_VALUE_ACCESS_PATTERN.test(config.expression);
-}
-function isCrossFieldBuiltInValidator(config) {
-    if (config.type === 'custom') {
-        return false;     }
-        if ('expression' in config && typeof config.expression === 'string') {
-        return FORM_VALUE_ACCESS_PATTERN.test(config.expression);
-    }
-    return false;
-}
-function isResourceBasedValidator(config) {
-    return config.type === 'async' || config.type === 'http';
-}
-function hasCrossFieldWhenCondition(config, context) {
-    if (!('when' in config) || !config.when) {
-        return false;
-    }
-    return isCrossFieldExpression(config.when, context);
-}
-function isCrossFieldStateLogic(config, context) {
-    return isCrossFieldExpression(config.condition, context);
-}
-function isCrossFieldSchema(config, context) {
-    if (config.type !== 'applyWhen' || !config.condition) {
-        return false;
-    }
-    return isCrossFieldExpression(config.condition, context);
-}
-
-function applyEmailValidator(path) {
-    email(path);
-}
-function applyMinValidator(path, value, expression) {
-    if (expression) {
-        min(path, createDynamicValueFunction(expression));
-    }
-    else {
-        min(path, value);
-    }
-}
-function applyMaxValidator(path, value, expression) {
-    if (expression) {
-        max(path, createDynamicValueFunction(expression));
-    }
-    else {
-        max(path, value);
-    }
-}
-function applyMinLengthValidator(path, value, expression) {
-    if (expression) {
-        minLength(path, createDynamicValueFunction(expression));
-    }
-    else {
-        minLength(path, value);
-    }
-}
-function applyMaxLengthValidator(path, value, expression) {
-    if (expression) {
-        maxLength(path, createDynamicValueFunction(expression));
-    }
-    else {
-        maxLength(path, value);
-    }
-}
-function applyPatternValidator(path, value, expression) {
-    if (expression) {
-        pattern(path, createDynamicValueFunction(expression));
-    }
-    else {
-        pattern(path, value);
-    }
-}
-function createConditionalLogic(when) {
-    return when ? createLogicFunction(when) : undefined;
-}
-function applyValidator(config, fieldPath) {
-    const path = fieldPath;
-    if (!isResourceBasedValidator(config) && (isCrossFieldBuiltInValidator(config) || hasCrossFieldWhenCondition(config))) {
-        return;
-    }
-    switch (config.type) {
-        case 'required':
-            if (config.when) {
-                required(path, { when: createLogicFunction(config.when) });
-            }
-            else {
-                required(path);
-            }
-            break;
-        case 'email':
-            applyEmailValidator(fieldPath);
-            break;
-        case 'min':
-            if (typeof config.value === 'number') {
-                applyMinValidator(fieldPath, config.value, config.expression);
-            }
-            break;
-        case 'max':
-            if (typeof config.value === 'number') {
-                applyMaxValidator(fieldPath, config.value, config.expression);
-            }
-            break;
-        case 'minLength':
-            if (typeof config.value === 'number') {
-                applyMinLengthValidator(fieldPath, config.value, config.expression);
-            }
-            break;
-        case 'maxLength':
-            if (typeof config.value === 'number') {
-                applyMaxLengthValidator(fieldPath, config.value, config.expression);
-            }
-            break;
-        case 'pattern':
-            if (config.value instanceof RegExp || typeof config.value === 'string') {
-                let regexPattern;
-                if (typeof config.value === 'string') {
-                    try {
-                        regexPattern = new RegExp(config.value);
-                    }
-                    catch (e) {
-                        throw new DynamicFormError(`Invalid regex pattern in validator: '${config.value}' — ${e instanceof Error ? e.message : String(e)}`);
-                    }
-                }
-                else {
-                    regexPattern = config.value;
-                }
-                applyPatternValidator(fieldPath, regexPattern, config.expression);
-            }
-            break;
-        case 'custom':
-            applyCustomValidator(config, path);
-            break;
-        case 'async':
-            applyAsyncValidator(config, path);
-            break;
-        case 'http':
-            applyUnifiedHttpValidator(config, path);
-            break;
-    }
-}
-function applyCustomValidator(config, fieldPath) {
-    if (isCrossFieldValidator(config)) {
-        return;
+    if (logic) {
+        arrayFieldObj['logic'] = logic;
     }
-    let validatorFn;
-    if (config.expression) {
-        validatorFn = createExpressionValidator(config);
+    if (minLength !== undefined) {
+        arrayFieldObj['minLength'] = minLength;
     }
-    else if (config.fn || config.functionName) {
-        validatorFn = createFunctionValidator(config);
+    if (maxLength !== undefined) {
+        arrayFieldObj['maxLength'] = maxLength;
     }
-    else {
-        const logger = inject(DynamicFormLogger);
-        logger.warn('Custom validator must have one of "expression", "functionName", or "fn"');
-        return;
+    if (wrappers !== undefined) {
+        arrayFieldObj['wrappers'] = wrappers;
     }
-    const whenLogic = createConditionalLogic(config.when);
-    validate(fieldPath, (ctx) => {
-        if (whenLogic && !whenLogic(ctx))
-            return null;
-        return validatorFn(ctx);
-    });
-}
-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 (skipAutoWrappers !== undefined) {
+        arrayFieldObj['skipAutoWrappers'] = skipAutoWrappers;
     }
-    if (config.fn) {
-        const inlineFn = config.fn;
-        return (ctx) => inlineFn(ctx, config.params);
+    if (skipDefaultWrappers !== undefined) {
+        arrayFieldObj['skipDefaultWrappers'] = skipDefaultWrappers;
     }
-    const functionName = config.functionName;
-    if (!functionName) {
-        logger.warn('Custom validator missing functionName');
-        return () => null;
+        const arrayField = arrayFieldObj;
+                                                const primitiveFieldKey = !isObjectTemplate ? template.key : undefined;
+    const metadataTemplate = isObjectTemplate ? buildObjectItemTemplate(template, removeButton) : template;
+    setNormalizedArrayMetadata(arrayFieldObj, {
+        ...(hasAutoRemove && { autoRemoveButton: buildRemoveButton(removeButton) }),
+        ...(primitiveFieldKey && { primitiveFieldKey }),
+        template: metadataTemplate,
+    });
+        let addButtonField;
+    if (addButton !== false) {
+        const buttonConfig = (typeof addButton === 'object' ? addButton : {});
+                addButtonField = {
+            key: `${key}__add`,
+            type: 'addArrayItem',
+            label: buttonConfig.label ?? 'Add',
+            arrayKey: key,
+            template: addTemplate,
+            ...(buttonConfig.props && { props: buttonConfig.props }),
+                                    ...(logic && { logic }),
+        };
     }
-    const registry = inject(FunctionRegistryService);
-    const validatorFn = registry.getValidator(functionName);
-    if (!validatorFn) {
-        throw new DynamicFormError(`Custom validator "${functionName}" not found. Register it with customFnConfig.validators.`);
+    return { arrayField, addButton: addButtonField };
+}
+function buildPrimitiveItem(template, value) {
+    return { ...template, value };
+}
+function buildObjectItem(template, valueObj, removeButton) {
+    const fieldsWithValues = template.map((templateField) => ({
+        ...templateField,
+        ...(Object.hasOwn(valueObj, templateField.key) && { value: valueObj[templateField.key] }),
+    }));
+    if (removeButton === false) {
+        return fieldsWithValues;
     }
-    return (ctx) => validatorFn(ctx, config.params);
+    return [...fieldsWithValues, buildRemoveButton(removeButton)];
 }
-function createExpressionValidator(config) {
-    const logger = inject(DynamicFormLogger);
-    const expression = config.expression;
-    if (!expression) {
-        logger.warn('Custom validator missing expression');
-        return () => null;
+function buildObjectItemTemplate(template, removeButton) {
+    if (removeButton === false) {
+        return template;
     }
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const functionRegistry = inject(FunctionRegistryService);
-    return (ctx) => {
-        try {
-            const evaluationContext = fieldContextRegistry.createEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-            const result = ExpressionParser.evaluate(expression, evaluationContext);
-            if (result) {
-                return null;
-            }
-            const kind = config.kind || 'custom';
-            const validationError = { kind };
-            if (config.errorParams) {
-                Object.entries(config.errorParams).forEach(([key, expression]) => {
-                    try {
-                        validationError[key] = ExpressionParser.evaluate(expression, evaluationContext);
-                    }
-                    catch (err) {
-                        logger.warn(`Error evaluating errorParam "${key}":`, expression, err);
-                    }
-                });
-            }
-            return validationError;
-        }
-        catch (error) {
-                                    logger.error('Error evaluating custom validator expression:', expression, error);
-            return { kind: config.kind || 'custom' };
-        }
+    return [...template, buildRemoveButton(removeButton)];
+}
+function buildRemoveButton(config) {
+    const buttonConfig = (typeof config === 'object' ? config : {});
+        return {
+        key: '__remove',
+        type: 'removeArrayItem',
+        label: buttonConfig.label ?? 'Remove',
+        ...(buttonConfig.props && { props: buttonConfig.props }),
     };
 }
-function applyAsyncValidator(config, fieldPath) {
-    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 {
-                throw new DynamicFormError('Async validator requires one of "functionName" or "fn".');
-    }
-    const whenLogic = createConditionalLogic(config.when);
-    const asyncOptions = {
-        params: (ctx) => {
-            if (whenLogic && !whenLogic(ctx))
-                return undefined;
-            return validatorConfig.params(ctx, config.params);
+
+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);
         },
-        factory: validatorConfig.factory,
-        onSuccess: validatorConfig.onSuccess,
-        onError: validatorConfig.onError,
     };
-    validateAsync(fieldPath, asyncOptions);
 }
-function applyUnifiedHttpValidator(config, fieldPath) {
-    if (isFunctionHttpValidator(config)) {
-        applyFunctionHttpValidator(config, fieldPath);
-        return;
+class ArrayItemRegistryService {
+    slots = new Map();
+        slotFor(arrayPath) {
+        let slot = this.slots.get(arrayPath);
+        if (!slot) {
+            slot = createSlot();
+            this.slots.set(arrayPath, slot);
+        }
+        return slot;
     }
-                const declarative = config;
-    if (!declarative.http || !declarative.responseMapping) {
-        throw new DynamicFormError('HTTP validator requires one of "functionName" / "fn" (function-based) or "http" + "responseMapping" (declarative).');
+        clearAll() {
+        for (const slot of this.slots.values())
+            slot.clear();
+        this.slots.clear();
     }
-    applyDeclarativeHttpValidator(config, fieldPath);
+    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 });
 }
-function applyFunctionHttpValidator(config, fieldPath) {
-    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.');
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ArrayItemRegistryService, decorators: [{
+            type: Injectable
+        }] });
+
+class SchemaRegistryService {
+    registeredSchemas = new Map();
+        registerSchema(schema) {
+        this.registeredSchemas.set(schema.name, schema);
     }
-    let httpValidatorConfig;
-    if (config.fn) {
-        httpValidatorConfig = config.fn;
+        getSchema(name) {
+        return this.registeredSchemas.get(name);
     }
-    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.`);
-        }
+        getAllSchemas() {
+        return new Map(this.registeredSchemas);
     }
-    else {
-                throw new DynamicFormError('HTTP validator requires one of "functionName" or "fn".');
+        clearSchemas() {
+        this.registeredSchemas.clear();
     }
-    const whenLogic = createConditionalLogic(config.when);
-    const httpOptions = {
-        request: (ctx) => {
-            if (whenLogic && !whenLogic(ctx))
-                return undefined;
-            return httpValidatorConfig.request(ctx, config.params);
-        },
-        onSuccess: httpValidatorConfig.onSuccess,
-        onError: httpValidatorConfig.onError,
-    };
-    validateHttp(fieldPath, httpOptions);
-}
-function applyDeclarativeHttpValidator(config, fieldPath) {
-    const fieldContextRegistry = inject(FieldContextRegistryService);
-    const functionRegistry = inject(FunctionRegistryService);
-    const logger = inject(DynamicFormLogger);
-    const whenLogic = createConditionalLogic(config.when);
-    validateHttp(fieldPath, {
-        request: (ctx) => {
-            if (whenLogic && !whenLogic(ctx))
-                return undefined;
-                                                const evalCtx = fieldContextRegistry.createReactiveEvaluationContext(ctx, functionRegistry.getCustomFunctions());
-                        return resolveHttpRequest(config.http, evalCtx) ?? undefined;
-        },
-        onSuccess: (response) => {
-            return evaluateHttpValidationResponse(response, config.responseMapping, logger);
-        },
-        onError: (error) => {
-            logger.warn('HTTP validator request failed:', error);
-            return { kind: config.responseMapping.errorKind };
-        },
-    });
-}
-function applyValidators(configs, fieldPath) {
-    configs.forEach((config) => applyValidator(config, fieldPath));
+        resolveSchema(schema) {
+        if (typeof schema === 'string') {
+            return this.getSchema(schema) || null;
+        }
+        return schema;
+    }
+    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.14", ngImport: i0, type: SchemaRegistryService, decorators: [{
+            type: Injectable
+        }] });
 
 const DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
 
@@ -4225,15 +1560,6 @@ function collectFieldsFromObjectItem(itemFields, allFields) {
     }
 }
 
-const FIELD_REGISTRY = new InjectionToken('FIELD_REGISTRY', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-function getFieldValueHandling(fieldType, registry) {
-    const definition = registry.get(fieldType);
-    return definition?.valueHandling ?? 'include';
-}
-
 function getFieldDefaultValue(field, registry) {
     const valueHandling = getFieldValueHandling(field.type, registry);
         if (valueHandling === 'exclude') {
@@ -4304,227 +1630,37 @@ function getFieldDefaultValue(field, registry) {
         if (!itemDefinitions || itemDefinitions.length === 0) {
             return [];
         }
-                return itemDefinitions.map((itemDef) => {
-                                    if (!Array.isArray(itemDef)) {
-                return getFieldDefaultValue(itemDef, registry);
-            }
-                        const itemFields = itemDef;
-            let itemValue = {};
-            for (const templateField of itemFields) {
-                const fieldValue = getFieldDefaultValue(templateField, registry);
-                const fieldValueHandling = getFieldValueHandling(templateField.type, registry);
-                if (templateField.type === 'group' && 'key' in templateField && templateField.key) {
-                                        itemValue[templateField.key] = fieldValue;
-                }
-                else if (templateField.type === 'row' || templateField.type === 'container') {
-                                        if (fieldValue && typeof fieldValue === 'object') {
-                        itemValue = { ...itemValue, ...fieldValue };
-                    }
-                }
-                else if (fieldValueHandling === 'include' && 'key' in templateField && templateField.key) {
-                    itemValue[templateField.key] = fieldValue;
-                }
-            }
-            return itemValue;
-        });
-    }
-                        if (field.type === 'input' && 'props' in field) {
-        const props = field.props;
-        if (props?.type === 'number') {
-            return NaN;
-        }
-    }
-    return '';
-}
-
-function isEqual(a, b) {
-    return isEqualInternal(a, b, new WeakMap(), new WeakMap());
-}
-function isEqualInternal(a, b, seenA, seenB) {
-        if (a === b)
-        return true;
-        if (typeof a === 'number' && typeof b === 'number') {
-        return Object.is(a, b);
-    }
-        if (a == null || b == null)
-        return false;
-        if (typeof a !== typeof b)
-        return false;
-        if (typeof a !== 'object') {
-        return Object.is(a, b);
-    }
-        const objA = a;
-    const objB = b;
-        if (seenA.has(objA) || seenB.has(objB)) {
-                return seenA.get(objA) === objB && seenB.get(objB) === objA;
-    }
-        seenA.set(objA, objB);
-    seenB.set(objB, objA);
-        if (objA.constructor !== objB.constructor)
-        return false;
-        if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-    }
-        if (a instanceof RegExp && b instanceof RegExp) {
-        return a.source === b.source && a.flags === b.flags;
-    }
-        if (a instanceof Map && b instanceof Map) {
-        if (a.size !== b.size)
-            return false;
-        for (const [key, value] of a) {
-            if (!b.has(key) || !isEqualInternal(value, b.get(key), seenA, seenB)) {
-                return false;
-            }
-        }
-        return true;
-    }
-        if (a instanceof Set && b instanceof Set) {
-        if (a.size !== b.size)
-            return false;
-        for (const value of a) {
-            if (!b.has(value)) {
-                                                if (typeof value === 'object' && value !== null) {
-                    let found = false;
-                    for (const bValue of b) {
-                        if (typeof bValue === 'object' && bValue !== null && isEqualInternal(value, bValue, seenA, seenB)) {
-                            found = true;
-                            break;
-                        }
-                    }
-                    if (!found)
-                        return false;
-                }
-                else {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-        if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        return a.every((item, index) => isEqualInternal(item, b[index], seenA, seenB));
-    }
-        const recordA = a;
-    const recordB = b;
-        const keysA = [...Object.keys(recordA), ...Object.getOwnPropertySymbols(recordA)];
-    const keysB = [...Object.keys(recordB), ...Object.getOwnPropertySymbols(recordB)];
-    if (keysA.length !== keysB.length)
-        return false;
-        const keySetB = new Set(keysB);
-    return keysA.every((key) => keySetB.has(key) && isEqualInternal(recordA[key], recordB[key], seenA, seenB));
-}
-function omit(obj, keys) {
-    const result = { ...obj };
-    keys.forEach((key) => delete result[key]);
-    return result;
-}
-function keyBy(array, key) {
-    return array.reduce((acc, item) => {
-        acc[String(item[key])] = item;
-        return acc;
-    }, {});
-}
-function mapValues(obj, fn) {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        acc[key] = fn(value, key);
-        return acc;
-    }, {});
-}
-function deepMergeDefaults(defaults, value) {
-    if (value == null)
-        return { ...defaults };
-    const result = { ...defaults };
-    for (const key of Object.keys(value)) {
-        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
-            continue;
-        const incoming = value[key];
-        const existing = result[key];
-        if (isPlainObject(existing) && isPlainObject(incoming)) {
-            result[key] = deepMergeDefaults(existing, incoming);
-        }
-        else if (Array.isArray(existing) && Array.isArray(incoming)) {
-            result[key] = mergeArrayDefaults(existing, incoming);
-        }
-        else {
-            result[key] = incoming;
-        }
-    }
-    return result;
-}
-function mergeArrayDefaults(defaults, value) {
-    if (defaults.length !== value.length)
-        return value;
-                if (!value.some((item, i) => isPlainObject(defaults[i]) && isPlainObject(item)))
-        return value;
-    return value.map((item, i) => {
-        const defaultItem = defaults[i];
-        if (isPlainObject(defaultItem) && isPlainObject(item)) {
-            return deepMergeDefaults(defaultItem, item);
-        }
-        return item;
-    });
-}
-function isPlainObject(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === null || proto === Object.prototype;
-}
-const DEFAULT_MEMOIZE_MAX_SIZE = 100;
-function memoize(fn, resolverOrOptions) {
-    const options = typeof resolverOrOptions === 'function' ? { resolver: resolverOrOptions } : (resolverOrOptions ?? {});
-    const { resolver, maxSize = DEFAULT_MEMOIZE_MAX_SIZE } = options;
-    const cache = new Map();
-    return ((...args) => {
-        const key = resolver ? resolver(...args) : JSON.stringify(args);
-        const cachedValue = cache.get(key);
-        if (cachedValue !== undefined) {
-            cache.delete(key);
-            cache.set(key, cachedValue);
-            return cachedValue;
-        }
-        const result = fn(...args);
-        if (cache.size >= maxSize) {
-            const oldestKey = cache.keys().next().value;
-            if (oldestKey !== undefined) {
-                cache.delete(oldestKey);
-            }
-        }
-        cache.set(key, result);
-        return result;
-    });
-}
-function normalizeFieldsArray(fields) {
-    return Array.isArray(fields) ? [...fields] : Object.values(fields);
-}
-function getChangedKeys(previous, current) {
-    const changedKeys = new Set();
-        if (!previous && !current)
-        return changedKeys;
-    if (!previous) {
-        return new Set(Object.keys(current ?? {}));
-    }
-    if (!current) {
-        return new Set(Object.keys(previous));
-    }
-        const allKeys = new Set([...Object.keys(previous), ...Object.keys(current)]);
-        for (const key of allKeys) {
-        const prevValue = previous[key];
-        const currValue = current[key];
-                if (!(key in previous) || !(key in current)) {
-            changedKeys.add(key);
-            continue;
-        }
-                if (!isEqual(prevValue, currValue)) {
-            changedKeys.add(key);
+                return itemDefinitions.map((itemDef) => {
+                                    if (!Array.isArray(itemDef)) {
+                return getFieldDefaultValue(itemDef, registry);
+            }
+                        const itemFields = itemDef;
+            let itemValue = {};
+            for (const templateField of itemFields) {
+                const fieldValue = getFieldDefaultValue(templateField, registry);
+                const fieldValueHandling = getFieldValueHandling(templateField.type, registry);
+                if (templateField.type === 'group' && 'key' in templateField && templateField.key) {
+                                        itemValue[templateField.key] = fieldValue;
+                }
+                else if (templateField.type === 'row' || templateField.type === 'container') {
+                                        if (fieldValue && typeof fieldValue === 'object') {
+                        itemValue = { ...itemValue, ...fieldValue };
+                    }
+                }
+                else if (fieldValueHandling === 'include' && 'key' in templateField && templateField.key) {
+                    itemValue[templateField.key] = fieldValue;
+                }
+            }
+            return itemValue;
+        });
+    }
+                        if (field.type === 'input' && 'props' in field) {
+        const props = field.props;
+        if (props?.type === 'number') {
+            return NaN;
         }
     }
-    return changedKeys;
-}
-function assertNever(value) {
-    throw new DynamicFormError(`Unexpected value: ${JSON.stringify(value)}`);
+    return '';
 }
 
 function applyFormLevelSchema(path, formLevelSchema) {
@@ -4958,6 +2094,27 @@ function convertBuiltInToCustomValidator(config) {
     };
 }
 
+function inheritContainerExclusion(container, child) {
+    const inheritedHidden = container.hidden === true || child.inheritedExclusionState?.hidden === true;
+    const inheritedDisabled = container.disabled === true || child.inheritedExclusionState?.disabled === true;
+    const inheritedReadonly = container.readonly === true || child.inheritedExclusionState?.readonly === true;
+    const hasInheritedState = inheritedHidden || inheritedDisabled || inheritedReadonly;
+    const containerExcludeConfig = container.excludeValueIfHidden !== undefined ||
+        container.excludeValueIfDisabled !== undefined ||
+        container.excludeValueIfReadonly !== undefined;
+    if (!hasInheritedState && !containerExcludeConfig) {
+        return child;
+    }
+    return {
+        ...child,
+        ...(hasInheritedState
+            ? { inheritedExclusionState: { hidden: inheritedHidden, disabled: inheritedDisabled, readonly: inheritedReadonly } }
+            : {}),
+                excludeValueIfHidden: child.excludeValueIfHidden ?? container.excludeValueIfHidden,
+        excludeValueIfDisabled: child.excludeValueIfDisabled ?? container.excludeValueIfDisabled,
+        excludeValueIfReadonly: child.excludeValueIfReadonly ?? container.excludeValueIfReadonly,
+    };
+}
 function flattenFields(fields, registry, options = {}) {
     const result = [];
     let autoKeyCounter = 0;
@@ -4978,7 +2135,7 @@ function flattenFields(fields, registry, options = {}) {
                                     if (field.fields) {
                 const fields = field.fields;
                 const flattenedChildren = flattenFields(normalizeFieldsArray(fields), registry, options);
-                                                result.push(...flattenedChildren);
+                                                                                                                result.push(...flattenedChildren.map((child) => inheritContainerExclusion(field, child)));
             }
         }
         else if (isGroupField(field)) {
@@ -5063,64 +2220,6 @@ const CONTAINER_FIELD_PROCESSORS = new InjectionToken('CONTAINER_FIELD_PROCESSOR
     factory: () => createContainerFieldProcessors(),
 });
 
-function getGridClassString(fieldDef) {
-    const col = fieldDef.col;
-    if (typeof col === 'number' && Number.isInteger(col) && col > 0 && col <= 12) {
-        return `df-col-${col}`;
-    }
-    return '';
-}
-function buildClassName(fieldDef) {
-    const gridClass = getGridClassString(fieldDef);
-    const userClass = fieldDef.className;
-    const classes = [];
-    if (gridClass) {
-        classes.push(gridClass);
-    }
-    if (userClass) {
-        classes.push(userClass);
-    }
-    return classes.length > 0 ? classes.join(' ') : undefined;
-}
-
-function buildBaseInputs(fieldDef, defaultProps) {
-    const { key, label, className, tabIndex, props, meta, addons } = fieldDef;
-    const inputs = {};
-                        inputs['key'] = key;
-    if (label !== undefined) {
-        inputs['label'] = label;
-    }
-        const gridClassString = getGridClassString(fieldDef);
-    const allClasses = [];
-    if (gridClassString) {
-        allClasses.push(gridClassString);
-    }
-    if (className) {
-        allClasses.push(className);
-    }
-    if (allClasses.length > 0) {
-        inputs['className'] = allClasses.join(' ');
-    }
-    if (tabIndex !== undefined) {
-        inputs['tabIndex'] = tabIndex;
-    }
-            const fieldProps = props;
-    const mergedProps = fieldProps !== undefined || defaultProps !== undefined ? { ...(defaultProps ?? {}), ...(fieldProps ?? {}) } : undefined;
-    if (mergedProps !== undefined) {
-        inputs['props'] = mergedProps;
-    }
-    if (meta !== undefined) {
-        inputs['meta'] = meta;
-    }
-                    if (addons !== undefined) {
-        inputs['addons'] = addons;
-    }
-    return inputs;
-}
-function baseFieldMapper(fieldDef) {
-            return computed(() => buildBaseInputs(fieldDef));
-}
-
 const EMPTY_OVERRIDES = Object.freeze({});
 function createPropertyOverrideStore() {
     const store = new Map();
@@ -5452,7 +2551,7 @@ function createFieldResolutionPipe(getContext) {
         }
         const context = getContext();
         return forkJoin(fields.map((f) => resolveField(f, context)));
-    }), map((fields) => fields.filter((f) => f !== undefined)), scan$1(reconcileFields, []));
+    }), map((fields) => fields.filter((f) => f !== undefined)), scan(reconcileFields, []));
 }
 
 class FormModeValidator {
@@ -5565,6 +2664,9 @@ function collectFieldData(fields, data, registry, pathPrefix, collectKeys = true
     for (const field of fields) {
                                 const valueHandling = field.type ? getFieldValueHandling(field.type, registry) : 'include';
         const participatesInValue = valueHandling !== 'exclude' && valueHandling !== 'flatten';
+                if (field.key && field.key.includes('.') && participatesInValue) {
+            data.dottedKeys.push(field.key);
+        }
         if (collectKeys && field.key && participatesInValue) {
             const scopedKey = pathPrefix ? `${pathPrefix}.${field.key}` : field.key;
             data.keys.push(scopedKey);
@@ -5661,8 +2763,16 @@ function validateFormConfig(fields, registry, logger) {
         domIds: [],
         types: new Set(),
         regexErrors: [],
+        dottedKeys: [],
     };
     collectFieldData(fields, data, registry, '');
+    if (data.dottedKeys.length > 0) {
+        const list = Array.from(new Set(data.dottedKeys))
+            .map((k) => `'${k}'`)
+            .join(', ');
+        throw new DynamicFormError(`Field key(s) contain a dot: ${list}. Dotted keys are not supported — express nesting with 'group' fields ` +
+            `(e.g. { type: 'group', key: 'address', fields: [{ type: 'input', key: 'city' }] }).`);
+    }
     validateNoDuplicateKeys(data.keys);
     validateNoDomIdCollisions(data.domIds);
     validateFieldTypesRegistered(data.types, registry, logger);
@@ -5864,11 +2974,6 @@ function formatAddonWarning(w) {
     }
 }
 
-const ADDON_KIND_REGISTRY = new InjectionToken('ADDON_KIND_REGISTRY', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-
 const VALUE_EXCLUSION_DEFAULTS = new InjectionToken('VALUE_EXCLUSION_DEFAULTS', {
     providedIn: 'root',
     factory: () => ({
@@ -5887,15 +2992,16 @@ function resolveExclusionConfig(global, form, field) {
 }
 function shouldExcludeField(field, fieldState, config) {
     const state = fieldState();
-    const isHidden = state.hidden() || field.hidden === true;
+    const inherited = field.inheritedExclusionState;
+    const isHidden = state.hidden() || field.hidden === true || inherited?.hidden === true;
     if (config.excludeValueIfHidden && isHidden) {
         return true;
     }
-    const isDisabled = state.disabled() || field.disabled === true;
+    const isDisabled = state.disabled() || field.disabled === true || inherited?.disabled === true;
     if (config.excludeValueIfDisabled && isDisabled) {
         return true;
     }
-    const isReadonly = state.readonly() || field.readonly === true;
+    const isReadonly = state.readonly() || field.readonly === true || inherited?.readonly === true;
     if (config.excludeValueIfReadonly && isReadonly) {
         return true;
     }
@@ -5920,9 +3026,10 @@ function filterFormValue(rawValue, schemaFields, formTree, registry, globalDefau
         const resolvedConfig = resolveExclusionConfig(globalDefaults, formOptions, fieldExclusion);
                 const fieldState = formTree[key];
         if (!fieldState || typeof fieldState !== 'function') {
-            const staticallyExcluded = (resolvedConfig.excludeValueIfHidden && field.hidden === true) ||
-                (resolvedConfig.excludeValueIfDisabled && field.disabled === true) ||
-                (resolvedConfig.excludeValueIfReadonly && field.readonly === true);
+            const inherited = field.inheritedExclusionState;
+            const staticallyExcluded = (resolvedConfig.excludeValueIfHidden && (field.hidden === true || inherited?.hidden === true)) ||
+                (resolvedConfig.excludeValueIfDisabled && (field.disabled === true || inherited?.disabled === true)) ||
+                (resolvedConfig.excludeValueIfReadonly && (field.readonly === true || inherited?.readonly === true));
             if (!staticallyExcluded) {
                 result[key] = rawValue[key];
             }
@@ -6315,7 +3422,16 @@ class FormStateMachine {
                         this.config.logger.warn('RestoreValues effect: pendingFormSetup was not set — falling back to recomputing.');
                     }
                     const formSetup = state.pendingFormSetup ?? this.config.createFormSetup(state.pendingConfig);
-                    const validKeys = new Set(formSetup.schemaFields.map((f) => f.key).filter((key) => key !== undefined));
+                                                                                                    const oldTypeByKey = new Map();
+                    for (const f of state.currentFormSetup.schemaFields) {
+                        if (f.key !== undefined)
+                            oldTypeByKey.set(f.key, f.type);
+                    }
+                    const validKeys = new Set();
+                    for (const f of formSetup.schemaFields) {
+                        if (f.key !== undefined && oldTypeByKey.get(f.key) === f.type)
+                            validKeys.add(f.key);
+                    }
                     this.config.restoreValue(effect.values, validKeys);
                     this.dispatch({ type: Action.RestoreComplete });
                 });
@@ -6641,7 +3757,7 @@ class FormStateManager {
         reset$;
         cleared$;
         get ready$() {
-        return this.machine.state$.pipe(filter(isReadyState), take$1(1), map(() => undefined));
+        return this.machine.state$.pipe(filter(isReadyState), take(1), map(() => undefined));
     }
                 constructor() {
         this.resolvedFields = derivedFromDeferred(this.fieldsSource, pipe(switchMap((fields) => {
@@ -6698,7 +3814,7 @@ class FormStateManager {
                 }
                 return results;
             }));
-        }), map((fields) => fields.filter((f) => f !== undefined)), scan$1(reconcileFields, [])), { initialValue: [], injector: this.injector });
+        }), map((fields) => fields.filter((f) => f !== undefined)), scan(reconcileFields, [])), { initialValue: [], injector: this.injector });
                         this.isFieldPipelineSettled = computed(() => {
             return this.fieldsSource().length === this.resolvedFields().length;
         }, ...(ngDevMode ? [{ debugName: "isFieldPipelineSettled" }] : /* istanbul ignore next */ []));
@@ -6741,9 +3857,14 @@ class FormStateManager {
                         filtered[key] = val;
                     }
                 }
-                if (Object.keys(filtered).length > 0) {
-                    this.deps.value.update((current) => ({ ...current, ...filtered }));
-                }
+                                                                                                this.deps.value.update((current) => {
+                    const next = { ...current, ...filtered };
+                    for (const key of Object.keys(values)) {
+                        if (!validKeys.has(key))
+                            delete next[key];
+                    }
+                    return next;
+                });
             },
             onTransition: (transition) => {
                 this.logger.debug('State transition:', transition.from.type, '→', transition.to.type, transition.action.type);
@@ -7010,10 +4131,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
-function createWarningTracker() {
-    return { warnedKeys: new Set() };
-}
-
 const DERIVATION_WARNING_TRACKER = new InjectionToken('DerivationWarningTracker', {
     providedIn: null,
     factory: createWarningTracker,
@@ -7126,6 +4243,12 @@ function parseDerivationKey(key) {
     return { fieldKey: key };
 }
 
+function isThenableOrObservable(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.then === 'function' || typeof candidate.subscribe === 'function';
+}
 function computeValueFromEntry(entry, evalContext, options) {
     if (entry.value !== undefined) {
         return entry.value;
@@ -7142,7 +4265,13 @@ function computeValueFromEntry(entry, evalContext, options) {
             const kind = options.functionKind ?? 'Derivation function';
             throw new DynamicFormError(`${kind} '${entry.functionName}' not found in customFnConfig.derivations`);
         }
-        return fn(evalContext);
+        const result = fn(evalContext);
+        if (isThenableOrObservable(result)) {
+            evalContext.logger.warn(`Derivation for '${options.subject}' returned a Promise or Observable. ` +
+                `Synchronous derivations must return a value; use 'asyncDerivations' or an HTTP derivation for asynchronous logic. Skipping.`);
+            return undefined;
+        }
+        return result;
     }
     throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', 'functionName', or 'fn'.`);
 }
@@ -8252,8 +5381,19 @@ function createHttpDerivationStream(entry, formValue$, context) {
                             subscriber.complete();
                             return;
                         }
-                                                const currentForm = untracked(() => context.form());
-                        applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
+                                                                                                const currentForm = untracked(() => context.form());
+                        if (entry.stopOnUserOverride && readFieldDirty(currentForm, entry.fieldKey)) {
+                            const derivationLogger = untracked(() => context.derivationLogger());
+                            derivationLogger.evaluation({
+                                debugName: entry.debugName,
+                                fieldKey: entry.fieldKey,
+                                result: 'skipped',
+                                skipReason: 'user-override',
+                            });
+                            subscriber.complete();
+                            return;
+                        }
+                                                applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
                         const derivationLogger = untracked(() => context.derivationLogger());
                         derivationLogger.evaluation({
                             debugName: entry.debugName,
@@ -8391,8 +5531,19 @@ function createAsyncDerivationStream(entry, formValue$, context) {
                             subscriber.complete();
                             return;
                         }
-                                                const currentForm = untracked(() => context.form());
-                        applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
+                                                                                                const currentForm = untracked(() => context.form());
+                        if (entry.stopOnUserOverride && readFieldDirty(currentForm, entry.fieldKey)) {
+                            const derivationLogger = untracked(() => context.derivationLogger());
+                            derivationLogger.evaluation({
+                                debugName: entry.debugName,
+                                fieldKey: entry.fieldKey,
+                                result: 'skipped',
+                                skipReason: 'user-override',
+                            });
+                            subscriber.complete();
+                            return;
+                        }
+                                                applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
                         const derivationLogger = untracked(() => context.derivationLogger());
                         derivationLogger.evaluation({
                             debugName: entry.debugName,
@@ -9562,8 +6713,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
             type: Injectable
         }] });
 
-const DF_FIELD_TEMPLATES = new InjectionToken('DF_FIELD_TEMPLATES');
-
 class DynamicForm {
                     config = input.required({ ...(ngDevMode ? { debugName: "config" } : /* istanbul ignore next */ {}), alias: 'dynamic-form' });
         formOptions = input(undefined, ...(ngDevMode ? [{ debugName: "formOptions" }] : /* istanbul ignore next */ []));
@@ -9848,240 +6997,6 @@ const BUILT_IN_ADDON_KINDS = [
     },
 ];
 
-const noOpLogger = {
-        debug: () => { },
-        info: () => { },
-        warn: () => { },
-        error: () => { },
-};
-const DEFAULT_SUBMIT_BUTTON_OPTIONS = {
-    disableWhenInvalid: true,
-    disableWhileSubmitting: true,
-};
-const DEFAULT_NEXT_BUTTON_OPTIONS = {
-    disableWhenPageInvalid: true,
-    disableWhileSubmitting: true,
-};
-function evaluateFormStateCondition(condition, ctx) {
-    const form = ctx.form();
-    switch (condition) {
-        case 'formInvalid':
-            return !form.valid();
-        case 'formSubmitting':
-            return form.submitting();
-        case 'pageInvalid':
-            return ctx.currentPageValid ? !ctx.currentPageValid() : false;
-        default:
-            return false;
-    }
-}
-function evaluateLogicCondition(condition, ctx) {
-        if (typeof condition === 'boolean') {
-        return condition;
-    }
-        if (isFormStateCondition(condition)) {
-        return evaluateFormStateCondition(condition, ctx);
-    }
-        const formValue = (ctx.formValue ?? ctx.form().value());
-    const evaluationContext = {
-        fieldValue: undefined,
-        formValue,
-        fieldPath: '',
-        logger: ctx.logger ?? noOpLogger,
-    };
-    return evaluateCondition(condition, evaluationContext);
-}
-function hasFieldLevelDisabledCondition(fieldLogic, ctx) {
-    if (!fieldLogic || fieldLogic.length === 0) {
-        return false;
-    }
-    return fieldLogic.filter((logic) => logic.type === 'disabled').some((logic) => evaluateLogicCondition(logic.condition, ctx));
-}
-function hasCustomLogicOfType(fieldLogic, logicType) {
-    if (!fieldLogic || fieldLogic.length === 0) {
-        return false;
-    }
-    return fieldLogic.some((logic) => logic.type === logicType);
-}
-function evaluateLogicOfType(fieldLogic, logicType, ctx) {
-    if (!fieldLogic || fieldLogic.length === 0) {
-        return false;
-    }
-    const buttonCtx = {
-        form: ctx.form,
-        formValue: ctx.formValue,
-        logger: ctx.logger,
-    };
-    return fieldLogic.filter((logic) => logic.type === logicType).some((logic) => evaluateLogicCondition(logic.condition, buttonCtx));
-}
-function resolveSubmitButtonDisabled(ctx) {
-    return computed(() => {
-                if (ctx.explicitlyDisabled) {
-            return true;
-        }
-                if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
-            return hasFieldLevelDisabledCondition(ctx.fieldLogic, ctx);
-        }
-                const options = {
-            ...DEFAULT_SUBMIT_BUTTON_OPTIONS,
-            ...ctx.formOptions?.submitButton,
-        };
-        const form = ctx.form();
-        if (options.disableWhenInvalid && !form.valid()) {
-            return true;
-        }
-        if (options.disableWhileSubmitting && form.submitting()) {
-            return true;
-        }
-        return false;
-    });
-}
-function resolveNextButtonDisabled(ctx) {
-    return computed(() => {
-                if (ctx.explicitlyDisabled) {
-            return true;
-        }
-                if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
-            return hasFieldLevelDisabledCondition(ctx.fieldLogic, ctx);
-        }
-                const options = {
-            ...DEFAULT_NEXT_BUTTON_OPTIONS,
-            ...ctx.formOptions?.nextButton,
-        };
-        const form = ctx.form();
-        if (options.disableWhenPageInvalid && ctx.currentPageValid && !ctx.currentPageValid()) {
-            return true;
-        }
-        if (options.disableWhileSubmitting && form.submitting()) {
-            return true;
-        }
-        return false;
-    });
-}
-function evaluateNonFieldHidden(ctx) {
-        if (ctx.explicitValue) {
-        return true;
-    }
-        if (hasCustomLogicOfType(ctx.fieldLogic, 'hidden')) {
-        return evaluateLogicOfType(ctx.fieldLogic, 'hidden', {
-            form: ctx.form,
-            formValue: ctx.formValue,
-            logger: ctx.logger,
-        });
-    }
-        return false;
-}
-function resolveNonFieldHidden(ctx) {
-    return computed(() => evaluateNonFieldHidden(ctx));
-}
-function evaluateNonFieldDisabled(ctx) {
-        if (ctx.explicitValue) {
-        return true;
-    }
-        if (hasCustomLogicOfType(ctx.fieldLogic, 'disabled')) {
-        return evaluateLogicOfType(ctx.fieldLogic, 'disabled', {
-            form: ctx.form,
-            formValue: ctx.formValue,
-            logger: ctx.logger,
-        });
-    }
-        return false;
-}
-function resolveNonFieldDisabled(ctx) {
-    return computed(() => evaluateNonFieldDisabled(ctx));
-}
-
-function applyHiddenLogic(inputs, fieldDef, rootFormRegistry) {
-    const rootForm = rootFormRegistry.rootForm();
-    if (rootForm && (fieldDef.hidden === true || fieldDef.logic?.some((l) => l.type === 'hidden'))) {
-                        inputs['hidden'] = evaluateNonFieldHidden({
-            form: rootForm,
-            fieldLogic: fieldDef.logic,
-            explicitValue: fieldDef.hidden,
-            formValue: rootFormRegistry.formValue(),
-        });
-    }
-}
-
-function arrayFieldMapper(fieldDef) {
-    const rootFormRegistry = inject(RootFormRegistryService);
-    const className = buildClassName(fieldDef);
-    return computed(() => {
-        const inputs = {
-            key: fieldDef.key,
-            field: fieldDef,
-            ...(className !== undefined && { className }),
-        };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
-        return inputs;
-    });
-}
-
-function groupFieldMapper(fieldDef) {
-    const rootFormRegistry = inject(RootFormRegistryService);
-    const className = buildClassName(fieldDef);
-    return computed(() => {
-        const inputs = {
-            key: fieldDef.key,
-            field: fieldDef,
-            ...(className !== undefined && { className }),
-        };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
-        return inputs;
-    });
-}
-
-const ROW_WRAPPERS = [{ type: 'row' }];
-function rowFieldMapper(fieldDef) {
-    const rootFormRegistry = inject(RootFormRegistryService);
-    const className = buildClassName(fieldDef);
-    return computed(() => {
-                                                        const containerField = { ...fieldDef, type: 'container', wrappers: ROW_WRAPPERS };
-        const inputs = {
-            key: fieldDef.key,
-            field: containerField,
-            ...(className !== undefined && { className }),
-        };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
-        return inputs;
-    });
-}
-
-function pageFieldMapper(fieldDef) {
-    const className = buildClassName(fieldDef);
-        return computed(() => ({
-        key: fieldDef.key,
-        field: fieldDef,
-        ...(className !== undefined && { className }),
-    }));
-}
-
-function textFieldMapper(fieldDef) {
-    const rootFormRegistry = inject(RootFormRegistryService);
-    const defaultProps = inject(DEFAULT_PROPS);
-        return computed(() => {
-        const baseInputs = buildBaseInputs(fieldDef, defaultProps());
-        const inputs = { ...baseInputs };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
-        return inputs;
-    });
-}
-
-function containerFieldMapper(fieldDef) {
-    const rootFormRegistry = inject(RootFormRegistryService);
-    const className = buildClassName(fieldDef);
-    return computed(() => {
-                                                        const containerField = { ...fieldDef, wrappers: undefined, skipAutoWrappers: undefined, skipDefaultWrappers: undefined };
-        const inputs = {
-            key: fieldDef.key,
-            field: containerField,
-            ...(className !== undefined && { className }),
-        };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
-        return inputs;
-    });
-}
-
 const CONTAINER_FIELD_TYPES_BASE = {
     renderReadyWhen: ['field'],
 };
@@ -10091,35 +7006,35 @@ const DISPLAY_FIELD_TYPES_BASE = {
 const BUILT_IN_FIELDS = [
     {
         name: 'row',
-                                loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BluTT44A.mjs'),
+                                loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-bA-8ICHF.mjs'),
         mapper: rowFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'group',
-        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-2bWHql4u.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-D0_nmXf2.mjs'),
         mapper: groupFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'array',
-        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-D6GEsH72.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-BfRH3TBm.mjs'),
         mapper: arrayFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'page',
-        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-zF-vEv5V.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-BJRNnoz-.mjs'),
         mapper: pageFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'text',
-        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-_8_vVeH0.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-DABkT0O7.mjs'),
         mapper: textFieldMapper,
         valueHandling: 'exclude',
         ...DISPLAY_FIELD_TYPES_BASE,
@@ -10130,7 +7045,7 @@ const BUILT_IN_FIELDS = [
     },
     {
         name: 'container',
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-BluTT44A.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-bA-8ICHF.mjs'),
         mapper: containerFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
@@ -10139,7 +7054,7 @@ const BUILT_IN_FIELDS = [
 const BUILT_IN_WRAPPERS = [
     {
         wrapperName: 'css',
-        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-CgMQOaG7.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-DjhcONFh.mjs'),
     },
     {
         wrapperName: 'row',
@@ -10255,10 +7170,6 @@ function withEventFormValue() {
     return createFeature('event-form-value', [{ provide: EMIT_FORM_VALUE_ON_EVENTS, useValue: true }]);
 }
 
-function hasFormValue(event) {
-    return 'formValue' in event && event.formValue !== undefined;
-}
-
 function withValueExclusionDefaults(config) {
     const resolved = {
         excludeValueIfHidden: config?.excludeValueIfHidden ?? true,
@@ -10283,23 +7194,6 @@ function wrapperProps() {
     return undefined;
 }
 
-function isFieldBoundContext(ctx) {
-    return ctx.form !== null;
-}
-
-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 });
-    }
-        return computed(() => value);
-}
-
 class DfAddonSlot {
     registry = injectAddonKindRegistry();
     logger = inject(DynamicFormLogger);
@@ -10381,27 +7275,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                 }]
         }], 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 }] }] } });
 
-class DynamicTextPipe {
-    injector = inject(Injector);
-        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',
-                }]
-        }] });
-
 class TextAddonComponent {
     addon = input.required(...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
         fieldInputs = input(...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
@@ -10524,6 +7397,10 @@ async function runPresetAction(preset, ctx, collaborators, adapterLabel, fieldLa
                                 if (ctx.form === null && preset !== 'copy' && preset !== 'paste') {
         collaborators.logger.warn(`preset '${String(preset)}' fired without a host field context — ignoring.`);
         return;
+    }
+                if (ctx.form !== null && (preset === 'clear' || preset === 'reset' || preset === 'paste') && ctx.form.disabled()) {
+        collaborators.logger.warn(`preset '${String(preset)}' skipped — host '${fieldLabel}' is disabled.`);
+        return;
     }
     switch (preset) {
         case 'clear': {
@@ -10641,14 +7518,6 @@ function sanitizeFormConfigPure(config, fieldRegistry, kindRegistry, options = {
     return { sanitized: { ...config, fields: fields }, warnings };
 }
 
-function isValueField(field) {
-                return 'value' in field || 'nullable' in field;
-}
-
-function isCheckedField(field) {
-    return field.type === 'checkbox' || field.type === 'toggle';
-}
-
 function arrayEvent(arrayKey) {
     return {
                 append: (template) => new AppendArrayItemEvent(arrayKey, template),
@@ -10661,28 +7530,6 @@ function arrayEvent(arrayKey) {
     };
 }
 
-function resolveTokens(args, context) {
-    return args.map((arg) => {
-                if (typeof arg !== 'string') {
-            return arg;
-        }
-                switch (arg) {
-            case '$key':
-                return context.key;
-            case '$index':
-                return context.index;
-            case '$arrayKey':
-                return context.arrayKey;
-            case '$template':
-                return context.template;
-            case 'formValue':
-                return context.formValue;
-            default:
-                                return arg;
-        }
-    });
-}
-
 
 function formConfig(config) {
     return config;
@@ -10771,106 +7618,7 @@ function createField(type, config) {
 }
 const field = createField;
 
-function dynamicTextToObservable(value, injector) {
-    if (value === undefined) {
-        return of('');
-    }
-    if (isObservable(value)) {
-        return value;
-    }
-    if (isSignal(value)) {
-        return toObservable(value, { injector });
-    }
-    return of(String(value));
-}
-
-function applyMetaToElement(element, meta, previouslyApplied) {
-    const newApplied = new Set();
-        for (const attr of previouslyApplied) {
-        if (!meta || !(attr in meta) || meta[attr] === undefined) {
-            element.removeAttribute(attr);
-        }
-    }
-    if (!meta)
-        return newApplied;
-        for (const [key, value] of Object.entries(meta)) {
-        if (value === undefined || value === null)
-            continue;
-        element.setAttribute(key, String(value));
-        newApplied.add(key);
-    }
-    return newApplied;
-}
-
-function interpolateParams(message, error) {
-    let result = message;
-    const params = extractErrorParams(error);
-    Object.entries(params).forEach(([key, value]) => {
-        const placeholder = new RegExp(`{{\\s*${key}\\s*}}`, 'g');
-        result = result.replace(placeholder, safeToString(value));
-    });
-    return result;
-}
-function safeToString(value) {
-    if (value === null || value === undefined) {
-        return '';
-    }
-        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return String(value);
-    }
-        if (value instanceof RegExp) {
-        return value.toString();
-    }
-        if (value instanceof Date) {
-        return value.toISOString();
-    }
-        if (Array.isArray(value)) {
-        return value.join(', ');
-    }
-        try {
-                if (typeof value === 'object' && value.toString !== Object.prototype.toString) {
-            return value.toString();
-        }
-                return JSON.stringify(value);
-    }
-    catch {
-                return '[object]';
-    }
-}
-function extractErrorParams(error) {
-    const params = {};
-        if ('min' in error)
-        params.min = error.min;
-    if ('max' in error)
-        params.max = error.max;
-    if ('pattern' in error)
-        params.pattern = error.pattern;
-    if ('actual' in error)
-        params.actual = error.actual;
-    if ('expected' in error)
-        params.expected = error.expected;
-                    if ('requiredLength' in error) {
-        params.requiredLength = error.requiredLength;
-    }
-    else if ('minLength' in error) {
-                params.requiredLength = error.minLength;
-        params.minLength = error.minLength;
-    }
-    else if ('maxLength' in error) {
-                params.requiredLength = error.maxLength;
-        params.maxLength = error.maxLength;
-    }
-    if ('actualLength' in error)
-        params.actualLength = error.actualLength;
-            Object.keys(error).forEach((key) => {
-        if (key !== 'kind' && !(key in params)) {
-            params[key] = error[key];
-        }
-    });
-    return params;
-}
-
 
 
-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-CPkVjU_N.mjs.map
+export { sanitizeFormConfig as $, ADDON_ACTION_HANDLERS as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DfAddonSlot as D, EventDispatcher as E, FormClearEvent as F, formatAddonWarning as G, getFieldDefaultValue as H, InsertArrayItemEvent as I, getNormalizedArrayMetadata as J, injectAddonKindRegistry as K, injectFieldRegistry as L, MoveArrayItemEvent as M, NextPageEvent as N, injectFieldsSupportingAddons as O, PageChangeEvent as P, isSameWrapperChain as Q, RemoveAtIndexEvent as R, ShiftArrayItemEvent as S, TemplateAddonComponent as T, isWrappersBundle as U, logAddonWarnings as V, mapFieldToInputs as W, provideAddonActions as X, provideDynamicForm as Y, resolveWrappers as Z, runPresetAction as _, ADDON_ACTION_REGISTRY as a, sanitizeFormConfigPure as a0, validateFieldAddons as a1, walkAndValidateAddons as a2, withCustomAddon as a3, withEventFormValue as a4, withLegacyStatusClasses as a5, withLoggerConfig as a6, withValidationExecutionDefaults as a7, withValueExclusionDefaults as a8, wrapperProps as a9, ADDON_KIND_COMPONENT_CACHE as b, ADDON_KIND_DEFINITIONS as c, AppendArrayItemEvent as d, ArrayItemRegistryService as e, ComponentAddonComponent as f, ConsoleLogger as g, DfFieldOutlet as h, DfTemplate as i, DynamicForm as j, FormResetEvent as k, PopArrayItemEvent as l, PrependArrayItemEvent as m, PreviousPageEvent as n, SubmitEvent as o, TextAddonComponent as p, arrayEvent as q, createField as r, createFieldResolutionPipe as s, createHiddenSignal as t, createRenderReadySignal as u, createSchemaFromFields as v, createWrapperChainController as w, createWrappers as x, field as y, formConfig as z };
+//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-CNc4a_Xv.mjs.map