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

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

@@ -1,3 +1,2136 @@
-export { o as ActivePageInitializedEvent, y as AppendArrayItemEvent, B as BUILT_IN_FIELDS, z as ComponentAddonComponent, E as ConsoleLogger, G as DfTemplate, H as DynamicForm, I as EventDispatcher, J as FormClearEvent, K as FormResetEvent, x as FormSubmitEvent, L as GoToPageEvent, M as InsertArrayItemEvent, N as MoveArrayItemEvent, O as NextPageEvent, Q as PageChangeEvent, R as PagerStateEvent, T as PopArrayItemEvent, U as PrependArrayItemEvent, W as PreviousPageEvent, X as RemoveAtIndexEvent, Y as ShiftArrayItemEvent, Z as TemplateAddonComponent, _ as TextAddonComponent, $ as arrayEvent, a0 as createWrappers, a1 as isWrappersBundle, a2 as provideDynamicForm, a3 as sanitizeFormConfig, a4 as withAddonActions, a5 as withCustomAddon, a6 as withEventFormValue, a7 as withExperimentalWebMcp, a8 as withFieldWindowing, a9 as withLegacyStatusClasses, aa as withLoggerConfig, ab as withPagePreload, ac as withValidationExecutionDefaults, ad as withValueExclusionDefaults, ae as wrapperProps } from './ng-forge-dynamic-forms-ng-forge-dynamic-forms-CXQe_5td.mjs';
-export { DF_FIELD_TEMPLATES, DynamicFormError, DynamicFormLogger, NoopLogger, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, resolveDynamicValue, rowError } from '@ng-forge/dynamic-forms/internal';
-//# sourceMappingURL=ng-forge-dynamic-forms.mjs.map
+import { d as FieldViewportObserver, f as resolveFieldParking, h as FIELD_WINDOWING, i as initializationComponentKey, m as clampWindowSize, n as collectInitializingContainerKeys, p as resolveFieldWindowing, t as DfFieldOutlet, u as resolveWrappers } from "./ng-forge-dynamic-forms-df-field-outlet.directive-CQsDMV-s.mjs";
+import { a as walkAndValidateAddons, n as FormStateManager, o as normalizeSimplifiedArrays, r as VALUE_EXCLUSION_DEFAULTS, s as FormSubmitEvent, t as FORM_STATE_DEPS } from "./ng-forge-dynamic-forms-form-state-manager-DcOXRFRL.mjs";
+import { c as PROPERTY_OVERRIDE_STORE, l as createPropertyOverrideStore, u as injectFieldRegistry } from "./ng-forge-dynamic-forms-resolve-field-ByGa5cpo.mjs";
+import { a as resolveDefaultExport, n as loadWrapperComponent } from "./ng-forge-dynamic-forms-wrapper-chain-BnntfNU1.mjs";
+import { n as getNormalizedArrayMetadata } from "./ng-forge-dynamic-forms-default-value-D5M4MNE-.mjs";
+import { a as isDynamicFormFeature, i as createFeature, n as withLoggerConfig, o as DERIVATION_WARNING_TRACKER, r as ConsoleLogger, s as someField } from "./ng-forge-dynamic-forms-with-logger-config-BAATqYY0.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 { n as createContainerFieldProcessors, t as CONTAINER_FIELD_PROCESSORS } from "./ng-forge-dynamic-forms-container-field-processors-C_JRvaVt.mjs";
+import { t as DEV_MODE } from "./ng-forge-dynamic-forms-dev-mode-4rbYBBo_.mjs";
+import { t as VALIDATION_EXECUTION_DEFAULTS } from "./ng-forge-dynamic-forms-validation-execution.token-BFyySKtp.mjs";
+import { t as ActivePageInitializedEvent } from "./ng-forge-dynamic-forms-active-page-initialized.event-CiKN-mcc.mjs";
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, DestroyRef, Directive, ElementRef, EnvironmentInjector, Injectable, InjectionToken, Injector, PLATFORM_ID, PendingTasks, TemplateRef, afterNextRender, computed, contentChildren, inject, input, isDevMode, linkedSignal, makeEnvironmentProviders, model, runInInjectionContext, signal, untracked } from "@angular/core";
+import { explicitEffect } from "ngxtension/explicit-effect";
+import { EMPTY, catchError, defer, exhaustMap, filter, firstValueFrom, from, isObservable, shareReplay, take, tap } from "rxjs";
+import { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DF_FIELD_TEMPLATES as DF_FIELD_TEMPLATES$1, DynamicFormError, DynamicFormError as DynamicFormError$1, DynamicFormLogger, DynamicFormLogger as DynamicFormLogger$1, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, EventBus, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, LogicFunctionCacheService, NoopLogger, RootFormRegistryService, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_COMPONENT_LOAD_CACHE, WRAPPER_REGISTRY, arrayFieldMapper, containerFieldMapper, createAddonActionRegistry, createWarningTracker, evaluateCondition, getGridClassString, groupFieldMapper, hasFormValue, isArrayField, isContainerField, isContainerField as isContainerField$1, isDerivationLogicConfig, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isPageField, isPageField as isPageField$1, isRowField, isRowField as isRowField$1, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, isWrapperTypeDefinition as isWrapperTypeDefinition$1, pageFieldMapper, resolveDynamicValue, rowError, rowFieldMapper, textFieldMapper } from "@ng-forge/dynamic-forms/internal";
+import { AsyncPipe, NgComponentOutlet, NgTemplateOutlet, isPlatformBrowser } from "@angular/common";
+import { outputFromObservable, takeUntilDestroyed, toObservable } from "@angular/core/rxjs-interop";
+import { provideSignalFormsConfig, submit } from "@angular/forms/signals";
+import { NG_STATUS_CLASSES } from "@angular/forms/signals/compat";
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+function isPending(formSignal) {
+	return formSignal()().pending();
+}
+function isTreeValidationErrors(result) {
+	const isError = (v) => typeof v === "object" && v !== null && "kind" in v;
+	return Array.isArray(result) ? result.every(isError) && result.length > 0 : isError(result);
+}
+function wrapSubmissionAction(action) {
+	return async (formTree) => {
+		const result = action(formTree);
+		const resolved = isObservable(result) ? await firstValueFrom(result) : await Promise.resolve(result);
+		return isTreeValidationErrors(resolved) ? resolved : void 0;
+	};
+}
+function createSubmissionHandler(options) {
+	const { eventBus, configSignal, formSignal, validSignal, logger } = options;
+	return eventBus.on("submit").pipe(exhaustMap((event) => {
+		const reply = event.reply;
+		reply?.accept();
+		const submissionConfig = configSignal().submission;
+		if (!submissionConfig?.action) {
+			reply?.settle(validSignal() ? { status: "dispatched" } : { status: "validation-failed" });
+			return EMPTY;
+		}
+		if (!validSignal()) {
+			logger.debug("Submission action skipped: form is not valid (invalid or pending async validators)");
+			reply?.settle(isPending(formSignal) ? { status: "pending-validation" } : { status: "validation-failed" });
+			return EMPTY;
+		}
+		const wrappedAction = wrapSubmissionAction(submissionConfig.action);
+		return defer(() => {
+			const formTree = formSignal();
+			return from(submit(formTree, wrappedAction)).pipe(tap(() => {
+				reply?.settle(formTree().errorSummary().length ? { status: "server-errors" } : { status: "success" });
+			}), catchError((error) => {
+				logger.error("Submission action failed:", error);
+				reply?.settle({
+					status: "action-failed",
+					error
+				});
+				return EMPTY;
+			}));
+		});
+	}));
+}
+function collectFieldDefs(fields, out = []) {
+	for (const field of fields ?? []) {
+		out.push(field);
+		const children = field.fields;
+		if (Array.isArray(children)) for (const child of children) if (Array.isArray(child)) collectFieldDefs(child, out);
+		else collectFieldDefs([child], out);
+		const metadata = getNormalizedArrayMetadata(field);
+		const template = metadata?.template;
+		if (Array.isArray(template)) collectFieldDefs(template, out);
+		else if (template) collectFieldDefs([template], out);
+		if (metadata?.autoRemoveButton) collectFieldDefs([metadata.autoRemoveButton], out);
+	}
+	return out;
+}
+function injectFormComponentPreloader() {
+	const fieldRegistry = injectFieldRegistry();
+	const wrapperRegistry = inject(WRAPPER_REGISTRY);
+	const wrapperCache = inject(WRAPPER_COMPONENT_CACHE);
+	const wrapperLoadCache = inject(WRAPPER_COMPONENT_LOAD_CACHE);
+	const autoAssociations = inject(WRAPPER_AUTO_ASSOCIATIONS);
+	const defaultWrappers = inject(DEFAULT_WRAPPERS, { optional: true });
+	const preloadedConfigs = /* @__PURE__ */ new WeakSet();
+	const preloadedFieldRoots = /* @__PURE__ */ new WeakSet();
+	const preloadFields = (fields) => {
+		const unseenFields = fields.filter((field) => {
+			if (preloadedFieldRoots.has(field)) return false;
+			preloadedFieldRoots.add(field);
+			return true;
+		});
+		if (unseenFields.length === 0) return;
+		const defs = collectFieldDefs(normalizeSimplifiedArrays(unseenFields));
+		if (defs.length === 0) return;
+		const fieldTypes = /* @__PURE__ */ new Set();
+		const wrapperTypes = /* @__PURE__ */ new Set();
+		for (const def of defs) {
+			if (def.type) fieldTypes.add(def.type);
+			for (const wrapper of resolveWrappers(def, defaultWrappers?.(), autoAssociations, wrapperRegistry)) wrapperTypes.add(wrapper.type);
+		}
+		const started = [];
+		for (const type of fieldTypes) {
+			if (fieldRegistry.getLoadedComponent(type)) continue;
+			started.push(Promise.resolve(fieldRegistry.loadTypeComponent(type)).catch(() => void 0));
+		}
+		for (const type of wrapperTypes) {
+			if (wrapperCache.has(type)) continue;
+			started.push(loadWrapperComponent(type, wrapperRegistry, wrapperCache, wrapperLoadCache).catch(() => void 0));
+		}
+		Promise.allSettled(started);
+	};
+	return {
+		preloadConfig: (config) => {
+			if (preloadedConfigs.has(config)) return;
+			preloadedConfigs.add(config);
+			const fields = config.fields;
+			if (fields.length > 0 && fields.every(isPageField$1)) return;
+			preloadFields(fields);
+		},
+		preloadFields
+	};
+}
+var PageChangeEvent = class {
+	currentPageIndex;
+	totalPages;
+	previousPageIndex;
+	type = "page-change";
+	constructor(currentPageIndex, totalPages, previousPageIndex) {
+		this.currentPageIndex = currentPageIndex;
+		this.totalPages = totalPages;
+		this.previousPageIndex = previousPageIndex;
+	}
+};
+var PagerStateEvent = class {
+	state;
+	type = "pager-state";
+	constructor(state) {
+		this.state = state;
+	}
+};
+const PAGE_PRELOAD_WINDOW = new InjectionToken("PAGE_PRELOAD_WINDOW", {
+	providedIn: "root",
+	factory: () => 1
+});
+function collectLeafFieldKeys(fields) {
+	const keys = [];
+	for (const field of fields) if (isRowField$1(field) || isGenericContainerField(field)) keys.push(...collectLeafFieldKeys(field.fields));
+	else if (field.key) keys.push(field.key);
+	return keys;
+}
+var PageOrchestratorComponent = class PageOrchestratorComponent {
+	eventBus = inject(EventBus);
+	fieldContextRegistry = inject(FieldContextRegistryService);
+	functionRegistry = inject(FunctionRegistryService);
+	formOptions = inject(FORM_OPTIONS, { optional: true });
+	globalPreloadWindow = inject(PAGE_PRELOAD_WINDOW);
+	stateManager = inject(FormStateManager, { optional: true });
+	pendingPageRequest = computed(() => this.stateManager?.pendingPageRequest() ?? null, ...ngDevMode ? [{ debugName: "pendingPageRequest" }] : /* istanbul ignore next */ []);
+	schemaCurrent = computed(() => this.stateManager?.isSchemaCurrent() ?? true, ...ngDevMode ? [{ debugName: "schemaCurrent" }] : /* istanbul ignore next */ []);
+	configScope = computed(() => this.stateManager?.activeConfig(), ...ngDevMode ? [{ debugName: "configScope" }] : /* istanbul ignore next */ []);
+	pageFields = input.required(...ngDevMode ? [{ debugName: "pageFields" }] : /* istanbul ignore next */ []);
+	form = input.required(...ngDevMode ? [{ debugName: "form" }] : /* istanbul ignore next */ []);
+	fieldSignalContext = input.required(...ngDevMode ? [{ debugName: "fieldSignalContext" }] : /* istanbul ignore next */ []);
+	pageHiddenStates = computed(() => {
+		return this.pageFields().map((page) => this.evaluatePageHidden(page));
+	}, ...ngDevMode ? [{ debugName: "pageHiddenStates" }] : /* istanbul ignore next */ []);
+	visiblePageIndices = computed(() => {
+		return this.pageHiddenStates().map((hidden, index) => ({
+			index,
+			hidden
+		})).filter((item) => !item.hidden).map((item) => item.index);
+	}, ...ngDevMode ? [{ debugName: "visiblePageIndices" }] : /* istanbul ignore next */ []);
+	activePageOwnership = linkedSignal({
+		...ngDevMode ? { debugName: "activePageOwnership" } : /* istanbul ignore next */ {},
+		source: this.configScope,
+		computation: (config, previous) => {
+			const totalPages = this.pageFields().length;
+			if (totalPages === 0) return {
+				config,
+				initialized: true,
+				index: 0
+			};
+			return untracked(() => {
+				const owned = this.stateManager?.activePageState();
+				if ((previous === void 0 || previous.source === config) && owned !== void 0 && owned.config === config && owned.initialized && owned.index >= 0 && owned.index < totalPages) return {
+					config,
+					initialized: true,
+					index: owned.index
+				};
+				if (this.initialPage().validate && !this.schemaCurrent()) return {
+					config,
+					initialized: false,
+					index: 0
+				};
+				return {
+					config,
+					initialized: true,
+					index: this.resolveInitialLanding()
+				};
+			});
+		}
+	});
+	currentPageIndex = computed(() => this.activePageOwnership().index, ...ngDevMode ? [{ debugName: "currentPageIndex" }] : /* istanbul ignore next */ []);
+	setCurrentPageIndex(index) {
+		this.activePageOwnership.update((ownership) => ({
+			...ownership,
+			initialized: true,
+			index
+		}));
+	}
+	resolveInitialLanding() {
+		const { index, validate } = this.initialPage();
+		const visible = this.visiblePageIndices();
+		if (index === 0 || visible.length === 0) return 0;
+		const target = visible.includes(index) ? index : this.findNearestVisiblePage(index, visible);
+		if (target <= 0) return Math.max(target, 0);
+		if (!validate) return target;
+		return visible.filter((i) => i < target).find((i) => !this.isPageValid(i)) ?? target;
+	}
+	initialPage = computed(() => {
+		const raw = this.formOptions?.()?.initialPage;
+		const totalPages = this.pageFields().length;
+		const requested = typeof raw === "number" ? raw : raw?.index;
+		const validate = typeof raw === "number" ? false : raw?.validate ?? false;
+		if (typeof requested !== "number" || !Number.isFinite(requested) || requested < 0 || totalPages === 0) return {
+			index: 0,
+			validate: false
+		};
+		return {
+			index: Math.min(Math.trunc(requested), totalPages - 1),
+			validate
+		};
+	}, ...ngDevMode ? [{ debugName: "initialPage" }] : /* istanbul ignore next */ []);
+	state = computed(() => {
+		const currentIndex = this.currentPageIndex();
+		const totalPages = this.pageFields().length;
+		const visibleIndices = this.visiblePageIndices();
+		const currentVisiblePosition = visibleIndices.indexOf(currentIndex);
+		return {
+			currentPageIndex: currentIndex,
+			totalPages,
+			isFirstPage: currentVisiblePosition === 0 || currentVisiblePosition === -1,
+			isLastPage: currentVisiblePosition >= visibleIndices.length - 1
+		};
+	}, ...ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []);
+	currentPageValid = computed(() => (this.stateManager?.isSchemaCurrent() ?? true) && this.isPageValid(this.currentPageIndex()), ...ngDevMode ? [{ debugName: "currentPageValid" }] : /* istanbul ignore next */ []);
+	isPageValid(pageIndex) {
+		const pages = this.pageFields();
+		const form = this.form();
+		if (pageIndex < 0 || pageIndex >= pages.length) return true;
+		const leafKeys = collectLeafFieldKeys(pages[pageIndex].fields || []);
+		for (const fieldKey of leafKeys) {
+			const field = form[fieldKey];
+			if (field && typeof field === "function") {
+				const fieldState = field();
+				if (fieldState && typeof fieldState.valid === "function" && !fieldState.valid()) return false;
+			}
+		}
+		return true;
+	}
+	extendedFieldSignalContext = computed(() => ({
+		...this.fieldSignalContext(),
+		currentPageValid: this.currentPageValid
+	}), ...ngDevMode ? [{ debugName: "extendedFieldSignalContext" }] : /* istanbul ignore next */ []);
+	preloadWindow = computed(() => {
+		const perForm = this.formOptions?.()?.pagePreloadWindow;
+		return clampWindowSize(perForm, this.globalPreloadWindow);
+	}, ...ngDevMode ? [{ debugName: "preloadWindow" }] : /* istanbul ignore next */ []);
+	pageRenderStates = computed(() => {
+		const activeIndex = this.currentPageIndex();
+		const hiddenStates = this.pageHiddenStates();
+		const preloadWindow = this.preloadWindow();
+		return this.pageFields().map((field, index) => ({
+			field,
+			index,
+			hidden: hiddenStates[index],
+			active: index === activeIndex,
+			preload: index !== activeIndex && Math.abs(index - activeIndex) <= preloadWindow
+		}));
+	}, ...ngDevMode ? [{ debugName: "pageRenderStates" }] : /* istanbul ignore next */ []);
+	constructor() {
+		this.setupEventListeners();
+		const preloader = injectFormComponentPreloader();
+		explicitEffect([this.pageRenderStates], ([states]) => {
+			preloader.preloadFields(states.filter((page) => !page.hidden && (page.active || page.preload)).map((page) => page.field));
+		});
+		explicitEffect([this.schemaCurrent, this.pageFields], ([schemaCurrent]) => {
+			const ownership = this.activePageOwnership();
+			if (!schemaCurrent || ownership.initialized) return;
+			this.activePageOwnership.set({
+				...ownership,
+				initialized: true,
+				index: this.resolveInitialLanding()
+			});
+		});
+		explicitEffect([this.state, this.visiblePageIndices], ([state, visibleIndices]) => {
+			if (visibleIndices.indexOf(state.currentPageIndex) === -1 && visibleIndices.length > 0) {
+				const nearest = this.findNearestVisiblePage(state.currentPageIndex, visibleIndices);
+				if (nearest !== -1) this.executePageChange(nearest);
+			}
+		});
+	}
+	navigateToNextPage() {
+		if ((this.formOptions?.()?.nextButton?.disableWhenPageInvalid ?? true) && !this.currentPageValid()) return {
+			success: false,
+			newPageIndex: this.state().currentPageIndex,
+			error: "Current page has invalid fields"
+		};
+		const currentState = this.state();
+		const visibleIndices = this.visiblePageIndices();
+		if (currentState.isLastPage) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: "Already on the last visible page"
+		};
+		const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
+		if (currentVisiblePosition === -1 || currentVisiblePosition >= visibleIndices.length - 1) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: "No next visible page available"
+		};
+		const nextVisiblePageIndex = visibleIndices[currentVisiblePosition + 1];
+		return this.executePageChange(nextVisiblePageIndex);
+	}
+	navigateToPreviousPage() {
+		const currentState = this.state();
+		const visibleIndices = this.visiblePageIndices();
+		if (currentState.isFirstPage) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: "Already on the first visible page"
+		};
+		const currentVisiblePosition = visibleIndices.indexOf(currentState.currentPageIndex);
+		if (currentVisiblePosition <= 0) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: "No previous visible page available"
+		};
+		const prevVisiblePageIndex = visibleIndices[currentVisiblePosition - 1];
+		return this.executePageChange(prevVisiblePageIndex);
+	}
+	navigateToPage(pageIndex, options) {
+		const currentIndex = this.state().currentPageIndex;
+		const visibleIndices = this.visiblePageIndices();
+		if (pageIndex <= currentIndex || !visibleIndices.includes(pageIndex)) return this.executePageChange(pageIndex);
+		if (options?.validate === false) return this.executePageChange(pageIndex);
+		if (!(this.formOptions?.()?.nextButton?.disableWhenPageInvalid ?? true)) return this.executePageChange(pageIndex);
+		const firstInvalidPage = visibleIndices.filter((index) => index >= currentIndex && index < pageIndex).find((index) => !this.isPageValid(index));
+		if (firstInvalidPage === void 0) return this.executePageChange(pageIndex);
+		this.executePageChange(firstInvalidPage);
+		return {
+			success: false,
+			newPageIndex: firstInvalidPage,
+			error: `Cannot navigate to page ${pageIndex}: page ${firstInvalidPage} has invalid fields`
+		};
+	}
+	executePageChange(pageIndex) {
+		const currentState = this.state();
+		const totalPages = currentState.totalPages;
+		if (pageIndex < 0 || pageIndex >= totalPages) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: `Invalid page index: ${pageIndex}. Valid range is 0 to ${totalPages - 1}`
+		};
+		const visibleIndices = this.visiblePageIndices();
+		if (!visibleIndices.includes(pageIndex)) return {
+			success: false,
+			newPageIndex: currentState.currentPageIndex,
+			error: `Cannot navigate to hidden page at index ${pageIndex}. Visible pages: [${visibleIndices.join(", ")}]`
+		};
+		if (pageIndex === currentState.currentPageIndex) return {
+			success: true,
+			newPageIndex: pageIndex
+		};
+		const previousIndex = currentState.currentPageIndex;
+		this.setCurrentPageIndex(pageIndex);
+		this.eventBus.dispatch(PageChangeEvent, pageIndex, totalPages, previousIndex);
+		return {
+			success: true,
+			newPageIndex: pageIndex
+		};
+	}
+	findNearestVisiblePage(currentIndex, visibleIndices) {
+		let nearest = -1;
+		let minDistance = Infinity;
+		for (const idx of visibleIndices) {
+			const distance = Math.abs(idx - currentIndex);
+			if (distance < minDistance || distance === minDistance && idx > nearest) {
+				minDistance = distance;
+				nearest = idx;
+			}
+		}
+		return nearest;
+	}
+	setupEventListeners() {
+		this.eventBus.on("next-page").pipe(takeUntilDestroyed()).subscribe(() => {
+			this.navigateToNextPage();
+		});
+		this.eventBus.on("previous-page").pipe(takeUntilDestroyed()).subscribe(() => {
+			this.navigateToPreviousPage();
+		});
+		explicitEffect([this.pendingPageRequest], ([request]) => {
+			if (!request) return;
+			this.stateManager?.pendingPageRequest.set(null);
+			this.navigateToPage(request.index, request.options);
+		});
+		explicitEffect([this.state], ([state]) => this.eventBus.dispatch(PagerStateEvent, state));
+		explicitEffect([this.activePageOwnership], ([ownership]) => this.stateManager?.activePageState.set(ownership));
+	}
+	evaluatePageHidden(page) {
+		if (!page.logic || page.logic.length === 0) return false;
+		const hiddenLogic = page.logic.filter((l) => l.type === "hidden");
+		if (hiddenLogic.length === 0) return false;
+		for (const logic of hiddenLogic) {
+			if (typeof logic.condition === "boolean") {
+				if (logic.condition) return true;
+				continue;
+			}
+			const condition = logic.condition;
+			const context = this.fieldContextRegistry.createDisplayOnlyContext(page.key || "", this.functionRegistry.getCustomFunctions());
+			if (evaluateCondition(condition, context)) return true;
+		}
+		return false;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: PageOrchestratorComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.5",
+		type: PageOrchestratorComponent,
+		isStandalone: true,
+		selector: "div[page-orchestrator]",
+		inputs: {
+			pageFields: {
+				classPropertyName: "pageFields",
+				publicName: "pageFields",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			form: {
+				classPropertyName: "form",
+				publicName: "form",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			fieldSignalContext: {
+				classPropertyName: "fieldSignalContext",
+				publicName: "fieldSignalContext",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			}
+		},
+		host: {
+			properties: {
+				"attr.data-current-page": "state().currentPageIndex",
+				"attr.data-total-pages": "state().totalPages"
+			},
+			classAttribute: "df-page-orchestrator"
+		},
+		providers: [{
+			provide: FIELD_SIGNAL_CONTEXT,
+			useFactory: (orchestrator) => orchestrator.extendedFieldSignalContext(),
+			deps: [PageOrchestratorComponent]
+		}],
+		ngImport: i0,
+		template: `
+    @for (page of pageRenderStates(); track page.field.key) {
+      <!--
+        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
+        derives schema/value/validators from config (not from mounted components),
+        so unmounting a hidden page has no effect on form state — only on render +
+        CD cost. This is the page-level equivalent of the existing field-level
+        \`@if (!field.hidden())\` gate in page-field.component.ts.
+      -->
+      @if (!page.hidden) {
+        @if (page.active || page.preload) {
+          @defer (when page.active; on idle) {
+            <section page-field [field]="page.field" [key]="page.field.key" [pageIndex]="page.index" [isVisible]="page.active"></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="page.index" [attr.data-page-key]="page.field.key"></div>
+          }
+        } @else {
+          <!--
+            Pages outside the preload window remain lightweight placeholders.
+            Form state derives from config, so leaving their components unmounted
+            does not affect validity, derivations, or navigation. The active page
+            renders directly; configured neighbours preload declaratively on idle.
+          -->
+          <div class="df-page-placeholder" [attr.data-page-index]="page.index" [attr.data-page-key]="page.field.key"></div>
+        }
+      }
+    }
+  `,
+		isInline: true,
+		styles: [":host{display:block;position:relative;width:100%}\n"],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush,
+		deferBlockDependencies: [() => [import("./ng-forge-dynamic-forms-page-field.component-BRjQmWC9.mjs").then((m) => m.default)]]
+	});
+};
+i0.ɵɵngDeclareClassMetadataAsync({
+	minVersion: "18.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: PageOrchestratorComponent,
+	resolveDeferredDeps: () => [import("./ng-forge-dynamic-forms-page-field.component-BRjQmWC9.mjs").then((m) => m.default)],
+	resolveMetadata: (PageFieldComponent) => ({
+		decorators: [{
+			type: Component,
+			args: [{
+				selector: "div[page-orchestrator]",
+				imports: [PageFieldComponent],
+				template: `
+    @for (page of pageRenderStates(); track page.field.key) {
+      <!--
+        Skip pages hidden by 'hidden' logic conditions entirely. FormStateManager
+        derives schema/value/validators from config (not from mounted components),
+        so unmounting a hidden page has no effect on form state — only on render +
+        CD cost. This is the page-level equivalent of the existing field-level
+        \`@if (!field.hidden())\` gate in page-field.component.ts.
+      -->
+      @if (!page.hidden) {
+        @if (page.active || page.preload) {
+          @defer (when page.active; on idle) {
+            <section page-field [field]="page.field" [key]="page.field.key" [pageIndex]="page.index" [isVisible]="page.active"></section>
+          } @placeholder {
+            <div class="df-page-placeholder" [attr.data-page-index]="page.index" [attr.data-page-key]="page.field.key"></div>
+          }
+        } @else {
+          <!--
+            Pages outside the preload window remain lightweight placeholders.
+            Form state derives from config, so leaving their components unmounted
+            does not affect validity, derivations, or navigation. The active page
+            renders directly; configured neighbours preload declaratively on idle.
+          -->
+          <div class="df-page-placeholder" [attr.data-page-index]="page.index" [attr.data-page-key]="page.field.key"></div>
+        }
+      }
+    }
+  `,
+				host: {
+					class: "df-page-orchestrator",
+					"[attr.data-current-page]": "state().currentPageIndex",
+					"[attr.data-total-pages]": "state().totalPages"
+				},
+				providers: [{
+					provide: FIELD_SIGNAL_CONTEXT,
+					useFactory: (orchestrator) => orchestrator.extendedFieldSignalContext(),
+					deps: [PageOrchestratorComponent]
+				}],
+				changeDetection: ChangeDetectionStrategy.OnPush,
+				styles: [":host{display:block;position:relative;width:100%}\n"]
+			}]
+		}],
+		ctorParameters: () => [],
+		propDecorators: {
+			pageFields: [{
+				type: i0.Input,
+				args: [{
+					isSignal: true,
+					alias: "pageFields",
+					required: true
+				}]
+			}],
+			form: [{
+				type: i0.Input,
+				args: [{
+					isSignal: true,
+					alias: "form",
+					required: true
+				}]
+			}],
+			fieldSignalContext: [{
+				type: i0.Input,
+				args: [{
+					isSignal: true,
+					alias: "fieldSignalContext",
+					required: true
+				}]
+			}]
+		}
+	})
+});
+function configHasDerivations(fields) {
+	return someField(fields, (field) => {
+		if (!field.key) return false;
+		const validationField = field;
+		return !!validationField.derivation || !!validationField.logic?.some(isDerivationLogicConfig);
+	});
+}
+const DERIVATION_RENDER_GATE = new InjectionToken("DERIVATION_RENDER_GATE");
+function createDerivationRenderGate() {
+	const stateManager = inject(FormStateManager);
+	const injector = inject(Injector);
+	const pendingTasks = inject(PendingTasks);
+	const logger = inject(DynamicFormLogger$1);
+	const hasDerivations = computed(() => {
+		const setup = stateManager.formSetup();
+		return !!setup && configHasDerivations(setup.schemaFields);
+	}, ...ngDevMode ? [{ debugName: "hasDerivations" }] : /* istanbul ignore next */ []);
+	const engine = signal("idle", ...ngDevMode ? [{ debugName: "engine" }] : /* istanbul ignore next */ []);
+	explicitEffect([hasDerivations], ([has]) => {
+		if (!has || engine() !== "idle") return;
+		engine.set("loading");
+		pendingTasks.run(() => import("./ng-forge-dynamic-forms-bootstrap-derivation-orchestrator-EuYCbquo.mjs").then(({ bootstrapDerivationOrchestrator }) => {
+			runInInjectionContext(injector, () => bootstrapDerivationOrchestrator());
+			engine.set("wired");
+		}).catch((error) => {
+			engine.set("failed");
+			logger.error("Failed to load the derivation engine; derivations will not apply.", error);
+		}));
+	});
+	return computed(() => {
+		if (!hasDerivations()) return true;
+		const state = engine();
+		return state === "wired" || state === "failed";
+	});
+}
+const WEB_MCP_ENABLED = new InjectionToken("WEB_MCP_ENABLED", {
+	providedIn: "root",
+	factory: () => false
+});
+const WEB_MCP_GATE = new InjectionToken("WEB_MCP_GATE");
+function createWebMcpGate() {
+	const enabled = inject(WEB_MCP_ENABLED);
+	const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+	const stateManager = inject(FormStateManager);
+	const injector = inject(Injector);
+	const destroyRef = inject(DestroyRef);
+	const logger = inject(DynamicFormLogger$1);
+	if (!enabled || !isBrowser) return computed(() => "disabled");
+	const registration = computed(() => {
+		const options = stateManager.effectiveFormOptions().webMcp;
+		return options ? {
+			options,
+			setup: stateManager.formSetup()
+		} : void 0;
+	}, ...ngDevMode ? [{ debugName: "registration" }] : /* istanbul ignore next */ []);
+	const status = signal("idle", ...ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []);
+	let epoch;
+	let epochId = 0;
+	const closeEpoch = () => {
+		epoch?.abort();
+		epoch = void 0;
+	};
+	destroyRef.onDestroy(closeEpoch);
+	explicitEffect([registration], ([input]) => {
+		closeEpoch();
+		epochId += 1;
+		const thisEpoch = epochId;
+		if (!input) {
+			status.set("idle");
+			return;
+		}
+		const controller = new AbortController();
+		epoch = controller;
+		status.set("registering");
+		import("./ng-forge-dynamic-forms-bootstrap-web-mcp-2wQK_wPp.mjs").then(({ bootstrapWebMcp }) => {
+			if (thisEpoch !== epochId || controller.signal.aborted) return;
+			return runInInjectionContext(injector, () => bootstrapWebMcp(input.options, controller.signal));
+		}).then((result) => {
+			if (thisEpoch !== epochId || controller.signal.aborted) return;
+			if (result) status.set(result);
+		}).catch((error) => {
+			if (thisEpoch !== epochId) return;
+			status.set("failed");
+			logger.error("Failed to load the WebMCP registrar; this form will not be exposed to agents.", error);
+		});
+	});
+	return status.asReadonly();
+}
+const FORM_INITIALIZER = new InjectionToken("FORM_INITIALIZER");
+const AUTO_ID_PREFIX = "df-";
+var DynamicFormInstanceRegistry = class DynamicFormInstanceRegistry {
+	slots = /* @__PURE__ */ new Map();
+	_membership = signal(0, ...ngDevMode ? [{ debugName: "_membership" }] : /* istanbul ignore next */ []);
+	multiplePresent = computed(() => {
+		this._membership();
+		let visible = 0;
+		for (const isVisible of this.slots.values()) if (isVisible()) {
+			visible += 1;
+			if (visible > 1) return true;
+		}
+		return false;
+	}, ...ngDevMode ? [{ debugName: "multiplePresent" }] : /* istanbul ignore next */ []);
+	register(visible) {
+		let slot = 1;
+		while (this.slots.has(slot)) slot++;
+		this.slots.set(slot, visible);
+		this._membership.update((m) => m + 1);
+		return `${AUTO_ID_PREFIX}${slot}`;
+	}
+	unregister(id) {
+		this.slots.delete(Number(id.slice(3)));
+		this._membership.update((m) => m + 1);
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DynamicFormInstanceRegistry,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DynamicFormInstanceRegistry,
+		providedIn: "root"
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: DynamicFormInstanceRegistry,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const INVALID_ID_CHARS = /[^\w-]+/g;
+function sanitizeIdPrefix(prefix) {
+	return prefix.replace(INVALID_ID_CHARS, "_");
+}
+function isRendered(host) {
+	if (!host.isConnected) return false;
+	if (typeof host.checkVisibility === "function") return host.checkVisibility();
+	const rect = host.getBoundingClientRect();
+	return rect.width > 0 || rect.height > 0;
+}
+var FormIdPrefixService = class FormIdPrefixService {
+	registry = inject(DynamicFormInstanceRegistry);
+	options = inject(FORM_OPTIONS, { optional: true });
+	logger = inject(DynamicFormLogger$1, { optional: true });
+	host = inject(ElementRef).nativeElement;
+	visible = signal(true, ...ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []);
+	autoId = this.registry.register(this.visible);
+	rawPrefix = computed(() => this.options?.()?.idPrefix?.trim() || void 0, ...ngDevMode ? [{ debugName: "rawPrefix" }] : /* istanbul ignore next */ []);
+	prefix = computed(() => {
+		const explicit = this.rawPrefix();
+		if (explicit) return sanitizeIdPrefix(explicit);
+		return this.registry.multiplePresent() ? this.autoId : "";
+	}, ...ngDevMode ? [{ debugName: "prefix" }] : /* istanbul ignore next */ []);
+	constructor() {
+		const destroyRef = inject(DestroyRef);
+		destroyRef.onDestroy(() => this.registry.unregister(this.autoId));
+		if (isPlatformBrowser(inject(PLATFORM_ID)) && typeof ResizeObserver !== "undefined") {
+			const ro = new ResizeObserver(() => this.visible.set(isRendered(this.host)));
+			ro.observe(this.host);
+			destroyRef.onDestroy(() => ro.disconnect());
+		}
+		if (isDevMode()) explicitEffect([this.rawPrefix], ([raw]) => {
+			const safe = raw ? sanitizeIdPrefix(raw) : raw;
+			if (raw && safe !== raw) this.logger?.warn(`idPrefix "${raw}" sanitized to "${safe}".`);
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: FormIdPrefixService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: FormIdPrefixService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: FormIdPrefixService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+function coreProviders() {
+	return [
+		EventBus,
+		{
+			provide: CONTAINER_FIELD_PROCESSORS,
+			useFactory: createContainerFieldProcessors
+		},
+		SchemaRegistryService,
+		FunctionRegistryService,
+		{
+			provide: FORM_STATE_DEPS,
+			useFactory: () => ({
+				config: null,
+				formOptions: null,
+				value: null,
+				source: null
+			})
+		},
+		FormStateManager,
+		{
+			provide: RootFormRegistryService,
+			useFactory: (stateManager) => new RootFormRegistryService(stateManager.formValue, computed(() => stateManager.form())),
+			deps: [FormStateManager]
+		},
+		FieldContextRegistryService,
+		ArrayItemRegistryService,
+		{
+			provide: DEFAULT_PROPS,
+			useFactory: (stateManager) => computed(() => stateManager.activeConfig()?.defaultProps),
+			deps: [FormStateManager]
+		},
+		{
+			provide: DEFAULT_WRAPPERS,
+			useFactory: (stateManager) => computed(() => stateManager.activeConfig()?.defaultWrappers),
+			deps: [FormStateManager]
+		},
+		{
+			provide: DEFAULT_VALIDATION_MESSAGES,
+			useFactory: (stateManager) => computed(() => stateManager.activeConfig()?.defaultValidationMessages),
+			deps: [FormStateManager]
+		},
+		{
+			provide: FORM_OPTIONS,
+			useFactory: (stateManager) => stateManager.effectiveFormOptions,
+			deps: [FormStateManager]
+		},
+		{
+			provide: EXTERNAL_DATA,
+			useFactory: (stateManager) => computed(() => stateManager.activeConfig()?.externalData),
+			deps: [FormStateManager]
+		},
+		FormIdPrefixService,
+		FieldViewportObserver,
+		{
+			provide: FORM_ID_PREFIX,
+			useFactory: (svc) => svc.prefix,
+			deps: [FormIdPrefixService]
+		},
+		{
+			provide: DEPRECATION_WARNING_TRACKER,
+			useFactory: createWarningTracker
+		},
+		{
+			provide: ADDON_ACTION_REGISTRY,
+			useFactory: createAddonActionRegistry
+		}
+	];
+}
+function derivationProviders() {
+	return [{
+		provide: DERIVATION_WARNING_TRACKER,
+		useFactory: createWarningTracker
+	}, {
+		provide: DERIVATION_RENDER_GATE,
+		useFactory: createDerivationRenderGate
+	}];
+}
+function propertyDerivationProviders() {
+	return [{
+		provide: PROPERTY_OVERRIDE_STORE,
+		useFactory: createPropertyOverrideStore
+	}];
+}
+function httpExpressionProviders() {
+	return [{
+		provide: HTTP_CONDITION_CACHE,
+		useFactory: () => new HttpConditionCache(100)
+	}, HttpConditionFunctionCacheService];
+}
+function asyncExpressionProviders() {
+	return [AsyncConditionFunctionCacheService];
+}
+function dynamicValueProviders() {
+	return [DynamicValueFunctionCacheService];
+}
+function logicProviders() {
+	return [LogicFunctionCacheService];
+}
+function provideDynamicFormDI() {
+	return [
+		...coreProviders(),
+		...logicProviders(),
+		...dynamicValueProviders(),
+		...httpExpressionProviders(),
+		...asyncExpressionProviders(),
+		...propertyDerivationProviders(),
+		...derivationProviders(),
+		{
+			provide: WEB_MCP_GATE,
+			useFactory: createWebMcpGate
+		}
+	];
+}
+var EventDispatcher = class EventDispatcher {
+	bus;
+	dispatch(event) {
+		this.bus?.emitInstance(event);
+	}
+	connect(bus) {
+		this.bus = bus;
+	}
+	disconnect() {
+		this.bus = void 0;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: EventDispatcher,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: EventDispatcher
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: EventDispatcher,
+	decorators: [{ type: Injectable }]
+});
+var DfTemplate = class DfTemplate {
+	dfTemplate = input.required(...ngDevMode ? [{ debugName: "dfTemplate" }] : /* istanbul ignore next */ []);
+	templateRef = inject(TemplateRef);
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DfTemplate,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Directive
+	});
+	static ɵdir = i0.ɵɵngDeclareDirective({
+		minVersion: "17.1.0",
+		version: "22.2.5",
+		type: DfTemplate,
+		isStandalone: true,
+		selector: "ng-template[dfTemplate]",
+		inputs: { dfTemplate: {
+			classPropertyName: "dfTemplate",
+			publicName: "dfTemplate",
+			isSignal: true,
+			isRequired: true,
+			transformFunction: null
+		} },
+		exportAs: ["dfTemplate"],
+		ngImport: i0
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: DfTemplate,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "ng-template[dfTemplate]",
+			exportAs: "dfTemplate"
+		}]
+	}],
+	propDecorators: { dfTemplate: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "dfTemplate",
+			required: true
+		}]
+	}] }
+});
+var DfFieldTemplateRegistry = class DfFieldTemplateRegistry {
+	_map = signal(/* @__PURE__ */ new Map(), ...ngDevMode ? [{ debugName: "_map" }] : /* istanbul ignore next */ []);
+	map = this._map.asReadonly();
+	set(value) {
+		this._map.set(value);
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DfFieldTemplateRegistry,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DfFieldTemplateRegistry
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: DfFieldTemplateRegistry,
+	decorators: [{ type: Injectable }]
+});
+var DynamicForm = class DynamicForm {
+	config = input.required({
+		...ngDevMode ? { debugName: "config" } : /* istanbul ignore next */ {},
+		alias: "dynamic-form"
+	});
+	formOptions = input(void 0, ...ngDevMode ? [{ debugName: "formOptions" }] : /* istanbul ignore next */ []);
+	value = model(void 0, ...ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []);
+	source = input("inline", ...ngDevMode ? [{ debugName: "source" }] : /* istanbul ignore next */ []);
+	destroyRef = inject(DestroyRef);
+	injector = inject(Injector);
+	environmentInjector = inject(EnvironmentInjector);
+	eventBus = inject(EventBus);
+	logger = inject(DynamicFormLogger$1);
+	dispatcher = inject(EventDispatcher, { optional: true });
+	templateRegistry = inject(DfFieldTemplateRegistry);
+	globalFieldWindowing = inject(FIELD_WINDOWING);
+	_projectedTemplates = contentChildren(DfTemplate, ...ngDevMode ? [{ debugName: "_projectedTemplates" }] : /* istanbul ignore next */ []);
+	stateManager = this.connectDeps();
+	formIdPrefix = inject(FormIdPrefixService);
+	idPrefix = this.formIdPrefix.prefix;
+	componentId = "dynamic-form";
+	activeConfig = this.stateManager.activeConfig;
+	renderPhase = this.stateManager.renderPhase;
+	formModeDetection = this.stateManager.formModeDetection;
+	pageFieldDefinitions = this.stateManager.pageFieldDefinitions;
+	effectiveFormOptions = this.stateManager.effectiveFormOptions;
+	fieldSignalContext = this.stateManager.fieldSignalContext;
+	defaultValues = this.stateManager.defaultValues;
+	form = this.stateManager.form;
+	formValue = this.stateManager.formValue;
+	valid = this.stateManager.valid;
+	invalid = this.stateManager.invalid;
+	dirty = this.stateManager.dirty;
+	touched = this.stateManager.touched;
+	errors = this.stateManager.errors;
+	disabled = this.stateManager.disabled;
+	submitting = this.stateManager.submitting;
+	fieldLoadingErrors = this.stateManager.fieldLoadingErrors;
+	derivationReady = inject(DERIVATION_RENDER_GATE);
+	shouldRender = computed(() => this.stateManager.shouldRender() && this.stateManager.formSchemaReady() && this.derivationReady(), ...ngDevMode ? [{ debugName: "shouldRender" }] : /* istanbul ignore next */ []);
+	webMcpStatus = inject(WEB_MCP_GATE);
+	resolvedFields = this.stateManager.resolvedFields;
+	fieldWindowing = computed(() => resolveFieldWindowing(this.globalFieldWindowing, this.effectiveFormOptions()?.fieldWindowing), ...ngDevMode ? [{ debugName: "fieldWindowing" }] : /* istanbul ignore next */ []);
+	initializedComponents = signal(/* @__PURE__ */ new Set(), ...ngDevMode ? [{ debugName: "initializedComponents" }] : /* istanbul ignore next */ []);
+	initialPageReady = signal(false, ...ngDevMode ? [{ debugName: "initialPageReady" }] : /* istanbul ignore next */ []);
+	initializationReady = computed(() => {
+		const config = this.activeConfig();
+		if (!config) return false;
+		if (this.formModeDetection().mode === "paged") return this.initialPageReady();
+		const initialized = this.initializedComponents();
+		return [initializationComponentKey("dynamic-form", this.componentId), ...collectInitializingContainerKeys(config.fields ?? [])].every((key) => initialized.has(key));
+	}, ...ngDevMode ? [{ debugName: "initializationReady" }] : /* istanbul ignore next */ []);
+	initialized$ = toObservable(this.initializationReady, { injector: this.injector }).pipe(filter((ready) => ready), take(1), shareReplay({
+		bufferSize: 1,
+		refCount: false
+	}));
+	validityChange = outputFromObservable(toObservable(this.valid));
+	dirtyChange = outputFromObservable(toObservable(this.dirty));
+	submitted = outputFromObservable(this.stateManager.submitted$);
+	reset = outputFromObservable(this.eventBus.on("form-reset"));
+	cleared = outputFromObservable(this.eventBus.on("form-clear"));
+	events = outputFromObservable(this.eventBus.events$);
+	initialized = outputFromObservable(this.initialized$);
+	activePageInitialized = outputFromObservable(this.eventBus.on("active-page-initialized"));
+	onPageChange = outputFromObservable(this.eventBus.on("page-change"));
+	onPageNavigationStateChange = outputFromObservable(this.eventBus.on("pager-state"));
+	constructor() {
+		this.eventBus.on("component-initialized").pipe(takeUntilDestroyed(this.destroyRef)).subscribe((event) => {
+			const key = initializationComponentKey(event.componentType, event.componentId);
+			this.initializedComponents.update((current) => {
+				if (current.has(key)) return current;
+				const next = new Set(current);
+				next.add(key);
+				return next;
+			});
+		});
+		this.eventBus.on("active-page-initialized").pipe(takeUntilDestroyed(this.destroyRef), take(1)).subscribe(() => this.initialPageReady.set(true));
+		this.dispatcher?.connect(this.eventBus);
+		this.destroyRef.onDestroy(() => this.dispatcher?.disconnect());
+		inject(FORM_INITIALIZER, { optional: true });
+		const preload = injectFormComponentPreloader();
+		explicitEffect([this.config], ([config]) => preload.preloadConfig(config));
+		this.setupEffects();
+		this.setupEventHandlers();
+	}
+	onNativeSubmit(event) {
+		event.preventDefault();
+		this.eventBus.dispatch(FormSubmitEvent);
+	}
+	windowsField(field, index) {
+		const w = this.fieldWindowing();
+		return w.enabled && index >= w.eager && !isContainerField$1(field.fieldDef);
+	}
+	placeholderGridClass(field) {
+		const grid = getGridClassString(field.fieldDef);
+		return grid ? `df-field-placeholder ${grid}` : "df-field-placeholder";
+	}
+	setupEffects() {
+		explicitEffect([this.formModeDetection, this.pageFieldDefinitions], ([{ mode }, pages]) => {
+			if (mode === "paged" && pages.length > 0) this.eventBus.dispatch(ComponentInitializedEvent, "dynamic-form", this.componentId);
+		});
+		explicitEffect([
+			this.resolvedFields,
+			this.formModeDetection,
+			this.activeConfig
+		], ([, { mode }, config]) => {
+			if (config && mode === "non-paged") afterNextRender(() => {
+				this.eventBus.dispatch(ComponentInitializedEvent, "dynamic-form", this.componentId);
+			}, { injector: this.injector });
+		});
+		explicitEffect([this._projectedTemplates], ([templates]) => {
+			const map = /* @__PURE__ */ new Map();
+			for (const t of templates) map.set(t.dfTemplate(), t.templateRef);
+			this.templateRegistry.set(map);
+		});
+	}
+	connectDeps() {
+		const deps = inject(FORM_STATE_DEPS);
+		deps.config = this.config;
+		deps.formOptions = this.formOptions;
+		deps.value = this.value;
+		deps.source = this.source;
+		return inject(FormStateManager);
+	}
+	setupEventHandlers() {
+		createSubmissionHandler({
+			eventBus: this.eventBus,
+			configSignal: this.config,
+			formSignal: this.form,
+			validSignal: this.valid,
+			logger: this.logger
+		}).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({ error: (err) => this.logger.error("Submission handler error", err) });
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: DynamicForm,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.5",
+		type: DynamicForm,
+		isStandalone: true,
+		selector: "form[dynamic-form]",
+		inputs: {
+			config: {
+				classPropertyName: "config",
+				publicName: "dynamic-form",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			formOptions: {
+				classPropertyName: "formOptions",
+				publicName: "formOptions",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			value: {
+				classPropertyName: "value",
+				publicName: "value",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			},
+			source: {
+				classPropertyName: "source",
+				publicName: "source",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		outputs: {
+			value: "valueChange",
+			validityChange: "validityChange",
+			dirtyChange: "dirtyChange",
+			submitted: "submitted",
+			reset: "reset",
+			cleared: "cleared",
+			events: "events",
+			initialized: "initialized",
+			activePageInitialized: "activePageInitialized",
+			onPageChange: "onPageChange",
+			onPageNavigationStateChange: "onPageNavigationStateChange"
+		},
+		host: {
+			attributes: { "novalidate": "" },
+			listeners: { "submit": "onNativeSubmit($event)" },
+			properties: {
+				"class.disabled": "disabled()",
+				"class.df-form-paged": "formModeDetection().mode === \"paged\"",
+				"class.df-form-non-paged": "formModeDetection().mode === \"non-paged\"",
+				"attr.data-form-mode": "formModeDetection().mode",
+				"attr.id": "idPrefix() || null"
+			},
+			classAttribute: "df-dynamic-form df-form"
+		},
+		providers: [
+			provideDynamicFormDI(),
+			DfFieldTemplateRegistry,
+			{
+				provide: DF_FIELD_TEMPLATES$1,
+				useFactory: () => inject(DfFieldTemplateRegistry).map
+			}
+		],
+		queries: [{
+			propertyName: "_projectedTemplates",
+			predicate: DfTemplate,
+			isSignal: true
+		}],
+		ngImport: i0,
+		template: `
+    @if (shouldRender()) {
+      @switch (formModeDetection().mode) {
+        @case ('paged') {
+          <div page-orchestrator [pageFields]="pageFieldDefinitions()" [form]="form()" [fieldSignalContext]="fieldSignalContext()"></div>
+        }
+        @case ('non-paged') {
+          @for (field of resolvedFields(); track field.key; let i = $index) {
+            @if (windowsField(field, i)) {
+              @if (!field.hidden()) {
+                @defer (on viewport) {
+                  <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+                } @placeholder {
+                  <div
+                    [class]="placeholderGridClass(field)"
+                    [style.min-height]="fieldWindowing().placeholderHeight"
+                    [attr.data-field-key]="field.key"
+                    aria-hidden="true"
+                  ></div>
+                }
+              }
+            } @else {
+              <!-- DfFieldOutlet owns the hidden gate so an already-mounted field can be detached
+                   and restored without recreating its component and wrapper chain. -->
+              <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            }
+          }
+        }
+        @default {
+          never;
+        }
+      }
+    }
+  `,
+		isInline: true,
+		styles: [".df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap, .5rem);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-sm, .5rem)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns, 12),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-md, .5rem)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-lg, .5rem)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-xl, .5rem)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--df-form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{gap:0}.df-field-placeholder{display:block}\n"],
+		dependencies: [{
+			kind: "directive",
+			type: DfFieldOutlet,
+			selector: "[dfFieldOutlet]",
+			inputs: ["dfFieldOutlet", "dfFieldOutletEnvironmentInjector"]
+		}, {
+			kind: "component",
+			type: PageOrchestratorComponent,
+			selector: "div[page-orchestrator]",
+			inputs: [
+				"pageFields",
+				"form",
+				"fieldSignalContext"
+			]
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush,
+		deferBlockDependencies: [() => [DfFieldOutlet]]
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: DynamicForm,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "form[dynamic-form]",
+			imports: [DfFieldOutlet, PageOrchestratorComponent],
+			template: `
+    @if (shouldRender()) {
+      @switch (formModeDetection().mode) {
+        @case ('paged') {
+          <div page-orchestrator [pageFields]="pageFieldDefinitions()" [form]="form()" [fieldSignalContext]="fieldSignalContext()"></div>
+        }
+        @case ('non-paged') {
+          @for (field of resolvedFields(); track field.key; let i = $index) {
+            @if (windowsField(field, i)) {
+              @if (!field.hidden()) {
+                @defer (on viewport) {
+                  <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+                } @placeholder {
+                  <div
+                    [class]="placeholderGridClass(field)"
+                    [style.min-height]="fieldWindowing().placeholderHeight"
+                    [attr.data-field-key]="field.key"
+                    aria-hidden="true"
+                  ></div>
+                }
+              }
+            } @else {
+              <!-- DfFieldOutlet owns the hidden gate so an already-mounted field can be detached
+                   and restored without recreating its component and wrapper chain. -->
+              <ng-container *dfFieldOutlet="field; environmentInjector: environmentInjector" />
+            }
+          }
+        }
+        @default {
+          never;
+        }
+      }
+    }
+  `,
+			providers: [
+				provideDynamicFormDI(),
+				DfFieldTemplateRegistry,
+				{
+					provide: DF_FIELD_TEMPLATES$1,
+					useFactory: () => inject(DfFieldTemplateRegistry).map
+				}
+			],
+			host: {
+				class: "df-dynamic-form df-form",
+				novalidate: "",
+				"[class.disabled]": "disabled()",
+				"[class.df-form-paged]": "formModeDetection().mode === \"paged\"",
+				"[class.df-form-non-paged]": "formModeDetection().mode === \"non-paged\"",
+				"[attr.data-form-mode]": "formModeDetection().mode",
+				"[attr.id]": "idPrefix() || null",
+				"(submit)": "onNativeSubmit($event)"
+			},
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			styles: [".df-form{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}.df-form>*{grid-column:1/-1}.df-row{display:grid;grid-template-columns:repeat(var(--df-grid-columns, 12),1fr);gap:var(--df-grid-gap, .5rem);align-items:start;width:100%}.df-row>*:not([class*=df-col-]){grid-column:1/-1}.df-col-1{grid-column:span 1}.df-col-2{grid-column:span 2}.df-col-3{grid-column:span 3}.df-col-4{grid-column:span 4}.df-col-5{grid-column:span 5}.df-col-6{grid-column:span 6}.df-col-7{grid-column:span 7}.df-col-8{grid-column:span 8}.df-col-9{grid-column:span 9}.df-col-10{grid-column:span 10}.df-col-11{grid-column:span 11}.df-col-12{grid-column:span 12}.df-col-auto{grid-column:span auto;width:auto}.df-col-full{grid-column:1/-1}.df-col-start-1{grid-column-start:1}.df-col-start-2{grid-column-start:2}.df-col-start-3{grid-column-start:3}.df-col-start-4{grid-column-start:4}.df-col-start-5{grid-column-start:5}.df-col-start-6{grid-column-start:6}.df-col-start-7{grid-column-start:7}.df-col-start-8{grid-column-start:8}.df-col-start-9{grid-column-start:9}.df-col-start-10{grid-column-start:10}.df-col-start-11{grid-column-start:11}.df-col-start-12{grid-column-start:12}.df-col-end-1{grid-column-end:1}.df-col-end-2{grid-column-end:2}.df-col-end-3{grid-column-end:3}.df-col-end-4{grid-column-end:4}.df-col-end-5{grid-column-end:5}.df-col-end-6{grid-column-end:6}.df-col-end-7{grid-column-end:7}.df-col-end-8{grid-column-end:8}.df-col-end-9{grid-column-end:9}.df-col-end-10{grid-column-end:10}.df-col-end-11{grid-column-end:11}.df-col-end-12{grid-column-end:12}.df-col-end-13{grid-column-end:13}@media(max-width:576px){.df-form{--df-grid-gap: var(--df-grid-gap-sm, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-sm, .5rem)}.df-row{grid-template-columns:1fr}.df-row>*{grid-column:1/-1!important}.df-row.df-row-mobile-keep-cols{grid-template-columns:repeat(var(--df-grid-columns, 12),1fr)}.df-row.df-row-mobile-keep-cols>*{grid-column:revert!important}}@media(min-width:577px)and (max-width:768px){.df-form{--df-grid-gap: var(--df-grid-gap-md, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-md, .5rem)}.df-row{--df-grid-columns: 6}.df-col-sm-1{grid-column:span 1}.df-col-sm-2{grid-column:span 2}.df-col-sm-3{grid-column:span 3}.df-col-sm-4{grid-column:span 4}.df-col-sm-5{grid-column:span 5}.df-col-sm-6{grid-column:span 6}.df-col-sm-full{grid-column:1/-1}}@media(min-width:769px)and (max-width:992px){.df-form{--df-grid-gap: var(--df-grid-gap-lg, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-lg, .5rem)}.df-col-md-1{grid-column:span 1}.df-col-md-2{grid-column:span 2}.df-col-md-3{grid-column:span 3}.df-col-md-4{grid-column:span 4}.df-col-md-5{grid-column:span 5}.df-col-md-6{grid-column:span 6}.df-col-md-7{grid-column:span 7}.df-col-md-8{grid-column:span 8}.df-col-md-9{grid-column:span 9}.df-col-md-10{grid-column:span 10}.df-col-md-11{grid-column:span 11}.df-col-md-12{grid-column:span 12}.df-col-md-full{grid-column:1/-1}}@media(min-width:993px){.df-form{--df-grid-gap: var(--df-grid-gap-xl, .5rem);--df-grid-row-gap: var(--df-grid-row-gap-xl, .5rem)}.df-col-lg-1{grid-column:span 1}.df-col-lg-2{grid-column:span 2}.df-col-lg-3{grid-column:span 3}.df-col-lg-4{grid-column:span 4}.df-col-lg-5{grid-column:span 5}.df-col-lg-6{grid-column:span 6}.df-col-lg-7{grid-column:span 7}.df-col-lg-8{grid-column:span 8}.df-col-lg-9{grid-column:span 9}.df-col-lg-10{grid-column:span 10}.df-col-lg-11{grid-column:span 11}.df-col-lg-12{grid-column:span 12}.df-col-lg-full{grid-column:1/-1}}.df-gap-none{--df-grid-gap: 0}.df-gap-xs{--df-grid-gap: .25rem}.df-gap-sm{--df-grid-gap: .5rem}.df-gap-md{--df-grid-gap: 1rem}.df-gap-lg{--df-grid-gap: 1.5rem}.df-gap-xl{--df-grid-gap: 2rem}.df-row-gap-none{--df-grid-row-gap: 0}.df-row-gap-xs{--df-grid-row-gap: .25rem}.df-row-gap-sm{--df-grid-row-gap: .5rem}.df-row-gap-md{--df-grid-row-gap: 1rem}.df-row-gap-lg{--df-grid-row-gap: 1.5rem}.df-row-gap-xl{--df-grid-row-gap: 2rem}.df-field{display:block;width:100%;min-width:0;overflow:hidden;margin:0}.df-group,.df-page{display:block;width:100%}.df-form.disabled,.df-row.disabled,.df-field.disabled{opacity:.6;pointer-events:none}.df-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-sr-only-focusable:focus,.df-sr-only-focusable:active{position:static;width:auto;height:auto;padding:inherit;margin:inherit;overflow:visible;clip:auto;white-space:normal}.df-live-region{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.df-form :focus-visible{outline:2px solid var(--df-focus-color, #005fcc);outline-offset:2px}.df-group:focus-within{outline:1px dashed var(--df-focus-color, #005fcc);outline-offset:4px}:host{display:grid;grid-template-columns:1fr;gap:var(--df-grid-row-gap, .5rem);width:100%}:host>*{grid-column:1/-1}:host.df-form-spacing-custom{--df-grid-row-gap: var(--df-form-custom-spacing, 1.5rem)}:host.df-form-gap-none{--df-grid-row-gap: 0}:host.df-form-gap-xs{--df-grid-row-gap: .25rem}:host.df-form-gap-sm{--df-grid-row-gap: .5rem}:host.df-form-gap-md{--df-grid-row-gap: 1rem}:host.df-form-gap-lg{--df-grid-row-gap: 1.5rem}:host.df-form-gap-xl{--df-grid-row-gap: 2rem}:host.df-form-paged{gap:0}.df-field-placeholder{display:block}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		config: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "dynamic-form",
+				required: true
+			}]
+		}],
+		formOptions: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "formOptions",
+				required: false
+			}]
+		}],
+		value: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "value",
+				required: false
+			}]
+		}, {
+			type: i0.Output,
+			args: ["valueChange"]
+		}],
+		source: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "source",
+				required: false
+			}]
+		}],
+		_projectedTemplates: [{
+			type: i0.ContentChildren,
+			args: [i0.forwardRef(() => DfTemplate), { isSignal: true }]
+		}],
+		validityChange: [{
+			type: i0.Output,
+			args: ["validityChange"]
+		}],
+		dirtyChange: [{
+			type: i0.Output,
+			args: ["dirtyChange"]
+		}],
+		submitted: [{
+			type: i0.Output,
+			args: ["submitted"]
+		}],
+		reset: [{
+			type: i0.Output,
+			args: ["reset"]
+		}],
+		cleared: [{
+			type: i0.Output,
+			args: ["cleared"]
+		}],
+		events: [{
+			type: i0.Output,
+			args: ["events"]
+		}],
+		initialized: [{
+			type: i0.Output,
+			args: ["initialized"]
+		}],
+		activePageInitialized: [{
+			type: i0.Output,
+			args: ["activePageInitialized"]
+		}],
+		onPageChange: [{
+			type: i0.Output,
+			args: ["onPageChange"]
+		}],
+		onPageNavigationStateChange: [{
+			type: i0.Output,
+			args: ["onPageNavigationStateChange"]
+		}]
+	}
+});
+const BUILT_IN_ADDON_TYPES = [
+	{
+		type: "text",
+		loadComponent: () => Promise.resolve().then(() => text_addon_component_exports).then((m) => m.TextAddonComponent),
+		validate: (addon, fieldKey) => {
+			const text = addon.text;
+			if (text === void 0 || text === null) throw new DynamicFormError$1(`Addon type 'text' requires a 'text' field (field: '${fieldKey}').`);
+			if (typeof text === "string" && text.length === 0) throw new DynamicFormError$1(`Addon type 'text' requires a non-empty 'text' string (field: '${fieldKey}').`);
+		}
+	},
+	{
+		type: "template",
+		loadComponent: () => Promise.resolve().then(() => template_addon_component_exports).then((m) => m.TemplateAddonComponent),
+		validate: (addon, fieldKey) => {
+			const key = addon.templateKey;
+			if (typeof key !== "string" || key.length === 0) throw new DynamicFormError$1(`Addon type 'template' requires a non-empty 'templateKey' string (field: '${fieldKey}').`);
+		}
+	},
+	{
+		type: "component",
+		jsonSafe: false,
+		loadComponent: () => Promise.resolve().then(() => component_addon_component_exports).then((m) => m.ComponentAddonComponent),
+		validate: (addon, fieldKey) => {
+			if (typeof addon.component !== "function") throw new DynamicFormError$1(`Addon type 'component' requires a 'component' loader function (field: '${fieldKey}').`);
+		}
+	}
+];
+const CONTAINER_FIELD_TYPES_BASE = { renderReadyWhen: ["field"] };
+const DISPLAY_FIELD_TYPES_BASE = { renderReadyWhen: [] };
+const BUILT_IN_FIELDS = [
+	{
+		name: "row",
+		loadComponent: () => import("./ng-forge-dynamic-forms-container-field.component-Bg7Win9n.mjs"),
+		mapper: rowFieldMapper,
+		valueHandling: "flatten",
+		...CONTAINER_FIELD_TYPES_BASE
+	},
+	{
+		name: "group",
+		loadComponent: () => import("./ng-forge-dynamic-forms-group-field.component-BjZi0bhq.mjs"),
+		mapper: groupFieldMapper,
+		valueHandling: "include",
+		...CONTAINER_FIELD_TYPES_BASE
+	},
+	{
+		name: "array",
+		loadComponent: () => import("./ng-forge-dynamic-forms-array-field.component-Dv9mPnJ3.mjs"),
+		mapper: arrayFieldMapper,
+		valueHandling: "include",
+		...CONTAINER_FIELD_TYPES_BASE
+	},
+	{
+		name: "page",
+		loadComponent: () => import("./ng-forge-dynamic-forms-page-field.component-BRjQmWC9.mjs"),
+		mapper: pageFieldMapper,
+		valueHandling: "flatten",
+		...CONTAINER_FIELD_TYPES_BASE
+	},
+	{
+		name: "text",
+		loadComponent: () => import("./ng-forge-dynamic-forms-text-field.component--MAh_h4Q.mjs"),
+		mapper: textFieldMapper,
+		valueHandling: "exclude",
+		...DISPLAY_FIELD_TYPES_BASE
+	},
+	{
+		name: "hidden",
+		valueHandling: "include"
+	},
+	{
+		name: "container",
+		loadComponent: () => import("./ng-forge-dynamic-forms-container-field.component-Bg7Win9n.mjs"),
+		mapper: containerFieldMapper,
+		valueHandling: "flatten",
+		...CONTAINER_FIELD_TYPES_BASE
+	}
+];
+const BUILT_IN_WRAPPERS = [
+	{
+		wrapperName: "css",
+		loadComponent: () => import("./ng-forge-dynamic-forms-css-wrapper.component-R2yc-H0T.mjs")
+	},
+	{
+		wrapperName: "row",
+		loadComponent: () => import("./ng-forge-dynamic-forms-row-wrapper.component-CuFycQb-.mjs")
+	},
+	{
+		wrapperName: "field-errors",
+		loadComponent: () => import("./ng-forge-dynamic-forms-field-errors-wrapper.component-DKgkpIpG.mjs"),
+		rendersFieldErrors: true
+	}
+];
+function createWrappers(...registrations) {
+	return {
+		ɵkind: "wrappers",
+		ɵregistrations: registrations,
+		ɵdefinitions: registrations.map(({ wrapperName, loadComponent, types }) => ({
+			wrapperName,
+			loadComponent,
+			types
+		}))
+	};
+}
+function isWrappersBundle(value) {
+	return typeof value === "object" && value !== null && "ɵkind" in value && value.ɵkind === "wrappers" && "ɵdefinitions" in value && Array.isArray(value.ɵdefinitions);
+}
+function provideDynamicForm(...items) {
+	const fieldTypes = items.filter((item) => !isDynamicFormFeature(item) && !isWrapperTypeDefinition$1(item) && !isWrappersBundle(item));
+	const wrapperTypes = items.filter(isWrapperTypeDefinition$1);
+	const wrapperBundles = items.filter(isWrappersBundle);
+	const features = items.filter(isDynamicFormFeature);
+	const fields = [...BUILT_IN_FIELDS, ...fieldTypes];
+	const customWrappers = [...wrapperTypes, ...wrapperBundles.flatMap((bundle) => bundle.ɵdefinitions)];
+	const wrappers = [...BUILT_IN_WRAPPERS, ...customWrappers];
+	const featureProviders = [];
+	const hasLoggerFeature = features.some((feature) => feature.ɵkind === "logger");
+	features.forEach((feature) => {
+		featureProviders.push(...feature.ɵproviders);
+	});
+	const defaultLoggerProvider = hasLoggerFeature ? [] : [{
+		provide: DynamicFormLogger$1,
+		useValue: new ConsoleLogger()
+	}];
+	return makeEnvironmentProviders([
+		...defaultLoggerProvider,
+		{
+			provide: FIELD_REGISTRY,
+			useFactory: () => {
+				const logger = inject(DynamicFormLogger$1);
+				const registry = /* @__PURE__ */ new Map();
+				fields.forEach((fieldType) => {
+					if (DEV_MODE && registry.has(fieldType.name)) logger.warn(`Field type "${fieldType.name}" is already registered. Overwriting.`);
+					registry.set(fieldType.name, fieldType);
+				});
+				for (const [legacy, canonical] of Object.entries({
+					addArrayItem: "add-array-item",
+					prependArrayItem: "prepend-array-item",
+					insertArrayItem: "insert-array-item",
+					removeArrayItem: "remove-array-item",
+					popArrayItem: "pop-array-item",
+					shiftArrayItem: "shift-array-item"
+				})) {
+					const def = registry.get(canonical);
+					if (def && !registry.has(legacy)) registry.set(legacy, def);
+				}
+				return registry;
+			}
+		},
+		{
+			provide: WRAPPER_REGISTRY,
+			useFactory: () => {
+				const logger = inject(DynamicFormLogger$1);
+				const registry = /* @__PURE__ */ new Map();
+				const builtInNames = new Set(BUILT_IN_WRAPPERS.map((w) => w.wrapperName));
+				BUILT_IN_WRAPPERS.forEach((wrapperType) => registry.set(wrapperType.wrapperName, wrapperType));
+				const seenCustom = DEV_MODE ? /* @__PURE__ */ new Set() : null;
+				customWrappers.forEach((wrapperType) => {
+					const name = wrapperType.wrapperName;
+					if (seenCustom) {
+						if (seenCustom.has(name) && !builtInNames.has(name)) logger.warn(`Wrapper type "${name}" is already registered. Overwriting.`);
+						seenCustom.add(name);
+					}
+					registry.set(name, wrapperType);
+				});
+				return registry;
+			}
+		},
+		{
+			provide: WRAPPER_AUTO_ASSOCIATIONS,
+			useFactory: () => {
+				const autoMap = /* @__PURE__ */ new Map();
+				for (const wrapperType of wrappers) {
+					if (!wrapperType.types) continue;
+					for (const fieldType of wrapperType.types) {
+						const existing = autoMap.get(fieldType) ?? [];
+						existing.push({ type: wrapperType.wrapperName });
+						autoMap.set(fieldType, existing);
+					}
+				}
+				return autoMap;
+			}
+		},
+		{
+			provide: ADDON_TYPE_REGISTRY,
+			useFactory: () => {
+				const logger = inject(DynamicFormLogger$1);
+				const contributed = inject(ADDON_TYPE_DEFINITIONS, { optional: true }) ?? [];
+				const registry = /* @__PURE__ */ new Map();
+				for (const def of BUILT_IN_ADDON_TYPES) registry.set(def.type, def);
+				for (const def of contributed) {
+					if (DEV_MODE && registry.has(def.type)) logger.warn(`Addon type "${def.type}" is already registered. Overwriting.`);
+					registry.set(def.type, def);
+				}
+				return registry;
+			}
+		},
+		{
+			provide: ADDON_TYPE_COMPONENT_CACHE,
+			useFactory: () => /* @__PURE__ */ new Map()
+		},
+		...featureProviders
+	]);
+}
+function withEventFormValue() {
+	return createFeature("event-form-value", [{
+		provide: EMIT_FORM_VALUE_ON_EVENTS,
+		useValue: true
+	}]);
+}
+function withValueExclusionDefaults(config) {
+	const resolved = {
+		excludeValueIfHidden: config?.excludeValueIfHidden ?? true,
+		excludeValueIfDisabled: config?.excludeValueIfDisabled ?? true,
+		excludeValueIfReadonly: config?.excludeValueIfReadonly ?? true
+	};
+	return createFeature("value-exclusion", [{
+		provide: VALUE_EXCLUSION_DEFAULTS,
+		useValue: resolved
+	}]);
+}
+function withPagePreload(window) {
+	const resolved = clampWindowSize(window, 1);
+	return createFeature("page-preload", [{
+		provide: PAGE_PRELOAD_WINDOW,
+		useValue: resolved
+	}]);
+}
+function withFieldWindowing(config) {
+	const resolved = {
+		enabled: true,
+		eager: clampWindowSize(config?.eager, 12),
+		placeholderHeight: config?.placeholderHeight ?? "4rem",
+		park: resolveFieldParking({
+			enabled: true,
+			margin: "100%"
+		}, config?.park)
+	};
+	return createFeature("field-windowing", [{
+		provide: FIELD_WINDOWING,
+		useValue: resolved
+	}]);
+}
+function withExperimentalWebMcp() {
+	return createFeature("web-mcp", [{
+		provide: WEB_MCP_ENABLED,
+		useValue: true
+	}]);
+}
+function withValidationExecutionDefaults(config) {
+	const resolved = { validateWhenHidden: config?.validateWhenHidden ?? false };
+	return createFeature("validation-execution", [{
+		provide: VALIDATION_EXECUTION_DEFAULTS,
+		useValue: resolved
+	}]);
+}
+function withLegacyStatusClasses() {
+	return createFeature("legacy-status-classes", [...provideSignalFormsConfig({ classes: NG_STATUS_CLASSES })]);
+}
+function wrapperProps() {}
+var text_addon_component_exports = /* @__PURE__ */ __exportAll({ TextAddonComponent: () => TextAddonComponent });
+var TextAddonComponent = class TextAddonComponent {
+	addon = input.required(...ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []);
+	fieldInputs = input(...ngDevMode ? [void 0, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []);
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: TextAddonComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.1.0",
+		version: "22.2.5",
+		type: TextAddonComponent,
+		isStandalone: true,
+		selector: "df-text-addon",
+		inputs: {
+			addon: {
+				classPropertyName: "addon",
+				publicName: "addon",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			fieldInputs: {
+				classPropertyName: "fieldInputs",
+				publicName: "fieldInputs",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		host: { properties: { "attr.aria-hidden": "\"true\"" } },
+		ngImport: i0,
+		template: `<span>{{ addon().text | dynamicText | async }}</span>`,
+		isInline: true,
+		dependencies: [{
+			kind: "pipe",
+			type: AsyncPipe,
+			name: "async"
+		}, {
+			kind: "pipe",
+			type: DynamicTextPipe,
+			name: "dynamicText"
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: TextAddonComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "df-text-addon",
+			imports: [AsyncPipe, DynamicTextPipe],
+			template: `<span>{{ addon().text | dynamicText | async }}</span>`,
+			host: { "[attr.aria-hidden]": "\"true\"" },
+			changeDetection: ChangeDetectionStrategy.OnPush
+		}]
+	}],
+	propDecorators: {
+		addon: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "addon",
+				required: true
+			}]
+		}],
+		fieldInputs: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "fieldInputs",
+				required: false
+			}]
+		}]
+	}
+});
+var template_addon_component_exports = /* @__PURE__ */ __exportAll({ TemplateAddonComponent: () => TemplateAddonComponent });
+var TemplateAddonComponent = class TemplateAddonComponent {
+	templates = inject(DF_FIELD_TEMPLATES$1, { optional: true });
+	logger = inject(DynamicFormLogger$1);
+	addon = input.required(...ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []);
+	fieldInputs = input(...ngDevMode ? [void 0, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []);
+	template = computed(() => {
+		const map = this.templates?.();
+		const key = this.addon().templateKey;
+		return map?.get(key) ?? null;
+	}, ...ngDevMode ? [{ debugName: "template" }] : /* istanbul ignore next */ []);
+	outletContext = computed(() => ({ $implicit: this.fieldInputs() }), ...ngDevMode ? [{ debugName: "outletContext" }] : /* istanbul ignore next */ []);
+	constructor() {
+		explicitEffect([this.template, this.addon], ([tpl, addon]) => {
+			if (!tpl) this.logger.warn(`Template addon: no <ng-template dfTemplate="${addon.templateKey}"> found. Did you project it as a child of <df-dynamic-form>?`);
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: TemplateAddonComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.5",
+		type: TemplateAddonComponent,
+		isStandalone: true,
+		selector: "df-template-addon",
+		inputs: {
+			addon: {
+				classPropertyName: "addon",
+				publicName: "addon",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			fieldInputs: {
+				classPropertyName: "fieldInputs",
+				publicName: "fieldInputs",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		ngImport: i0,
+		template: `
+    @if (template(); as tpl) {
+      <ng-container *ngTemplateOutlet="tpl; context: outletContext()" />
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "directive",
+			type: NgTemplateOutlet,
+			selector: "[ngTemplateOutlet]",
+			inputs: [
+				"ngTemplateOutletContext",
+				"ngTemplateOutlet",
+				"ngTemplateOutletInjector"
+			]
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: TemplateAddonComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "df-template-addon",
+			imports: [NgTemplateOutlet],
+			template: `
+    @if (template(); as tpl) {
+      <ng-container *ngTemplateOutlet="tpl; context: outletContext()" />
+    }
+  `,
+			changeDetection: ChangeDetectionStrategy.OnPush
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		addon: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "addon",
+				required: true
+			}]
+		}],
+		fieldInputs: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "fieldInputs",
+				required: false
+			}]
+		}]
+	}
+});
+var component_addon_component_exports = /* @__PURE__ */ __exportAll({ ComponentAddonComponent: () => ComponentAddonComponent });
+var ComponentAddonComponent = class ComponentAddonComponent {
+	logger = inject(DynamicFormLogger$1);
+	addon = input.required(...ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []);
+	fieldInputs = input(...ngDevMode ? [void 0, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []);
+	inputs = computed(() => this.addon().inputs ?? {}, ...ngDevMode ? [{ debugName: "inputs" }] : /* istanbul ignore next */ []);
+	asyncLoaded = signal(void 0, ...ngDevMode ? [{ debugName: "asyncLoaded" }] : /* istanbul ignore next */ []);
+	resolvedComponent = computed(() => {
+		const current = this.addon();
+		const loaded = this.asyncLoaded();
+		return loaded?.addon === current ? loaded.component : void 0;
+	}, ...ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []);
+	constructor() {
+		explicitEffect([this.addon], ([addon]) => {
+			Promise.resolve(addon.component()).then((mod) => {
+				const component = resolveDefaultExport(mod);
+				if (component) this.asyncLoaded.set({
+					addon,
+					component
+				});
+			}).catch((error) => {
+				this.logger.warn(`Failed to load component addon (slot: '${addon.slot}'): ${error instanceof Error ? error.message : String(error)}`);
+			});
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.5",
+		ngImport: i0,
+		type: ComponentAddonComponent,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "17.0.0",
+		version: "22.2.5",
+		type: ComponentAddonComponent,
+		isStandalone: true,
+		selector: "df-component-addon",
+		inputs: {
+			addon: {
+				classPropertyName: "addon",
+				publicName: "addon",
+				isSignal: true,
+				isRequired: true,
+				transformFunction: null
+			},
+			fieldInputs: {
+				classPropertyName: "fieldInputs",
+				publicName: "fieldInputs",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			}
+		},
+		ngImport: i0,
+		template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: inputs()" />
+    }
+  `,
+		isInline: true,
+		dependencies: [{
+			kind: "directive",
+			type: NgComponentOutlet,
+			selector: "[ngComponentOutlet]",
+			inputs: [
+				"ngComponentOutlet",
+				"ngComponentOutletInputs",
+				"ngComponentOutletInjector",
+				"ngComponentOutletEnvironmentInjector",
+				"ngComponentOutletContent",
+				"ngComponentOutletNgModule"
+			],
+			exportAs: ["ngComponentOutlet"]
+		}],
+		changeDetection: i0.ChangeDetectionStrategy.OnPush
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.5",
+	ngImport: i0,
+	type: ComponentAddonComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "df-component-addon",
+			imports: [NgComponentOutlet],
+			template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: inputs()" />
+    }
+  `,
+			changeDetection: ChangeDetectionStrategy.OnPush
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		addon: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "addon",
+				required: true
+			}]
+		}],
+		fieldInputs: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "fieldInputs",
+				required: false
+			}]
+		}]
+	}
+});
+function withCustomAddon(definition) {
+	return createFeature("addons", [{
+		provide: ADDON_TYPE_DEFINITIONS,
+		useValue: definition,
+		multi: true
+	}]);
+}
+function withAddonActions(handlers) {
+	return createFeature("addon-actions", [{
+		provide: ADDON_ACTION_HANDLERS,
+		useValue: handlers,
+		multi: true
+	}]);
+}
+function sanitizeFormConfig(config, options = {}) {
+	const fieldRegistry = inject(FIELD_REGISTRY);
+	const typeRegistry = inject(ADDON_TYPE_REGISTRY);
+	const source = options.source ?? "inline";
+	const { fields, warnings } = walkAndValidateAddons(config.fields ?? [], fieldRegistry, typeRegistry, source);
+	return {
+		sanitized: {
+			...config,
+			fields
+		},
+		warnings
+	};
+}
+var GoToPageEvent = class {
+	pageIndex;
+	options;
+	type = "go-to-page";
+	constructor(pageIndex, options) {
+		this.pageIndex = pageIndex;
+		this.options = options;
+	}
+};
+var NextPageEvent = class {
+	type = "next-page";
+};
+var PreviousPageEvent = class {
+	type = "previous-page";
+};
+var FormResetEvent = class {
+	type = "form-reset";
+};
+var FormClearEvent = class {
+	type = "form-clear";
+};
+var AppendArrayItemEvent = class {
+	arrayKey;
+	template;
+	type = "append-array-item";
+	constructor(arrayKey, template) {
+		this.arrayKey = arrayKey;
+		this.template = template;
+	}
+};
+var PrependArrayItemEvent = class {
+	arrayKey;
+	template;
+	type = "prepend-array-item";
+	constructor(arrayKey, template) {
+		this.arrayKey = arrayKey;
+		this.template = template;
+	}
+};
+var InsertArrayItemEvent = class {
+	arrayKey;
+	index;
+	template;
+	type = "insert-array-item";
+	constructor(arrayKey, index, template) {
+		this.arrayKey = arrayKey;
+		this.index = index;
+		this.template = template;
+	}
+};
+var PopArrayItemEvent = class {
+	arrayKey;
+	type = "pop-array-item";
+	constructor(arrayKey) {
+		this.arrayKey = arrayKey;
+	}
+};
+var ShiftArrayItemEvent = class {
+	arrayKey;
+	type = "shift-array-item";
+	constructor(arrayKey) {
+		this.arrayKey = arrayKey;
+	}
+};
+var MoveArrayItemEvent = class {
+	arrayKey;
+	fromIndex;
+	toIndex;
+	type = "move-array-item";
+	constructor(arrayKey, fromIndex, toIndex) {
+		this.arrayKey = arrayKey;
+		this.fromIndex = fromIndex;
+		this.toIndex = toIndex;
+	}
+};
+var RemoveAtIndexEvent = class {
+	arrayKey;
+	index;
+	type = "remove-at-index";
+	constructor(arrayKey, index) {
+		this.arrayKey = arrayKey;
+		this.index = index;
+	}
+};
+function arrayEvent(arrayKey) {
+	return {
+		append: (template) => new AppendArrayItemEvent(arrayKey, template),
+		prepend: (template) => new PrependArrayItemEvent(arrayKey, template),
+		insertAt: (index, template) => new InsertArrayItemEvent(arrayKey, index, template),
+		pop: () => new PopArrayItemEvent(arrayKey),
+		shift: () => new ShiftArrayItemEvent(arrayKey),
+		removeAt: (index) => new RemoveAtIndexEvent(arrayKey, index),
+		move: (from, to) => new MoveArrayItemEvent(arrayKey, from, to)
+	};
+}
+export { ActivePageInitializedEvent, AppendArrayItemEvent, BUILT_IN_FIELDS, ComponentAddonComponent, ConsoleLogger, DF_FIELD_TEMPLATES, DfTemplate, DynamicForm, DynamicFormError, DynamicFormLogger, EventDispatcher, FormClearEvent, FormResetEvent, FormSubmitEvent, GoToPageEvent, InsertArrayItemEvent, MoveArrayItemEvent, NextPageEvent, NoopLogger, PageChangeEvent, PagerStateEvent, PopArrayItemEvent, PrependArrayItemEvent, PreviousPageEvent, RemoveAtIndexEvent, ShiftArrayItemEvent, TemplateAddonComponent, TextAddonComponent, arrayEvent, createWrappers, hasFormValue, isArrayField, isContainerField, isDisplayOnlyField, isFieldBoundContext, isFormStateCondition, isGroupField, isHiddenField, isLeafField, isPageField, isRowField, isSimplifiedArrayField, isValueBearingField, isWrapperTypeDefinition, isWrappersBundle, provideDynamicForm, resolveDynamicValue, rowError, sanitizeFormConfig, withAddonActions, withCustomAddon, withEventFormValue, withExperimentalWebMcp, withFieldWindowing, withLegacyStatusClasses, withLoggerConfig, withPagePreload, withValidationExecutionDefaults, withValueExclusionDefaults, wrapperProps };
+
+//# sourceMappingURL=ng-forge-dynamic-forms.mjs.map