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

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

@@ -0,0 +1,1887 @@
+import { c as traverseFieldsWithContext, o as DERIVATION_WARNING_TRACKER, t as DERIVATION_LOG_CONFIG } from "./ng-forge-dynamic-forms-with-logger-config-BAATqYY0.mjs";
+import { n as FormStateManager } from "./ng-forge-dynamic-forms-form-state-manager-BJKBX4FL.mjs";
+import { c as PROPERTY_OVERRIDE_STORE } from "./ng-forge-dynamic-forms-resolve-field-ByGa5cpo.mjs";
+import { t as DEV_MODE } from "./ng-forge-dynamic-forms-dev-mode-4rbYBBo_.mjs";
+import "./ng-forge-dynamic-forms-debounce-CG3uP5B-.mjs";
+import "./ng-forge-dynamic-forms-schema-registry.service-axBV9FBH.mjs";
+import { DestroyRef, Injector, computed, inject, isSignal, isWritableSignal, untracked } from "@angular/core";
+import { explicitEffect } from "ngxtension/explicit-effect";
+import { EMPTY, Observable, auditTime, catchError, combineLatestWith, debounceTime, distinctUntilChanged, exhaustMap, filter, from, map, merge, of, pairwise, queueScheduler, scheduled, startWith, switchMap, timer } from "rxjs";
+import { DynamicFormError, DynamicFormLogger, EXTERNAL_DATA, ExpressionParser, FORM_OPTIONS, FunctionRegistryService as FunctionRegistryService$1, createDefaultDerivationLogConfig, createFormFieldStateMap, evaluateCondition, extractExpressionDependencies, extractStringDependencies, getChangedKeys, getChangedKeysWithin, getNestedValue, hasTargetProperty, isDerivationLogicConfig, isEqual, readFieldStateInfo, resolveHttpRequest, shouldLog } from "@ng-forge/dynamic-forms/internal";
+import { takeUntilDestroyed, toObservable } from "@angular/core/rxjs-interop";
+import { HttpClient } from "@angular/common/http";
+import { catchError as catchError$1 } from "rxjs/operators";
+var ActiveDerivationLogger = class {
+	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 !== void 0 && { 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
+			});
+		}
+	}
+	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";
+		}
+	}
+};
+var NoopDerivationLogger = class {
+	cycleStart() {}
+	iteration() {}
+	evaluation() {}
+	summary() {}
+	maxIterationsReached() {}
+};
+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 placeholderIndex = path.indexOf(".$.");
+	if (placeholderIndex === -1) return {
+		arrayPath: "",
+		relativePath: "",
+		isArrayPath: false
+	};
+	return {
+		arrayPath: path.substring(0, placeholderIndex),
+		relativePath: path.substring(placeholderIndex + 3),
+		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 createDerivationChainContext() {
+	return {
+		appliedDerivations: /* @__PURE__ */ new Set(),
+		iteration: 0
+	};
+}
+function createDerivationKey(fieldKey) {
+	return fieldKey;
+}
+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 !== void 0) 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] : void 0);
+		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;
+		}
+		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 void 0;
+	return fieldKey.slice(0, lastDot);
+}
+function resolveArrayItemScope(pathInfo, arrayItem) {
+	const relativePath = pathInfo.isArrayPath ? pathInfo.relativePath : "";
+	const innerParentPath = relativePath.includes(".") ? relativePath.slice(0, relativePath.lastIndexOf(".")) : "";
+	return {
+		relativePath,
+		groupValue: innerParentPath ? getNestedValue(arrayItem, innerParentPath) : arrayItem,
+		fieldValue: relativePath ? getNestedValue(arrayItem, relativePath) : arrayItem
+	};
+}
+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 void 0;
+		current = next;
+	}
+	const fieldAccessor = current[parts[parts.length - 1]];
+	if (!fieldAccessor) return void 0;
+	return untracked(fieldAccessor);
+}
+function readFieldDirty(rootForm, fieldPath) {
+	const fieldInstance = resolveFieldInstance(rootForm, fieldPath);
+	if (!fieldInstance) return void 0;
+	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 ?? 10;
+	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 {
+		if (applyValueToForm(entry.fieldKey, newValue, context.rootForm, context.logger, context.warningTracker)) {
+			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) : void 0;
+	const parentPath = getParentPathInScope(entry.fieldKey);
+	const groupValue = parentPath ? getNestedValue(formValue, parentPath) : void 0;
+	return {
+		fieldValue,
+		formValue: parentPath !== void 0 ? 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 === void 0 || current === null) return void 0;
+		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 arrayAccessor = context.rootForm[arrayPath];
+		if (arrayAccessor) {
+			const itemAccessor = arrayAccessor[String(itemIndex)];
+			if (itemAccessor) {
+				const fieldAccessor = itemAccessor[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 !== void 0 ? "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;
+	if (!(readFieldDirty(context.rootForm, resolvedFieldKey) ?? false)) 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) {
+	return applyDerivations({ entries: 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;
+	}) }, context, changedFields);
+}
+function topologicalSort(entries) {
+	if (entries.length <= 1) return [...entries];
+	const graph = /* @__PURE__ */ new Map();
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		graph.set(entry, /* @__PURE__ */ new Set());
+		inDegree.set(entry, 0);
+	}
+	const derivationsByField = /* @__PURE__ */ 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(".")) : void 0;
+		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) ?? /* @__PURE__ */ 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 = /* @__PURE__ */ 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 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") return effectiveFieldKey;
+		if (dep.startsWith(`\$self.`)) return effectiveFieldKey + dep.slice(5);
+		if (dep === "$group" || dep.startsWith(`\$group.`)) {
+			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") return groupPath;
+			return groupPath + dep.slice(6);
+		}
+		return dep;
+	});
+}
+const CONTEXT_TRAVERSAL_OPTIONS = {
+	onArrayChild: (_parent, field) => ({
+		arrayPath: field.key,
+		groupPath: void 0
+	}),
+	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) {
+	return {
+		fieldKey: buildEffectiveFieldKey(fieldKey, context),
+		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 : void 0;
+	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 !== void 0) conflictingSyncSources.push("value");
+		if (untypedConfig.expression !== void 0) conflictingSyncSources.push("expression");
+		if (untypedConfig.functionName !== void 0) conflictingSyncSources.push("functionName");
+		if (untypedConfig.fn !== void 0) 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 !== void 0 || untypedConfig.asyncFn !== void 0)) throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "http"' alongside an async function — these are mutually exclusive.`);
+	if (untypedConfig.source === "asyncFunction" && (untypedConfig.http !== void 0 || untypedConfig.responseExpression !== void 0)) 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 : void 0;
+	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 = /* @__PURE__ */ new Set();
+	const dependencyMap = /* @__PURE__ */ new Map();
+	for (const entry of collection.entries) {
+		const deps = dependencyMap.get(entry.fieldKey) ?? /* @__PURE__ */ 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) if (dependencyMap.get(fieldB)?.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 = /* @__PURE__ */ new Map();
+	const ensureNode = (fieldKey) => {
+		let node = graph.get(fieldKey);
+		if (!node) {
+			node = {
+				fieldKey,
+				dependsOn: /* @__PURE__ */ new Set(),
+				dependedOnBy: /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+	const parent = /* @__PURE__ */ new Map();
+	for (const fieldKey of graph.keys()) visitState.set(fieldKey, 0);
+	for (const fieldKey of graph.keys()) if (visitState.get(fieldKey) === 0) {
+		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);
+	path.push(fieldKey);
+	const node = graph.get(fieldKey);
+	if (!node) {
+		visitState.set(fieldKey, 2);
+		path.pop();
+		return null;
+	}
+	for (const targetFieldKey of node.dependedOnBy) {
+		const targetState = visitState.get(targetFieldKey);
+		if (targetState === 1) {
+			const cyclePath = extractCyclePath(path, targetFieldKey);
+			if (isBidirectionalCycle(cyclePath, bidirectionalPairs)) continue;
+			return {
+				hasCycle: true,
+				cyclePath,
+				errorMessage: formatCycleError(cyclePath)
+			};
+		}
+		if (targetState === 0) {
+			parent.set(targetFieldKey, fieldKey);
+			const result = dfsVisit(targetFieldKey, graph, visitState, parent, path, bidirectionalPairs);
+			if (result) return result;
+		}
+	}
+	visitState.set(fieldKey, 2);
+	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) {
+	return `Derivation cycle detected: ${cyclePath.join(" -> ")}\nThis 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,
+		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) {
+				if (readFieldDirty(formAccessor, entry.fieldKey)) {
+					if (entry.reEngageOnDependencyChange && changedFields.size > 0) {
+						if (entry.dependsOn.some((dep) => changedFields.has(dep))) resetFieldState(formAccessor, entry.fieldKey);
+						else {
+							untracked(() => context.derivationLogger()).evaluation({
+								debugName: entry.debugName,
+								fieldKey: entry.fieldKey,
+								result: "skipped",
+								skipReason: "user-override"
+							});
+							subscriber.complete();
+							return;
+						}
+					} else {
+						untracked(() => context.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) : void 0;
+			const evalContext = {
+				fieldValue,
+				formValue: current,
+				fieldPath: entry.fieldKey,
+				customFunctions,
+				externalData,
+				logger: context.logger,
+				fieldState,
+				formFieldState: createFormFieldStateMap(formAccessor, false)
+			};
+			if (entry.condition !== true) {
+				if (!(typeof entry.condition === "boolean" ? entry.condition : evaluateCondition(entry.condition, evalContext))) {
+					untracked(() => context.derivationLogger()).evaluation({
+						debugName: entry.debugName,
+						fieldKey: entry.fieldKey,
+						result: "skipped",
+						skipReason: "condition-false"
+					});
+					subscriber.complete();
+					return;
+				}
+			}
+			const resolvedRequest = resolveHttpRequest(entry.http, evalContext);
+			if (!resolvedRequest) {
+				untracked(() => context.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)) {
+							untracked(() => context.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)) {
+							untracked(() => context.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);
+						untracked(() => context.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$1((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,
+		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) {
+				if (readFieldDirty(formAccessor, entry.fieldKey)) {
+					if (entry.reEngageOnDependencyChange) resetFieldState(formAccessor, entry.fieldKey);
+					else {
+						untracked(() => context.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] : void 0);
+			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) : void 0;
+			const evalContext = {
+				fieldValue,
+				formValue: current,
+				fieldPath: entry.fieldKey,
+				customFunctions,
+				externalData,
+				logger: context.logger,
+				fieldState,
+				formFieldState: createFormFieldStateMap(formAccessor, false)
+			};
+			if (entry.condition !== true) {
+				if (!(typeof entry.condition === "boolean" ? entry.condition : evaluateCondition(entry.condition, evalContext))) {
+					untracked(() => context.derivationLogger()).evaluation({
+						debugName: entry.debugName,
+						fieldKey: entry.fieldKey,
+						result: "skipped",
+						skipReason: "condition-false"
+					});
+					subscriber.complete();
+					return;
+				}
+			}
+			const asyncSub = from(asyncFn(evalContext)).subscribe({
+				next: (newValue) => {
+					try {
+						const currentFormValue = untracked(() => context.formValue());
+						const currentValue = getNestedValue(currentFormValue, entry.fieldKey);
+						if (isEqual(currentValue, newValue)) {
+							untracked(() => context.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)) {
+							untracked(() => context.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);
+						untracked(() => context.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$1((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 void 0;
+	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 = /* @__PURE__ */ new Set();
+	for (const entry of entries) if (entry.trigger === "debounced") periods.add(entry.debounceMs ?? 500);
+	return Array.from(periods);
+}
+function entrySetsEqual(prev, next, sig) {
+	if (prev.length !== next.length) return false;
+	const counts = /* @__PURE__ */ 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 = /* @__PURE__ */ 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(500), 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 - 500);
+			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) {
+	buildEntryStreamPipeline({
+		collection$: toObservable(opts.collectionSignal, { injector: opts.injector }),
+		selectEntries: opts.selectEntries,
+		entrySignature: opts.entrySignature,
+		createStream: opts.createStream
+	}).pipe(catchError((err) => {
+		opts.logger.error(opts.errorLabel, err);
+		return EMPTY;
+	}), takeUntilDestroyed(opts.destroyRef)).subscribe();
+}
+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 entriesToProcess = (changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries).filter((entry) => !isAsyncPropertyDerivationEntry(entry));
+	for (const entry of entriesToProcess) try {
+		if (tryApplyPropertyDerivation(entry, context)) 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) {
+	return applyPropertyDerivations({ entries: collection.entries.filter((entry) => {
+		if (trigger === "onChange") return !entry.trigger || entry.trigger === "onChange";
+		return entry.trigger === trigger;
+	}) }, 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 evalContext = createEvaluationContext(entry, untracked(() => context.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) : void 0;
+	return {
+		fieldValue,
+		formValue: parentPath !== void 0 ? 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 { relativePath, groupValue, fieldValue } = resolveArrayItemScope(parseArrayPath(entry.fieldKey), 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,
+		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 evalContext = {
+				fieldValue: getNestedValue(current, entry.fieldKey),
+				formValue: current,
+				fieldPath: entry.fieldKey,
+				customFunctions,
+				externalData,
+				logger: context.logger
+			};
+			if (entry.condition !== true) {
+				if (!(typeof entry.condition === "boolean" ? entry.condition : evaluateCondition(entry.condition, evalContext))) {
+					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$1((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+		return EMPTY;
+	}));
+}
+const LOG_PREFIX = "Async Property Derivation -";
+const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
+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,
+		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] : void 0);
+			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 evalContext = {
+				fieldValue: getNestedValue(current, entry.fieldKey),
+				formValue: current,
+				fieldPath: entry.fieldKey,
+				customFunctions,
+				externalData,
+				logger: context.logger
+			};
+			if (entry.condition !== true) {
+				if (!(typeof entry.condition === "boolean" ? entry.condition : evaluateCondition(entry.condition, evalContext))) {
+					subscriber.complete();
+					return;
+				}
+			}
+			const asyncSub = from(asyncFn(evalContext)).subscribe({
+				next: (newValue) => {
+					try {
+						untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
+						subscriber.complete();
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+						subscriber.complete();
+					}
+				},
+				error: (error) => {
+					const message = error instanceof Error ? error.message : String(error);
+					context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+					subscriber.complete();
+				},
+				complete: () => {
+					subscriber.complete();
+				}
+			});
+			return () => {
+				asyncSub.unsubscribe();
+			};
+		});
+	}), catchError$1((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+		return EMPTY;
+	}));
+}
+var DerivationOrchestrator = class {
+	config;
+	injector = inject(Injector);
+	destroyRef = inject(DestroyRef);
+	logger = inject(DynamicFormLogger);
+	warningTracker = inject(DERIVATION_WARNING_TRACKER);
+	functionRegistry = inject(FunctionRegistryService$1);
+	httpClient = inject(HttpClient, { optional: true });
+	formOptions;
+	derivationCollection;
+	propertyDerivationCollection;
+	constructor(config) {
+		this.config = config;
+		const valueEnabled = !!(config.form && config.derivationLogger);
+		const propertyStore = config.propertyStore;
+		const sharedAllDerivations = valueEnabled && !!propertyStore ? 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;
+		}, ...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;
+		}, ...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 result = applyDerivationsForTrigger(collection, "onChange", {
+			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)
+		}, 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 ?? 500) === debounceMs);
+		if (debouncedEntries.length === 0) return;
+		const result = applyDerivationsForTrigger({ entries: debouncedEntries }, "debounced", {
+			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)
+		}, 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) {
+		applyPropertyDerivationsForTrigger(collection, "onChange", {
+			formValue: this.config.formValue,
+			store,
+			derivationFunctions: this.functionRegistry.getDerivationFunctions(),
+			customFunctions: this.functionRegistry.getCustomFunctions(),
+			externalData: resolveExternalData(this.config.externalData),
+			logger: this.logger,
+			warningTracker: this.warningTracker
+		});
+	}
+	applyDebouncedPropertyEntriesForPeriod(debounceMs, collection, store, changedFields) {
+		const debouncedEntries = collection.entries.filter((entry) => entry.trigger === "debounced" && (entry.debounceMs ?? 500) === debounceMs);
+		if (debouncedEntries.length === 0) return;
+		applyPropertyDerivationsForTrigger({ entries: debouncedEntries }, "debounced", {
+			formValue: this.config.formValue,
+			store,
+			derivationFunctions: this.functionRegistry.getDerivationFunctions(),
+			customFunctions: this.functionRegistry.getCustomFunctions(),
+			externalData: resolveExternalData(this.config.externalData),
+			logger: this.logger,
+			warningTracker: this.warningTracker
+		}, 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}` : void 0,
+		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}` : void 0,
+		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);
+	createDerivationOrchestrator({
+		schemaFields: computed(() => stateManager.formSetup()?.schemaFields),
+		formValue: stateManager.formValue,
+		form: computed(() => stateManager.form()),
+		derivationLogger: computed(() => createDerivationLogger(logConfig, logger)),
+		propertyStore,
+		externalData
+	});
+}
+export { bootstrapDerivationOrchestrator };
+
+//# sourceMappingURL=ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-B6WH0Etk.mjs.map