@ng-forge/dynamic-forms 1.3.0-next.1 → 1.3.0-next.3

package/fesm2022/ng-forge-dynamic-forms-form-state-manager-DcOXRFRL.mjs

@@ -0,0 +1,1522 @@
+import { r as setNormalizedArrayMetadata } from "./ng-forge-dynamic-forms-default-value-D5M4MNE-.mjs";
+import { t as ArrayItemRegistryService } from "./ng-forge-dynamic-forms-array-item-registry.service-D-AxVLdk.mjs";
+import { t as SchemaRegistryService } from "./ng-forge-dynamic-forms-schema-registry.service-axBV9FBH.mjs";
+import { t as CONTAINER_FIELD_PROCESSORS } from "./ng-forge-dynamic-forms-container-field-processors-C_JRvaVt.mjs";
+import { a as resolveField, i as reconcileFields, o as resolveFieldSync, u as injectFieldRegistry } from "./ng-forge-dynamic-forms-resolve-field-ByGa5cpo.mjs";
+import { t as DEV_MODE } from "./ng-forge-dynamic-forms-dev-mode-4rbYBBo_.mjs";
+import * as i0 from "@angular/core";
+import { DestroyRef, Injectable, InjectionToken, Injector, afterNextRender, computed, inject, injectAsync, linkedSignal, resource, runInInjectionContext, signal, untracked } from "@angular/core";
+import { explicitEffect } from "ngxtension/explicit-effect";
+import { EMPTY, Observable, Subject, catchError, concatMap, filter, forkJoin, map, of, pipe, scan, switchMap, take } from "rxjs";
+import { ADDON_TYPE_REGISTRY, DynamicFormError, DynamicFormLogger, EventBus, FIELD_SIGNAL_CONTEXT, FunctionRegistryService, assertNever, deepMergeDefaults, derivedFromDeferred, detectFormMode, getFieldValueHandling, hasChildFields, isArrayField, isContainerField, isEqual, isGroupField, isPageField, isSimplifiedArrayField, normalizeFieldsArray, validatePageNesting } from "@ng-forge/dynamic-forms/internal";
+import { takeUntilDestroyed, toObservable } from "@angular/core/rxjs-interop";
+import { form } from "@angular/forms/signals";
+var FormSubmitEvent = class {
+	reply;
+	type = "submit";
+	constructor(reply) {
+		this.reply = reply;
+	}
+};
+function normalizeSimplifiedArrays(fields) {
+	return fields.flatMap((field) => {
+		if (isContainerField(field) && !isArrayField(field) && hasChildFields(field)) return [{
+			...field,
+			fields: normalizeSimplifiedArrays(field.fields)
+		}];
+		if (isArrayField(field) && !isSimplifiedArrayField(field)) {
+			const normalizedItems = field.fields.map((item) => Array.isArray(item) ? normalizeSimplifiedArrays(item) : item);
+			return [{
+				...field,
+				fields: normalizedItems
+			}];
+		}
+		if (isSimplifiedArrayField(field)) {
+			const { arrayField, addButton } = expandSimplifiedArray(field);
+			return addButton ? [arrayField, addButton] : [arrayField];
+		}
+		return [field];
+	});
+}
+const INVALID_ARRAY_CHILD_TYPES = /* @__PURE__ */ new Set(["page", "array"]);
+function validateSimplifiedTemplate(field) {
+	const { template, key } = field;
+	if (Array.isArray(template)) {
+		const templateFields = template;
+		for (const tmpl of templateFields) if (INVALID_ARRAY_CHILD_TYPES.has(tmpl.type)) throw new DynamicFormError(`Simplified array "${key}" template contains a '${tmpl.type}' field (key: '${tmpl.key}'). Only leaf fields, rows, and groups are allowed as array children.`);
+	} else {
+		const singleTemplate = template;
+		if (INVALID_ARRAY_CHILD_TYPES.has(singleTemplate.type)) throw new DynamicFormError(`Simplified array "${key}" template has type '${singleTemplate.type}'. Only leaf fields, rows, and groups are allowed as array children.`);
+	}
+}
+function expandSimplifiedArray(field) {
+	const { template, value = [], addButton, removeButton, key, logic, minLength, maxLength, wrappers, skipAutoWrappers, skipDefaultWrappers, validators, validationMessages, required, validateWhenHidden } = field;
+	const isObjectTemplate = Array.isArray(template);
+	const values = value;
+	validateSimplifiedTemplate(field);
+	const items = values.map((v) => {
+		if (isObjectTemplate) return buildObjectItem(template, v, removeButton);
+		return buildPrimitiveItem(template, v);
+	});
+	const addTemplate = isObjectTemplate ? buildObjectItemTemplate(template, removeButton) : template;
+	const hasAutoRemove = !isObjectTemplate && removeButton !== false;
+	const arrayFieldObj = {
+		key,
+		type: "array",
+		fields: items
+	};
+	if (logic) arrayFieldObj["logic"] = logic;
+	if (minLength !== void 0) arrayFieldObj["minLength"] = minLength;
+	if (maxLength !== void 0) arrayFieldObj["maxLength"] = maxLength;
+	if (wrappers !== void 0) arrayFieldObj["wrappers"] = wrappers;
+	if (skipAutoWrappers !== void 0) arrayFieldObj["skipAutoWrappers"] = skipAutoWrappers;
+	if (skipDefaultWrappers !== void 0) arrayFieldObj["skipDefaultWrappers"] = skipDefaultWrappers;
+	if (validators !== void 0) arrayFieldObj["validators"] = validators;
+	if (validationMessages !== void 0) arrayFieldObj["validationMessages"] = validationMessages;
+	if (required !== void 0) arrayFieldObj["required"] = required;
+	if (validateWhenHidden !== void 0) arrayFieldObj["validateWhenHidden"] = validateWhenHidden;
+	const arrayField = arrayFieldObj;
+	const primitiveFieldKey = !isObjectTemplate ? template.key : void 0;
+	const metadataTemplate = isObjectTemplate ? buildObjectItemTemplate(template, removeButton) : template;
+	setNormalizedArrayMetadata(arrayFieldObj, {
+		...hasAutoRemove && { autoRemoveButton: buildRemoveButton(removeButton) },
+		...primitiveFieldKey && { primitiveFieldKey },
+		template: metadataTemplate
+	});
+	let addButtonField;
+	if (addButton !== false) {
+		const buttonConfig = typeof addButton === "object" ? addButton : {};
+		addButtonField = {
+			key: `${key}__add`,
+			type: "add-array-item",
+			label: buttonConfig.label ?? "Add",
+			arrayKey: key,
+			template: addTemplate,
+			...buttonConfig.props && { props: buttonConfig.props },
+			...logic && { logic }
+		};
+	}
+	return {
+		arrayField,
+		addButton: addButtonField
+	};
+}
+function buildPrimitiveItem(template, value) {
+	return {
+		...template,
+		value
+	};
+}
+function buildObjectItem(template, valueObj, removeButton) {
+	const fieldsWithValues = template.map((templateField) => ({
+		...templateField,
+		...Object.hasOwn(valueObj, templateField.key) && { value: valueObj[templateField.key] }
+	}));
+	if (removeButton === false) return fieldsWithValues;
+	return [...fieldsWithValues, buildRemoveButton(removeButton)];
+}
+function buildObjectItemTemplate(template, removeButton) {
+	if (removeButton === false) return template;
+	return [...template, buildRemoveButton(removeButton)];
+}
+function buildRemoveButton(config) {
+	const buttonConfig = typeof config === "object" ? config : {};
+	return {
+		key: "__remove",
+		type: "remove-array-item",
+		label: buttonConfig.label ?? "Remove",
+		...buttonConfig.props && { props: buttonConfig.props }
+	};
+}
+var FormModeValidator = class {
+	static validateFormConfiguration(fields) {
+		const modeDetection = detectFormMode(fields);
+		const additionalErrors = [];
+		if (modeDetection.mode === "paged" && modeDetection.isValid) for (let i = 0; i < fields.length; i++) {
+			const field = fields[i];
+			if (isPageField(field)) {
+				if (!validatePageNesting(field)) additionalErrors.push(`Page field at index ${i} (key: "${field.key || "unknown"}") contains nested page fields, which is not allowed.`);
+			}
+		}
+		const allErrors = [...modeDetection.errors, ...additionalErrors];
+		const isFullyValid = modeDetection.isValid && additionalErrors.length === 0;
+		return {
+			mode: modeDetection.mode,
+			isValid: isFullyValid,
+			errors: allErrors,
+			warnings: this.generateWarnings(fields, modeDetection)
+		};
+	}
+	static validateFormConfigurationOrThrow(fields) {
+		const result = this.validateFormConfiguration(fields);
+		if (!result.isValid) {
+			const errorMessage = [`Invalid form configuration (${result.mode} mode):`, ...result.errors.map((error) => `  - ${error}`)].join("\n");
+			throw new DynamicFormError(errorMessage);
+		}
+	}
+	static generateWarnings(fields, modeDetection) {
+		const warnings = [];
+		if (modeDetection.mode === "paged" && fields.length === 1) warnings.push("Single page form detected. Consider using non-paged mode for better performance if page navigation is not needed.");
+		if (modeDetection.mode === "paged") for (let i = 0; i < fields.length; i++) {
+			const field = fields[i];
+			if (isPageField(field)) {
+				if (!field.fields || field.fields.length === 0) warnings.push(`Page field at index ${i} (key: "${field.key || "unknown"}") contains no fields and will render as empty.`);
+			}
+		}
+		return warnings;
+	}
+};
+function collectFieldData(fields, data, registry, pathPrefix, collectKeys = true) {
+	for (const field of fields) {
+		const valueHandling = field.type ? getFieldValueHandling(field.type, registry) : "include";
+		const participatesInValue = valueHandling !== "exclude" && valueHandling !== "flatten";
+		if (field.key && field.key.includes(".") && participatesInValue) data.dottedKeys.push(field.key);
+		if (collectKeys && field.key && participatesInValue) {
+			const scopedKey = pathPrefix ? `${pathPrefix}.${field.key}` : field.key;
+			data.keys.push(scopedKey);
+			data.domIds.push(scopedKey.replace(/\./g, "_"));
+		}
+		if (field.type) data.types.add(field.type);
+		const fieldWithValidation = field;
+		if ("pattern" in field && typeof fieldWithValidation.pattern === "string") validateRegexPattern(fieldWithValidation.pattern, field.key || "<unknown>", data.regexErrors);
+		if ("validators" in field && fieldWithValidation.validators) {
+			for (const validator of fieldWithValidation.validators) if (validator.type === "pattern" && "value" in validator && typeof validator.value === "string") validateRegexPattern(validator.value, field.key || "<unknown>", data.regexErrors);
+		}
+		if (hasChildFields(field)) {
+			const childCollectKeys = collectKeys && field.type !== "array";
+			const childPrefix = isGroupField(field) && field.key ? pathPrefix ? `${pathPrefix}.${field.key}` : field.key : pathPrefix;
+			const children = normalizeFieldsArray(field.fields);
+			for (const child of children) if (Array.isArray(child)) collectFieldData(child, data, registry, childPrefix, childCollectKeys);
+			else collectFieldData([child], data, registry, childPrefix, childCollectKeys);
+		}
+	}
+}
+function validateRegexPattern(pattern, fieldKey, errors) {
+	try {
+		new RegExp(pattern);
+	} catch (e) {
+		errors.push(DEV_MODE ? `Invalid regex pattern in validator for field '${fieldKey}': '${pattern}' — ${e instanceof Error ? e.message : String(e)}` : `Invalid regex pattern: '${pattern}'`);
+	}
+}
+function validateNoDuplicateKeys(allKeys) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	for (const key of allKeys) {
+		if (seen.has(key)) duplicates.add(key);
+		seen.add(key);
+	}
+	if (duplicates.size > 0) {
+		const duplicateList = Array.from(duplicates).map((k) => `'${k}'`).join(", ");
+		throw new DynamicFormError(DEV_MODE ? `Duplicate field keys detected: ${duplicateList}. Field keys must be unique within their group scope (the same key may appear inside different groups).` : `Duplicate field keys detected: ${duplicateList}.`);
+	}
+}
+function validateNoDomIdCollisions(domIds) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	for (const id of domIds) {
+		if (seen.has(id)) duplicates.add(id);
+		seen.add(id);
+	}
+	if (duplicates.size > 0) {
+		const duplicateList = Array.from(duplicates).map((k) => `'${k}'`).join(", ");
+		throw new DynamicFormError(DEV_MODE ? `DOM id collision detected for: ${duplicateList}. Group-nested keys are joined with '_' to form DOM ids (e.g. group 'foo' + leaf 'bar' renders as id='foo_bar'). A separate top-level key like 'foo_bar' or a different group/leaf pair that underscores to the same string will produce duplicate ids. Rename one of the colliding keys.` : `DOM id collision detected for: ${duplicateList}.`);
+	}
+}
+function validateFieldTypesRegistered(allTypes, registry, logger) {
+	if (registry.size === 0) return;
+	const unregistered = [];
+	for (const type of allTypes) if (!registry.has(type)) unregistered.push(type);
+	if (unregistered.length > 0) {
+		const typeList = unregistered.map((t) => `'${t}'`).join(", ");
+		logger.warn(`Unknown field type(s): ${typeList}. Register them via provideDynamicForm(...withXxxFields()) or a custom registry entry. These fields will be skipped during rendering.`);
+	}
+}
+function validateFormConfig(fields, registry, logger) {
+	const data = {
+		keys: [],
+		domIds: [],
+		types: /* @__PURE__ */ new Set(),
+		regexErrors: [],
+		dottedKeys: []
+	};
+	collectFieldData(fields, data, registry, "");
+	if (data.dottedKeys.length > 0) {
+		const list = Array.from(new Set(data.dottedKeys)).map((k) => `'${k}'`).join(", ");
+		throw new DynamicFormError(DEV_MODE ? `Field key(s) contain a dot: ${list}. Dotted keys are not supported — express nesting with 'group' fields (e.g. { type: 'group', key: 'address', fields: [{ type: 'input', key: 'city' }] }).` : `Field key(s) contain a dot: ${list}.`);
+	}
+	validateNoDuplicateKeys(data.keys);
+	validateNoDomIdCollisions(data.domIds);
+	if (DEV_MODE) validateFieldTypesRegistered(data.types, registry, logger);
+	if (data.regexErrors.length > 0) throw new DynamicFormError(data.regexErrors.length === 1 ? data.regexErrors[0] : `Invalid regex pattern(s) found:\n${data.regexErrors.map((e) => `  - ${e}`).join("\n")}`);
+}
+function validateFieldAddons(field, fieldRegistry, typeRegistry, source) {
+	const warnings = [];
+	const incoming = field.addons;
+	if (!incoming?.length) return {
+		addons: [],
+		warnings
+	};
+	const fieldType = field.type;
+	const fieldDef = fieldRegistry.get(fieldType);
+	if (!fieldDef) {
+		warnings.push({
+			type: "unknown-field-type",
+			fieldKey: field.key,
+			fieldType
+		});
+		return {
+			addons: [],
+			warnings
+		};
+	}
+	const addonSupport = fieldDef.addons;
+	if (!addonSupport) {
+		warnings.push({
+			type: "field-type-no-addon-support",
+			fieldKey: field.key,
+			fieldType
+		});
+		return {
+			addons: [],
+			warnings
+		};
+	}
+	const allowedSlots = addonSupport.slots;
+	const allowedTypes = addonSupport.allowedTypes;
+	const registeredTypes = Array.from(typeRegistry.keys());
+	const survivors = [];
+	for (const addon of incoming) {
+		if (!allowedSlots.includes(addon.slot)) {
+			warnings.push({
+				type: "unknown-slot",
+				fieldKey: field.key,
+				fieldType,
+				slot: String(addon.slot),
+				allowedSlots
+			});
+			continue;
+		}
+		const typeDef = typeRegistry.get(addon.type);
+		if (!typeDef) {
+			warnings.push({
+				type: "unknown-type",
+				fieldKey: field.key,
+				addonType: addon.type,
+				registeredTypes
+			});
+			continue;
+		}
+		if (allowedTypes && !allowedTypes.includes(typeDef.type)) {
+			warnings.push({
+				type: "type-not-allowed",
+				fieldKey: field.key,
+				fieldType,
+				addonType: typeDef.type,
+				allowedTypes
+			});
+			continue;
+		}
+		if (source === "json" && typeDef.jsonSafe === false) {
+			warnings.push({
+				type: "code-only-type-in-json",
+				fieldKey: field.key,
+				addonType: typeDef.type
+			});
+			continue;
+		}
+		let sanitized = addon;
+		let stripped = false;
+		const ensureCopy = () => {
+			if (!stripped) sanitized = { ...sanitized };
+			stripped = true;
+		};
+		const declaredVariants = [
+			"preset",
+			"actionRef",
+			"action"
+		].filter((k) => sanitized[k] !== void 0);
+		if (source === "json") {
+			const dropReactiveFn = (key) => {
+				if (typeof sanitized[key] === "function") {
+					ensureCopy();
+					delete sanitized[key];
+					warnings.push({
+						type: "code-only-action-in-json",
+						fieldKey: field.key,
+						reason: `function '${key}' on type '${typeDef.type}' (use a signal/observable in code, or omit in JSON)`
+					});
+				}
+			};
+			if (typeof sanitized.action === "function") {
+				ensureCopy();
+				delete sanitized.action;
+				warnings.push({
+					type: "code-only-action-in-json",
+					fieldKey: field.key,
+					reason: `inline 'action' function on type '${typeDef.type}'`
+				});
+			}
+			dropReactiveFn("hidden");
+			dropReactiveFn("disabled");
+			dropReactiveFn("loading");
+		}
+		if (declaredVariants.length > 1) {
+			ensureCopy();
+			for (const k of declaredVariants.slice(1)) delete sanitized[k];
+			warnings.push({
+				type: "code-only-action-in-json",
+				fieldKey: field.key,
+				reason: `multiple click variants on type '${typeDef.type}' (${declaredVariants.join(", ")}); kept '${declaredVariants[0]}'`
+			});
+		}
+		if (stripped) {
+			survivors.push(sanitized);
+			continue;
+		}
+		if (typeDef.validate) try {
+			typeDef.validate(addon, field.key);
+		} catch (error) {
+			warnings.push({
+				type: "shape-violation",
+				fieldKey: field.key,
+				addonType: typeDef.type,
+				reason: error instanceof Error ? error.message : String(error)
+			});
+			continue;
+		}
+		survivors.push(addon);
+	}
+	return {
+		addons: survivors,
+		warnings
+	};
+}
+function walkAndValidateAddons(fields, fieldRegistry, typeRegistry, source) {
+	const allWarnings = [];
+	return {
+		fields: fields.map((field) => {
+			let next = field;
+			if (field.addons?.length) {
+				const { addons, warnings } = validateFieldAddons(field, fieldRegistry, typeRegistry, source);
+				allWarnings.push(...warnings);
+				next = {
+					...next,
+					addons
+				};
+			}
+			const children = next.fields;
+			if (Array.isArray(children)) {
+				const { fields: visited, warnings } = walkAndValidateAddons(children, fieldRegistry, typeRegistry, source);
+				allWarnings.push(...warnings);
+				next = {
+					...next,
+					fields: visited
+				};
+			}
+			return next;
+		}),
+		warnings: allWarnings
+	};
+}
+function addonWarningKey(w) {
+	switch (w.type) {
+		case "unknown-field-type": return `${w.type}|${w.fieldKey}|${w.fieldType}`;
+		case "field-type-no-addon-support": return `${w.type}|${w.fieldKey}|${w.fieldType}`;
+		case "unknown-slot": return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.slot}`;
+		case "unknown-type": return `${w.type}|${w.fieldKey}|${w.addonType}`;
+		case "type-not-allowed": return `${w.type}|${w.fieldKey}|${w.fieldType}|${w.addonType}`;
+		case "shape-violation": return `${w.type}|${w.fieldKey}|${w.addonType}|${w.reason}`;
+		case "code-only-type-in-json": return `${w.type}|${w.fieldKey}|${w.addonType}`;
+		case "code-only-action-in-json": return `${w.type}|${w.fieldKey}|${w.reason}`;
+	}
+}
+function formatAddonWarning(w) {
+	switch (w.type) {
+		case "unknown-field-type": return `Field '${w.fieldKey}': unknown field type '${w.fieldType}'. Addons dropped.`;
+		case "field-type-no-addon-support": return `Field '${w.fieldKey}' (type: '${w.fieldType}'): this field type does not declare addon support. Addons dropped. If this is incorrect, add 'addons: { slots: [...] }' to the field type registration.`;
+		case "unknown-slot": return `Field '${w.fieldKey}' (type: '${w.fieldType}'): slot '${w.slot}' is not supported. Allowed: ${w.allowedSlots.join(", ")}. Addon dropped.`;
+		case "unknown-type": return `Field '${w.fieldKey}': addon type '${w.addonType}' is not registered. Did you forget withCustomAddon({ type: '${w.addonType}', ... })? Currently registered: ${w.registeredTypes.join(", ") || "(none)"}. Addon dropped.`;
+		case "type-not-allowed": return `Field '${w.fieldKey}' (type: '${w.fieldType}'): addon type '${w.addonType}' is not in the allowed list. Allowed: ${w.allowedTypes.join(", ")}. Addon dropped.`;
+		case "shape-violation": return `Field '${w.fieldKey}': addon type '${w.addonType}' shape invalid: ${w.reason}. Addon dropped.`;
+		case "code-only-type-in-json": return `Field '${w.fieldKey}': addon type '${w.addonType}' is code-only and cannot be used with JSON-derived configs. Addon dropped.`;
+		case "code-only-action-in-json": return `Field '${w.fieldKey}': ${w.reason}. Use 'preset' or 'actionRef' instead. Addon dropped.`;
+	}
+}
+const VALUE_EXCLUSION_DEFAULTS = new InjectionToken("VALUE_EXCLUSION_DEFAULTS", {
+	providedIn: "root",
+	factory: () => ({
+		excludeValueIfHidden: true,
+		excludeValueIfDisabled: true,
+		excludeValueIfReadonly: true
+	})
+});
+function resolveExclusionConfig(global, form, field) {
+	return {
+		excludeValueIfHidden: field?.excludeValueIfHidden ?? form?.excludeValueIfHidden ?? global.excludeValueIfHidden,
+		excludeValueIfDisabled: field?.excludeValueIfDisabled ?? form?.excludeValueIfDisabled ?? global.excludeValueIfDisabled,
+		excludeValueIfReadonly: field?.excludeValueIfReadonly ?? form?.excludeValueIfReadonly ?? global.excludeValueIfReadonly
+	};
+}
+function hasEnabledValueExclusion(fields, global, form) {
+	return fields.some((field) => {
+		const resolved = resolveExclusionConfig(global, form, field);
+		if (resolved.excludeValueIfHidden || resolved.excludeValueIfDisabled || resolved.excludeValueIfReadonly) return true;
+		return isGroupField(field) && !!field.fields && hasEnabledValueExclusion(Object.values(field.fields), global, form);
+	});
+}
+function filterDeclaredValueShape(rawValue, fields, registry) {
+	const kept = {};
+	for (const field of fields) {
+		const key = field.key;
+		if (!key || !(key in rawValue)) continue;
+		const valueHandling = getFieldValueHandling(field.type, registry);
+		if (valueHandling === "exclude" || valueHandling === "flatten") continue;
+		const value = rawValue[key];
+		if (isGroupField(field) && field.fields && value !== null && typeof value === "object" && !Array.isArray(value)) {
+			kept[key] = filterDeclaredValueShape(value, Object.values(field.fields), registry);
+			continue;
+		}
+		kept[key] = value;
+	}
+	return kept;
+}
+function shouldExcludeField(field, fieldState, config) {
+	const state = fieldState();
+	const inherited = field.inheritedExclusionState;
+	const isHidden = state.hidden() || field.hidden === true || inherited?.hidden === true;
+	if (config.excludeValueIfHidden && isHidden) return true;
+	const isDisabled = state.disabled() || field.disabled === true || inherited?.disabled === true;
+	if (config.excludeValueIfDisabled && isDisabled) return true;
+	const isReadonly = state.readonly() || field.readonly === true || inherited?.readonly === true;
+	if (config.excludeValueIfReadonly && isReadonly) return true;
+	return false;
+}
+function filterFormValue(rawValue, schemaFields, formTree, registry, globalDefaults, formOptions, exclusionEnabled = hasEnabledValueExclusion(schemaFields, globalDefaults, formOptions)) {
+	if (!exclusionEnabled) return filterDeclaredValueShape(rawValue, schemaFields, registry);
+	const result = {};
+	for (const field of schemaFields) {
+		const key = field.key;
+		if (!key) continue;
+		const valueHandling = getFieldValueHandling(field.type, registry);
+		if (valueHandling === "exclude" || valueHandling === "flatten") continue;
+		if (!(key in rawValue)) continue;
+		const resolvedConfig = resolveExclusionConfig(globalDefaults, formOptions, {
+			excludeValueIfHidden: field.excludeValueIfHidden,
+			excludeValueIfDisabled: field.excludeValueIfDisabled,
+			excludeValueIfReadonly: field.excludeValueIfReadonly
+		});
+		const fieldState = formTree[key];
+		if (!fieldState || typeof fieldState !== "function") {
+			const inherited = field.inheritedExclusionState;
+			if (!(resolvedConfig.excludeValueIfHidden && (field.hidden === true || inherited?.hidden === true) || resolvedConfig.excludeValueIfDisabled && (field.disabled === true || inherited?.disabled === true) || resolvedConfig.excludeValueIfReadonly && (field.readonly === true || inherited?.readonly === true))) result[key] = rawValue[key];
+			continue;
+		}
+		if (shouldExcludeField(field, fieldState, resolvedConfig)) continue;
+		if (isGroupField(field) && field.fields) {
+			const groupValue = rawValue[key];
+			if (groupValue && typeof groupValue === "object") result[key] = filterFormValue(groupValue, Object.values(field.fields), fieldState, registry, globalDefaults, formOptions, true);
+			else result[key] = groupValue;
+			continue;
+		}
+		if (isArrayField(field)) {
+			result[key] = rawValue[key];
+			continue;
+		}
+		result[key] = rawValue[key];
+	}
+	return result;
+}
+const LifecycleState = {
+	Uninitialized: "uninitialized",
+	Initializing: "initializing",
+	Ready: "ready",
+	Transitioning: "transitioning",
+	Destroyed: "destroyed"
+};
+const Phase = {
+	Teardown: "teardown",
+	Applying: "applying",
+	Restoring: "restoring"
+};
+const Action = {
+	Initialize: "initialize",
+	ConfigChange: "config-change",
+	SetupComplete: "setup-complete",
+	ValueCaptured: "value-captured",
+	TeardownComplete: "teardown-complete",
+	ApplyComplete: "apply-complete",
+	RestoreComplete: "restore-complete",
+	Destroy: "destroy"
+};
+const Effect = {
+	CaptureValue: "capture-value",
+	WaitFrameBoundary: "wait-frame-boundary",
+	CreateForm: "create-form",
+	RestoreValues: "restore-values"
+};
+function isReadyState(state) {
+	return state.type === LifecycleState.Ready;
+}
+function isTransitioningState(state) {
+	return state.type === LifecycleState.Transitioning;
+}
+function createUninitializedState() {
+	return { type: LifecycleState.Uninitialized };
+}
+function createInitializingState(config) {
+	return {
+		type: LifecycleState.Initializing,
+		config
+	};
+}
+function createReadyState(config, formSetup) {
+	return {
+		type: LifecycleState.Ready,
+		config,
+		formSetup
+	};
+}
+function createTransitioningState(phase, currentConfig, pendingConfig, currentFormSetup, preservedValue, pendingFormSetup) {
+	return {
+		type: LifecycleState.Transitioning,
+		phase,
+		currentConfig,
+		pendingConfig,
+		currentFormSetup,
+		preservedValue,
+		pendingFormSetup
+	};
+}
+function createDestroyedState() {
+	return { type: LifecycleState.Destroyed };
+}
+var SideEffectScheduler = class {
+	injector;
+	abortController = new AbortController();
+	get destroyed() {
+		return this.abortController.signal.aborted;
+	}
+	constructor(options) {
+		this.injector = options.injector;
+		options.destroyRef.onDestroy(() => {
+			this.abortController.abort();
+		});
+	}
+	executeBlocking(effect) {
+		return new Observable((subscriber) => {
+			if (this.destroyed) {
+				subscriber.complete();
+				return;
+			}
+			try {
+				const result = effect();
+				subscriber.next(result);
+				subscriber.complete();
+			} catch (error) {
+				subscriber.error(error);
+			}
+		});
+	}
+	executeAtFrameBoundary(effect, options) {
+		if (options?.skipIf?.()) return this.executeBlocking(effect);
+		return new Observable((subscriber) => {
+			if (this.destroyed) {
+				subscriber.complete();
+				return;
+			}
+			const frameId = requestAnimationFrame(() => {
+				if (this.destroyed) {
+					subscriber.complete();
+					return;
+				}
+				try {
+					const result = effect();
+					subscriber.next(result);
+					subscriber.complete();
+				} catch (error) {
+					subscriber.error(error);
+				}
+			});
+			return () => {
+				cancelAnimationFrame(frameId);
+			};
+		});
+	}
+	executeAfterRender(effect) {
+		return new Observable((subscriber) => {
+			if (this.destroyed) {
+				subscriber.complete();
+				return;
+			}
+			const local = new AbortController();
+			afterNextRender(() => {
+				if (local.signal.aborted || this.destroyed) {
+					subscriber.complete();
+					return;
+				}
+				try {
+					const result = effect();
+					subscriber.next(result);
+					subscriber.complete();
+				} catch (error) {
+					subscriber.error(error);
+				}
+			}, { injector: this.injector });
+			return () => {
+				local.abort();
+			};
+		});
+	}
+};
+function createSideEffectScheduler(injector) {
+	return new SideEffectScheduler({
+		injector,
+		destroyRef: injector.get(DestroyRef)
+	});
+}
+var FormStateMachine = class {
+	config;
+	actions$ = new Subject();
+	_state;
+	state;
+	state$;
+	get currentState() {
+		return this._state();
+	}
+	constructor(config) {
+		this.config = config;
+		this._state = signal(createUninitializedState(), ...ngDevMode ? [{ debugName: "_state" }] : /* istanbul ignore next */ []);
+		this.state = this._state.asReadonly();
+		this.state$ = toObservable(this._state, { injector: config.injector });
+		this.setupActionProcessing();
+	}
+	dispatch(action) {
+		this.actions$.next(action);
+	}
+	setupActionProcessing() {
+		this.actions$.pipe(concatMap((action) => this.processAction(action).pipe(catchError((error) => {
+			this.config.logger.error(`Action '${action.type}' failed:`, error);
+			this.recoverFromError(error, action);
+			return EMPTY;
+		}))), takeUntilDestroyed(this.config.destroyRef)).subscribe();
+	}
+	processAction(action) {
+		const currentState = this._state();
+		const result = this.computeTransition(currentState, action);
+		this.config.onTransition?.({
+			from: currentState,
+			to: result.state,
+			action,
+			timestamp: Date.now()
+		});
+		this._state.set(result.state);
+		return this.executeSideEffects(result.sideEffects);
+	}
+	recoverFromError(error, action) {
+		const state = this._state();
+		if (state.type === LifecycleState.Initializing) this._state.set(createUninitializedState());
+		else if (isTransitioningState(state)) this._state.set(createReadyState(state.currentConfig, state.currentFormSetup));
+		this.config.onError?.(error, action);
+	}
+	computeTransition(state, action) {
+		switch (action.type) {
+			case Action.Initialize: return this.handleInitialize(state, action.config);
+			case Action.ConfigChange: return this.handleConfigChange(state, action.config);
+			case Action.SetupComplete: return this.handleSetupComplete(state, action.formSetup);
+			case Action.ValueCaptured: return this.handleValueCaptured(state, action.value);
+			case Action.TeardownComplete: return this.handleTeardownComplete(state);
+			case Action.ApplyComplete: return this.handleApplyComplete(state, action.formSetup);
+			case Action.RestoreComplete: return this.handleRestoreComplete(state);
+			case Action.Destroy: return this.handleDestroy();
+			default: return assertNever(action);
+		}
+	}
+	handleInitialize(state, config) {
+		if (state.type !== LifecycleState.Uninitialized) return {
+			state,
+			sideEffects: []
+		};
+		return {
+			state: createInitializingState(config),
+			sideEffects: [{ type: Effect.CreateForm }]
+		};
+	}
+	handleConfigChange(state, config) {
+		if (state.type === LifecycleState.Uninitialized) return {
+			state: createInitializingState(config),
+			sideEffects: [{ type: Effect.CreateForm }]
+		};
+		if (state.type === LifecycleState.Initializing) return {
+			state: createInitializingState(config),
+			sideEffects: [{ type: Effect.CreateForm }]
+		};
+		if (this.config.isSubmitting?.()) {
+			this.config.logger.warn("Config changed during active submission; ignoring. Apply config changes after submission completes.");
+			return {
+				state,
+				sideEffects: []
+			};
+		}
+		if (isReadyState(state)) return {
+			state: createTransitioningState(Phase.Teardown, state.config, config, state.formSetup),
+			sideEffects: [{ type: Effect.CaptureValue }, { type: Effect.WaitFrameBoundary }]
+		};
+		if (isTransitioningState(state)) return {
+			state: createTransitioningState(state.phase, state.currentConfig, config, state.currentFormSetup, state.preservedValue, state.pendingFormSetup),
+			sideEffects: []
+		};
+		return {
+			state,
+			sideEffects: []
+		};
+	}
+	handleSetupComplete(state, formSetup) {
+		if (state.type === LifecycleState.Initializing) return {
+			state: createReadyState(state.config, formSetup),
+			sideEffects: []
+		};
+		return {
+			state,
+			sideEffects: []
+		};
+	}
+	handleValueCaptured(state, value) {
+		if (!isTransitioningState(state)) return {
+			state,
+			sideEffects: []
+		};
+		return {
+			state: createTransitioningState(state.phase, state.currentConfig, state.pendingConfig, state.currentFormSetup, value, state.pendingFormSetup),
+			sideEffects: []
+		};
+	}
+	handleTeardownComplete(state) {
+		if (!isTransitioningState(state) || state.phase !== Phase.Teardown) return {
+			state,
+			sideEffects: []
+		};
+		return {
+			state: createTransitioningState(Phase.Applying, state.currentConfig, state.pendingConfig, state.currentFormSetup, state.preservedValue),
+			sideEffects: [{ type: Effect.CreateForm }]
+		};
+	}
+	handleApplyComplete(state, formSetup) {
+		if (!isTransitioningState(state) || state.phase !== Phase.Applying) return {
+			state,
+			sideEffects: []
+		};
+		if (state.preservedValue && Object.keys(state.preservedValue).length > 0) return {
+			state: createTransitioningState(Phase.Restoring, state.currentConfig, state.pendingConfig, state.currentFormSetup, state.preservedValue, formSetup),
+			sideEffects: [{
+				type: Effect.RestoreValues,
+				values: state.preservedValue
+			}]
+		};
+		return {
+			state: createReadyState(state.pendingConfig, formSetup),
+			sideEffects: []
+		};
+	}
+	handleRestoreComplete(state) {
+		if (!isTransitioningState(state) || state.phase !== Phase.Restoring) return {
+			state,
+			sideEffects: []
+		};
+		if (DEV_MODE && !state.pendingFormSetup) this.config.logger.warn("handleRestoreComplete: pendingFormSetup was not set — falling back to recomputing. This indicates a bug in the transition flow.");
+		const formSetup = state.pendingFormSetup ?? this.config.createFormSetup(state.pendingConfig);
+		return {
+			state: createReadyState(state.pendingConfig, formSetup),
+			sideEffects: []
+		};
+	}
+	handleDestroy() {
+		return {
+			state: createDestroyedState(),
+			sideEffects: []
+		};
+	}
+	executeSideEffects(effects) {
+		if (effects.length === 0) return of(void 0);
+		return effects.reduce((chain$, effect) => chain$.pipe(concatMap(() => this.executeSideEffect(effect))), of(void 0));
+	}
+	executeSideEffect(effect) {
+		const { scheduler } = this.config;
+		switch (effect.type) {
+			case Effect.CaptureValue: return scheduler.executeBlocking(() => {
+				const value = this.config.captureValue();
+				this.dispatch({
+					type: Action.ValueCaptured,
+					value
+				});
+			});
+			case Effect.WaitFrameBoundary: return scheduler.executeAtFrameBoundary(() => {
+				this.dispatch({ type: Action.TeardownComplete });
+			}, { skipIf: this.config.isFieldPipelineSettled });
+			case Effect.CreateForm: return scheduler.executeBlocking(() => {
+				const state = untracked(() => this._state());
+				let config;
+				if (state.type === LifecycleState.Initializing) config = state.config;
+				else if (isTransitioningState(state) && state.phase === Phase.Applying) config = state.pendingConfig;
+				if (!config) return;
+				const formSetup = this.config.createFormSetup(config);
+				this.config.onFormCreated?.(formSetup);
+				if (state.type === LifecycleState.Initializing) this.dispatch({
+					type: Action.SetupComplete,
+					formSetup
+				});
+				else if (isTransitioningState(state) && state.phase === Phase.Applying) this.dispatch({
+					type: Action.ApplyComplete,
+					formSetup
+				});
+			});
+			case Effect.RestoreValues: return scheduler.executeAfterRender(() => {
+				const state = untracked(() => this._state());
+				if (!isTransitioningState(state) || state.phase !== Phase.Restoring) return;
+				if (DEV_MODE && !state.pendingFormSetup) this.config.logger.warn("RestoreValues effect: pendingFormSetup was not set — falling back to recomputing.");
+				const formSetup = state.pendingFormSetup ?? this.config.createFormSetup(state.pendingConfig);
+				const oldTypeByKey = /* @__PURE__ */ new Map();
+				for (const f of state.currentFormSetup.schemaFields) if (f.key !== void 0) oldTypeByKey.set(f.key, f.type);
+				const validKeys = /* @__PURE__ */ new Set();
+				for (const f of formSetup.schemaFields) if (f.key !== void 0 && oldTypeByKey.get(f.key) === f.type) validKeys.add(f.key);
+				this.config.restoreValue(effect.values, validKeys);
+				this.dispatch({ type: Action.RestoreComplete });
+			});
+			default: return assertNever(effect);
+		}
+	}
+};
+function createFormStateMachine(config) {
+	return new FormStateMachine(config);
+}
+const FORM_STATE_DEPS = new InjectionToken("FORM_STATE_DEPS");
+function asFieldTreeRecord(tree) {
+	return tree;
+}
+const BOUND_VALUE_EXCLUSION_BASELINE = {
+	excludeValueIfHidden: false,
+	excludeValueIfDisabled: false,
+	excludeValueIfReadonly: false
+};
+function isFieldExcluded(axes) {
+	return !!axes && (axes.hidden || axes.disabled || axes.readonly);
+}
+function collectFieldStateSnapshot(fields, treeRecord, pathParts, out) {
+	for (const field of fields) {
+		const key = field.key;
+		if (!key) continue;
+		const subtree = treeRecord[key];
+		if (!subtree || typeof subtree !== "function") continue;
+		const state = subtree();
+		const path = [...pathParts, key];
+		out[path.join(".")] = {
+			hidden: state.hidden(),
+			disabled: state.disabled(),
+			readonly: state.readonly()
+		};
+		if (isGroupField(field) && field.fields) collectFieldStateSnapshot(field.fields, asFieldTreeRecord(subtree), path, out);
+	}
+}
+function getValueAtPath(source, segments) {
+	let current = source;
+	for (const segment of segments) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[segment];
+	}
+	return current;
+}
+function isRestoreRelevant(value) {
+	return !(typeof value === "number" && Number.isNaN(value));
+}
+function setValueAtPath(target, segments, value) {
+	if (segments.length === 0) return target;
+	const [head, ...rest] = segments;
+	const next = { ...target };
+	if (rest.length === 0) next[head] = value;
+	else {
+		const child = target[head];
+		next[head] = setValueAtPath(child !== null && typeof child === "object" ? child : {}, rest, value);
+	}
+	return next;
+}
+var FormStateManager = class FormStateManager {
+	injector = inject(Injector);
+	destroyRef = inject(DestroyRef);
+	logger = inject(DynamicFormLogger);
+	eventBus = inject(EventBus);
+	functionRegistry = inject(FunctionRegistryService);
+	schemaRegistry = inject(SchemaRegistryService);
+	arrayItemRegistry = inject(ArrayItemRegistryService, { optional: true });
+	deps = (() => {
+		const raw = inject(FORM_STATE_DEPS);
+		if (!raw.config || !raw.formOptions || !raw.value) throw new DynamicFormError("FormStateDeps must be connected before FormStateManager is created. Ensure DynamicForm assigns its input signals to FORM_STATE_DEPS.");
+		return raw;
+	})();
+	valueExclusionDefaults = inject(VALUE_EXCLUSION_DEFAULTS);
+	fieldRegistry = injectFieldRegistry();
+	addonKindRegistry = inject(ADDON_TYPE_REGISTRY);
+	lastAddonWarningKeys = /* @__PURE__ */ new Set();
+	scheduler = createSideEffectScheduler(this.injector);
+	machine;
+	fieldProcessors = inject(CONTAINER_FIELD_PROCESSORS);
+	fieldLoadingErrors = signal([], ...ngDevMode ? [{ debugName: "fieldLoadingErrors" }] : /* istanbul ignore next */ []);
+	_formCache = { current: void 0 };
+	activeConfig = computed(() => {
+		const state = this.machine.state();
+		if (state.type === LifecycleState.Uninitialized) return this.deps.config();
+		if (isReadyState(state)) return state.config;
+		if (isTransitioningState(state)) {
+			if (state.phase === Phase.Teardown || state.phase === Phase.Applying) return state.currentConfig;
+			return state.pendingConfig;
+		}
+		if (state.type === LifecycleState.Initializing) return state.config;
+	}, ...ngDevMode ? [{ debugName: "activeConfig" }] : /* istanbul ignore next */ []);
+	renderPhase = computed(() => {
+		const state = this.machine.state();
+		if (isTransitioningState(state) && state.phase === Phase.Teardown) return Phase.Teardown;
+		return "render";
+	}, ...ngDevMode ? [{ debugName: "renderPhase" }] : /* istanbul ignore next */ []);
+	shouldRender = computed(() => this.activeConfig() !== void 0, ...ngDevMode ? [{ debugName: "shouldRender" }] : /* istanbul ignore next */ []);
+	formModeDetection = computed(() => {
+		const config = this.activeConfig();
+		if (!config) return {
+			mode: "non-paged",
+			isValid: true,
+			errors: []
+		};
+		return detectFormMode(config.fields || []);
+	}, ...ngDevMode ? [{ debugName: "formModeDetection" }] : /* istanbul ignore next */ []);
+	effectiveFormOptions = computed(() => {
+		const configOptions = this.activeConfig()?.options || {};
+		const inputOptions = this.deps.formOptions() ?? void 0;
+		return {
+			...configOptions,
+			...inputOptions
+		};
+	}, ...ngDevMode ? [{ debugName: "effectiveFormOptions" }] : /* istanbul ignore next */ []);
+	pendingPageRequest = signal(null, ...ngDevMode ? [{ debugName: "pendingPageRequest" }] : /* istanbul ignore next */ []);
+	pageFieldDefinitions = computed(() => {
+		const config = this.activeConfig();
+		if (this.formModeDetection().mode === "paged" && config?.fields) return config.fields.filter(isPageField);
+		return [];
+	}, ...ngDevMode ? [{ debugName: "pageFieldDefinitions" }] : /* istanbul ignore next */ []);
+	rawFieldRegistry = computed(() => this.fieldRegistry.raw, ...ngDevMode ? [{ debugName: "rawFieldRegistry" }] : /* istanbul ignore next */ []);
+	formSetup = computed(() => {
+		const registry = this.rawFieldRegistry();
+		const state = this.machine.state();
+		if (isReadyState(state)) return state.formSetup;
+		if (isTransitioningState(state)) {
+			if (state.phase === Phase.Restoring && state.pendingFormSetup) return state.pendingFormSetup;
+			return state.currentFormSetup;
+		}
+		const config = this.activeConfig();
+		if (config) this.registerValidatorsFromConfig(config);
+		if (!config) return this.createEmptyFormSetup(registry);
+		if (config.fields && config.fields.length > 0) {
+			const modeDetection = this.formModeDetection();
+			return this.createFormSetupFromConfig(config.fields, modeDetection.mode, registry);
+		}
+		return this.createEmptyFormSetup(registry);
+	}, ...ngDevMode ? [{ debugName: "formSetup" }] : /* istanbul ignore next */ []);
+	formSetupConfig = computed(() => {
+		const state = this.machine.state();
+		if (isReadyState(state)) return state.config;
+		if (isTransitioningState(state)) {
+			if (state.phase === Phase.Restoring && state.pendingFormSetup) return state.pendingConfig;
+			return state.currentConfig;
+		}
+		if (state.type === LifecycleState.Initializing) return state.config;
+		if (state.type === LifecycleState.Uninitialized) return this.activeConfig();
+	}, ...ngDevMode ? [{ debugName: "formSetupConfig" }] : /* istanbul ignore next */ []);
+	activePageState = linkedSignal({
+		...ngDevMode ? { debugName: "activePageState" } : /* istanbul ignore next */ {},
+		source: this.activeConfig,
+		computation: (config) => ({
+			config,
+			initialized: false,
+			index: 0
+		})
+	});
+	defaultValues = linkedSignal(() => this.formSetup().defaultValues, ...ngDevMode ? [{ debugName: "defaultValues" }] : /* istanbul ignore next */ []);
+	validKeys = computed(() => {
+		const schemaFields = this.formSetup().schemaFields;
+		if (!schemaFields || schemaFields.length === 0) return void 0;
+		const keys = /* @__PURE__ */ new Set();
+		for (const field of schemaFields) {
+			if (field.key === void 0) continue;
+			keys.add(field.key);
+		}
+		return keys;
+	}, ...ngDevMode ? [{ debugName: "validKeys" }] : /* istanbul ignore next */ []);
+	boundValueExclusionEnabled = computed(() => {
+		const setup = this.formSetup();
+		if (!setup.schemaFields || setup.schemaFields.length === 0) return false;
+		const options = this.effectiveFormOptions();
+		return hasEnabledValueExclusion(setup.schemaFields, BOUND_VALUE_EXCLUSION_BASELINE, {
+			excludeValueIfHidden: options.excludeValueIfHidden,
+			excludeValueIfDisabled: options.excludeValueIfDisabled,
+			excludeValueIfReadonly: options.excludeValueIfReadonly
+		});
+	}, ...ngDevMode ? [{ debugName: "boundValueExclusionEnabled" }] : /* istanbul ignore next */ []);
+	valueExclusionEnabled = computed(() => {
+		const setup = this.formSetup();
+		if (!setup.schemaFields || setup.schemaFields.length === 0) return false;
+		const options = this.effectiveFormOptions();
+		return hasEnabledValueExclusion(setup.schemaFields, this.valueExclusionDefaults, {
+			excludeValueIfHidden: options.excludeValueIfHidden,
+			excludeValueIfDisabled: options.excludeValueIfDisabled,
+			excludeValueIfReadonly: options.excludeValueIfReadonly
+		});
+	}, ...ngDevMode ? [{ debugName: "valueExclusionEnabled" }] : /* istanbul ignore next */ []);
+	fieldStateSnapshot = computed(() => {
+		const schemaFields = this.formSetup().schemaFields;
+		if (!this.formSchemaReady() || !this.boundValueExclusionEnabled() || !schemaFields || schemaFields.length === 0) return {};
+		const snapshot = {};
+		collectFieldStateSnapshot(schemaFields, asFieldTreeRecord(this.form()), [], snapshot);
+		return snapshot;
+	}, ...ngDevMode ? [{ debugName: "fieldStateSnapshot" }] : /* istanbul ignore next */ []);
+	excludedValueStore = signal({}, ...ngDevMode ? [{ debugName: "excludedValueStore" }] : /* istanbul ignore next */ []);
+	prevFieldStateSnapshot = signal({}, ...ngDevMode ? [{ debugName: "prevFieldStateSnapshot" }] : /* istanbul ignore next */ []);
+	lastOutwardValue = {
+		current: void 0,
+		pending: false
+	};
+	lastExternalValue = { current: void 0 };
+	externalValue = computed(() => {
+		const incoming = this.deps.value();
+		if (this.lastOutwardValue.pending && incoming === this.lastOutwardValue.current) {
+			this.lastOutwardValue.pending = false;
+			return this.lastExternalValue.current;
+		}
+		this.lastOutwardValue.pending = false;
+		this.lastExternalValue.current = incoming;
+		return incoming;
+	}, ...ngDevMode ? [{ debugName: "externalValue" }] : /* istanbul ignore next */ []);
+	entity = linkedSignal(() => {
+		this.externalValue();
+		const inputValue = untracked(() => this.deps.value());
+		const defaults = this.defaultValues();
+		const keys = this.validKeys();
+		const saved = this.excludedValueStore();
+		const withSaved = deepMergeDefaults(defaults, saved);
+		const combined = deepMergeDefaults(withSaved, inputValue);
+		if (keys) {
+			const filtered = {};
+			for (const key of Object.keys(combined)) if (keys.has(key)) filtered[key] = combined[key];
+			return filtered;
+		}
+		return combined;
+	}, {
+		debugName: "FormStateManager.entity",
+		equal: isEqual
+	});
+	loadFormSchemaService = injectAsync(() => import("./ng-forge-dynamic-forms-form-schema.service-Dd-gHJ_7.mjs"));
+	formSchemaRequest = computed(() => {
+		const setup = this.formSetup();
+		const config = this.activeConfig();
+		if (!config || !(setup.schemaFields?.length > 0) && !config.schema) return void 0;
+		return {
+			fields: setup.schemaFields ?? [],
+			registry: setup.registry,
+			formLevelSchema: config.schema,
+			validateWhenHidden: this.effectiveFormOptions().validateWhenHidden
+		};
+	}, ...ngDevMode ? [{ debugName: "formSchemaRequest" }] : /* istanbul ignore next */ []);
+	formSchemaResource = resource({
+		...ngDevMode ? { debugName: "formSchemaResource" } : /* istanbul ignore next */ {},
+		params: () => this.formSchemaRequest(),
+		loader: async ({ params }) => {
+			const schemaService = await this.loadFormSchemaService();
+			return runInInjectionContext(this.injector, () => schemaService.create(params));
+		}
+	});
+	schemaCache = { current: void 0 };
+	trackSchemaCache = computed(() => {
+		const request = this.formSchemaRequest();
+		if (!request) {
+			this.schemaCache.current = void 0;
+			return;
+		}
+		if (this.formSchemaResource.status() === "error") {
+			this.schemaCache.current = void 0;
+			return;
+		}
+		if (this.formSchemaResource.hasValue()) this.schemaCache.current = {
+			schema: this.formSchemaResource.value(),
+			request
+		};
+		return this.schemaCache.current;
+	}, ...ngDevMode ? [{ debugName: "trackSchemaCache" }] : /* istanbul ignore next */ []);
+	isSchemaCurrent = computed(() => {
+		if (this.formSetupConfig() !== this.activeConfig()) return false;
+		const request = this.formSchemaRequest();
+		if (!request) return true;
+		return this.trackSchemaCache()?.request === request;
+	}, ...ngDevMode ? [{ debugName: "isSchemaCurrent" }] : /* istanbul ignore next */ []);
+	formSchemaReady = computed(() => {
+		if (this.formSetupConfig() !== this.activeConfig()) return false;
+		if (!this.formSchemaRequest()) return true;
+		if (this.formSchemaResource.status() === "error") return true;
+		return this.trackSchemaCache() !== void 0;
+	}, ...ngDevMode ? [{ debugName: "formSchemaReady" }] : /* istanbul ignore next */ []);
+	formSchema = computed(() => this.trackSchemaCache()?.schema, ...ngDevMode ? [{ debugName: "formSchema" }] : /* istanbul ignore next */ []);
+	form = computed(() => {
+		const schema = this.formSchema();
+		const injector = this.injector;
+		return untracked(() => schema ? form(this.entity, schema, { injector }) : form(this.entity, { injector }));
+	}, ...ngDevMode ? [{ debugName: "form" }] : /* istanbul ignore next */ []);
+	isFieldPipelineSettled;
+	fieldSignalContext = computed(() => {
+		const formSignal = this.form;
+		const isSettled = () => this.isFieldPipelineSettled();
+		const formCache = this._formCache;
+		return {
+			injector: this.injector,
+			value: this.deps.value,
+			defaultValues: this.defaultValues,
+			get form() {
+				const currentForm = formSignal();
+				if (!isSettled() && formCache.current) return formCache.current;
+				formCache.current = currentForm;
+				return currentForm;
+			}
+		};
+	}, ...ngDevMode ? [{ debugName: "fieldSignalContext" }] : /* istanbul ignore next */ []);
+	formInstance = computed(() => this.form()(), ...ngDevMode ? [{ debugName: "formInstance" }] : /* istanbul ignore next */ []);
+	modelValue = computed(() => this.formInstance().value(), ...ngDevMode ? [{ debugName: "modelValue" }] : /* istanbul ignore next */ []);
+	formValue = computed(() => this.modelValue(), ...ngDevMode ? [{ debugName: "formValue" }] : /* istanbul ignore next */ []);
+	filteredFormValue = computed(() => {
+		const rawValue = this.modelValue();
+		const setup = this.formSetup();
+		const schemaFields = setup.schemaFields;
+		const options = this.effectiveFormOptions();
+		if (!this.formSchemaReady() || !schemaFields || schemaFields.length === 0) return rawValue;
+		const formTree = this.form();
+		const formOptions = {
+			excludeValueIfHidden: options.excludeValueIfHidden,
+			excludeValueIfDisabled: options.excludeValueIfDisabled,
+			excludeValueIfReadonly: options.excludeValueIfReadonly
+		};
+		return filterFormValue(rawValue, schemaFields, asFieldTreeRecord(formTree), setup.registry, this.valueExclusionDefaults, formOptions, this.valueExclusionEnabled());
+	}, ...ngDevMode ? [{ debugName: "filteredFormValue" }] : /* istanbul ignore next */ []);
+	boundFormValue = computed(() => {
+		const rawValue = this.modelValue();
+		const setup = this.formSetup();
+		const schemaFields = setup.schemaFields;
+		const options = this.effectiveFormOptions();
+		if (!this.formSchemaReady() || !schemaFields || schemaFields.length === 0) return rawValue;
+		const formTree = this.form();
+		const formOptions = {
+			excludeValueIfHidden: options.excludeValueIfHidden,
+			excludeValueIfDisabled: options.excludeValueIfDisabled,
+			excludeValueIfReadonly: options.excludeValueIfReadonly
+		};
+		return filterFormValue(rawValue, schemaFields, asFieldTreeRecord(formTree), setup.registry, BOUND_VALUE_EXCLUSION_BASELINE, formOptions, this.boundValueExclusionEnabled());
+	}, ...ngDevMode ? [{ debugName: "boundFormValue" }] : /* istanbul ignore next */ []);
+	valid = computed(() => this.formSchemaReady() && this.formSchemaResource.status() !== "error" && this.formInstance().valid(), ...ngDevMode ? [{ debugName: "valid" }] : /* istanbul ignore next */ []);
+	invalid = computed(() => !this.formSchemaReady() || this.formSchemaResource.status() === "error" || this.formInstance().invalid(), ...ngDevMode ? [{ debugName: "invalid" }] : /* istanbul ignore next */ []);
+	dirty = computed(() => this.formSchemaReady() && this.formInstance().dirty(), ...ngDevMode ? [{ debugName: "dirty" }] : /* istanbul ignore next */ []);
+	touched = computed(() => this.formSchemaReady() && this.formInstance().touched(), ...ngDevMode ? [{ debugName: "touched" }] : /* istanbul ignore next */ []);
+	errors = computed(() => this.formSchemaReady() ? this.formInstance().errors() : [], ...ngDevMode ? [{ debugName: "errors" }] : /* istanbul ignore next */ []);
+	disabled = computed(() => {
+		const optionsDisabled = this.effectiveFormOptions().disabled;
+		const formDisabled = this.formSchemaReady() && this.formInstance().disabled();
+		return optionsDisabled ?? formDisabled;
+	}, ...ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []);
+	submitting = computed(() => this.formSchemaReady() && this.formInstance().submitting(), ...ngDevMode ? [{ debugName: "submitting" }] : /* istanbul ignore next */ []);
+	fieldsSource = computed(() => {
+		const state = this.machine.state();
+		if (isTransitioningState(state)) {
+			const oldFields = state.currentConfig.fields ?? [];
+			const newFields = state.pendingConfig.fields ?? [];
+			const newKeys = new Set(newFields.map((f) => f.key));
+			if (state.phase === Phase.Teardown || state.phase === Phase.Applying) return oldFields.filter((f) => newKeys.has(f.key));
+			if (state.phase === Phase.Restoring) return state.pendingFormSetup?.fields ?? this.formSetup().fields;
+		}
+		return this.formSetup().fields;
+	}, {
+		...ngDevMode ? { debugName: "fieldsSource" } : /* istanbul ignore next */ {},
+		equal: (a, b) => {
+			if (a === b) return true;
+			if (a.length !== b.length) return false;
+			return a.every((field, i) => field === b[i]);
+		}
+	});
+	fieldInjector = computed(() => Injector.create({
+		parent: this.injector,
+		providers: [{
+			provide: FIELD_SIGNAL_CONTEXT,
+			useValue: this.fieldSignalContext()
+		}]
+	}), ...ngDevMode ? [{ debugName: "fieldInjector" }] : /* istanbul ignore next */ []);
+	resolvedFields;
+	submitted$;
+	reset$;
+	cleared$;
+	get ready$() {
+		return this.machine.state$.pipe(filter(isReadyState), take(1), map(() => void 0));
+	}
+	constructor() {
+		this.resolvedFields = derivedFromDeferred(this.fieldsSource, pipe(switchMap((fields) => {
+			if (!fields || fields.length === 0) return of([]);
+			const registry = this.rawFieldRegistry();
+			const injector = this.fieldInjector();
+			const syncContext = {
+				getLoadedComponent: (type) => this.fieldRegistry.getLoadedComponent(type),
+				registry,
+				injector
+			};
+			const results = new Array(fields.length);
+			const asyncIndexes = [];
+			const asyncObs = [];
+			const onError = (fieldDef, error) => {
+				const fieldKey = fieldDef.key || "<no key>";
+				this.fieldLoadingErrors.update((errors) => [...errors, {
+					fieldType: fieldDef.type,
+					fieldKey,
+					error: error instanceof Error ? error : new Error(String(error))
+				}]);
+				this.logger.error(`Failed to load component for field type '${fieldDef.type}' (key: ${fieldKey}). Ensure the field type is registered in your field registry.`, error);
+			};
+			for (let i = 0; i < fields.length; i++) {
+				const f = fields[i];
+				if (!this.fieldRegistry.getType(f.type)?.loadComponent || this.fieldRegistry.getLoadedComponent(f.type)) results[i] = resolveFieldSync(f, syncContext);
+				else {
+					asyncIndexes.push(i);
+					asyncObs.push(resolveField(f, {
+						loadTypeComponent: (type) => this.fieldRegistry.loadTypeComponent(type),
+						registry,
+						injector,
+						destroyRef: this.destroyRef,
+						onError
+					}));
+				}
+			}
+			if (asyncObs.length === 0) return of(results);
+			return forkJoin(asyncObs).pipe(map((asyncResults) => {
+				for (let j = 0; j < asyncResults.length; j++) results[asyncIndexes[j]] = asyncResults[j];
+				return results;
+			}));
+		}), map((fields) => fields.filter((f) => f !== void 0)), scan(reconcileFields, [])), {
+			initialValue: [],
+			injector: this.injector
+		});
+		this.isFieldPipelineSettled = computed(() => {
+			return this.fieldsSource().length === this.resolvedFields().length;
+		}, ...ngDevMode ? [{ debugName: "isFieldPipelineSettled" }] : /* istanbul ignore next */ []);
+		this.submitted$ = this.eventBus.on("submit").pipe(filter(() => {
+			if (!this.valid()) {
+				this.logger.debug("Form submitted while invalid, not emitting to (submitted) output");
+				return false;
+			}
+			return true;
+		}), switchMap(() => {
+			if ((this.activeConfig()?.submission)?.action) {
+				this.logger.warn("Both `submission.action` and `(submitted)` output are configured. When using `submission.action`, the `(submitted)` output will not emit. Use either `submission.action` OR `(submitted)`, not both.");
+				return EMPTY;
+			}
+			return of(this.filteredFormValue());
+		}), takeUntilDestroyed(this.destroyRef));
+		this.reset$ = this.eventBus.on("form-reset").pipe(map(() => void 0), takeUntilDestroyed(this.destroyRef));
+		this.cleared$ = this.eventBus.on("form-clear").pipe(map(() => void 0), takeUntilDestroyed(this.destroyRef));
+		this.eventBus.on("go-to-page").pipe(takeUntilDestroyed(this.destroyRef)).subscribe((event) => this.pendingPageRequest.set({
+			index: event.pageIndex,
+			options: event.options
+		}));
+		this.machine = createFormStateMachine({
+			injector: this.injector,
+			destroyRef: this.destroyRef,
+			scheduler: this.scheduler,
+			logger: this.logger,
+			createFormSetup: (config) => {
+				this.registerValidatorsFromConfig(config);
+				return this.createFormSetupFromConfig(config.fields ?? [], detectFormMode(config.fields ?? []).mode, this.rawFieldRegistry());
+			},
+			captureValue: () => this.formValue(),
+			isSubmitting: this.submitting,
+			isFieldPipelineSettled: () => this.isFieldPipelineSettled(),
+			restoreValue: (values, validKeys) => {
+				const filtered = {};
+				for (const [key, val] of Object.entries(values)) if (validKeys.has(key)) filtered[key] = val;
+				this.deps.value.update((current) => {
+					const next = {
+						...current,
+						...filtered
+					};
+					for (const key of Object.keys(values)) if (!validKeys.has(key)) delete next[key];
+					return next;
+				});
+			},
+			onTransition: (transition) => {
+				this.logger.debug("State transition:", transition.from.type, "→", transition.to.type, transition.action.type);
+			},
+			onError: (error, action) => {
+				this.logger.error(`State machine error recovery triggered for action '${action.type}':`, error);
+			}
+		});
+		runInInjectionContext(this.injector, () => {
+			this.setupEffects();
+			this.setupEventHandlers();
+		});
+	}
+	updateValue(value) {
+		this.deps.value.set(value);
+	}
+	reset() {
+		const rootField = this.form()();
+		this.excludedValueStore.set({});
+		const defaults = this.defaultValues();
+		rootField.value.set(defaults);
+		this.deps.value.set(defaults);
+		rootField.reset();
+	}
+	clear() {
+		const rootField = this.form()();
+		this.excludedValueStore.set({});
+		const emptyValue = {};
+		rootField.value.set(emptyValue);
+		this.deps.value.set(emptyValue);
+		rootField.reset();
+	}
+	submit() {
+		this.eventBus.dispatch(FormSubmitEvent);
+	}
+	setupEffects() {
+		explicitEffect([this.formSchemaResource.error], ([error]) => {
+			if (error) this.logger.error("Failed to compile the form schema; rendering without validation and blocking submission.", error);
+		});
+		explicitEffect([this.deps.config], ([config]) => {
+			this.fieldLoadingErrors.set([]);
+			if (this.machine.currentState.type === LifecycleState.Uninitialized) this.machine.dispatch({
+				type: Action.Initialize,
+				config
+			});
+			else this.machine.dispatch({
+				type: Action.ConfigChange,
+				config
+			});
+		});
+		explicitEffect([this.fieldStateSnapshot], ([snapshot]) => {
+			const currentSaved = this.excludedValueStore();
+			const currentEntity = this.entity();
+			const boundValue = this.boundFormValue();
+			const prev = this.prevFieldStateSnapshot();
+			let newSaved = currentSaved;
+			for (const [path, axes] of Object.entries(snapshot)) if (isFieldExcluded(axes) && !isFieldExcluded(prev[path])) {
+				const segments = path.split(".");
+				const inEntity = getValueAtPath(currentEntity, segments);
+				const inBound = getValueAtPath(boundValue, segments);
+				if (inEntity !== void 0 && inBound === void 0 && isRestoreRelevant(inEntity)) newSaved = setValueAtPath(newSaved, segments, inEntity);
+			}
+			this.prevFieldStateSnapshot.set({ ...snapshot });
+			if (newSaved !== currentSaved && !isEqual(newSaved, currentSaved)) this.excludedValueStore.set(newSaved);
+		});
+		let warnedAboutMissingArrayRegistry = false;
+		explicitEffect([this.formSetup], () => {
+			this.prevFieldStateSnapshot.set({});
+			if (Object.keys(this.excludedValueStore()).length > 0) this.excludedValueStore.set({});
+			if (this.arrayItemRegistry) this.arrayItemRegistry.clearAll();
+			else if (DEV_MODE && !warnedAboutMissingArrayRegistry) {
+				warnedAboutMissingArrayRegistry = true;
+				this.logger.warn("ArrayItemRegistryService was not provided to FormStateManager. Array fields will lose dynamically-added item templates across hide/show cycles. This usually means DynamicForm was bootstrapped without provideDynamicFormDI() — check your providers chain.");
+			}
+		});
+		explicitEffect([this.boundFormValue], ([currentBound]) => {
+			const currentValue = this.deps.value();
+			if (!isEqual(currentBound, currentValue)) {
+				this.lastOutwardValue.current = currentBound;
+				this.lastOutwardValue.pending = true;
+				this.deps.value.set(currentBound);
+			}
+		});
+		if (DEV_MODE) explicitEffect([this.activeConfig], ([config]) => {
+			if (!config) return;
+			const validation = FormModeValidator.validateFormConfiguration(config.fields || []);
+			if (!validation.isValid) this.logger.error("Invalid form configuration:", validation.errors);
+			if (validation.warnings.length > 0) this.logger.warn("Form configuration warnings:", validation.warnings);
+		});
+	}
+	setupEventHandlers() {
+		this.eventBus.on("form-reset").pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.reset());
+		this.eventBus.on("form-clear").pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => this.clear());
+	}
+	registerValidatorsFromConfig({ customFnConfig, schemas }) {
+		if (schemas) schemas.forEach((schema) => {
+			this.schemaRegistry.registerSchema(schema);
+		});
+		if (!customFnConfig) return;
+		if (customFnConfig.customFunctions) Object.entries(customFnConfig.customFunctions).forEach(([name, fn]) => {
+			this.functionRegistry.registerCustomFunction(name, fn);
+		});
+		if (customFnConfig.derivations) this.functionRegistry.setDerivationFunctions(customFnConfig.derivations);
+		if (customFnConfig.asyncDerivations) this.functionRegistry.setAsyncDerivationFunctions(customFnConfig.asyncDerivations);
+		if (customFnConfig.asyncConditions) this.functionRegistry.setAsyncConditionFunctions(customFnConfig.asyncConditions);
+		this.functionRegistry.setValidators(customFnConfig.validators);
+		this.functionRegistry.setAsyncValidators(customFnConfig.asyncValidators);
+		this.functionRegistry.setHttpValidators(customFnConfig.httpValidators);
+	}
+	createFormSetupFromConfig(fields, mode, registry) {
+		const normalizedFields = normalizeSimplifiedArrays(fields);
+		validateFormConfig(normalizedFields, registry, this.logger);
+		const source = this.deps.source?.() ?? "inline";
+		const { fields: sanitizedFields, warnings: addonWarnings } = walkAndValidateAddons(normalizedFields, registry, this.addonKindRegistry, source);
+		if (DEV_MODE) {
+			const nextKeys = /* @__PURE__ */ new Set();
+			for (const w of addonWarnings) {
+				const key = addonWarningKey(w);
+				nextKeys.add(key);
+				if (!this.lastAddonWarningKeys.has(key)) this.logger.warn(formatAddonWarning(w));
+			}
+			this.lastAddonWarningKeys = nextKeys;
+		}
+		const validatedFields = sanitizedFields;
+		const flattenedFields = this.fieldProcessors.memoizedFlattenFields(validatedFields, registry);
+		const flattenedFieldsForRendering = this.fieldProcessors.memoizedFlattenFieldsForRendering(validatedFields, registry);
+		const fieldsById = this.fieldProcessors.memoizedKeyBy(flattenedFields);
+		const defaultValues = this.fieldProcessors.memoizedDefaultValues(fieldsById, registry);
+		return {
+			fields: mode === "paged" ? [] : flattenedFieldsForRendering,
+			schemaFields: flattenedFields,
+			originalFields: fields,
+			defaultValues,
+			mode,
+			registry
+		};
+	}
+	createEmptyFormSetup(registry) {
+		return {
+			fields: [],
+			schemaFields: [],
+			defaultValues: {},
+			mode: "non-paged",
+			registry
+		};
+	}
+	ngOnDestroy() {
+		this.machine.dispatch({ type: Action.Destroy });
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: FormStateManager,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: FormStateManager
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: FormStateManager,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+export { walkAndValidateAddons as a, formatAddonWarning as i, FormStateManager as n, normalizeSimplifiedArrays as o, VALUE_EXCLUSION_DEFAULTS as r, FormSubmitEvent as s, FORM_STATE_DEPS as t };
+
+//# sourceMappingURL=ng-forge-dynamic-forms-form-state-manager-DcOXRFRL.mjs.map