@ng-forge/dynamic-forms 1.3.0-next.2 → 1.3.0-next.4

package/fesm2022/ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-CTOTwzzw.mjs

@@ -1,2394 +0,0 @@
-import { untracked, isWritableSignal, isSignal, inject, Injector, DestroyRef, computed } from '@angular/core';
-import { createDefaultDerivationLogConfig, shouldLog, ExpressionParser, DynamicFormError, getNestedValue, createFormFieldStateMap, isEqual, readFieldStateInfo, evaluateCondition, extractStringDependencies, extractExpressionDependencies, isDerivationLogicConfig, hasTargetProperty, getChangedKeys, resolveHttpRequest, getChangedKeysWithin, DynamicFormLogger, FunctionRegistryService, FORM_OPTIONS, EXTERNAL_DATA } from '@ng-forge/dynamic-forms/internal';
-import { t as traverseFieldsWithContext, q as DEV_MODE, u as DERIVATION_WARNING_TRACKER, v as FormStateManager, w as DERIVATION_LOG_CONFIG, P as PROPERTY_OVERRIDE_STORE } from './ng-forge-dynamic-forms-ng-forge-dynamic-forms-CXQe_5td.mjs';
-import { HttpClient } from '@angular/common/http';
-import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { explicitEffect } from 'ngxtension/explicit-effect';
-import { D as DEFAULT_DEBOUNCE_MS } from './ng-forge-dynamic-forms-debounce-C9F4v1Ke.mjs';
-import { EMPTY, startWith, pairwise, map, filter, debounceTime, switchMap, Observable, from, distinctUntilChanged, merge, combineLatestWith, auditTime, exhaustMap, scheduled, queueScheduler, of, timer, catchError as catchError$1 } from 'rxjs';
-import { catchError } from 'rxjs/operators';
-
-class ActiveDerivationLogger {
-    logger;
-    config = createDefaultDerivationLogConfig();
-        setConfig(config) {
-        this.config = config;
-    }
-    cycleStart(trigger, entryCount) {
-        if (!shouldLog(this.config, 'verbose'))
-            return;
-        this.logger.debug(`Derivation - Starting cycle (${trigger}) with ${entryCount} derivation(s)`);
-    }
-    iteration(iterationNumber) {
-        if (!shouldLog(this.config, 'verbose'))
-            return;
-        this.logger.debug(`Derivation - Iteration ${iterationNumber}`);
-    }
-    evaluation(entry) {
-        if (!shouldLog(this.config, 'verbose'))
-            return;
-        const name = entry.debugName ? `"${entry.debugName}"` : entry.fieldKey;
-        switch (entry.result) {
-            case 'applied':
-                this.logger.debug(`Derivation - Applied ${name}`, {
-                    field: entry.fieldKey,
-                    previousValue: entry.previousValue,
-                    newValue: entry.newValue,
-                    ...(entry.durationMs !== undefined && { durationMs: entry.durationMs }),
-                });
-                break;
-            case 'skipped':
-                this.logger.debug(`Derivation - Skipped ${name} (${this.formatSkipReason(entry.skipReason)})`, {
-                    field: entry.fieldKey,
-                    reason: entry.skipReason,
-                });
-                break;
-            case 'error':
-                this.logger.debug(`Derivation - Error ${name}`, {
-                    field: entry.fieldKey,
-                    error: entry.error,
-                });
-                break;
-        }
-    }
-    summary(result, trigger) {
-        if (!shouldLog(this.config, 'summary'))
-            return;
-                if (result.appliedCount === 0 && result.errorCount === 0)
-            return;
-        this.logger.debug(`Derivation - Cycle complete (${trigger})`, {
-            applied: result.appliedCount,
-            skipped: result.skippedCount,
-            errors: result.errorCount,
-            iterations: result.iterations,
-        });
-    }
-    maxIterationsReached(result, trigger) {
-        this.logger.warn(`Derivation - Max iterations reached (${trigger}). ` +
-            `This may indicate a loop in derivation logic. ` +
-            `Applied: ${result.appliedCount}, Skipped: ${result.skippedCount}, Errors: ${result.errorCount}`);
-    }
-    formatSkipReason(reason) {
-        switch (reason) {
-            case 'condition-false':
-                return 'condition not met';
-            case 'value-unchanged':
-                return 'value unchanged';
-            case 'already-applied':
-                return 'already applied this cycle';
-            case 'user-override':
-                return 'user override active';
-            case 'target-not-found':
-                return 'target not found';
-            default:
-                return 'unknown';
-        }
-    }
-}
-class NoopDerivationLogger {
-    cycleStart() {
-        /* no-op */
-    }
-    iteration() {
-        /* no-op */
-    }
-    evaluation() {
-        /* no-op */
-    }
-    summary() {
-        /* no-op */
-    }
-    maxIterationsReached() {
-        /* no-op */
-    }
-}
-const NOOP_INSTANCE = new NoopDerivationLogger();
-function createDerivationLogger(config, logger) {
-    const effectiveConfig = config ?? createDefaultDerivationLogConfig();
-        if (effectiveConfig.level === 'none') {
-        return NOOP_INSTANCE;
-    }
-        const service = new ActiveDerivationLogger();
-    service.logger = logger;
-    service.setConfig(effectiveConfig);
-    return service;
-}
-
-function parseArrayPath(path) {
-    const ARRAY_PLACEHOLDER = '.$.';
-    const placeholderIndex = path.indexOf(ARRAY_PLACEHOLDER);
-    if (placeholderIndex === -1) {
-        return {
-            arrayPath: '',
-            relativePath: '',
-            isArrayPath: false,
-        };
-    }
-    return {
-        arrayPath: path.substring(0, placeholderIndex),
-        relativePath: path.substring(placeholderIndex + ARRAY_PLACEHOLDER.length),
-        isArrayPath: true,
-    };
-}
-function resolveArrayPath(path, index) {
-    const info = parseArrayPath(path);
-    if (!info.isArrayPath) {
-        return path;
-    }
-    return `${info.arrayPath}.${index}.${info.relativePath}`;
-}
-function isArrayPlaceholderPath(path) {
-    return path.includes('.$.');
-}
-function extractArrayPath(path) {
-    return parseArrayPath(path).arrayPath;
-}
-function splitPath(path) {
-    if (!path)
-        return [];
-            return path
-        .replace(/\[(\d+)\]/g, '.$1')
-        .split('.')
-        .filter(Boolean);
-}
-function joinPath(segments) {
-    return segments.join('.');
-}
-function getParentPath(path) {
-    const segments = splitPath(path);
-    if (segments.length <= 1)
-        return '';
-    return joinPath(segments.slice(0, -1));
-}
-function getLeafPath(path) {
-    const segments = splitPath(path);
-    return segments[segments.length - 1] ?? '';
-}
-function parseMultiArrayPath(path) {
-    const parts = path.split('.');
-    const segments = [];
-    const placeholderPositions = [];
-    for (let i = 0; i < parts.length; i++) {
-        if (parts[i] === '$') {
-            placeholderPositions.push(i);
-        }
-        else {
-            segments.push(parts[i]);
-        }
-    }
-    return {
-        isArrayPath: placeholderPositions.length > 0,
-        placeholderCount: placeholderPositions.length,
-        segments,
-        placeholderPositions,
-    };
-}
-function resolveMultiArrayPath(path, indices) {
-    const parts = path.split('.');
-    let indexPointer = 0;
-    const resolved = parts.map((part) => {
-        if (part === '$') {
-            if (indexPointer >= indices.length) {
-                throw new Error(`Not enough indices provided for path '${path}'. ` +
-                    `Expected ${parts.filter((p) => p === '$').length} indices, got ${indices.length}.`);
-            }
-            return String(indices[indexPointer++]);
-        }
-        return part;
-    });
-    if (indexPointer < indices.length) {
-        throw new Error(`Too many indices provided for path '${path}'. ` + `Expected ${indexPointer} indices, got ${indices.length}.`);
-    }
-    return resolved.join('.');
-}
-function countArrayPlaceholders(path) {
-    return path.split('.').filter((part) => part === '$').length;
-}
-
-function createEmptyDerivationCollection() {
-    return { entries: [] };
-}
-function createDerivationChainContext() {
-    return {
-        appliedDerivations: new Set(),
-        iteration: 0,
-    };
-}
-function createDerivationKey(fieldKey) {
-    return fieldKey;
-}
-function parseDerivationKey(key) {
-    return { fieldKey: key };
-}
-
-function isThenableOrObservable(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return typeof candidate.then === 'function' || typeof candidate.subscribe === 'function';
-}
-function computeValueFromEntry(entry, evalContext, options) {
-    if (entry.value !== undefined) {
-        return entry.value;
-    }
-    if (entry.expression) {
-        return ExpressionParser.evaluate(entry.expression, evalContext);
-    }
-    if (entry.fn || entry.functionName) {
-        if (entry.fn && entry.functionName) {
-            evalContext.logger.warn(`Both "fn" and "functionName" are set on derivation for '${options.subject}'. Inline "fn" takes precedence; "functionName" is ignored.`);
-        }
-        const fn = entry.fn ?? (entry.functionName ? options.derivationFunctions?.[entry.functionName] : undefined);
-        if (!fn) {
-            const kind = options.functionKind ?? 'Derivation function';
-            throw new DynamicFormError(`${kind} '${entry.functionName}' not found in customFnConfig.derivations`);
-        }
-        const result = fn(evalContext);
-        if (isThenableOrObservable(result)) {
-            evalContext.logger.warn(`Derivation for '${options.subject}' returned a Promise or Observable. ` +
-                `Synchronous derivations must return a value; use 'asyncDerivations' or an HTTP derivation for asynchronous logic. Skipping.`);
-            return undefined;
-        }
-        return result;
-    }
-    throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', 'functionName', or 'fn'.`);
-}
-
-function getParentPathInScope(fieldKey) {
-    const lastDot = fieldKey.lastIndexOf('.');
-    if (lastDot <= 0)
-        return undefined;
-    return fieldKey.slice(0, lastDot);
-}
-function resolveArrayItemScope(pathInfo, arrayItem) {
-    const relativePath = pathInfo.isArrayPath ? pathInfo.relativePath : '';
-    const innerParentPath = relativePath.includes('.') ? relativePath.slice(0, relativePath.lastIndexOf('.')) : '';
-    const groupValue = innerParentPath ? getNestedValue(arrayItem, innerParentPath) : arrayItem;
-    const fieldValue = relativePath ? getNestedValue(arrayItem, relativePath) : arrayItem;
-    return { relativePath, groupValue, fieldValue };
-}
-
-const MAX_DERIVATION_ITERATIONS = 10;
-const ARRAY_PLACEHOLDER = '.$.';
-const MAX_AST_CACHE_SIZE = 1000;
-const DERIVATION_KEY_DELIMITER = '\x00';
-
-function resolveFieldInstance(rootForm, fieldPath) {
-    const parts = fieldPath.split('.');
-    let current = rootForm;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const next = current[parts[i]];
-        if (!next)
-            return undefined;
-        current = next;
-    }
-    const fieldAccessor = current[parts[parts.length - 1]];
-    if (!fieldAccessor)
-        return undefined;
-    return untracked(fieldAccessor);
-}
-function readFieldDirty(rootForm, fieldPath) {
-    const fieldInstance = resolveFieldInstance(rootForm, fieldPath);
-    if (!fieldInstance)
-        return undefined;
-    return untracked(fieldInstance.dirty);
-}
-function resetFieldState(rootForm, fieldPath) {
-    const fieldInstance = resolveFieldInstance(rootForm, fieldPath);
-    if (!fieldInstance)
-        return;
-    fieldInstance.reset();
-}
-function applyValueToForm(targetPath, value, rootForm, logger, warningTracker) {
-        if (!targetPath.includes('.')) {
-        return setFieldValue(rootForm, targetPath, value, logger, warningTracker);
-    }
-        const parts = targetPath.split('.');
-    let current = rootForm;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-                if (part === '$') {
-                                    return false;
-        }
-                const next = current[part];
-        if (!next) {
-            warnMissingField(targetPath, logger, warningTracker);
-            return false;         }
-        current = next;
-    }
-        const finalPart = parts[parts.length - 1];
-    return setFieldValue(current, finalPart, value, logger, warningTracker);
-}
-function setFieldValue(parent, fieldKey, value, logger, warningTracker) {
-    const fieldAccessor = parent[fieldKey];
-    if (!fieldAccessor) {
-        warnMissingField(fieldKey, logger, warningTracker);
-        return false;
-    }
-        const fieldInstance = untracked(fieldAccessor);
-    if (!fieldInstance || typeof fieldInstance !== 'object') {
-        warnMissingField(fieldKey, logger, warningTracker);
-        return false;
-    }
-        const valueSignal = fieldInstance.value;
-    if (isWritableSignal(valueSignal)) {
-                                valueSignal.set(value);
-        return true;
-    }
-    else {
-        warnMissingField(fieldKey, logger, warningTracker);
-        return false;
-    }
-}
-function warnMissingField(fieldKey, logger, warningTracker) {
-        if (warningTracker) {
-        if (warningTracker.warnedKeys.has(fieldKey)) {
-            return;
-        }
-        warningTracker.warnedKeys.add(fieldKey);
-    }
-    logger?.warn(`Derivation: target field '${fieldKey}' not found in form. ` +
-        `Ensure the field is defined in your form configuration. ` +
-        `This warning is shown once per field.`);
-}
-
-function applyDerivations(collection, context, changedFields) {
-    const chainContext = createDerivationChainContext();
-    chainContext.changedFields = changedFields;
-        chainContext.formFieldState = createFormFieldStateMap(context.rootForm, false);
-    const { derivationLogger } = context;
-    const maxIterations = context.maxIterations ?? MAX_DERIVATION_ITERATIONS;
-    let appliedCount = 0;
-    let skippedCount = 0;
-    let errorCount = 0;
-    let warnCount = 0;
-        const entriesToProcess = changedFields ? getEntriesForChangedFields$1(collection.entries, changedFields) : collection.entries;
-        derivationLogger.cycleStart('onChange', entriesToProcess.length);
-        let hasChanges = true;
-    while (hasChanges && chainContext.iteration < maxIterations) {
-        chainContext.iteration++;
-        hasChanges = false;
-                derivationLogger.iteration(chainContext.iteration);
-        for (const entry of entriesToProcess) {
-            const result = tryApplyDerivation(entry, context, chainContext);
-            if (result.applied) {
-                appliedCount++;
-                hasChanges = true;
-            }
-            else if (result.error) {
-                errorCount++;
-            }
-            else if (result.warning) {
-                warnCount++;
-                skippedCount++;
-            }
-            else {
-                skippedCount++;
-            }
-        }
-    }
-        const processingResult = {
-        appliedCount,
-        skippedCount,
-        errorCount,
-        warnCount,
-        iterations: chainContext.iteration,
-        maxIterationsReached: chainContext.iteration >= maxIterations,
-    };
-    if (processingResult.maxIterationsReached) {
-        derivationLogger.maxIterationsReached(processingResult, 'onChange');
-    }
-        derivationLogger.summary(processingResult, 'onChange');
-    return processingResult;
-}
-function getEntriesForChangedFields$1(entries, changedFields) {
-    return entries.filter((entry) => {
-                if (entry.dependsOn.length === 0 || entry.dependsOn.includes('*')) {
-            return true;
-        }
-                if (entry.dependsOn.some((dep) => changedFields.has(dep))) {
-            return true;
-        }
-                                for (const changed of changedFields) {
-                        if (entry.fieldKey.startsWith(changed + '.'))
-                return true;
-                        if (entry.dependsOn.some((dep) => dep.startsWith(changed + '.')))
-                return true;
-        }
-        return false;
-    });
-}
-function tryApplyDerivation(entry, context, chainContext) {
-    const { derivationLogger } = context;
-        if (entry.http || entry.asyncFunctionName || entry.asyncFn) {
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-        if (isArrayPlaceholderPath(entry.fieldKey)) {
-        return tryApplyArrayDerivation(entry, context, chainContext);
-    }
-    const derivationKey = createDerivationKey(entry.fieldKey);
-        if (chainContext.appliedDerivations.has(derivationKey)) {
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'skipped',
-            skipReason: 'already-applied',
-        });
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-        if (shouldSkipForUserOverride(entry, entry.fieldKey, context, chainContext)) {
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'skipped',
-            skipReason: 'user-override',
-        });
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-        const formValue = untracked(() => context.formValue());
-    const evalContext = createEvaluationContext$1(entry, formValue, context, chainContext);
-        if (!evaluateDerivationCondition(entry.condition, evalContext)) {
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'skipped',
-            skipReason: 'condition-false',
-        });
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-        let newValue;
-    try {
-        newValue = computeDerivedValue(entry, evalContext, context);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        context.logger.error(formatDerivationError(entry, 'compute', errorMessage));
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'error',
-            error: errorMessage,
-        });
-        return {
-            applied: false,
-            fieldKey: entry.fieldKey,
-            error: errorMessage,
-        };
-    }
-                        const currentValue = getNestedValue(formValue, entry.fieldKey);
-    if (isEqual(currentValue, newValue)) {
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'skipped',
-            skipReason: 'value-unchanged',
-        });
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-        try {
-        const wasApplied = applyValueToForm(entry.fieldKey, newValue, context.rootForm, context.logger, context.warningTracker);
-        if (wasApplied) {
-            chainContext.appliedDerivations.add(derivationKey);
-            derivationLogger.evaluation({
-                debugName: entry.debugName,
-                fieldKey: entry.fieldKey,
-                result: 'applied',
-                previousValue: currentValue,
-                newValue,
-            });
-            return { applied: true, fieldKey: entry.fieldKey, newValue };
-        }
-        else {
-                                    derivationLogger.evaluation({
-                debugName: entry.debugName,
-                fieldKey: entry.fieldKey,
-                result: 'skipped',
-                skipReason: 'target-not-found',
-            });
-            return {
-                applied: false,
-                fieldKey: entry.fieldKey,
-                warning: `Field '${entry.fieldKey}' not found`,
-            };
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        context.logger.error(formatDerivationError(entry, 'apply', errorMessage));
-        derivationLogger.evaluation({
-            debugName: entry.debugName,
-            fieldKey: entry.fieldKey,
-            result: 'error',
-            error: errorMessage,
-        });
-        return {
-            applied: false,
-            fieldKey: entry.fieldKey,
-            error: errorMessage,
-        };
-    }
-}
-function tryApplyArrayDerivation(entry, context, chainContext) {
-    const formValue = untracked(() => context.formValue());
-        const pathInfo = parseArrayPath(entry.fieldKey);
-    if (!pathInfo.isArrayPath) {
-        return { applied: false, fieldKey: entry.fieldKey, error: 'Invalid array derivation path' };
-    }
-    const { arrayPath } = pathInfo;
-        const arrayValue = getNestedValue(formValue, arrayPath);
-    if (!Array.isArray(arrayValue)) {
-        return { applied: false, fieldKey: entry.fieldKey };
-    }
-    let appliedAny = false;
-        for (let i = 0; i < arrayValue.length; i++) {
-        const resolvedPath = resolveArrayPath(entry.fieldKey, i);
-        const derivationKey = createDerivationKey(resolvedPath);
-                if (chainContext.appliedDerivations.has(derivationKey)) {
-            continue;
-        }
-                if (shouldSkipForUserOverride(entry, resolvedPath, context, chainContext)) {
-            context.derivationLogger.evaluation({
-                debugName: entry.debugName,
-                fieldKey: resolvedPath,
-                result: 'skipped',
-                skipReason: 'user-override',
-            });
-            continue;
-        }
-                const arrayItem = arrayValue[i];
-        const evalContext = createArrayItemEvaluationContext$1(entry, arrayItem, formValue, i, arrayPath, context, chainContext);
-                if (!evaluateDerivationCondition(entry.condition, evalContext)) {
-            continue;
-        }
-                let newValue;
-        try {
-            newValue = computeDerivedValue(entry, evalContext, context);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.logger.error(formatDerivationError(entry, 'compute', `[index ${i}] ${errorMessage}`));
-            continue;
-        }
-                const currentValue = getNestedValue(formValue, resolvedPath);
-        if (isEqual(currentValue, newValue)) {
-            continue;
-        }
-                try {
-            applyValueToForm(resolvedPath, newValue, context.rootForm, context.logger, context.warningTracker);
-            chainContext.appliedDerivations.add(derivationKey);
-            appliedAny = true;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.logger.error(formatDerivationError(entry, 'apply', `[index ${i}] ${errorMessage}`));
-        }
-    }
-    return { applied: appliedAny, fieldKey: entry.fieldKey };
-}
-function createEvaluationContext$1(entry, formValue, context, chainContext) {
-    const fieldValue = getNestedValue(formValue, entry.fieldKey);
-            const fieldAccessor = getFieldTreeByPath(context.rootForm, entry.fieldKey);
-    const fieldState = fieldAccessor ? readFieldStateInfo(fieldAccessor, false) : undefined;
-            const parentPath = getParentPathInScope(entry.fieldKey);
-    const groupValue = parentPath ? getNestedValue(formValue, parentPath) : undefined;
-            const scopedToGroup = parentPath !== undefined;
-    return {
-        fieldValue,
-        formValue: scopedToGroup ? (groupValue ?? {}) : formValue,
-        fieldPath: entry.fieldKey,
-        groupValue,
-        customFunctions: context.customFunctions,
-        externalData: context.externalData,
-        logger: context.logger,
-        rootFormValue: formValue,
-        fieldState,
-        formFieldState: chainContext.formFieldState,
-    };
-}
-function getFieldTreeByPath(root, path) {
-    let current = root;
-    for (const segment of path.split('.')) {
-        if (current === undefined || current === null)
-            return undefined;
-        current = current[segment];
-    }
-    return current;
-}
-function createArrayItemEvaluationContext$1(entry, arrayItem, rootFormValue, itemIndex, arrayPath, context, chainContext) {
-                        const pathInfo = parseArrayPath(entry.fieldKey);
-    let fieldState;
-    if (pathInfo.isArrayPath && pathInfo.relativePath) {
-        const rootFormRecord = context.rootForm;
-        const arrayAccessor = rootFormRecord[arrayPath];
-        if (arrayAccessor) {
-            const arrayItems = arrayAccessor;
-            const itemAccessor = arrayItems[String(itemIndex)];
-            if (itemAccessor) {
-                const itemFields = itemAccessor;
-                const fieldAccessor = itemFields[pathInfo.relativePath];
-                if (fieldAccessor) {
-                    fieldState = readFieldStateInfo(fieldAccessor, false);
-                }
-            }
-        }
-    }
-    const { relativePath, groupValue, fieldValue } = resolveArrayItemScope(pathInfo, arrayItem);
-    return {
-        fieldValue,
-        formValue: arrayItem,
-        fieldPath: relativePath ? `${arrayPath}.${itemIndex}.${relativePath}` : `${arrayPath}.${itemIndex}`,
-        groupValue,
-        customFunctions: context.customFunctions,
-        externalData: context.externalData,
-        logger: context.logger,
-                rootFormValue,
-        arrayIndex: itemIndex,
-        arrayPath,
-        fieldState,
-        formFieldState: chainContext.formFieldState,
-    };
-}
-function evaluateDerivationCondition(condition, context) {
-    if (typeof condition === 'boolean') {
-        return condition;
-    }
-    return evaluateCondition(condition, context);
-}
-function computeDerivedValue(entry, evalContext, applicatorContext) {
-    return computeValueFromEntry(entry, evalContext, {
-        derivationFunctions: applicatorContext.derivationFunctions,
-        subject: entry.fieldKey,
-    });
-}
-const ERROR_PREFIX$1 = '[Derivation]';
-function formatDerivationError(entry, phase, message) {
-    const source = entry.expression
-        ? `expression: "${entry.expression.substring(0, 50)}${entry.expression.length > 50 ? '...' : ''}"`
-        : entry.functionName
-            ? `function: "${entry.functionName}"`
-            : entry.fn
-                ? 'inline fn'
-                : entry.value !== undefined
-                    ? 'static value'
-                    : 'unknown source';
-    return `${ERROR_PREFIX$1} Failed to ${phase} derivation (field: ${entry.fieldKey}, ${source}): ${message}`;
-}
-function hasDependencyChanged(entry, changedFields) {
-    return entry.dependsOn.some((dep) => dep === '*' || changedFields.has(dep));
-}
-function shouldSkipForUserOverride(entry, resolvedFieldKey, context, chainContext) {
-    if (!entry.stopOnUserOverride)
-        return false;
-    const isDirty = readFieldDirty(context.rootForm, resolvedFieldKey) ?? false;
-                    if (!isDirty)
-        return false;
-        if (entry.reEngageOnDependencyChange && chainContext.changedFields) {
-        if (hasDependencyChanged(entry, chainContext.changedFields)) {
-            resetFieldState(context.rootForm, resolvedFieldKey);
-                        return false;
-        }
-    }
-        return true;
-}
-function applyDerivationsForTrigger(collection, trigger, context, changedFields) {
-        const filteredEntries = collection.entries.filter((entry) => {
-        if (entry.http || entry.asyncFunctionName || entry.asyncFn)
-            return false;
-        if (trigger === 'onChange') {
-            return !entry.trigger || entry.trigger === 'onChange';
-        }
-        return entry.trigger === trigger;
-    });
-        const filteredCollection = {
-        entries: filteredEntries,
-    };
-    return applyDerivations(filteredCollection, context, changedFields);
-}
-function getDebouncedDerivationEntries(collection) {
-    return collection.entries.filter((entry) => entry.trigger === 'debounced');
-}
-
-function topologicalSort(entries) {
-    if (entries.length <= 1) {
-        return [...entries];
-    }
-            const graph = new Map();
-    const inDegree = new Map();
-        for (const entry of entries) {
-        graph.set(entry, new Set());
-        inDegree.set(entry, 0);
-    }
-            const derivationsByField = new Map();
-    for (const entry of entries) {
-                const fieldEntries = derivationsByField.get(entry.fieldKey) ?? [];
-        fieldEntries.push(entry);
-        derivationsByField.set(entry.fieldKey, fieldEntries);
-                        if (entry.fieldKey.includes('.$.')) {
-            const relativePath = entry.fieldKey.split('.$.')[1];
-            if (relativePath) {
-                const relativeEntries = derivationsByField.get(relativePath) ?? [];
-                relativeEntries.push(entry);
-                derivationsByField.set(relativePath, relativeEntries);
-            }
-        }
-    }
-        const wildcardDependents = [];
-    for (const entry of entries) {
-        if (entry.dependsOn.includes('*')) {
-            wildcardDependents.push(entry);
-        }
-    }
-                for (const entryB of entries) {
-                                const groupPath = entryB.fieldKey.includes('.') && !entryB.fieldKey.includes('.$.')
-            ? entryB.fieldKey.slice(0, entryB.fieldKey.lastIndexOf('.'))
-            : undefined;
-        for (const dep of entryB.dependsOn) {
-                        if (dep === '*')
-                continue;
-                                    const producers = [
-                ...(derivationsByField.get(dep) ?? []),
-                ...(groupPath && !dep.includes('.') ? (derivationsByField.get(`${groupPath}.${dep}`) ?? []) : []),
-            ];
-            for (const entryA of producers) {
-                const entryAEdges = graph.get(entryA);
-                if (entryA !== entryB && entryAEdges && !entryAEdges.has(entryB)) {
-                    entryAEdges.add(entryB);
-                    inDegree.set(entryB, (inDegree.get(entryB) ?? 0) + 1);
-                }
-            }
-        }
-    }
-        for (const entryB of wildcardDependents) {
-        for (const entryA of entries) {
-            const entryAEdges = graph.get(entryA);
-            if (entryA !== entryB && entryAEdges && !entryAEdges.has(entryB)) {
-                entryAEdges.add(entryB);
-                inDegree.set(entryB, (inDegree.get(entryB) ?? 0) + 1);
-            }
-        }
-    }
-        const queue = [];
-    const sorted = [];
-        for (const entry of entries) {
-        if (inDegree.get(entry) === 0) {
-            queue.push(entry);
-        }
-    }
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current)
-            break;         sorted.push(current);
-                const neighbors = graph.get(current) ?? new Set();
-        for (const neighbor of neighbors) {
-            const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
-            inDegree.set(neighbor, newDegree);
-            if (newDegree === 0) {
-                queue.push(neighbor);
-            }
-        }
-    }
-            if (sorted.length !== entries.length) {
-                const sortedSet = new Set(sorted);
-        for (const entry of entries) {
-            if (!sortedSet.has(entry)) {
-                sorted.push(entry);
-            }
-        }
-    }
-    return sorted;
-}
-
-function extractDependenciesFromConfig(config) {
-    const deps = new Set();
-    if (config.dependsOn && config.dependsOn.length > 0) {
-        config.dependsOn.forEach((dep) => deps.add(dep));
-    }
-    else {
-        if (config.expression) {
-            extractStringDependencies(config.expression).forEach((dep) => deps.add(dep));
-        }
-                        if (config.functionName || config.fn) {
-            deps.add('*');
-        }
-    }
-    if (config.condition && config.condition !== true) {
-        extractExpressionDependencies(config.condition).forEach((dep) => deps.add(dep));
-    }
-    return Array.from(deps);
-}
-
-function extractInlineFn(config) {
-    return config.fn;
-}
-function extractInlineAsyncFn(config) {
-    return config.asyncFn;
-}
-
-const SELF_DEPENDENCY_TOKEN = '$self';
-const GROUP_DEPENDENCY_TOKEN = '$group';
-function buildEffectiveFieldKey(fieldKey, context) {
-    if (context.arrayPath && context.groupPath) {
-        return `${context.arrayPath}.$.${context.groupPath}.${fieldKey}`;
-    }
-    if (context.arrayPath) {
-        return `${context.arrayPath}.$.${fieldKey}`;
-    }
-    if (context.groupPath) {
-        return `${context.groupPath}.${fieldKey}`;
-    }
-    return fieldKey;
-}
-function buildNearestGroupPath(context) {
-    if (context.arrayPath && context.groupPath) {
-        return `${context.arrayPath}.$.${context.groupPath}`;
-    }
-    return context.arrayPath ?? context.groupPath;
-}
-function resolveTokenDependencies(deps, effectiveFieldKey, context) {
-    return deps.map((dep) => {
-        if (dep === SELF_DEPENDENCY_TOKEN) {
-            return effectiveFieldKey;
-        }
-        if (dep.startsWith(`${SELF_DEPENDENCY_TOKEN}.`)) {
-            return effectiveFieldKey + dep.slice(SELF_DEPENDENCY_TOKEN.length);
-        }
-        if (dep === GROUP_DEPENDENCY_TOKEN || dep.startsWith(`${GROUP_DEPENDENCY_TOKEN}.`)) {
-            const groupPath = buildNearestGroupPath(context);
-            if (!groupPath) {
-                throw new DynamicFormError(`Derivation for '${effectiveFieldKey}' uses '${dep}' but the field has no parent group or array. ` +
-                    `'${GROUP_DEPENDENCY_TOKEN}' is only valid for fields nested inside a group or array container.`);
-            }
-            if (dep === GROUP_DEPENDENCY_TOKEN)
-                return groupPath;
-            return groupPath + dep.slice(GROUP_DEPENDENCY_TOKEN.length);
-        }
-        return dep;
-    });
-}
-const CONTEXT_TRAVERSAL_OPTIONS = {
-    onArrayChild: (_parent, field) => ({ arrayPath: field.key, groupPath: undefined }),
-    onGroupChild: (parent, field) => {
-        if (!field.key)
-            return {};
-        return { groupPath: parent.groupPath ? `${parent.groupPath}.${field.key}` : field.key };
-    },
-};
-
-function collectDerivations(fields) {
-    const entries = [];
-    traverseFieldsWithContext(fields, {}, (field, context) => collectValueEntriesFromField(field, entries, context), CONTEXT_TRAVERSAL_OPTIONS);
-    return { entries: topologicalSort(entries) };
-}
-function collectAllDerivations(fields) {
-    const valueEntries = [];
-    const propertyEntries = [];
-    traverseFieldsWithContext(fields, {}, (field, context) => {
-        collectValueEntriesFromField(field, valueEntries, context);
-        collectPropertyEntriesFromField(field, propertyEntries, context);
-    }, CONTEXT_TRAVERSAL_OPTIONS);
-    return {
-        value: { entries: topologicalSort(valueEntries) },
-        property: { entries: propertyEntries },
-    };
-}
-function collectValueEntriesFromField(field, entries, context) {
-    const fieldKey = field.key;
-    if (!fieldKey)
-        return;
-    const validationField = field;
-    if (validationField.derivation) {
-        entries.push(createShorthandEntry(fieldKey, validationField.derivation, context));
-    }
-    if (validationField.logic) {
-        for (const logicConfig of validationField.logic) {
-            if (!isDerivationLogicConfig(logicConfig))
-                continue;
-            if (hasTargetProperty(logicConfig))
-                continue;             entries.push(createValueLogicEntry(fieldKey, logicConfig, context));
-        }
-    }
-}
-function collectPropertyEntriesFromField(field, entries, context) {
-    const fieldKey = field.key;
-    if (!fieldKey)
-        return;
-    const validationField = field;
-    if (!validationField.logic)
-        return;
-    for (const logicConfig of validationField.logic) {
-        if (!isDerivationLogicConfig(logicConfig))
-            continue;
-        if (!hasTargetProperty(logicConfig))
-            continue;
-        entries.push(createPropertyLogicEntry(fieldKey, logicConfig, context));
-    }
-}
-function createShorthandEntry(fieldKey, expression, context) {
-    const effectiveFieldKey = buildEffectiveFieldKey(fieldKey, context);
-    return {
-        fieldKey: effectiveFieldKey,
-        dependsOn: extractStringDependencies(expression),
-        condition: true,
-        expression,
-        trigger: 'onChange',
-        isShorthand: true,
-    };
-}
-function createValueLogicEntry(fieldKey, config, context) {
-    const effectiveFieldKey = buildEffectiveFieldKey(fieldKey, context);
-                                        if (config.source === 'http') {
-        if (config.dependsOn.length === 0) {
-            throw new DynamicFormError(`HTTP derivation for '${effectiveFieldKey}' requires explicit 'dependsOn'. ` +
-                `Wildcard dependencies would trigger HTTP requests on every form change.`);
-        }
-        if (config.dependsOn.includes('*')) {
-            throw new DynamicFormError(`HTTP derivation for '${effectiveFieldKey}' cannot use wildcard ('*') in 'dependsOn'. ` +
-                `Wildcards would trigger HTTP requests on every form change. Specify explicit field dependencies instead.`);
-        }
-    }
-    if (config.source === 'asyncFunction') {
-        if (config.dependsOn.length === 0) {
-            throw new DynamicFormError(`Async derivation for '${effectiveFieldKey}' requires explicit 'dependsOn'. ` +
-                `Wildcard dependencies would trigger async functions on every form change.`);
-        }
-        if (config.dependsOn.includes('*')) {
-            throw new DynamicFormError(`Async derivation for '${effectiveFieldKey}' cannot use wildcard ('*') in 'dependsOn'. ` +
-                `Wildcards would trigger async functions on every form change. Specify explicit field dependencies instead.`);
-        }
-    }
-    const dependsOn = resolveTokenDependencies(extractDependenciesFromConfig(config), effectiveFieldKey, context);
-    const condition = config.condition ?? true;
-    const trigger = config.trigger ?? 'onChange';
-    const debounceMs = trigger === 'debounced' ? config.debounceMs : undefined;
-    return {
-        fieldKey: effectiveFieldKey,
-        dependsOn,
-        condition,
-        value: config.value,
-        expression: config.expression,
-        functionName: config.functionName,
-        fn: extractInlineFn(config),
-        http: config.http,
-        responseExpression: config.responseExpression,
-        asyncFunctionName: config.asyncFunctionName,
-        asyncFn: extractInlineAsyncFn(config),
-        trigger,
-        debounceMs,
-        isShorthand: false,
-        originalConfig: config,
-        debugName: config.debugName,
-        stopOnUserOverride: config.stopOnUserOverride,
-        reEngageOnDependencyChange: config.reEngageOnDependencyChange,
-    };
-}
-function createPropertyLogicEntry(fieldKey, config, context) {
-    const effectiveFieldKey = buildEffectiveFieldKey(fieldKey, context);
-    const errorLocation = `'${effectiveFieldKey}.${config.targetProperty}'`;
-                    const untypedConfig = config;
-        if (untypedConfig.source === 'http' || untypedConfig.source === 'asyncFunction') {
-        const conflictingSyncSources = [];
-        if (untypedConfig.value !== undefined)
-            conflictingSyncSources.push('value');
-        if (untypedConfig.expression !== undefined)
-            conflictingSyncSources.push('expression');
-        if (untypedConfig.functionName !== undefined)
-            conflictingSyncSources.push('functionName');
-        if (untypedConfig.fn !== undefined)
-            conflictingSyncSources.push('fn');
-        if (conflictingSyncSources.length > 0) {
-            throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: ${JSON.stringify(untypedConfig.source)}' alongside ` +
-                `sync value source(s) [${conflictingSyncSources.join(', ')}]. These are mutually exclusive — remove either ` +
-                `the sync fields or the async source.`);
-        }
-    }
-    if (untypedConfig.source === 'http' && (untypedConfig.asyncFunctionName !== undefined || untypedConfig.asyncFn !== undefined)) {
-        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "http"' alongside an async function — these are mutually exclusive.`);
-    }
-    if (untypedConfig.source === 'asyncFunction' && (untypedConfig.http !== undefined || untypedConfig.responseExpression !== undefined)) {
-        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "asyncFunction"' alongside HTTP fields — these are mutually exclusive.`);
-    }
-    if (untypedConfig.source === 'http') {
-        if (!untypedConfig.http) {
-            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires an 'http' config object.`);
-        }
-        if (typeof untypedConfig.responseExpression !== 'string' || untypedConfig.responseExpression.trim() === '') {
-            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires a non-empty 'responseExpression'.`);
-        }
-        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
-            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
-                `Wildcard dependencies would trigger HTTP requests on every form change.`);
-        }
-        if (untypedConfig.dependsOn.includes('*')) {
-            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
-                `Wildcards would trigger HTTP requests on every form change. Specify explicit field dependencies instead.`);
-        }
-    }
-    if (untypedConfig.source === 'asyncFunction') {
-        if (!untypedConfig.asyncFunctionName && !untypedConfig.asyncFn) {
-            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires either 'asyncFunctionName' or 'asyncFn'.`);
-        }
-        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
-            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
-                `Wildcard dependencies would trigger async functions on every form change.`);
-        }
-        if (untypedConfig.dependsOn.includes('*')) {
-            throw new DynamicFormError(`Async property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
-                `Wildcards would trigger async functions on every form change. Specify explicit field dependencies instead.`);
-        }
-    }
-                            const dependsOn = resolveTokenDependencies(extractDependenciesFromConfig(config), effectiveFieldKey, context);
-    const condition = config.condition ?? true;
-    const trigger = config.trigger ?? 'onChange';
-    const debounceMs = trigger === 'debounced' ? config.debounceMs : undefined;
-    return {
-        fieldKey: effectiveFieldKey,
-        targetProperty: config.targetProperty,
-        dependsOn,
-        condition,
-        value: config.value,
-        expression: config.expression,
-        functionName: config.functionName,
-        fn: extractInlineFn(config),
-        http: config.http,
-        responseExpression: config.responseExpression,
-        asyncFunctionName: config.asyncFunctionName,
-        asyncFn: extractInlineAsyncFn(config),
-        trigger,
-        debounceMs,
-        debugName: config.debugName,
-        originalConfig: config,
-    };
-}
-
-function collectPropertyDerivations(fields) {
-    return collectAllDerivations(fields).property;
-}
-
-function detectCycles(collection) {
-        const graph = buildDependencyGraph(collection);
-        if (graph.size === 0) {
-        return { hasCycle: false };
-    }
-        const bidirectionalPairs = detectBidirectionalPairs(collection);
-        const result = detectCyclesWithDFS(graph, bidirectionalPairs);
-        if (bidirectionalPairs.size > 0) {
-        result.bidirectionalPairs = Array.from(bidirectionalPairs);
-    }
-    return result;
-}
-function detectBidirectionalPairs(collection) {
-    const pairs = new Set();
-        const dependencyMap = new Map();
-    for (const entry of collection.entries) {
-        const deps = dependencyMap.get(entry.fieldKey) ?? new Set();
-        for (const dep of entry.dependsOn) {
-            if (dep !== '*' && dep !== entry.fieldKey) {
-                deps.add(dep);
-            }
-        }
-        dependencyMap.set(entry.fieldKey, deps);
-    }
-        for (const [fieldA, depsA] of dependencyMap) {
-        for (const fieldB of depsA) {
-            const depsB = dependencyMap.get(fieldB);
-            if (depsB?.has(fieldA)) {
-                                const pairKey = fieldA < fieldB ? `${fieldA}↔${fieldB}` : `${fieldB}↔${fieldA}`;
-                pairs.add(pairKey);
-            }
-        }
-    }
-    return pairs;
-}
-function isBidirectionalCycle(cyclePath, bidirectionalPairs) {
-        if (cyclePath.length !== 3) {
-        return false;
-    }
-    const [first, second, third] = cyclePath;
-    if (first !== third) {
-        return false;
-    }
-        const pairKey = first < second ? `${first}↔${second}` : `${second}↔${first}`;
-    return bidirectionalPairs.has(pairKey);
-}
-function buildDependencyGraph(collection) {
-    const graph = new Map();
-        const ensureNode = (fieldKey) => {
-        let node = graph.get(fieldKey);
-        if (!node) {
-            node = {
-                fieldKey,
-                dependsOn: new Set(),
-                dependedOnBy: new Set(),
-            };
-            graph.set(fieldKey, node);
-        }
-        return node;
-    };
-    for (const entry of collection.entries) {
-        const fieldNode = ensureNode(entry.fieldKey);
-                                        for (const dep of entry.dependsOn) {
-                        if (dep !== '*' && dep !== entry.fieldKey) {
-                const depNode = ensureNode(dep);
-                                fieldNode.dependsOn.add(dep);
-                                depNode.dependedOnBy.add(entry.fieldKey);
-            }
-        }
-    }
-    return graph;
-}
-function detectCyclesWithDFS(graph, bidirectionalPairs) {
-    const visitState = new Map();
-    const parent = new Map();
-        for (const fieldKey of graph.keys()) {
-        visitState.set(fieldKey, 0 /* VisitState.Unvisited */);
-    }
-        for (const fieldKey of graph.keys()) {
-        if (visitState.get(fieldKey) === 0 /* VisitState.Unvisited */) {
-            const cycleResult = dfsVisit(fieldKey, graph, visitState, parent, [], bidirectionalPairs);
-            if (cycleResult) {
-                return cycleResult;
-            }
-        }
-    }
-    return { hasCycle: false };
-}
-function dfsVisit(fieldKey, graph, visitState, parent, path, bidirectionalPairs) {
-    visitState.set(fieldKey, 1 /* VisitState.InProgress */);
-    path.push(fieldKey);
-    const node = graph.get(fieldKey);
-    if (!node) {
-        visitState.set(fieldKey, 2 /* VisitState.Completed */);
-        path.pop();
-        return null;
-    }
-        for (const targetFieldKey of node.dependedOnBy) {
-        const targetState = visitState.get(targetFieldKey);
-        if (targetState === 1 /* VisitState.InProgress */) {
-                        const cyclePath = extractCyclePath(path, targetFieldKey);
-                                    if (isBidirectionalCycle(cyclePath, bidirectionalPairs)) {
-                                continue;
-            }
-            return {
-                hasCycle: true,
-                cyclePath,
-                errorMessage: formatCycleError(cyclePath),
-            };
-        }
-        if (targetState === 0 /* VisitState.Unvisited */) {
-            parent.set(targetFieldKey, fieldKey);
-            const result = dfsVisit(targetFieldKey, graph, visitState, parent, path, bidirectionalPairs);
-            if (result) {
-                return result;
-            }
-        }
-    }
-    visitState.set(fieldKey, 2 /* VisitState.Completed */);
-    path.pop();
-    return null;
-}
-function extractCyclePath(path, cycleStart) {
-    const cycleStartIndex = path.indexOf(cycleStart);
-    if (cycleStartIndex === -1) {
-                return [...path, cycleStart];
-    }
-        const cyclePath = path.slice(cycleStartIndex);
-    cyclePath.push(cycleStart);     return cyclePath;
-}
-function formatCycleError(cyclePath) {
-    const pathStr = cyclePath.join(' -> ');
-    return (`Derivation cycle detected: ${pathStr}\n` +
-        `This would cause an infinite loop at runtime. ` +
-        `Remove one of the derivations to break the cycle.`);
-}
-function validateNoCycles(collection, logger) {
-    const result = detectCycles(collection);
-    if (result.hasCycle) {
-        throw new Error(result.errorMessage);
-    }
-        if (DEV_MODE && result.bidirectionalPairs && result.bidirectionalPairs.length > 0 && logger) {
-        logger.warn('Derivation: bidirectional derivation patterns detected. ' +
-            'These patterns stabilize via equality checks, but may oscillate with floating-point values ' +
-            '(e.g., currency conversions with rounding). ' +
-            'Consider adding tolerance-based comparisons for numeric values.', result.bidirectionalPairs);
-    }
-}
-
-const LOG_PREFIX$3 = 'HTTP Derivation -';
-const DEFAULT_HTTP_DEBOUNCE_MS$1 = 300;
-function createHttpDerivationStream(entry, formValue$, context) {
-        if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX$3} HTTP derivation for array field '${entry.fieldKey}' is not supported. ` +
-            `Array HTTP derivations will be supported in a future release.`);
-        return EMPTY;
-    }
-    if (!entry.http || !entry.responseExpression) {
-        return EMPTY;
-    }
-        const responseExpression = entry.responseExpression;
-    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS$1;
-    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
-        current: current,
-        changedFields: getChangedKeys(previous, current),
-    })), 
-        filter(({ changedFields }) => {
-        if (changedFields.size === 0)
-            return false;
-        return entry.dependsOn.some((dep) => changedFields.has(dep));
-    }), debounceTime(debounceMs), switchMap(({ current, changedFields }) => {
-        return new Observable((subscriber) => {
-            const formAccessor = untracked(() => context.form());
-                        if (entry.stopOnUserOverride) {
-                const isDirty = readFieldDirty(formAccessor, entry.fieldKey);
-                if (isDirty) {
-                                        if (entry.reEngageOnDependencyChange && changedFields.size > 0) {
-                        if (entry.dependsOn.some((dep) => changedFields.has(dep))) {
-                            resetFieldState(formAccessor, entry.fieldKey);
-                                                    }
-                        else {
-                                                        const derivationLogger = untracked(() => context.derivationLogger());
-                            derivationLogger.evaluation({
-                                debugName: entry.debugName,
-                                fieldKey: entry.fieldKey,
-                                result: 'skipped',
-                                skipReason: 'user-override',
-                            });
-                            subscriber.complete();
-                            return;
-                        }
-                    }
-                    else {
-                        const derivationLogger = untracked(() => context.derivationLogger());
-                        derivationLogger.evaluation({
-                            debugName: entry.debugName,
-                            fieldKey: entry.fieldKey,
-                            result: 'skipped',
-                            skipReason: 'user-override',
-                        });
-                        subscriber.complete();
-                        return;
-                    }
-                }
-            }
-                        const customFunctions = context.customFunctions?.();
-            const externalData = context.externalData?.();
-                        const fieldValue = getNestedValue(current, entry.fieldKey);
-            const fieldAccessor = formAccessor[entry.fieldKey];
-            const fieldState = fieldAccessor ? readFieldStateInfo(fieldAccessor, false) : undefined;
-            const evalContext = {
-                fieldValue,
-                formValue: current,
-                fieldPath: entry.fieldKey,
-                customFunctions,
-                externalData,
-                logger: context.logger,
-                fieldState,
-                formFieldState: createFormFieldStateMap(formAccessor, false),
-            };
-                        if (entry.condition !== true) {
-                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
-                if (!conditionMet) {
-                    const derivationLogger = untracked(() => context.derivationLogger());
-                    derivationLogger.evaluation({
-                        debugName: entry.debugName,
-                        fieldKey: entry.fieldKey,
-                        result: 'skipped',
-                        skipReason: 'condition-false',
-                    });
-                    subscriber.complete();
-                    return;
-                }
-            }
-                        const resolvedRequest = resolveHttpRequest(entry.http, evalContext);
-            if (!resolvedRequest) {
-                const derivationLogger = untracked(() => context.derivationLogger());
-                derivationLogger.evaluation({
-                    debugName: entry.debugName,
-                    fieldKey: entry.fieldKey,
-                    result: 'skipped',
-                    skipReason: 'condition-false',
-                });
-                subscriber.complete();
-                return;
-            }
-                                                            const method = (resolvedRequest.method ?? 'GET').toUpperCase();
-            const httpSub = context.httpClient
-                .request(method, resolvedRequest.url, {
-                body: resolvedRequest.body,
-                headers: resolvedRequest.headers,
-            })
-                .subscribe({
-                next: (response) => {
-                    try {
-                                                const newValue = ExpressionParser.evaluate(responseExpression, { response });
-                                                const currentFormValue = untracked(() => context.formValue());
-                        const currentValue = getNestedValue(currentFormValue, entry.fieldKey);
-                        if (isEqual(currentValue, newValue)) {
-                            const derivationLogger = untracked(() => context.derivationLogger());
-                            derivationLogger.evaluation({
-                                debugName: entry.debugName,
-                                fieldKey: entry.fieldKey,
-                                result: 'skipped',
-                                skipReason: 'value-unchanged',
-                            });
-                            subscriber.complete();
-                            return;
-                        }
-                                                                                                const currentForm = untracked(() => context.form());
-                        if (entry.stopOnUserOverride && readFieldDirty(currentForm, entry.fieldKey)) {
-                            const derivationLogger = untracked(() => context.derivationLogger());
-                            derivationLogger.evaluation({
-                                debugName: entry.debugName,
-                                fieldKey: entry.fieldKey,
-                                result: 'skipped',
-                                skipReason: 'user-override',
-                            });
-                            subscriber.complete();
-                            return;
-                        }
-                                                applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
-                        const derivationLogger = untracked(() => context.derivationLogger());
-                        derivationLogger.evaluation({
-                            debugName: entry.debugName,
-                            fieldKey: entry.fieldKey,
-                            result: 'applied',
-                            previousValue: currentValue,
-                            newValue,
-                        });
-                        subscriber.complete();
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX$3} Failed to process response for '${entry.fieldKey}': ${message}`);
-                        subscriber.complete();
-                    }
-                },
-                error: (error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX$3} HTTP request failed for '${entry.fieldKey}': ${message}`);
-                    subscriber.complete();
-                },
-            });
-                                                return () => {
-                httpSub.unsubscribe();
-            };
-        });
-    }), catchError((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX$3} Unexpected stream error for '${entry.fieldKey}': ${message}`);
-        return EMPTY;
-    }));
-}
-
-const LOG_PREFIX$2 = 'Async Derivation -';
-const DEFAULT_ASYNC_DEBOUNCE_MS$1 = 300;
-function createAsyncDerivationStream(entry, formValue$, context) {
-        if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX$2} Async derivation for array field '${entry.fieldKey}' is not supported. ` +
-            `Array async derivations will be supported in a future release.`);
-        return EMPTY;
-    }
-    if (!entry.asyncFunctionName && !entry.asyncFn) {
-        context.logger.warn(`${LOG_PREFIX$2} Derivation for '${entry.fieldKey}' has neither "asyncFunctionName" nor "asyncFn". ` +
-            `One of the two is required for source: 'asyncFunction'.`);
-        return EMPTY;
-    }
-    if (entry.asyncFn && entry.asyncFunctionName) {
-        context.logger.warn(`${LOG_PREFIX$2} Both "asyncFn" and "asyncFunctionName" are set on derivation for '${entry.fieldKey}'. ` +
-            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
-    }
-    const inlineAsyncFn = entry.asyncFn;
-    const asyncFunctionName = entry.asyncFunctionName;
-    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS$1;
-                    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
-        current: current,
-        changedFields: getChangedKeys(previous, current),
-    })), 
-        filter(({ changedFields }) => {
-        if (changedFields.size === 0)
-            return false;
-        return entry.dependsOn.some((dep) => changedFields.has(dep));
-    }), debounceTime(debounceMs), switchMap(({ current, changedFields }) => {
-        return new Observable((subscriber) => {
-            const formAccessor = untracked(() => context.form());
-                        if (entry.stopOnUserOverride) {
-                const isDirty = readFieldDirty(formAccessor, entry.fieldKey);
-                if (isDirty) {
-                                                            if (entry.reEngageOnDependencyChange) {
-                        resetFieldState(formAccessor, entry.fieldKey);
-                                            }
-                    else {
-                        const derivationLogger = untracked(() => context.derivationLogger());
-                        derivationLogger.evaluation({
-                            debugName: entry.debugName,
-                            fieldKey: entry.fieldKey,
-                            result: 'skipped',
-                            skipReason: 'user-override',
-                        });
-                        subscriber.complete();
-                        return;
-                    }
-                }
-            }
-                        const customFunctions = context.customFunctions?.();
-            const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
-            const externalData = context.externalData?.();
-                        const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
-            if (!asyncFn) {
-                context.logger.warn(`${LOG_PREFIX$2} Async derivation function '${asyncFunctionName}' not found for field '${entry.fieldKey}'. ` +
-                    `Register it in customFnConfig.asyncDerivations.`);
-                subscriber.complete();
-                return;
-            }
-                        const fieldValue = getNestedValue(current, entry.fieldKey);
-            const fieldAccessor = formAccessor[entry.fieldKey];
-            const fieldState = fieldAccessor ? readFieldStateInfo(fieldAccessor, false) : undefined;
-            const evalContext = {
-                fieldValue,
-                formValue: current,
-                fieldPath: entry.fieldKey,
-                customFunctions,
-                externalData,
-                logger: context.logger,
-                fieldState,
-                formFieldState: createFormFieldStateMap(formAccessor, false),
-            };
-                        if (entry.condition !== true) {
-                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
-                if (!conditionMet) {
-                    const derivationLogger = untracked(() => context.derivationLogger());
-                    derivationLogger.evaluation({
-                        debugName: entry.debugName,
-                        fieldKey: entry.fieldKey,
-                        result: 'skipped',
-                        skipReason: 'condition-false',
-                    });
-                    subscriber.complete();
-                    return;
-                }
-            }
-                        const result$ = from(asyncFn(evalContext));
-            const asyncSub = result$.subscribe({
-                next: (newValue) => {
-                    try {
-                                                const currentFormValue = untracked(() => context.formValue());
-                        const currentValue = getNestedValue(currentFormValue, entry.fieldKey);
-                        if (isEqual(currentValue, newValue)) {
-                            const derivationLogger = untracked(() => context.derivationLogger());
-                            derivationLogger.evaluation({
-                                debugName: entry.debugName,
-                                fieldKey: entry.fieldKey,
-                                result: 'skipped',
-                                skipReason: 'value-unchanged',
-                            });
-                            subscriber.complete();
-                            return;
-                        }
-                                                                                                const currentForm = untracked(() => context.form());
-                        if (entry.stopOnUserOverride && readFieldDirty(currentForm, entry.fieldKey)) {
-                            const derivationLogger = untracked(() => context.derivationLogger());
-                            derivationLogger.evaluation({
-                                debugName: entry.debugName,
-                                fieldKey: entry.fieldKey,
-                                result: 'skipped',
-                                skipReason: 'user-override',
-                            });
-                            subscriber.complete();
-                            return;
-                        }
-                                                applyValueToForm(entry.fieldKey, newValue, currentForm, context.logger, context.warningTracker);
-                        const derivationLogger = untracked(() => context.derivationLogger());
-                        derivationLogger.evaluation({
-                            debugName: entry.debugName,
-                            fieldKey: entry.fieldKey,
-                            result: 'applied',
-                            previousValue: currentValue,
-                            newValue,
-                        });
-                        subscriber.complete();
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX$2} Failed to process result for '${entry.fieldKey}': ${message}`);
-                        subscriber.complete();
-                    }
-                },
-                error: (error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX$2} Async function failed for '${entry.fieldKey}': ${message}`);
-                    subscriber.complete();
-                },
-                complete: () => {
-                                                            subscriber.complete();
-                },
-            });
-                        return () => {
-                asyncSub.unsubscribe();
-            };
-        });
-    }), catchError((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX$2} Unexpected stream error for '${entry.fieldKey}': ${message}`);
-        return EMPTY;
-    }));
-}
-
-function resolveExternalData(externalDataSignal) {
-    const externalDataRecord = untracked(() => externalDataSignal?.());
-    if (!externalDataRecord)
-        return undefined;
-    const resolved = {};
-    for (const [key, value] of Object.entries(externalDataRecord)) {
-        if (isSignal(value)) {
-            resolved[key] = untracked(() => value());
-        }
-        else {
-            resolved[key] = value;
-        }
-    }
-    return resolved;
-}
-
-function getDebouncePeriods(entries) {
-    const periods = new Set();
-    for (const entry of entries) {
-        if (entry.trigger === 'debounced') {
-            periods.add(entry.debounceMs ?? DEFAULT_DEBOUNCE_MS);
-        }
-    }
-    return Array.from(periods);
-}
-function filterEntriesByDebouncePeriod(entries, period) {
-    return entries.filter((entry) => entry.trigger === 'debounced' && (entry.debounceMs ?? DEFAULT_DEBOUNCE_MS) === period);
-}
-
-function entrySetsEqual(prev, next, sig) {
-    if (prev.length !== next.length)
-        return false;
-    const counts = new Map();
-    for (const item of prev) {
-        const key = sig(item);
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-    }
-    for (const item of next) {
-        const key = sig(item);
-        const remaining = counts.get(key);
-        if (!remaining)
-            return false;
-        if (remaining === 1)
-            counts.delete(key);
-        else
-            counts.set(key, remaining - 1);
-    }
-    return counts.size === 0;
-}
-function buildEntryStreamPipeline(config) {
-    return config.collection$.pipe(map((collection) => config.selectEntries(collection)), distinctUntilChanged((prev, next) => entrySetsEqual(prev, next, config.entrySignature)), switchMap((entries) => {
-        if (entries.length === 0)
-            return EMPTY;
-        const streams = entries.map((entry) => config.createStream(entry)).filter((stream) => stream !== null);
-        if (streams.length === 0)
-            return EMPTY;
-        return merge(...streams);
-    }));
-}
-
-function rootSegment(path) {
-    const dot = path.indexOf('.');
-    return dot === -1 ? path : path.slice(0, dot);
-}
-function watchedRootKeys(collection) {
-    const watched = new Set();
-    for (const entry of collection.entries) {
-        const dependsOn = entry.dependsOn ?? [];
-        if (dependsOn.length === 0 || dependsOn.includes('*'))
-            continue;
-        for (const dep of dependsOn)
-            watched.add(rootSegment(dep));
-        if (entry.fieldKey)
-            watched.add(rootSegment(entry.fieldKey));
-    }
-    return watched;
-}
-function setupOnChangeStream(opts) {
-    const collection$ = toObservable(opts.collectionSignal, { injector: opts.injector });
-    const formValue$ = toObservable(opts.formValueSignal, { injector: opts.injector });
-    const extra$ = opts.additionalAwakeners?.length ? opts.additionalAwakeners.map((s) => toObservable(s, { injector: opts.injector })) : [];
-    collection$
-        .pipe(filter((collection) => collection !== null), 
-        map((collection) => [collection, watchedRootKeys(collection)]), combineLatestWith(formValue$, ...extra$), auditTime(0), startWith(null), pairwise(), filter((pair) => pair[1] !== null), map(([previous, current]) => {
-        const [collection, watched] = current[0];
-        return {
-            collection,
-            changedFields: getChangedKeysWithin(previous?.[1] ?? null, current[1], watched),
-        };
-    }), exhaustMap(({ collection, changedFields }) => {
-        opts.applyOnChange(collection, changedFields);
-        return scheduled([null], queueScheduler);
-    }), takeUntilDestroyed(opts.destroyRef))
-        .subscribe({
-        error: (err) => opts.logger.error(opts.errorLabel, err),
-    });
-}
-function setupDebouncedStream(opts) {
-    toObservable(opts.formValueSignal, { injector: opts.injector })
-        .pipe(debounceTime(DEFAULT_DEBOUNCE_MS), startWith(null), pairwise(), filter((pair) => pair[1] !== null), map(([previous, current]) => ({ current, changedFields: getChangedKeys(previous, current) })), filter(({ changedFields }) => changedFields.size > 0), switchMap(({ changedFields }) => {
-        const collection = untracked(() => opts.collectionSignal());
-        if (!collection)
-            return of(null);
-        const debouncePeriods = getDebouncePeriods(collection.entries);
-        if (debouncePeriods.length === 0)
-            return of(null);
-        const periodStreams = debouncePeriods.map((debounceMs) => {
-            const additionalWait = Math.max(0, debounceMs - DEFAULT_DEBOUNCE_MS);
-            if (additionalWait === 0) {
-                return of(null).pipe(map(() => {
-                    opts.applyDebouncedForPeriod(debounceMs, collection, changedFields);
-                }));
-            }
-            return timer(additionalWait).pipe(map(() => {
-                                const fresh = untracked(() => opts.collectionSignal()) ?? collection;
-                opts.applyDebouncedForPeriod(debounceMs, fresh, changedFields);
-            }));
-        });
-        return merge(...periodStreams);
-    }), takeUntilDestroyed(opts.destroyRef))
-        .subscribe({
-        error: (err) => opts.logger.error(opts.errorLabel, err),
-    });
-}
-function setupEntryAsyncStream(opts) {
-    const collection$ = toObservable(opts.collectionSignal, { injector: opts.injector });
-    buildEntryStreamPipeline({
-        collection$,
-        selectEntries: opts.selectEntries,
-        entrySignature: opts.entrySignature,
-        createStream: opts.createStream,
-    })
-        .pipe(catchError$1((err) => {
-        opts.logger.error(opts.errorLabel, err);
-        return EMPTY;
-    }), takeUntilDestroyed(opts.destroyRef))
-        .subscribe();
-}
-
-function createEmptyPropertyDerivationCollection() {
-    return { entries: [] };
-}
-function isAsyncPropertyDerivationEntry(entry) {
-    return Boolean(entry.http) || Boolean(entry.asyncFunctionName) || Boolean(entry.asyncFn);
-}
-
-const ERROR_PREFIX = '[PropertyDerivation]';
-function applyPropertyDerivations(collection, context, changedFields) {
-    let appliedCount = 0;
-    let skippedCount = 0;
-    let errorCount = 0;
-    const baseEntries = changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries;
-            const entriesToProcess = baseEntries.filter((entry) => !isAsyncPropertyDerivationEntry(entry));
-    for (const entry of entriesToProcess) {
-        try {
-            const applied = tryApplyPropertyDerivation(entry, context);
-            if (applied) {
-                appliedCount++;
-            }
-            else {
-                skippedCount++;
-            }
-        }
-        catch (error) {
-            errorCount++;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.logger.error(`${ERROR_PREFIX} Failed to process property derivation (field: ${entry.fieldKey}, property: ${entry.targetProperty}): ${errorMessage}`);
-        }
-    }
-    return { appliedCount, skippedCount, errorCount };
-}
-function applyPropertyDerivationsForTrigger(collection, trigger, context, changedFields) {
-    const filteredEntries = collection.entries.filter((entry) => {
-        if (trigger === 'onChange') {
-            return !entry.trigger || entry.trigger === 'onChange';
-        }
-        return entry.trigger === trigger;
-    });
-    const filteredCollection = { entries: filteredEntries };
-    return applyPropertyDerivations(filteredCollection, context, changedFields);
-}
-function getEntriesForChangedFields(entries, changedFields) {
-    return entries.filter((entry) => {
-        if (entry.dependsOn.includes('*'))
-            return true;
-        if (entry.dependsOn.some((dep) => changedFields.has(dep)))
-            return true;
-                                for (const changed of changedFields) {
-            if (entry.fieldKey.startsWith(changed + '.'))
-                return true;
-            if (entry.dependsOn.some((dep) => dep.startsWith(changed + '.')))
-                return true;
-        }
-        return false;
-    });
-}
-function tryApplyPropertyDerivation(entry, context) {
-        if (isArrayPlaceholderPath(entry.fieldKey)) {
-        return tryApplyArrayPropertyDerivation(entry, context);
-    }
-    const formValue = untracked(() => context.formValue());
-    const evalContext = createEvaluationContext(entry, formValue, context);
-        if (!evaluatePropertyCondition(entry.condition, evalContext)) {
-        return false;
-    }
-        const newValue = computePropertyValue(entry, evalContext, context);
-        context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue);
-    return true;
-}
-function tryApplyArrayPropertyDerivation(entry, context) {
-    const formValue = untracked(() => context.formValue());
-    const pathInfo = parseArrayPath(entry.fieldKey);
-    if (!pathInfo.isArrayPath) {
-        return false;
-    }
-    const { arrayPath } = pathInfo;
-    const arrayValue = getNestedValue(formValue, arrayPath);
-    if (!Array.isArray(arrayValue)) {
-        return false;
-    }
-    let appliedAny = false;
-    for (let i = 0; i < arrayValue.length; i++) {
-        const resolvedPath = resolveArrayPath(entry.fieldKey, i);
-        const arrayItem = arrayValue[i];
-        const evalContext = createArrayItemEvaluationContext(entry, arrayItem, formValue, i, arrayPath, context);
-        if (!evaluatePropertyCondition(entry.condition, evalContext)) {
-            continue;
-        }
-        try {
-            const newValue = computePropertyValue(entry, evalContext, context);
-            context.store.setOverride(resolvedPath, entry.targetProperty, newValue);
-            appliedAny = true;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.logger.error(`${ERROR_PREFIX} Failed to compute property derivation (field: ${entry.fieldKey}, property: ${entry.targetProperty}, index: ${i}): ${errorMessage}`);
-        }
-    }
-    return appliedAny;
-}
-function createEvaluationContext(entry, formValue, context) {
-    const fieldValue = getNestedValue(formValue, entry.fieldKey);
-            const parentPath = getParentPathInScope(entry.fieldKey);
-    const groupValue = parentPath ? getNestedValue(formValue, parentPath) : undefined;
-            const scopedToGroup = parentPath !== undefined;
-    return {
-        fieldValue,
-        formValue: scopedToGroup ? (groupValue ?? {}) : formValue,
-        fieldPath: entry.fieldKey,
-        groupValue,
-        customFunctions: context.customFunctions,
-        externalData: context.externalData,
-        logger: context.logger,
-        rootFormValue: formValue,
-    };
-}
-function createArrayItemEvaluationContext(entry, arrayItem, rootFormValue, itemIndex, arrayPath, context) {
-    const pathInfo = parseArrayPath(entry.fieldKey);
-    const { relativePath, groupValue, fieldValue } = resolveArrayItemScope(pathInfo, arrayItem);
-    return {
-        fieldValue,
-        formValue: arrayItem,
-        fieldPath: relativePath ? `${arrayPath}.${itemIndex}.${relativePath}` : `${arrayPath}.${itemIndex}`,
-        groupValue,
-        customFunctions: context.customFunctions,
-        externalData: context.externalData,
-        logger: context.logger,
-        rootFormValue,
-        arrayIndex: itemIndex,
-        arrayPath,
-    };
-}
-function evaluatePropertyCondition(condition, context) {
-    if (typeof condition === 'boolean') {
-        return condition;
-    }
-    return evaluateCondition(condition, context);
-}
-function computePropertyValue(entry, evalContext, applicatorContext) {
-    return computeValueFromEntry(entry, evalContext, {
-        derivationFunctions: applicatorContext.derivationFunctions,
-        subject: `${entry.fieldKey}.${entry.targetProperty}`,
-        functionKind: 'Property derivation function',
-    });
-}
-
-const LOG_PREFIX$1 = 'HTTP Property Derivation -';
-const DEFAULT_HTTP_DEBOUNCE_MS = 300;
-function createHttpPropertyDerivationStream(entry, formValue$, context) {
-        if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX$1} HTTP property derivation for array field '${entry.fieldKey}' is not supported. ` +
-            `Array HTTP property derivations will be supported in a future release.`);
-        return EMPTY;
-    }
-    if (!entry.http || !entry.responseExpression) {
-        return EMPTY;
-    }
-    const responseExpression = entry.responseExpression;
-    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS;
-    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
-        current: current,
-        changedFields: getChangedKeys(previous, current),
-    })), filter(({ changedFields }) => {
-        if (changedFields.size === 0)
-            return false;
-        return entry.dependsOn.some((dep) => changedFields.has(dep));
-    }), debounceTime(debounceMs), switchMap(({ current }) => {
-        return new Observable((subscriber) => {
-            const customFunctions = context.customFunctions?.();
-            const externalData = context.externalData?.();
-            const fieldValue = getNestedValue(current, entry.fieldKey);
-            const evalContext = {
-                fieldValue,
-                formValue: current,
-                fieldPath: entry.fieldKey,
-                customFunctions,
-                externalData,
-                logger: context.logger,
-            };
-                        if (entry.condition !== true) {
-                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
-                if (!conditionMet) {
-                    subscriber.complete();
-                    return;
-                }
-            }
-                        const resolvedRequest = resolveHttpRequest(entry.http, evalContext);
-            if (!resolvedRequest) {
-                subscriber.complete();
-                return;
-            }
-            const method = (resolvedRequest.method ?? 'GET').toUpperCase();
-                                                            const httpSub = context.httpClient
-                .request(method, resolvedRequest.url, {
-                body: resolvedRequest.body,
-                headers: resolvedRequest.headers,
-            })
-                .subscribe({
-                next: (response) => {
-                    try {
-                        const newValue = ExpressionParser.evaluate(responseExpression, { response });
-                                                                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
-                        subscriber.complete();
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX$1} Failed to process response for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-                        subscriber.complete();
-                    }
-                },
-                error: (error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX$1} HTTP request failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-                    subscriber.complete();
-                },
-            });
-            return () => {
-                httpSub.unsubscribe();
-            };
-        });
-    }), catchError((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-        return EMPTY;
-    }));
-}
-
-const LOG_PREFIX = 'Async Property Derivation -';
-const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
-function createAsyncPropertyDerivationStream(entry, formValue$, context) {
-    if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX} Async property derivation for array field '${entry.fieldKey}' is not supported. ` +
-            `Array async property derivations will be supported in a future release.`);
-        return EMPTY;
-    }
-    if (!entry.asyncFunctionName && !entry.asyncFn) {
-        context.logger.warn(`${LOG_PREFIX} Property derivation for '${entry.fieldKey}.${entry.targetProperty}' has neither "asyncFunctionName" nor "asyncFn". ` +
-            `One of the two is required for source: 'asyncFunction'.`);
-        return EMPTY;
-    }
-    if (entry.asyncFn && entry.asyncFunctionName) {
-        context.logger.warn(`${LOG_PREFIX} Both "asyncFn" and "asyncFunctionName" are set on property derivation for '${entry.fieldKey}.${entry.targetProperty}'. ` +
-            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
-    }
-    const inlineAsyncFn = entry.asyncFn;
-    const asyncFunctionName = entry.asyncFunctionName;
-    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
-    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
-        current: current,
-        changedFields: getChangedKeys(previous, current),
-    })), filter(({ changedFields }) => {
-        if (changedFields.size === 0)
-            return false;
-        return entry.dependsOn.some((dep) => changedFields.has(dep));
-    }), debounceTime(debounceMs), switchMap(({ current }) => {
-        return new Observable((subscriber) => {
-            const customFunctions = context.customFunctions?.();
-            const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
-            const externalData = context.externalData?.();
-            const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
-            if (!asyncFn) {
-                context.logger.warn(`${LOG_PREFIX} Async derivation function '${asyncFunctionName}' not found for '${entry.fieldKey}.${entry.targetProperty}'. ` +
-                    `Register it in customFnConfig.asyncDerivations.`);
-                subscriber.complete();
-                return;
-            }
-            const fieldValue = getNestedValue(current, entry.fieldKey);
-            const evalContext = {
-                fieldValue,
-                formValue: current,
-                fieldPath: entry.fieldKey,
-                customFunctions,
-                externalData,
-                logger: context.logger,
-            };
-            if (entry.condition !== true) {
-                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
-                if (!conditionMet) {
-                    subscriber.complete();
-                    return;
-                }
-            }
-            const result$ = from(asyncFn(evalContext));
-            const asyncSub = result$.subscribe({
-                next: (newValue) => {
-                    try {
-                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
-                        subscriber.complete();
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-                        subscriber.complete();
-                    }
-                },
-                error: (error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-                    subscriber.complete();
-                },
-                complete: () => {
-                    subscriber.complete();
-                },
-            });
-            return () => {
-                asyncSub.unsubscribe();
-            };
-        });
-    }), catchError((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
-        return EMPTY;
-    }));
-}
-
-class DerivationOrchestrator {
-    config;
-    injector = inject(Injector);
-    destroyRef = inject(DestroyRef);
-    logger = inject(DynamicFormLogger);
-    warningTracker = inject(DERIVATION_WARNING_TRACKER);
-    functionRegistry = inject(FunctionRegistryService);
-    httpClient = inject(HttpClient, { optional: true });
-                                formOptions;
-        derivationCollection;
-        propertyDerivationCollection;
-    constructor(config) {
-        this.config = config;
-        const valueEnabled = !!(config.form && config.derivationLogger);
-        const propertyStore = config.propertyStore;
-        const propertyEnabled = !!propertyStore;
-                                                                const sharedAllDerivations = valueEnabled && propertyEnabled
-            ? computed(() => {
-                const fields = config.schemaFields();
-                if (!fields || fields.length === 0)
-                    return null;
-                return collectAllDerivations(fields);
-            })
-            : null;
-        this.derivationCollection = valueEnabled
-            ? this.setupValuePipeline(sharedAllDerivations)
-            : computed(() => null);
-        this.propertyDerivationCollection = propertyStore
-            ? this.setupPropertyPipeline(propertyStore, sharedAllDerivations)
-            : computed(() => null);
-    }
-                setupValuePipeline(sharedAllDerivations) {
-        this.formOptions = inject(FORM_OPTIONS);
-        const collection = computed(() => {
-            const fields = this.config.schemaFields();
-            if (!fields || fields.length === 0) {
-                return null;
-            }
-                                    const collected = sharedAllDerivations ? (sharedAllDerivations()?.value ?? null) : collectDerivations(fields);
-            if (!collected || collected.entries.length === 0) {
-                return null;
-            }
-            validateNoCycles(collected, this.logger);
-            if (DEV_MODE) {
-                warnAboutWildcardDependencies(this.logger, collected.entries, fields.length);
-                warnAboutMisconfiguredReEngagement(this.logger, collected.entries);
-            }
-            return collected;
-        }, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "collection" }] : /* istanbul ignore next */ []));
-        setupOnChangeStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Derivation onChange stream error',
-            collectionSignal: collection,
-            formValueSignal: this.config.formValue,
-                                                additionalAwakeners: [this.config.form],
-            applyOnChange: (current, changedFields) => {
-                this.applyOnChangeDerivations(current, untracked(() => this.config.form()), changedFields);
-            },
-        });
-        setupDebouncedStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Derivation debounced stream error',
-            collectionSignal: collection,
-            formValueSignal: this.config.formValue,
-            applyDebouncedForPeriod: (debounceMs, current, changedFields) => {
-                const formAccessor = untracked(() => this.config.form());
-                if (!formAccessor)
-                    return;
-                this.applyDebouncedEntriesForPeriod(debounceMs, current, formAccessor, changedFields);
-            },
-        });
-        this.setupValueHttpStreams(collection);
-        this.setupValueAsyncFunctionStreams(collection);
-        return collection;
-    }
-                setupPropertyPipeline(propertyStore, sharedAllDerivations) {
-        const collection = computed(() => {
-            const fields = this.config.schemaFields();
-            if (!fields || fields.length === 0) {
-                return null;
-            }
-                                    const collected = sharedAllDerivations ? (sharedAllDerivations()?.property ?? null) : collectPropertyDerivations(fields);
-            if (!collected || collected.entries.length === 0) {
-                return null;
-            }
-            return collected;
-        }, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "collection" }] : /* istanbul ignore next */ []));
-                        explicitEffect([collection, this.config.schemaFields], ([current, fields]) => {
-            propertyStore.clear();
-            if (!current)
-                return;
-            for (const entry of current.entries) {
-                propertyStore.registerField(entry.fieldKey);
-            }
-            if (DEV_MODE) {
-                warnAboutWildcardPropertyDependencies(this.logger, current.entries, fields?.length ?? 0);
-            }
-        });
-        setupOnChangeStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Property derivation onChange stream error',
-            collectionSignal: collection,
-            formValueSignal: this.config.formValue,
-                                                applyOnChange: (current) => this.applyOnChangePropertyDerivations(current, propertyStore),
-        });
-        setupDebouncedStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Property derivation debounced stream error',
-            collectionSignal: collection,
-            formValueSignal: this.config.formValue,
-            applyDebouncedForPeriod: (debounceMs, current, changedFields) => {
-                this.applyDebouncedPropertyEntriesForPeriod(debounceMs, current, propertyStore, changedFields);
-            },
-        });
-        this.setupPropertyHttpStreams(collection, propertyStore);
-        this.setupPropertyAsyncFunctionStreams(collection, propertyStore);
-        return collection;
-    }
-                applyOnChangeDerivations(collection, formAccessor, changedFields) {
-        const applicatorContext = {
-            formValue: this.config.formValue,
-            rootForm: formAccessor,
-            derivationFunctions: this.functionRegistry.getDerivationFunctions(),
-            customFunctions: this.functionRegistry.getCustomFunctions(),
-            externalData: resolveExternalData(this.config.externalData),
-            logger: this.logger,
-            warningTracker: this.warningTracker,
-            derivationLogger: untracked(() => this.config.derivationLogger()),
-            maxIterations: untracked(() => this.formOptions()?.maxDerivationIterations),
-        };
-        const result = applyDerivationsForTrigger(collection, 'onChange', applicatorContext, changedFields);
-        if (result.maxIterationsReached) {
-            this.logger.warn(`Derivation processing reached max iterations. ` +
-                `This may indicate a loop in derivation logic that wasn't caught at build time. ` +
-                `Applied: ${result.appliedCount}, Skipped: ${result.skippedCount}, Errors: ${result.errorCount}`);
-        }
-    }
-    applyDebouncedEntriesForPeriod(debounceMs, collection, formAccessor, changedFields) {
-        const debouncedEntries = collection.entries.filter((entry) => entry.trigger === 'debounced' && (entry.debounceMs ?? DEFAULT_DEBOUNCE_MS) === debounceMs);
-        if (debouncedEntries.length === 0) {
-            return;
-        }
-        const filteredCollection = {
-            entries: debouncedEntries,
-        };
-        const applicatorContext = {
-            formValue: this.config.formValue,
-            rootForm: formAccessor,
-            derivationFunctions: this.functionRegistry.getDerivationFunctions(),
-            customFunctions: this.functionRegistry.getCustomFunctions(),
-            externalData: resolveExternalData(this.config.externalData),
-            logger: this.logger,
-            warningTracker: this.warningTracker,
-            derivationLogger: untracked(() => this.config.derivationLogger()),
-            maxIterations: untracked(() => this.formOptions()?.maxDerivationIterations),
-        };
-        const result = applyDerivationsForTrigger(filteredCollection, 'debounced', applicatorContext, changedFields);
-        if (result.maxIterationsReached) {
-            this.logger.warn(`Debounced derivation processing reached max iterations (${debounceMs}ms). ` +
-                `Applied: ${result.appliedCount}, Skipped: ${result.skippedCount}, Errors: ${result.errorCount}`);
-        }
-    }
-    setupValueHttpStreams(collectionSignal) {
-        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-        setupEntryAsyncStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'HTTP Derivation: outer stream error',
-            collectionSignal,
-            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
-            entrySignature: valueHttpEntrySignature,
-            createStream: (entry) => {
-                if (!this.httpClient) {
-                    this.logger.error('HTTP Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
-                    return null;
-                }
-                const context = {
-                    formValue: this.config.formValue,
-                    form: this.config.form,
-                    httpClient: this.httpClient,
-                    logger: this.logger,
-                    derivationLogger: this.config.derivationLogger,
-                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                    externalData: () => resolveExternalData(this.config.externalData),
-                    warningTracker: this.warningTracker,
-                };
-                return createHttpDerivationStream(entry, formValue$, context);
-            },
-        });
-    }
-    setupValueAsyncFunctionStreams(collectionSignal) {
-        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-        setupEntryAsyncStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Async Derivation: outer stream error',
-            collectionSignal,
-            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
-            entrySignature: valueAsyncEntrySignature,
-            createStream: (entry) => createAsyncDerivationStream(entry, formValue$, {
-                formValue: this.config.formValue,
-                form: this.config.form,
-                logger: this.logger,
-                derivationLogger: this.config.derivationLogger,
-                customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
-                externalData: () => resolveExternalData(this.config.externalData),
-                warningTracker: this.warningTracker,
-            }),
-        });
-    }
-                applyOnChangePropertyDerivations(collection, store) {
-        const applicatorContext = {
-            formValue: this.config.formValue,
-            store,
-            derivationFunctions: this.functionRegistry.getDerivationFunctions(),
-            customFunctions: this.functionRegistry.getCustomFunctions(),
-            externalData: resolveExternalData(this.config.externalData),
-            logger: this.logger,
-            warningTracker: this.warningTracker,
-        };
-        applyPropertyDerivationsForTrigger(collection, 'onChange', applicatorContext);
-    }
-    applyDebouncedPropertyEntriesForPeriod(debounceMs, collection, store, changedFields) {
-        const debouncedEntries = collection.entries.filter((entry) => entry.trigger === 'debounced' && (entry.debounceMs ?? DEFAULT_DEBOUNCE_MS) === debounceMs);
-        if (debouncedEntries.length === 0)
-            return;
-        const filteredCollection = { entries: debouncedEntries };
-        const applicatorContext = {
-            formValue: this.config.formValue,
-            store,
-            derivationFunctions: this.functionRegistry.getDerivationFunctions(),
-            customFunctions: this.functionRegistry.getCustomFunctions(),
-            externalData: resolveExternalData(this.config.externalData),
-            logger: this.logger,
-            warningTracker: this.warningTracker,
-        };
-        applyPropertyDerivationsForTrigger(filteredCollection, 'debounced', applicatorContext, changedFields);
-    }
-    setupPropertyHttpStreams(collectionSignal, store) {
-        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-        setupEntryAsyncStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'HTTP Property Derivation: outer stream error',
-            collectionSignal,
-            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
-            entrySignature: propertyHttpEntrySignature,
-            createStream: (entry) => {
-                if (!this.httpClient) {
-                    this.logger.error('HTTP Property Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
-                    return null;
-                }
-                return createHttpPropertyDerivationStream(entry, formValue$, {
-                    formValue: this.config.formValue,
-                    store,
-                    httpClient: this.httpClient,
-                    logger: this.logger,
-                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                    externalData: () => resolveExternalData(this.config.externalData),
-                });
-            },
-        });
-    }
-    setupPropertyAsyncFunctionStreams(collectionSignal, store) {
-        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-        setupEntryAsyncStream({
-            injector: this.injector,
-            destroyRef: this.destroyRef,
-            logger: this.logger,
-            errorLabel: 'Async Property Derivation: outer stream error',
-            collectionSignal,
-            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
-            entrySignature: propertyAsyncEntrySignature,
-            createStream: (entry) => createAsyncPropertyDerivationStream(entry, formValue$, {
-                formValue: this.config.formValue,
-                store,
-                logger: this.logger,
-                customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
-                externalData: () => resolveExternalData(this.config.externalData),
-            }),
-        });
-    }
-}
-function valueHttpEntrySignature(entry) {
-    const config = {
-        http: entry.http,
-        responseExpression: entry.responseExpression,
-        dependsOn: entry.dependsOn,
-        debounceMs: entry.debounceMs,
-        trigger: entry.trigger,
-        condition: entry.condition,
-        stopOnUserOverride: entry.stopOnUserOverride,
-        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
-    };
-    return `${entry.fieldKey}:${JSON.stringify(config)}`;
-}
-function valueAsyncEntrySignature(entry) {
-                    const config = {
-        asyncFunctionName: entry.asyncFunctionName,
-        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}` : undefined,
-        dependsOn: entry.dependsOn,
-        debounceMs: entry.debounceMs,
-        trigger: entry.trigger,
-        condition: entry.condition,
-        stopOnUserOverride: entry.stopOnUserOverride,
-        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
-    };
-    return `${entry.fieldKey}:${JSON.stringify(config)}`;
-}
-function propertyHttpEntrySignature(entry) {
-    const config = {
-        http: entry.http,
-        responseExpression: entry.responseExpression,
-        dependsOn: entry.dependsOn,
-        debounceMs: entry.debounceMs,
-        trigger: entry.trigger,
-        condition: entry.condition,
-    };
-    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
-}
-function propertyAsyncEntrySignature(entry) {
-    const config = {
-        asyncFunctionName: entry.asyncFunctionName,
-        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}.${entry.targetProperty}` : undefined,
-        dependsOn: entry.dependsOn,
-        debounceMs: entry.debounceMs,
-        trigger: entry.trigger,
-        condition: entry.condition,
-    };
-    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
-}
-function createDerivationOrchestrator(config) {
-    return new DerivationOrchestrator(config);
-}
-function warnAboutWildcardDependencies(logger, entries, fieldCount) {
-    const wildcardEntries = entries.filter((entry) => entry.dependsOn.includes('*'));
-    if (wildcardEntries.length === 0)
-        return;
-        const implicitWildcards = wildcardEntries.filter((entry) => !entry.http &&
-        !entry.asyncFunctionName &&
-        !entry.asyncFn &&
-        (entry.functionName || entry.fn) &&
-        (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
-    if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey} (${e.functionName ?? '<inline fn>'})`);
-        logger.warn('Derivation: custom functions without explicit dependsOn detected. ' +
-            `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
-            'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
-    }
-}
-function warnAboutMisconfiguredReEngagement(logger, entries) {
-    const misconfigured = entries.filter((entry) => entry.reEngageOnDependencyChange && !entry.stopOnUserOverride);
-    if (misconfigured.length === 0)
-        return;
-    const fieldKeys = misconfigured.map((e) => e.debugName ?? e.fieldKey);
-    logger.warn('Derivation: reEngageOnDependencyChange without stopOnUserOverride detected. ' +
-        'reEngageOnDependencyChange only takes effect when stopOnUserOverride is true. ' +
-        'Either add stopOnUserOverride: true or remove reEngageOnDependencyChange.', fieldKeys);
-}
-function warnAboutWildcardPropertyDependencies(logger, entries, fieldCount) {
-    const implicitWildcards = entries.filter((entry) => entry.dependsOn.includes('*') &&
-        (entry.functionName || entry.fn) &&
-        (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
-    if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey}.${e.targetProperty} (${e.functionName ?? '<inline fn>'})`);
-        logger.warn('PropertyDerivation: custom functions without explicit dependsOn detected. ' +
-            `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
-            'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
-    }
-}
-
-function bootstrapDerivationOrchestrator() {
-    const stateManager = inject(FormStateManager);
-    const logger = inject(DynamicFormLogger);
-    const logConfig = inject(DERIVATION_LOG_CONFIG);
-    const externalData = inject(EXTERNAL_DATA);
-    const propertyStore = inject(PROPERTY_OVERRIDE_STORE);
-                    const config = {
-        schemaFields: computed(() => stateManager.formSetup()?.schemaFields),
-        formValue: stateManager.formValue,
-        form: computed(() => stateManager.form()),
-        derivationLogger: computed(() => createDerivationLogger(logConfig, logger)),
-        propertyStore,
-        externalData,
-    };
-    createDerivationOrchestrator(config);
-}
-
-export { bootstrapDerivationOrchestrator };
-//# sourceMappingURL=ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-CTOTwzzw.mjs.map