@ng-forge/dynamic-forms 1.0.0-rc.4 → 1.1.0-next.1

package/fesm2022/ng-forge-dynamic-forms-internal.mjs

@@ -3,7 +3,7 @@ import { InjectionToken, computed, isSignal, inject, Injector, input, signal, Ch
 import { NgComponentOutlet } from '@angular/common';
 import { explicitEffect } from 'ngxtension/explicit-effect';
 import { toSignal, toObservable, rxResource } from '@angular/core/rxjs-interop';
-import { isObservable, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, of, from, map, catchError, tap, startWith, Subject, filter, TimeoutError, throwError } from 'rxjs';
+import { isObservable, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, map, tap, catchError, of, from, startWith, Subject, filter, TimeoutError, throwError } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
 import { email, min, max, minLength, maxLength, pattern, required, validate, validateAsync, validateHttp } from '@angular/forms/signals';
 import { scan, map as map$1, filter as filter$1, take, switchMap, timeout, catchError as catchError$1, shareReplay } from 'rxjs/operators';
@@ -155,14 +155,14 @@ class DfAddonSlot {
             });
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: DfAddonSlot, isStandalone: true, selector: "df-addon-slot", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.slot": "slotAttr()", "class": "className()", "style.display": "isHidden() ? \"none\" : null" } }, ngImport: i0, template: `
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DfAddonSlot, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.1", type: DfAddonSlot, isStandalone: true, selector: "df-addon-slot", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.slot": "slotAttr()", "class": "className()", "style.display": "isHidden() ? \"none\" : null" } }, ngImport: i0, template: `
     @if (resolvedComponent(); as cmp) {
       <ng-container *ngComponentOutlet="cmp; inputs: typeInputs()" />
     }
   `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DfAddonSlot, decorators: [{
             type: Component,
             args: [{
                     selector: 'df-addon-slot',
@@ -475,50 +475,6 @@ class AsyncConditionFunctionCacheService {
         asyncConditionFunctionCache = new Map();
 }
 
-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(',') + '}';
-}
-
-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');
-
-class RootFormRegistryService {
-    formValue;
-    rootForm;
-    constructor(formValue, rootForm) {
-        this.formValue = formValue;
-        this.rootForm = rootForm;
-    }
-}
-
-const DEPRECATION_WARNING_TRACKER = new InjectionToken('DeprecationWarningTracker');
-
 function compareValues(actual, expected, operator) {
     switch (operator) {
         case 'equals':
@@ -572,1445 +528,1355 @@ function hasNestedProperty(obj, path) {
     return keys[keys.length - 1] in current;
 }
 
-function safeReadPathKeys(fieldContext) {
-    if (!('pathKeys' in fieldContext) || typeof fieldContext.pathKeys !== 'function') {
-        return [];
+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';
     }
-    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],
-            };
+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;
     }
-    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);
+    skipWhitespace() {
+        while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
+            this.position++;
         }
-                                        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());
+    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 };
             }
-            catch (error) {
-                this.logger.warn('Unable to extract field key:', error);
+            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;
+                }
+                this.position++;
+            }
+            else {
+                value += char;
+                this.position++;
             }
         }
-                return '';
+        throw new ExpressionParserError('Unterminated string literal', start, this.expression);
     }
-        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;
-            }
+    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++;
         }
-                                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();
-                },
-            };
+        if (!/^\d+(\.\d+)?$/.test(value)) {
+            throw new ExpressionParserError(`Invalid number: ${value}`, start, this.expression);
         }
-        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;
+        return { type: TokenType.NUMBER, value, position: start };
     }
-        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);
+    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 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: "22.0.0", ngImport: i0, type: FieldContextRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: FieldContextRegistryService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: FieldContextRegistryService, decorators: [{
-            type: Injectable
-        }] });
-
-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();
+                const type = this.getKeywordType(value);
+        return { type, value, position: start };
     }
-        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));
+    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;
         }
     }
-        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: "22.0.0", ngImport: i0, type: FunctionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: FunctionRegistryService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: FunctionRegistryService, decorators: [{
-            type: Injectable
-        }] });
-
-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, /* @ts-ignore */
-            ...(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;
+    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 (resolved.kind === 'holdPrevious') {
-            return handle.resultResource.value();
+        if (threeChar === '!==') {
+            this.position += 3;
+            return { type: TokenType.NOT_EQUAL, value: '!==', position: start };
         }
-        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 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;
+                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);
         }
-    }
-    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);
-            }));
-        },
-    });
-    if (cacheKey !== undefined) {
-        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
-    }
-    return fn;
-}
-
-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;
+class Parser {
+    tokens = [];
+    current = 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;
+        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;
+                }
+                this.advance();             }
+            else {
+                this.current = savedPos;
+                return null;
             }
-            const token = this.nextToken();
-            tokens.push(token);
+            if (!this.check(TokenType.ARROW)) {
+                this.current = savedPos;
+                return null;
+            }
+            this.advance();             const body = this.parseExpression();
+            return { type: 'ArrowFunction', params, body };
         }
-        tokens.push({ type: TokenType.EOF, value: '', position: this.position });
-        return tokens;
+        return null;
     }
-    skipWhitespace() {
-        while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
-            this.position++;
+    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;
     }
-    nextToken() {
-        const char = this.expression[this.position];
-                if (char === '"' || char === "'") {
-            return this.readString(char);
+    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 };
         }
-                if (/[0-9]/.test(char)) {
-            return this.readNumber();
+        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 };
         }
-                if (/[a-zA-Z_$]/.test(char)) {
-            return this.readIdentifierOrKeyword();
+        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 };
         }
-                return this.readOperatorOrPunctuation();
+        return node;
     }
-    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 };
+    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 };
+        }
+        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 };
             }
-            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;
+            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 };
                 }
-                this.position++;
+                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 {
-                value += char;
-                this.position++;
+                break;
             }
         }
-        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++;
+        return node;
+    }
+    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 (!/^\d+(\.\d+)?$/.test(value)) {
-            throw new ExpressionParserError(`Invalid number: ${value}`, start, this.expression);
+        if (this.match(TokenType.UNDEFINED)) {
+            return { type: 'Literal', value: undefined };
         }
-        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++;
+        if (this.match(TokenType.NUMBER)) {
+            return { type: 'Literal', value: parseFloat(this.previous().value) };
         }
-                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;
+        if (this.match(TokenType.STRING)) {
+            return { type: 'Literal', value: this.previous().value };
+        }
+                if (this.match(TokenType.LBRACKET)) {
+            const elements = this.parseArrayElements();
+            this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
+            return { type: 'ArrayLiteral', elements };
+        }
+                if (this.match(TokenType.LBRACE)) {
+            const properties = this.parseObjectProperties();
+            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
+            return { type: 'ObjectLiteral', properties };
+        }
+                if (this.match(TokenType.IDENTIFIER)) {
+            return { type: 'Identifier', name: this.previous().value };
+        }
+                if (this.match(TokenType.LPAREN)) {
+            const expr = this.parseExpression();
+            this.consume(TokenType.RPAREN, 'Expected ")" after expression');
+            return expr;
         }
+        throw new ExpressionParserError(`Unexpected token: ${this.peek().value}`, this.peek().position, this.expression);
     }
-    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 };
+    parseArgumentList() {
+        const args = [];
+        if (!this.check(TokenType.RPAREN)) {
+            do {
+                args.push(this.parseExpression());
+            } while (this.match(TokenType.COMMA));
         }
-        if (threeChar === '!==') {
-            this.position += 3;
-            return { type: TokenType.NOT_EQUAL, value: '!==', position: start };
+        return args;
+    }
+    parseArrayElements() {
+        const elements = [];
+        if (!this.check(TokenType.RBRACKET)) {
+            do {
+                elements.push(this.parseExpression());
+            } while (this.match(TokenType.COMMA));
         }
-                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 };
+        return elements;
+    }
+    parseObjectProperties() {
+        const properties = [];
+        if (this.check(TokenType.RBRACE)) {
+            return properties;
         }
-                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);
+        do {
+                        if (this.check(TokenType.RBRACE))
+                break;
+            let key;
+            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
+                key = this.advance().value;
+            }
+            else {
+                throw new ExpressionParserError(`Expected property name (identifier or string) in object literal, got '${this.peek().value}'`, this.peek().position, this.expression);
+            }
+            this.consume(TokenType.COLON, 'Expected ":" after property name in object literal');
+            const value = this.parseExpression();
+            properties.push({ key, value });
+        } while (this.match(TokenType.COMMA));
+        return properties;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                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);
     }
 }
 
-class Parser {
-    tokens = [];
-    current = 0;
+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(expression) {
+    constructor(scope, expression) {
+        this.scope = scope;
         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);
+        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);
         }
-        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 };
+    evaluateIdentifier(name) {
+        if (name in this.scope) {
+            return this.scope[name];
+        }
+        return undefined;
     }
-        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 };
+    evaluateMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+            return undefined;
         }
-                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;
-                }
-                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 };
+                if (BLOCKED_PROPERTIES.has(node.property)) {
+            throw new ExpressionParserError(`Property "${node.property}" is not accessible for security reasons`, 0, this.expression);
         }
-        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 };
+                if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[node.property];
         }
-        return node;
+        return undefined;
     }
-    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 };
+    evaluateComputedMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+                                    return undefined;
         }
-        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 };
+        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);
         }
-        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 };
+        if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[key];
         }
-        return node;
+        return undefined;
     }
-    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 };
+    evaluateBinaryOp(node) {
+                if (node.operator === '&&') {
+            const left = this.evaluate(node.left);
+            return left ? this.evaluate(node.right) : left;
         }
-        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 };
+        if (node.operator === '||') {
+            const left = this.evaluate(node.left);
+            return left ? left : this.evaluate(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 };
+                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);
         }
-        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;
-            }
+    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);
         }
-        return node;
     }
-    parsePrimary() {
-                if (this.match(TokenType.TRUE)) {
-            return { type: 'Literal', value: true };
-        }
-        if (this.match(TokenType.FALSE)) {
-            return { type: 'Literal', value: false };
+    evaluateCallExpression(node) {
+                        if (node.callee.type !== 'MemberAccess') {
+            throw new ExpressionParserError('Only method calls are allowed, not arbitrary function calls', 0, this.expression);
         }
-        if (this.match(TokenType.NULL)) {
-            return { type: 'Literal', value: null };
+        const obj = this.evaluate(node.callee.object);
+                                                        if (obj === null || obj === undefined) {
+            return undefined;
         }
-        if (this.match(TokenType.UNDEFINED)) {
-            return { type: 'Literal', value: 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.match(TokenType.NUMBER)) {
-            return { type: 'Literal', value: parseFloat(this.previous().value) };
+                if (!this.isMethodSafe(obj, methodName)) {
+            throw new ExpressionParserError(`Method "${methodName}" is not allowed for security reasons`, 0, this.expression);
         }
-        if (this.match(TokenType.STRING)) {
-            return { type: 'Literal', value: this.previous().value };
+                const args = node.arguments.map((arg) => this.evaluate(arg));
+                const method = obj[methodName];
+        if (typeof method === 'function') {
+                        return method.call(obj, ...args);
         }
-                if (this.match(TokenType.LBRACKET)) {
-            const elements = this.parseArrayElements();
-            this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
-            return { type: 'ArrayLiteral', elements };
+        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);
         }
-                if (this.match(TokenType.LBRACE)) {
-            const properties = this.parseObjectProperties();
-            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
-            return { type: 'ObjectLiteral', properties };
+        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;
         }
-                if (this.match(TokenType.IDENTIFIER)) {
-            return { type: 'Identifier', name: this.previous().value };
+        const type = Array.isArray(obj) ? 'array' : obj instanceof Date ? 'date' : typeof obj;
+        const safeMethods = SAFE_METHODS[type];
+        if (!safeMethods) {
+            return false;
         }
-                if (this.match(TokenType.LPAREN)) {
-            const expr = this.parseExpression();
-            this.consume(TokenType.RPAREN, 'Expected ")" after expression');
-            return expr;
+        return safeMethods.has(methodName);
+    }
+}
+
+const MAX_AST_CACHE_SIZE = 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);
         }
-        throw new ExpressionParserError(`Unexpected token: ${this.peek().value}`, this.peek().position, this.expression);
+        return value;
     }
-    parseArgumentList() {
-        const args = [];
-        if (!this.check(TokenType.RPAREN)) {
-            do {
-                args.push(this.parseExpression());
-            } while (this.match(TokenType.COMMA));
+    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);
+            }
         }
-        return args;
     }
-    parseArrayElements() {
-        const elements = [];
-        if (!this.check(TokenType.RBRACKET)) {
-            do {
-                elements.push(this.parseExpression());
-            } while (this.match(TokenType.COMMA));
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+}
+const astCache = new LRUCache(MAX_AST_CACHE_SIZE);
+class ExpressionParser {
+        static parse(expression) {
+                const cached = astCache.get(expression);
+        if (cached) {
+            return cached;
         }
-        return elements;
+                const parser = new Parser(expression);
+        const ast = parser.parse();
+                astCache.set(expression, ast);
+        return ast;
     }
-    parseObjectProperties() {
-        const properties = [];
-        if (this.check(TokenType.RBRACE)) {
-            return properties;
+        static evaluate(expression, scope) {
+        try {
+            const ast = this.parse(expression);
+            const evaluator = new Evaluator(scope, expression);
+            return evaluator.evaluate(ast);
         }
-        do {
-                        if (this.check(TokenType.RBRACE))
-                break;
-            let key;
-            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
-                key = this.advance().value;
+        catch (error) {
+            if (error instanceof ExpressionParserError) {
+                throw error;
             }
-            else {
-                throw new ExpressionParserError(`Expected property name (identifier or string) in object literal, got '${this.peek().value}'`, this.peek().position, this.expression);
+                        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,
+        };
+    }
+}
+
+function isThenableOrObservable(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.then === 'function' || typeof candidate.subscribe === 'function';
+}
+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 {
+                const result = customFn(context);
+                if (isThenableOrObservable(result)) {
+                    context.logger.warn(`Custom condition '${registeredName ?? '<inline>'}' returned a Promise or Observable. ` +
+                        `Synchronous conditions must return a value; use an 'async' or 'http' condition type for asynchronous logic. Treating as false.`);
+                    return false;
+                }
+                return !!result;
             }
-            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();
-                return true;
+            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;
     }
-    check(type) {
-        if (this.isAtEnd())
-            return false;
-        return this.peek().type === type;
+    catch (error) {
+        context.logger.error('Error evaluating JavaScript expression:', expression.expression, error);
+        return false;
     }
-    advance() {
-        if (!this.isAtEnd())
-            this.current++;
-        return this.previous();
+}
+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 HttpConditionFunctionCacheService {
+        httpConditionFunctionCache = new Map();
+}
+
+function stableStringify(value) {
+    if (value === null || value === undefined) {
+        return String(value);
     }
-    isAtEnd() {
-        return this.peek().type === TokenType.EOF;
+    if (typeof value !== 'object') {
+        return JSON.stringify(value);
     }
-    peek() {
-        return this.tokens[this.current];
+    if (Array.isArray(value)) {
+        return '[' + value.map(stableStringify).join(',') + ']';
     }
-    previous() {
-        return this.tokens[this.current - 1];
+    const obj = value;
+    const sortedKeys = Object.keys(obj).sort();
+    const pairs = sortedKeys.map((key) => JSON.stringify(key) + ':' + stableStringify(obj[key]));
+    return '{' + pairs.join(',') + '}';
+}
+
+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.');
     }
-    consume(type, message) {
-        if (this.check(type))
-            return this.advance();
-        throw new ExpressionParserError(message, this.peek().position, this.expression);
+    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');
+
+class RootFormRegistryService {
+    formValue;
+    rootForm;
+    constructor(formValue, rootForm) {
+        this.formValue = formValue;
+        this.rootForm = rootForm;
     }
 }
 
-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;
+const DEPRECATION_WARNING_TRACKER = new InjectionToken('DeprecationWarningTracker');
+
+function safeReadPathKeys(fieldContext) {
+    if (!('pathKeys' in fieldContext) || typeof fieldContext.pathKeys !== 'function') {
+        return [];
     }
-        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);
+    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],
+            };
         }
     }
-    evaluateIdentifier(name) {
-        if (name in this.scope) {
-            return this.scope[name];
+    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);
         }
-        return undefined;
+                                        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);
+            },
+        };
     }
-    evaluateMemberAccess(node) {
-        const obj = this.evaluate(node.object);
-        if (obj === null || obj === undefined) {
-            return undefined;
+        extractFieldPath(fieldContext) {
+        if (isChildFieldContext(fieldContext)) {
+            try {
+                return String(fieldContext.key());
+            }
+            catch (error) {
+                this.logger.warn('Unable to extract field key:', error);
+            }
         }
-                if (BLOCKED_PROPERTIES.has(node.property)) {
-            throw new ExpressionParserError(`Property "${node.property}" is not accessible for security reasons`, 0, this.expression);
+                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;
+            }
         }
-                if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
-            return obj[node.property];
+                                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 undefined;
+        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();
+            },
+        };
     }
-    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)
+        resolveExternalData(reactive) {
+        const externalDataSignal = this.externalDataSignal;
+        if (!externalDataSignal)
+            return undefined;
+        const externalDataRecord = reactive ? externalDataSignal() : untracked(() => externalDataSignal());
+        if (!externalDataRecord) {
             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];
+        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 undefined;
+        return resolved;
     }
-    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);
+        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 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);
+        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, arrayScope) {
+        const rootFormValue = this.rootFormRegistry.formValue();
+        if (arrayScope) {
+            return this.buildArrayScopedContext(rootFormValue, arrayScope, undefined, customFunctions, true);
         }
+        const rootFormSignal = this.rootFormRegistry.rootForm;
+        return {
+            fieldValue: undefined,
+            formValue: rootFormValue,
+            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: "22.0.1", ngImport: i0, type: FieldContextRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FieldContextRegistryService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FieldContextRegistryService, decorators: [{
+            type: Injectable
+        }] });
+
+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);
     }
-    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);
-        }
+        getDerivationFunctions() {
+        return Object.fromEntries(this.derivationFunctions);
     }
-    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;
+        setDerivationFunctions(derivations) {
+        this.setRegistryIfChanged(this.derivationFunctions, derivations);
     }
-    evaluateArrayLiteral(node) {
-        return node.elements.map((element) => this.evaluate(element));
+        clearDerivationFunctions() {
+        this.derivationFunctions.clear();
     }
-    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;
+                    registerAsyncDerivationFunction(name, fn) {
+        this.asyncDerivationFunctions.set(name, fn);
     }
-    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);
-        };
+        getAsyncDerivationFunction(name) {
+        return this.asyncDerivationFunctions.get(name);
     }
-    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);
+        getAsyncDerivationFunctions() {
+        return Object.fromEntries(this.asyncDerivationFunctions);
     }
-}
-
-const MAX_AST_CACHE_SIZE = 1000;
-class LRUCache {
-    cache = new Map();
-    maxSize;
-    constructor(maxSize) {
-        this.maxSize = maxSize;
+        setAsyncDerivationFunctions(fns) {
+        this.setRegistryIfChanged(this.asyncDerivationFunctions, fns);
     }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-                        this.cache.delete(key);
-            this.cache.set(key, value);
-        }
-        return value;
+        clearAsyncDerivationFunctions() {
+        this.asyncDerivationFunctions.clear();
     }
-    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);
-            }
-        }
+                    registerAsyncConditionFunction(name, fn) {
+        this.asyncConditionFunctions.set(name, fn);
     }
-    clear() {
-        this.cache.clear();
+        getAsyncConditionFunction(name) {
+        return this.asyncConditionFunctions.get(name);
     }
-    get size() {
-        return this.cache.size;
+        getAsyncConditionFunctions() {
+        return Object.fromEntries(this.asyncConditionFunctions);
     }
-}
-const astCache = new LRUCache(MAX_AST_CACHE_SIZE);
-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;
+        setAsyncConditionFunctions(fns) {
+        this.setRegistryIfChanged(this.asyncConditionFunctions, fns);
     }
-        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);
-        }
+        clearAsyncConditionFunctions() {
+        this.asyncConditionFunctions.clear();
     }
-        static clearCache() {
-        astCache.clear();
+        registerValidator(name, fn) {
+        this.validators.set(name, fn);
     }
-        static getCacheStats() {
-        return {
-            size: astCache.size,
-            maxSize: MAX_AST_CACHE_SIZE,
-        };
+        getValidator(name) {
+        return this.validators.get(name);
     }
-}
-
-function isThenableOrObservable(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return typeof candidate.then === 'function' || typeof candidate.subscribe === 'function';
-}
-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 {
-                const result = customFn(context);
-                if (isThenableOrObservable(result)) {
-                    context.logger.warn(`Custom condition '${registeredName ?? '<inline>'}' returned a Promise or Observable. ` +
-                        `Synchronous conditions must return a value; use an 'async' or 'http' condition type for asynchronous logic. Treating as false.`);
-                    return false;
-                }
-                return !!result;
-            }
-            catch (error) {
-                context.logger.error('Error executing custom function:', registeredName ?? '<inline>', error);
-                return false;
-            }
+        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));
         }
-        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;
+        setValidators(validators) {
+        this.setRegistryIfChanged(this.validators, validators);
+    }
+        setAsyncValidators(asyncValidators) {
+        this.setRegistryIfChanged(this.asyncValidators, asyncValidators);
     }
-    catch (error) {
-        context.logger.error('Error evaluating JavaScript expression:', expression.expression, error);
-        return false;
+        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: "22.0.1", ngImport: i0, type: FunctionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FunctionRegistryService });
 }
-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 HttpConditionFunctionCacheService {
-        httpConditionFunctionCache = new Map();
-}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FunctionRegistryService, decorators: [{
+            type: Injectable
+        }] });
 
 class HttpConditionCache {
     cache = new Map();
@@ -2094,6 +1960,92 @@ function resolveHttpRequest(config, context) {
     return request;
 }
 
+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, /* @ts-ignore */
+            ...(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 {
@@ -2164,6 +2116,57 @@ function createHttpConditionLogicFunction(condition) {
     return fn;
 }
 
+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;
+        }
+    }
+    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);
+            }));
+        },
+    });
+    if (cacheKey !== undefined) {
+        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    }
+    return fn;
+}
+
 class LogicFunctionCacheService {
         logicFunctionCache = new Map();
         debouncedLogicFunctionCache = new Map();
@@ -2294,35 +2297,6 @@ function toReadonlyFieldTreeCached(cache, field) {
     return view;
 }
 
-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 };
-    }
-}
-
 const noOpLogger = {
         debug: () => { },
         info: () => { },
@@ -2357,7 +2331,10 @@ function evaluateLogicCondition(condition, ctx) {
         if (isFormStateCondition(condition)) {
         return evaluateFormStateCondition(condition, ctx);
     }
-        const formValue = (ctx.formValue ?? ctx.form().value());
+                        if (ctx.evaluationContext) {
+        return evaluateCondition(condition, ctx.evaluationContext());
+    }
+                    const formValue = (ctx.formValue ?? ctx.form().value());
     const evaluationContext = {
         fieldValue: undefined,
         formValue,
@@ -2385,6 +2362,7 @@ function evaluateLogicOfType(fieldLogic, logicType, ctx) {
     const buttonCtx = {
         form: ctx.form,
         formValue: ctx.formValue,
+        evaluationContext: ctx.evaluationContext,
         logger: ctx.logger,
     };
     return fieldLogic.filter((logic) => logic.type === logicType).some((logic) => evaluateLogicCondition(logic.condition, buttonCtx));
@@ -2441,6 +2419,7 @@ function evaluateNonFieldHidden(ctx) {
         return evaluateLogicOfType(ctx.fieldLogic, 'hidden', {
             form: ctx.form,
             formValue: ctx.formValue,
+            evaluationContext: ctx.evaluationContext,
             logger: ctx.logger,
         });
     }
@@ -2457,6 +2436,7 @@ function evaluateNonFieldDisabled(ctx) {
         return evaluateLogicOfType(ctx.fieldLogic, 'disabled', {
             form: ctx.form,
             formValue: ctx.formValue,
+            evaluationContext: ctx.evaluationContext,
             logger: ctx.logger,
         });
     }
@@ -2465,12 +2445,52 @@ function evaluateNonFieldDisabled(ctx) {
 function resolveNonFieldDisabled(ctx) {
     return computed(() => evaluateNonFieldDisabled(ctx));
 }
+function injectNonFieldEvaluationContext(fieldDef, options = {}) {
+    const fieldContextRegistry = inject(FieldContextRegistryService);
+    const functionRegistry = inject(FunctionRegistryService);
+                const arrayContext = options.scopeToArrayItem ? inject(ARRAY_CONTEXT, { optional: true }) : null;
+    return () => {
+        const arrayScope = arrayContext
+            ? { arrayKey: arrayContext.arrayKey, index: arrayContext.index(), localKey: fieldDef.key ?? '' }
+            : undefined;
+        return fieldContextRegistry.createDisplayOnlyContext(fieldDef.key ?? '', functionRegistry.getCustomFunctions(), arrayScope);
+    };
+}
 
 function isFunctionHttpValidator(config) {
     const c = config;
     return typeof c.functionName === 'string' || (c.fn !== null && typeof c.fn === 'object');
 }
 
+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 };
+    }
+}
+
 class DynamicValueFunctionCacheService {
         dynamicValueFunctionCache = new Map();
 }
@@ -2620,9 +2640,7 @@ function applyCustomValidator(config, fieldPath) {
         validatorFn = createFunctionValidator(config);
     }
     else {
-        const logger = inject(DynamicFormLogger);
-        logger.warn('Custom validator must have one of "expression", "functionName", or "fn"');
-        return;
+        throw new DynamicFormError('Custom validator requires one of "expression", "functionName", or "fn".');
     }
     const whenLogic = createConditionalLogic(config.when);
     validate(fieldPath, (ctx) => {
@@ -2642,8 +2660,7 @@ function createFunctionValidator(config) {
     }
     const functionName = config.functionName;
     if (!functionName) {
-        logger.warn('Custom validator missing functionName');
-        return () => null;
+        throw new DynamicFormError('Custom validator requires one of "functionName" or "fn".');
     }
     const registry = inject(FunctionRegistryService);
     const validatorFn = registry.getValidator(functionName);
@@ -2656,8 +2673,7 @@ function createExpressionValidator(config) {
     const logger = inject(DynamicFormLogger);
     const expression = config.expression;
     if (!expression) {
-        logger.warn('Custom validator missing expression');
-        return () => null;
+        throw new DynamicFormError('Custom validator requires a non-empty "expression".');
     }
     const fieldContextRegistry = inject(FieldContextRegistryService);
     const functionRegistry = inject(FunctionRegistryService);
@@ -2940,10 +2956,10 @@ class EventBus {
         }
         return this.pipeline$.pipe(filter((event) => event.type === eventType));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: EventBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: EventBus });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: EventBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: EventBus });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: EventBus, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: EventBus, decorators: [{
             type: Injectable
         }] });
 
@@ -2973,18 +2989,6 @@ function resolveTokens(args, context) {
     });
 }
 
-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 getGridClassString(fieldDef) {
     const col = fieldDef.col;
     if (typeof col === 'number' && Number.isInteger(col) && col > 0 && col <= 12) {
@@ -3005,8 +3009,22 @@ function buildClassName(fieldDef) {
     return classes.length > 0 ? classes.join(' ') : undefined;
 }
 
+function applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext) {
+    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(),
+            evaluationContext,
+        });
+    }
+}
+
 function arrayFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
+    const evaluationContext = injectNonFieldEvaluationContext(fieldDef, { scopeToArrayItem: true });
     const className = buildClassName(fieldDef);
     return computed(() => {
         const inputs = {
@@ -3014,7 +3032,7 @@ function arrayFieldMapper(fieldDef) {
             field: fieldDef,
             ...(className !== undefined && { className }),
         };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext);
         return inputs;
     });
 }
@@ -3059,6 +3077,7 @@ function baseFieldMapper(fieldDef) {
 
 function containerFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
+    const evaluationContext = injectNonFieldEvaluationContext(fieldDef, { scopeToArrayItem: true });
     const className = buildClassName(fieldDef);
     return computed(() => {
                                                         const containerField = { ...fieldDef, wrappers: undefined, skipAutoWrappers: undefined, skipDefaultWrappers: undefined };
@@ -3067,13 +3086,14 @@ function containerFieldMapper(fieldDef) {
             field: containerField,
             ...(className !== undefined && { className }),
         };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext);
         return inputs;
     });
 }
 
 function groupFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
+    const evaluationContext = injectNonFieldEvaluationContext(fieldDef, { scopeToArrayItem: true });
     const className = buildClassName(fieldDef);
     return computed(() => {
         const inputs = {
@@ -3081,7 +3101,7 @@ function groupFieldMapper(fieldDef) {
             field: fieldDef,
             ...(className !== undefined && { className }),
         };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext);
         return inputs;
     });
 }
@@ -3089,6 +3109,7 @@ function groupFieldMapper(fieldDef) {
 const ROW_WRAPPERS = [{ type: 'row' }];
 function rowFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
+    const evaluationContext = injectNonFieldEvaluationContext(fieldDef, { scopeToArrayItem: true });
     const className = buildClassName(fieldDef);
     return computed(() => {
                                                         const containerField = { ...fieldDef, type: 'container', wrappers: ROW_WRAPPERS };
@@ -3097,7 +3118,7 @@ function rowFieldMapper(fieldDef) {
             field: containerField,
             ...(className !== undefined && { className }),
         };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext);
         return inputs;
     });
 }
@@ -3113,11 +3134,12 @@ function pageFieldMapper(fieldDef) {
 
 function textFieldMapper(fieldDef) {
     const rootFormRegistry = inject(RootFormRegistryService);
+    const evaluationContext = injectNonFieldEvaluationContext(fieldDef, { scopeToArrayItem: true });
     const defaultProps = inject(DEFAULT_PROPS);
         return computed(() => {
         const baseInputs = buildBaseInputs(fieldDef, defaultProps());
         const inputs = { ...baseInputs };
-        applyHiddenLogic(inputs, fieldDef, rootFormRegistry);
+        applyHiddenLogic(inputs, fieldDef, rootFormRegistry, evaluationContext);
         return inputs;
     });
 }
@@ -3276,10 +3298,10 @@ class DynamicTextPipe {
         }
         return of(value || '');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DynamicTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.0", ngImport: i0, type: DynamicTextPipe, isStandalone: true, name: "dynamicText" });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DynamicTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: DynamicTextPipe, isStandalone: true, name: "dynamicText" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DynamicTextPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DynamicTextPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'dynamicText',
@@ -3609,5 +3631,5 @@ function createWarningTracker() {
 
 
 
-export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
+export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, compareValues, containerFieldMapper, createAddonActionRegistry, createDebouncedLogicFunction, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, injectNonFieldEvaluationContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, setupInitializationTracking, shouldLog, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
 //# sourceMappingURL=ng-forge-dynamic-forms-internal.mjs.map