@ng-forge/dynamic-forms 0.9.0-next.10 → 0.9.0-next.11

package/fesm2022/{ng-forge-dynamic-forms-ng-forge-dynamic-forms-DWPPLOrV.mjs → ng-forge-dynamic-forms-ng-forge-dynamic-forms-o3rJX4vG.mjs}

@@ -139,6 +139,32 @@ const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT', {
  * ```
  */
 const ARRAY_CONTEXT = new InjectionToken('ARRAY_CONTEXT');
+/**
+ * Injection token for providing group ancestry to mappers and components.
+ *
+ * Re-provided in two places:
+ * 1. `GroupFieldComponent` provides a context whose `groupPath()` is the
+ *    parent path extended by its own key (e.g. `'address'` or `'user.address'`).
+ * 2. `createArrayItemInjector` provides a sentinel with an empty `groupPath`,
+ *    resetting the chain at array boundaries — descendants of an array item
+ *    that re-enter a group compose paths INSIDE the array item, matching the
+ *    property-derivation collector's keying.
+ *
+ * `mapFieldToInputs` reads this to scope DOM IDs and override-store keys so
+ * the same leaf key can appear in different groups without colliding (#401).
+ *
+ * Inject with `{ optional: true }` because top-level fields with no group
+ * ancestor (and no enclosing array) won't have the token provided. The token
+ * IS present for fields inside an array even when no inner group exists — the
+ * array-boundary sentinel makes injection succeed with an empty `groupPath`.
+ */
+// No factory: GROUP_CONTEXT is optional-by-design — `GroupFieldComponent` and
+// `createArrayItemInjector` re-provide it where it makes sense, and consumers
+// inject with `{ optional: true }` to handle the top-level case. Mirrors the
+// ARRAY_CONTEXT pattern. Adding a throwing factory here fires even when
+// injected optionally (Angular still evaluates the tree-shakable factory
+// before honoring `optional`), so non-group fields would crash on every render.
+const GROUP_CONTEXT = new InjectionToken('GROUP_CONTEXT');
 /**
  * Injection token for form-level default props.
  *
@@ -2748,16 +2774,25 @@ function evaluateCondition(expression, context) {
         case 'javascript':
             return evaluateJavaScriptExpression(expression, context);
         case 'custom': {
-            const customFn = context.customFunctions?.[expression.functionName];
+            // Read both keys via cast — the XOR type narrows to `never` when both
+            // would be truthy, but JSON-loaded configs can produce that state at
+            // runtime. We accept it here, warn, and let inline win.
+            const bothSet = expression;
+            const inlineFn = bothSet.fn;
+            const registeredName = bothSet.functionName;
+            if (inlineFn && registeredName) {
+                context.logger.warn('Both "fn" and "functionName" are set on custom condition. Inline "fn" takes precedence; "functionName" is ignored.');
+            }
+            const customFn = inlineFn ?? (registeredName ? context.customFunctions?.[registeredName] : undefined);
             if (!customFn) {
-                context.logger.error('Custom function not found:', expression.functionName);
+                context.logger.error('Custom function not found:', registeredName);
                 return false;
             }
             try {
                 return !!customFn(context);
             }
             catch (error) {
-                context.logger.error('Error executing custom function:', expression.functionName, error);
+                context.logger.error('Error executing custom function:', registeredName ?? '<inline>', error);
                 return false;
             }
         }
@@ -2766,7 +2801,7 @@ function evaluateCondition(expression, context) {
         case 'or':
             return evaluateOrCondition(expression, context);
         case 'http':
-            context.logger.warn('[Dynamic Forms] HTTP conditions are resolved asynchronously via createHttpConditionLogicFunction(). ' +
+            context.logger.warn('HTTP conditions are resolved asynchronously via createHttpConditionLogicFunction(). ' +
                 'When used inside and/or composites, the HTTP result is not available synchronously. Returning false.');
             return false;
         case 'async':
@@ -4145,9 +4180,9 @@ class PageOrchestratorComponent {
         }
       }
     }
-  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-B9v_1shD.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-B9v_1shD.mjs').then(m => m.default)]] });
+  `, isInline: true, styles: [":host{display:block;position:relative;width:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, deferBlockDependencies: [() => [import('./ng-forge-dynamic-forms-page-field.component-BX4R9GGa.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-BX4R9GGa.mjs').then(m => m.default)]] });
 }
-i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.8", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-B9v_1shD.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
+i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.8", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-BX4R9GGa.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
                 type: Component,
                 args: [{ selector: 'div[page-orchestrator]', imports: [PageFieldComponent], template: `
     @for (pageField of pageFields(); track pageField.key; let i = $index) {
@@ -4628,7 +4663,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
  * Use this guard when you need type-safe access to `FunctionHttpValidatorConfig` properties.
  */
 function isFunctionHttpValidator(config) {
-    return 'functionName' in config && !!config.functionName;
+    const c = config;
+    return typeof c.functionName === 'string' || (c.fn !== null && typeof c.fn === 'object');
 }
 
 /**
@@ -5047,11 +5083,18 @@ function createAsyncConditionLogicFunction(condition) {
     const cacheService = inject(AsyncConditionFunctionCacheService);
     const pendingValue = condition.pendingValue ?? false;
     const debounceMs = condition.debounceMs ?? 300;
-    // Check function cache
-    const cacheKey = stableStringify(condition);
-    const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
-    if (cached) {
-        return cached;
+    if (condition.asyncFn && condition.asyncFunctionName) {
+        logger.warn('Both "asyncFn" and "asyncFunctionName" are set on async condition. Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.');
+    }
+    // Skip cross-condition caching when an inline function is used: stableStringify
+    // cannot distinguish two different inline functions, which would cause cache hits
+    // to wrongly reuse a LogicFn closing over a different function reference.
+    const cacheKey = condition.asyncFn ? undefined : stableStringify(condition);
+    if (cacheKey !== undefined) {
+        const cached = cacheService.asyncConditionFunctionCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
     }
     // Each condition needs its own per-field signal store.
     const perFunctionSignalStore = new Map();
@@ -5076,8 +5119,10 @@ function createAsyncConditionLogicFunction(condition) {
                 const asyncResource = rxResource({
                     params: () => debouncedTrigger() ?? undefined,
                     stream: ({ params: triggerKey }) => {
-                        // Look up the async function at call time (fresh reference)
-                        const asyncFn = functionRegistry.getAsyncConditionFunction(condition.asyncFunctionName);
+                        // Inline `asyncFn` wins; otherwise look up the registered function at call time
+                        // (fresh reference, in case the registry was updated after LogicFn creation).
+                        const asyncFn = condition.asyncFn ??
+                            (condition.asyncFunctionName ? functionRegistry.getAsyncConditionFunction(condition.asyncFunctionName) : undefined);
                         if (!asyncFn) {
                             logger.warn(`Async Condition - function '${condition.asyncFunctionName}' not found. ` +
                                 `Register it in customFnConfig.asyncConditions.`);
@@ -5129,7 +5174,9 @@ function createAsyncConditionLogicFunction(condition) {
         });
         return resultResource.value();
     };
-    cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    if (cacheKey !== undefined) {
+        cacheService.asyncConditionFunctionCache.set(cacheKey, fn);
+    }
     return fn;
 }
 
@@ -5764,12 +5811,12 @@ function applyCustomValidator(config, fieldPath) {
     if (config.expression) {
         validatorFn = createExpressionValidator(config);
     }
-    else if (config.functionName) {
+    else if (config.fn || config.functionName) {
         validatorFn = createFunctionValidator(config);
     }
     else {
         const logger = inject(DynamicFormLogger);
-        logger.warn('Custom validator must have either "expression" or "functionName"');
+        logger.warn('Custom validator must have one of "expression", "functionName", or "fn"');
         return;
     }
     const whenLogic = createConditionalLogic(config.when);
@@ -5781,6 +5828,13 @@ function applyCustomValidator(config, fieldPath) {
 }
 function createFunctionValidator(config) {
     const logger = inject(DynamicFormLogger);
+    if (config.fn && config.functionName) {
+        logger.warn('Both "fn" and "functionName" are set on custom validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    if (config.fn) {
+        const inlineFn = config.fn;
+        return (ctx) => inlineFn(ctx, config.params);
+    }
     const functionName = config.functionName;
     if (!functionName) {
         logger.warn('Custom validator missing functionName');
@@ -5841,10 +5895,24 @@ function createExpressionValidator(config) {
  * - onError: Optional handler for resource errors
  */
 function applyAsyncValidator(config, fieldPath) {
-    const registry = inject(FunctionRegistryService);
-    const validatorConfig = registry.getAsyncValidator(config.functionName);
-    if (!validatorConfig) {
-        throw new DynamicFormError(`Async validator "${config.functionName}" not found. Register it with customFnConfig.asyncValidators.`);
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on async validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let validatorConfig;
+    if (config.fn) {
+        validatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        validatorConfig = registry.getAsyncValidator(config.functionName);
+        if (!validatorConfig) {
+            throw new DynamicFormError(`Async validator "${config.functionName}" not found. Register it with customFnConfig.asyncValidators.`);
+        }
+    }
+    else {
+        // XOR type rejects this at compile time; JSON-loaded configs can still reach here at runtime.
+        throw new DynamicFormError('Async validator requires one of "functionName" or "fn".');
     }
     const whenLogic = createConditionalLogic(config.when);
     const asyncOptions = {
@@ -5866,10 +5934,16 @@ function applyAsyncValidator(config, fieldPath) {
 function applyUnifiedHttpValidator(config, fieldPath) {
     if (isFunctionHttpValidator(config)) {
         applyFunctionHttpValidator(config, fieldPath);
+        return;
     }
-    else {
-        applyDeclarativeHttpValidator(config, fieldPath);
+    // Declarative path requires both `http` and `responseMapping` — reject early
+    // for JSON-loaded configs that have neither side fully populated. The
+    // discriminated union forbids this at compile time.
+    const declarative = config;
+    if (!declarative.http || !declarative.responseMapping) {
+        throw new DynamicFormError('HTTP validator requires one of "functionName" / "fn" (function-based) or "http" + "responseMapping" (declarative).');
     }
+    applyDeclarativeHttpValidator(config, fieldPath);
 }
 /**
  * Apply function-based HTTP validator to field path using Angular's public validateHttp() API.
@@ -5880,10 +5954,24 @@ function applyUnifiedHttpValidator(config, fieldPath) {
  * - onError: Optional handler for HTTP errors
  */
 function applyFunctionHttpValidator(config, fieldPath) {
-    const registry = inject(FunctionRegistryService);
-    const httpValidatorConfig = registry.getHttpValidator(config.functionName);
-    if (!httpValidatorConfig) {
-        throw new DynamicFormError(`HTTP validator "${config.functionName}" not found. Register it with customFnConfig.httpValidators.`);
+    if (config.fn && config.functionName) {
+        const logger = inject(DynamicFormLogger);
+        logger.warn('Both "fn" and "functionName" are set on HTTP validator. Inline "fn" takes precedence; "functionName" is ignored.');
+    }
+    let httpValidatorConfig;
+    if (config.fn) {
+        httpValidatorConfig = config.fn;
+    }
+    else if (config.functionName) {
+        const registry = inject(FunctionRegistryService);
+        httpValidatorConfig = registry.getHttpValidator(config.functionName);
+        if (!httpValidatorConfig) {
+            throw new DynamicFormError(`HTTP validator "${config.functionName}" not found. Register it with customFnConfig.httpValidators.`);
+        }
+    }
+    else {
+        // XOR type rejects this at compile time; JSON-loaded configs can still reach here at runtime.
+        throw new DynamicFormError('HTTP validator requires one of "functionName" or "fn".');
     }
     const whenLogic = createConditionalLogic(config.when);
     const httpOptions = {
@@ -8467,22 +8555,31 @@ const PLACEHOLDER_INDEX = '$';
 /**
  * Builds a property override store key for a field.
  *
- * For non-array fields, the key is just the field's key.
- * For array item fields, the key includes the array path and either a concrete
- * index (e.g., `contacts.0.email`) or the `$` placeholder (e.g., `contacts.$.email`).
+ * For non-array fields, the key is the dot-joined group ancestors plus the
+ * field's leaf key (e.g., `address.street` for `street` inside `address`).
+ * For array item fields, the key includes the array path, either a concrete
+ * index or the `$` placeholder, and any group ancestors INSIDE the array
+ * item (e.g., `contacts.0.email`, `contacts.$.email`, or
+ * `contacts.0.profile.email` for a group nested under each contact).
+ *
+ * `groupPath` matches the form-value path of nested groups (collector resets
+ * it at array boundaries — see `property-derivation-collector.ts`), so the
+ * resulting key always mirrors the field's location in `formValue`.
  *
  * @param arrayKey - The array field key (e.g., 'contacts'), or undefined for non-array fields
  * @param index - The array item index, `PLACEHOLDER_INDEX` for the wildcard format, or undefined for non-array fields
  * @param fieldKey - The leaf field key (e.g., 'email')
- * @returns The store key (e.g., 'email', 'contacts.0.email', or 'contacts.$.email')
+ * @param groupPath - Dot-joined group ancestors scoped to the current array item (or top-level), or undefined when not inside any group
+ * @returns The store key (e.g., 'email', 'address.street', 'contacts.0.email', 'contacts.$.profile.email')
  *
  * @public
  */
-function buildPropertyOverrideKey(arrayKey, index, fieldKey) {
+function buildPropertyOverrideKey(arrayKey, index, fieldKey, groupPath) {
+    const leafScope = groupPath ? `${groupPath}.${fieldKey}` : fieldKey;
     if (arrayKey != null && index != null) {
-        return `${arrayKey}.${index}.${fieldKey}`;
+        return `${arrayKey}.${index}.${leafScope}`;
     }
-    return fieldKey;
+    return leafScope;
 }
 
 /**
@@ -8563,6 +8660,25 @@ function applyIndexSuffix(inputs, index) {
         key: `${key}_${index}`,
     };
 }
+/**
+ * Prefixes the key with the underscored group ancestor path so that the same
+ * leaf key inside different groups produces distinct DOM IDs (issue #401).
+ * Form-schema keys remain clean — only the rendered `key` input is rewritten.
+ *
+ * Dots in the group path become underscores, then the original leaf key is
+ * appended: `(groupPath='user.address', inputs.key='street')` →
+ * `inputs.key = 'user_address_street'`.
+ */
+function applyGroupPrefix(inputs, groupPath) {
+    const key = inputs['key'];
+    if (typeof key !== 'string' || groupPath.length === 0) {
+        return inputs;
+    }
+    return {
+        ...inputs,
+        key: `${groupPath.replace(/\./g, '_')}_${key}`,
+    };
+}
 /**
  * Main field mapper function that uses the field registry to get the appropriate mapper
  * based on the field's type property.
@@ -8599,6 +8715,10 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // Check if we're inside an array item context - if so, we need to suffix keys
     // Optional because ARRAY_CONTEXT is only provided inside array item injectors
     const arrayContext = inject(ARRAY_CONTEXT, { optional: true });
+    // Check if we're inside a group context - if so, prefix the key with the group path
+    // so overlapping leaf keys across groups produce distinct DOM IDs (issue #401).
+    // Optional because GROUP_CONTEXT is only provided by GroupFieldComponent.
+    const groupContext = inject(GROUP_CONTEXT, { optional: true });
     // Inject the property override store for property derivation overrides
     // Always available — provided at the DynamicForm component level via provideDynamicFormDI
     const store = inject(PROPERTY_OVERRIDE_STORE);
@@ -8609,6 +8729,7 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // Check that arrayContext exists and has a valid index signal (guards against mock injectors)
     const indexSignal = arrayContext?.index;
     const hasArrayContext = indexSignal !== undefined && isSignal(indexSignal);
+    const hasGroupContext = groupContext != null;
     // Fast-path check for property overrides: only fields whose definition declares
     // a property-derivation enter the computed() wrapper. We inspect the FieldDef
     // directly rather than asking the store, because the store's registration
@@ -8617,7 +8738,7 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
     // collector apply the same inclusion rule, so the answers always agree.
     const hasOverrides = fieldHasPropertyDerivations(fieldDef);
     // Fast path: no transformations needed
-    if (!hasPropsForwarding && !hasArrayContext && !hasOverrides) {
+    if (!hasPropsForwarding && !hasArrayContext && !hasGroupContext && !hasOverrides) {
         return mapperResult;
     }
     // Wrap in computed to apply transformations
@@ -8627,18 +8748,34 @@ function mapFieldToInputs(fieldDef, fieldRegistry) {
         if (hasPropsForwarding) {
             inputs = mergeForwardedPropsToMeta(inputs, propsToMeta);
         }
+        // Apply group prefix BEFORE array suffix so the resulting key reads as
+        // `{groupPath}_{key}_{index}` (e.g. `address_street_0`) — matching the
+        // form-value path order: group → leaf → array index.
+        if (hasGroupContext) {
+            // Non-null after the hasGroupContext guard.
+            inputs = applyGroupPrefix(inputs, groupContext.groupPath());
+        }
         // Apply index suffix for array items
         if (hasArrayContext) {
             const index = indexSignal();
             inputs = applyIndexSuffix(inputs, index);
         }
-        // Apply property overrides from the store (AFTER all static transformations)
+        // Apply property overrides from the store (AFTER all static transformations).
+        //
+        // INVARIANT: the store key MUST be built from `fieldDef.key` + the group/array
+        // ancestry (via buildPropertyOverrideKey) — NEVER from the DOM-scoped
+        // `inputs['key']` produced by applyGroupPrefix/applyIndexSuffix above. The
+        // collector (property-derivation-collector.ts) registers using the same
+        // shape; if these drift, overrides silently miss their target.
         if (hasOverrides) {
-            // Build the store key inside computed() so index signal read establishes reactive dependency
-            // Safe to access arrayContext/indexSignal directly — hasArrayContext already confirmed they exist
+            // Build inside computed() so the index/group signals establish reactive deps.
+            // GROUP_CONTEXT resets at array boundaries (see create-array-item-injector.ts),
+            // so groupPath() represents ancestors inside the current array item (or
+            // top-level groups when not in an array) — matching the collector.
+            const groupPath = hasGroupContext ? groupContext.groupPath() : undefined;
             const key = hasArrayContext
-                ? buildPropertyOverrideKey(arrayContext.arrayKey, indexSignal(), fieldDef.key)
-                : fieldDef.key;
+                ? buildPropertyOverrideKey(arrayContext.arrayKey, indexSignal(), fieldDef.key, groupPath || undefined)
+                : buildPropertyOverrideKey(undefined, undefined, fieldDef.key, groupPath || undefined);
             const overrides = store.getOverrides(key)();
             inputs = applyPropertyOverrides(inputs, overrides);
         }
@@ -9079,15 +9216,32 @@ function injectFieldRegistry() {
  * Collects all field keys, types, and validates regex patterns from a field tree
  * by recursively traversing containers (page, row, group, array).
  *
- * @param collectKeys - Whether to add field keys to data.keys for duplicate detection.
- *   Set to false when inside an array container: array item fields share template keys
- *   across items by design (e.g. every item has 'name', 'email'), so they must not
- *   participate in global duplicate-key checking.
+ * Keys are scoped by their group ancestors (e.g. `address.city` instead of `city`),
+ * so the same leaf key can appear inside different groups without conflict. Page and
+ * row containers do not contribute to the path because they flatten their children
+ * into the parent scope. Array items are excluded entirely from key collection
+ * because they share template keys across items by design.
+ *
+ * Fields whose registered `valueHandling` is anything other than `include` (e.g.
+ * buttons with `exclude`, page/row with `flatten`) are not collected: they don't
+ * bind to a form-value path, so duplicate-key uniqueness isn't meaningful for them.
+ *
+ * @param collectKeys - When false, the entire subtree skips key collection (used
+ *   when descending into an array container).
  */
-function collectFieldData(fields, data, collectKeys = true) {
+function collectFieldData(fields, data, registry, pathPrefix, collectKeys = true) {
     for (const field of fields) {
-        if (collectKeys && field.key) {
-            data.keys.push(field.key);
+        // Defensively skip only known non-include modes — unexpected/missing
+        // valueHandling defaults back to participating in duplicate detection so a
+        // mis-registered field type doesn't silently drop from collision checks.
+        const valueHandling = field.type ? getFieldValueHandling(field.type, registry) : 'include';
+        const participatesInValue = valueHandling !== 'exclude' && valueHandling !== 'flatten';
+        if (collectKeys && field.key && participatesInValue) {
+            const scopedKey = pathPrefix ? `${pathPrefix}.${field.key}` : field.key;
+            data.keys.push(scopedKey);
+            // Project to the DOM-ID format (dots → underscores) so we can detect
+            // collisions like top-level `'foo_bar'` vs group `'foo'` + leaf `'bar'`.
+            data.domIds.push(scopedKey.replace(/\./g, '_'));
         }
         if (field.type) {
             data.types.add(field.type);
@@ -9107,13 +9261,16 @@ function collectFieldData(fields, data, collectKeys = true) {
             // Array item fields share template keys across items by design — stop collecting keys
             // once inside an array. Types and regex patterns are still validated.
             const childCollectKeys = collectKeys && field.type !== 'array';
+            // Only group containers extend the scoping path — page/row flatten into the parent
+            // scope, and array items use dynamic indices that aren't statically knowable.
+            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, childCollectKeys);
+                    collectFieldData(child, data, registry, childPrefix, childCollectKeys);
                 }
                 else {
-                    collectFieldData([child], data, childCollectKeys);
+                    collectFieldData([child], data, registry, childPrefix, childCollectKeys);
                 }
             }
         }
@@ -9149,7 +9306,38 @@ function validateNoDuplicateKeys(allKeys) {
         const duplicateList = Array.from(duplicates)
             .map((k) => `'${k}'`)
             .join(', ');
-        throw new DynamicFormError(`Duplicate field keys detected: ${duplicateList}. Each field key must be unique within a form config.`);
+        throw new DynamicFormError(`Duplicate field keys detected: ${duplicateList}. Field keys must be unique within their group scope (the same key may appear inside different groups).`);
+    }
+}
+/**
+ * Validates that the underscore-projected DOM-ID namespace has no collisions.
+ *
+ * DOM IDs are built by underscore-joining the group ancestor path with the
+ * leaf key (e.g. `address_street`). Two scoped paths can land on the same
+ * DOM ID even when their form-value paths differ — e.g. a top-level key
+ * `'foo_bar'` and a leaf `'bar'` inside group `'foo'` both render as
+ * `id="foo_bar"`. The form-value-path check accepts this (paths are
+ * `'foo_bar'` vs `'foo.bar'` — distinct) but the rendered DOM would have
+ * duplicate IDs, breaking aria associations and CSS selectors.
+ *
+ * @throws {DynamicFormError} When two scoped paths project to the same DOM ID
+ */
+function validateNoDomIdCollisions(domIds) {
+    const seen = new Set();
+    const duplicates = 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(`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.`);
     }
 }
 /**
@@ -9187,11 +9375,13 @@ function validateFieldTypesRegistered(allTypes, registry, logger) {
 function validateFormConfig(fields, registry, logger) {
     const data = {
         keys: [],
+        domIds: [],
         types: new Set(),
         regexErrors: [],
     };
-    collectFieldData(fields, data);
+    collectFieldData(fields, data, registry, '');
     validateNoDuplicateKeys(data.keys);
+    validateNoDomIdCollisions(data.domIds);
     validateFieldTypesRegistered(data.types, registry, logger);
     if (data.regexErrors.length > 0) {
         throw new DynamicFormError(data.regexErrors.length === 1
@@ -11036,15 +11226,18 @@ function computeValueFromEntry(entry, evalContext, options) {
     if (entry.expression) {
         return ExpressionParser.evaluate(entry.expression, evalContext);
     }
-    if (entry.functionName) {
-        const fn = options.derivationFunctions?.[entry.functionName];
+    if (entry.fn || entry.functionName) {
+        if (entry.fn && entry.functionName) {
+            evalContext.logger.warn(`Both "fn" and "functionName" are set on derivation for '${options.subject}'. Inline "fn" takes precedence; "functionName" is ignored.`);
+        }
+        const fn = entry.fn ?? (entry.functionName ? options.derivationFunctions?.[entry.functionName] : undefined);
         if (!fn) {
             const kind = options.functionKind ?? 'Derivation function';
             throw new DynamicFormError(`${kind} '${entry.functionName}' not found in customFnConfig.derivations`);
         }
         return fn(evalContext);
     }
-    throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', or 'functionName'.`);
+    throw new DynamicFormError(`Derivation for ${options.subject} has no value source. Specify 'value', 'expression', 'functionName', or 'fn'.`);
 }
 
 /**
@@ -11447,7 +11640,7 @@ function getEntriesForChangedFields$1(entries, changedFields) {
 function tryApplyDerivation(entry, context, chainContext) {
     const { derivationLogger } = context;
     // HTTP and async entries are processed asynchronously in their own streams — skip in sync loop
-    if (entry.http || entry.asyncFunctionName) {
+    if (entry.http || entry.asyncFunctionName || entry.asyncFn) {
         return { applied: false, fieldKey: entry.fieldKey };
     }
     // Check if this is an array field derivation (has '$' placeholder)
@@ -11754,9 +11947,11 @@ function formatDerivationError(entry, phase, message) {
         ? `expression: "${entry.expression.substring(0, 50)}${entry.expression.length > 50 ? '...' : ''}"`
         : entry.functionName
             ? `function: "${entry.functionName}"`
-            : entry.value !== undefined
-                ? 'static value'
-                : 'unknown source';
+            : entry.fn
+                ? 'inline fn'
+                : entry.value !== undefined
+                    ? 'static value'
+                    : 'unknown source';
     return `${ERROR_PREFIX$1} Failed to ${phase} derivation (field: ${entry.fieldKey}, ${source}): ${message}`;
 }
 /**
@@ -11825,7 +12020,7 @@ function shouldSkipForUserOverride(entry, resolvedFieldKey, context, chainContex
 function applyDerivationsForTrigger(collection, trigger, context, changedFields) {
     // Filter entries by trigger type, excluding HTTP and async entries (processed in async streams)
     const filteredEntries = collection.entries.filter((entry) => {
-        if (entry.http || entry.asyncFunctionName)
+        if (entry.http || entry.asyncFunctionName || entry.asyncFn)
             return false;
         if (trigger === 'onChange') {
             return !entry.trigger || entry.trigger === 'onChange';
@@ -11994,7 +12189,7 @@ function topologicalSort(entries) {
  * Combines:
  * - Explicit `dependsOn` (when provided, it takes precedence over auto-detection)
  * - Expression-detected dependencies (only used when `dependsOn` is empty)
- * - `'*'` wildcard for `functionName` (only when `dependsOn` is empty)
+ * - `'*'` wildcard for `functionName` / inline `fn` (only when `dependsOn` is empty)
  * - Condition expression dependencies (always included)
  *
  * @internal
@@ -12008,7 +12203,9 @@ function extractDependenciesFromConfig(config) {
         if (config.expression) {
             extractStringDependencies(config.expression).forEach((dep) => deps.add(dep));
         }
-        if (config.functionName) {
+        // Inline `fn` mirrors `functionName` semantics: without explicit dependsOn,
+        // assume the function may depend on anything in the form.
+        if (config.functionName || config.fn) {
             deps.add('*');
         }
     }
@@ -12018,6 +12215,32 @@ function extractDependenciesFromConfig(config) {
     return Array.from(deps);
 }
 
+/**
+ * Reads the optional inline `fn` property off a derivation config.
+ *
+ * `fn` only appears on the function-mode branch of the discriminated union, so
+ * call sites that need to copy it through unconditionally must widen via cast.
+ * This helper centralises the cast and keeps it read-only — no widening, no
+ * mutation. Returns `undefined` for any non-function-mode variant.
+ *
+ * @internal
+ */
+function extractInlineFn(config) {
+    return config.fn;
+}
+/**
+ * Reads the optional inline `asyncFn` property off a derivation config.
+ *
+ * Same rationale as {@link extractInlineFn}: `asyncFn` only appears on the
+ * `source: 'asyncFunction'` branch, so collectors that copy it through need a
+ * cast. Read-only access, no widening.
+ *
+ * @internal
+ */
+function extractInlineAsyncFn(config) {
+    return config.asyncFn;
+}
+
 /**
  * Recursively walks a field-definition tree, invoking `visitor` for each field.
  *
@@ -12360,9 +12583,11 @@ function createLogicEntry(fieldKey, config, context) {
         value: config.value,
         expression: config.expression,
         functionName: config.functionName,
+        fn: extractInlineFn(config),
         http: config.http,
         responseExpression: config.responseExpression,
         asyncFunctionName: config.asyncFunctionName,
+        asyncFn: extractInlineAsyncFn(config),
         trigger,
         debounceMs,
         isShorthand: false,
@@ -12911,9 +13136,16 @@ function createAsyncDerivationStream(entry, formValue$, context) {
             `Array async derivations will be supported in a future release.`);
         return EMPTY;
     }
-    if (!entry.asyncFunctionName) {
+    if (!entry.asyncFunctionName && !entry.asyncFn) {
+        context.logger.warn(`${LOG_PREFIX} Derivation for '${entry.fieldKey}' has neither "asyncFunctionName" nor "asyncFn". ` +
+            `One of the two is required for source: 'asyncFunction'.`);
         return EMPTY;
     }
+    if (entry.asyncFn && entry.asyncFunctionName) {
+        context.logger.warn(`${LOG_PREFIX} Both "asyncFn" and "asyncFunctionName" are set on derivation for '${entry.fieldKey}'. ` +
+            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
+    }
+    const inlineAsyncFn = entry.asyncFn;
     const asyncFunctionName = entry.asyncFunctionName;
     const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
     // startWith(null) → pairwise() causes all fields to appear "changed" on the
@@ -12959,8 +13191,8 @@ function createAsyncDerivationStream(entry, formValue$, context) {
             const customFunctions = context.customFunctions?.();
             const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
             const externalData = context.externalData?.();
-            // Look up the async function
-            const asyncFn = asyncDerivationFunctions?.[asyncFunctionName];
+            // Inline `asyncFn` wins; otherwise look up the registered function.
+            const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
             if (!asyncFn) {
                 context.logger.warn(`${LOG_PREFIX} Async derivation function '${asyncFunctionName}' not found for field '${entry.fieldKey}'. ` +
                     `Register it in customFnConfig.asyncDerivations.`);
@@ -13388,7 +13620,7 @@ class DerivationOrchestrator {
         toObservable(this.derivationCollection, { injector: this.injector })
             .pipe(takeUntilDestroyed(this.destroyRef))
             .subscribe((collection) => {
-            const asyncEntries = collection?.entries.filter((entry) => entry.asyncFunctionName) ?? [];
+            const asyncEntries = collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [];
             if (asyncEntries.length === 0) {
                 this.teardownAsyncFunctionStreams();
                 this.lastAsyncEntryKeys = null;
@@ -13435,9 +13667,14 @@ class DerivationOrchestrator {
      * Used for smart teardown comparison.
      */
     computeAsyncEntryKeys(entries) {
+        // For inline `asyncFn` entries we tag the key with the field path (the real
+        // identity, since derivations are self-targeting) rather than the array
+        // index. Index-based tagging churned identities whenever topologicalSort
+        // reordered entries, causing unnecessary teardown + re-subscribe.
         return new Set(entries.map((entry) => {
             const config = {
                 asyncFunctionName: entry.asyncFunctionName,
+                asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}` : undefined,
                 dependsOn: entry.dependsOn,
                 debounceMs: entry.debounceMs,
                 stopOnUserOverride: entry.stopOnUserOverride,
@@ -13486,10 +13723,11 @@ function warnAboutWildcardDependencies$1(logger, entries, fieldCount) {
     // HTTP and async entries require explicit dependsOn (validated at collection time)
     const implicitWildcards = wildcardEntries.filter((entry) => !entry.http &&
         !entry.asyncFunctionName &&
-        entry.functionName &&
+        !entry.asyncFn &&
+        (entry.functionName || entry.fn) &&
         (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
     if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey} (${e.functionName})`);
+        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey} (${e.functionName ?? '<inline fn>'})`);
         logger.warn('Derivation: custom functions without explicit dependsOn detected. ' +
             `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
             'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
@@ -13972,8 +14210,16 @@ function collectPropertyDerivations(fields, logger, tracker) {
     const entries = [];
     const context = { logger, tracker };
     traverseFieldsWithContext(fields, context, (field, ctx) => collectFromField(field, entries, ctx), {
-        onArrayChild: (_, field) => ({ arrayPath: field.key }),
-        // Group and layout containers do not affect property-derivation paths.
+        // Array boundary: each item is its own model root. Reset groupPath so
+        // ancestor groups OUTSIDE the array don't bleed into per-item keys.
+        onArrayChild: (_, field) => ({ arrayPath: field.key, groupPath: undefined }),
+        onGroupChild: (parent, field) => {
+            // Keyless groups (rare) act like layout containers — pass through.
+            if (!field.key)
+                return {};
+            return { groupPath: parent.groupPath ? `${parent.groupPath}.${field.key}` : field.key };
+        },
+        // Layout containers (page, row, container) leave context unchanged.
     });
     return { entries };
 }
@@ -14005,7 +14251,7 @@ function collectFromField(field, entries, context) {
  * @internal
  */
 function createPropertyDerivationEntryFromDerivation(fieldKey, config, context) {
-    const effectiveFieldKey = buildPropertyOverrideKey(context.arrayPath, context.arrayPath ? PLACEHOLDER_INDEX : undefined, fieldKey);
+    const effectiveFieldKey = buildPropertyOverrideKey(context.arrayPath, context.arrayPath ? PLACEHOLDER_INDEX : undefined, fieldKey, context.groupPath);
     const dependsOn = extractDependenciesFromConfig(config);
     const condition = config.condition ?? true;
     const trigger = config.trigger ?? 'onChange';
@@ -14018,6 +14264,7 @@ function createPropertyDerivationEntryFromDerivation(fieldKey, config, context)
         value: config.value,
         expression: config.expression,
         functionName: config.functionName,
+        fn: extractInlineFn(config),
         trigger,
         debounceMs,
         debugName: config.debugName,
@@ -14172,10 +14419,10 @@ const PROPERTY_DERIVATION_ORCHESTRATOR = new InjectionToken('PROPERTY_DERIVATION
 // ─────────────────────────────────────────────────────────────────────────────
 function warnAboutWildcardDependencies(logger, entries, fieldCount) {
     const implicitWildcards = entries.filter((entry) => entry.dependsOn.includes('*') &&
-        entry.functionName &&
+        (entry.functionName || entry.fn) &&
         (!entry.originalConfig?.dependsOn || entry.originalConfig.dependsOn.length === 0));
     if (implicitWildcards.length > 0) {
-        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey}.${e.targetProperty} (${e.functionName})`);
+        const derivationDescs = implicitWildcards.map((e) => `${e.fieldKey}.${e.targetProperty} (${e.functionName ?? '<inline fn>'})`);
         logger.warn('PropertyDerivation: custom functions without explicit dependsOn detected. ' +
             `These run on EVERY form change, which may impact performance (form has ${fieldCount} fields). ` +
             'Consider specifying explicit dependsOn arrays for better performance.', derivationDescs);
@@ -15268,31 +15515,31 @@ const BUILT_IN_FIELDS = [
         // `row` is a virtual field type: it maps to ContainerFieldComponent, and
         // the rowFieldMapper injects a `{ type: 'row' }` wrapper so the container
         // renders the flex/grid layout via RowWrapperComponent.
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-CMhqFGJZ.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-Pcxg5PQu.mjs'),
         mapper: rowFieldMapper,
         valueHandling: 'flatten',
     },
     {
         name: 'group',
-        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-BhYFIDA1.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-fzKwPrQr.mjs'),
         mapper: groupFieldMapper,
         valueHandling: 'include',
     },
     {
         name: 'array',
-        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-DbWes42V.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-DJ-LiLm_.mjs'),
         mapper: arrayFieldMapper,
         valueHandling: 'include',
     },
     {
         name: 'page',
-        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-B9v_1shD.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-BX4R9GGa.mjs'),
         mapper: pageFieldMapper,
         valueHandling: 'flatten',
     },
     {
         name: 'text',
-        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-B4LnTnIA.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-B9SK8Vun.mjs'),
         mapper: textFieldMapper,
         valueHandling: 'exclude',
         ...DISPLAY_FIELD_TYPES_BASE,
@@ -15304,7 +15551,7 @@ const BUILT_IN_FIELDS = [
     },
     {
         name: 'container',
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-CMhqFGJZ.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-Pcxg5PQu.mjs'),
         mapper: containerFieldMapper,
         valueHandling: 'flatten',
     },
@@ -15312,7 +15559,7 @@ const BUILT_IN_FIELDS = [
 const BUILT_IN_WRAPPERS = [
     {
         wrapperName: 'css',
-        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-htvP_o95.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-CJACCIEK.mjs'),
     },
     {
         wrapperName: 'row',
@@ -16386,5 +16633,5 @@ function extractErrorParams(error) {
  * Generated bundle index. Do not edit.
  */
 
-export { SubmitEvent as $, ARRAY_CONTEXT as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DynamicFormLogger as D, EventBus as E, FIELD_SIGNAL_CONTEXT as F, DEFAULT_VALIDATION_MESSAGES as G, DynamicForm as H, DynamicFormError as I, EventDispatcher as J, FIELD_REGISTRY as K, FORM_OPTIONS as L, FormClearEvent as M, FormResetEvent as N, INITIALIZATION_TIMEOUT_MS as O, InsertArrayItemEvent as P, MoveArrayItemEvent as Q, RootFormRegistryService as R, NextPageEvent as S, NoopLogger as T, PageChangeEvent as U, PopArrayItemEvent as V, WRAPPER_AUTO_ASSOCIATIONS as W, PrependArrayItemEvent as X, PreviousPageEvent as Y, RemoveAtIndexEvent as Z, ShiftArrayItemEvent as _, DEFAULT_WRAPPERS as a, WRAPPER_REGISTRY as a0, applyMetaToElement as a1, applyValidator as a2, applyValidators as a3, arrayEvent as a4, arrayFieldMapper as a5, baseFieldMapper as a6, buildBaseInputs as a7, containerFieldMapper as a8, createField as a9, resolveNextButtonDisabled as aA, resolveNonFieldDisabled as aB, resolveNonFieldHidden as aC, resolveSubmitButtonDisabled as aD, resolveTokens as aE, rowFieldMapper as aF, textFieldMapper as aG, toReadonlyFieldTree as aH, withEventFormValue as aI, withLoggerConfig as aJ, withPreviousValue as aK, withValidationExecutionDefaults as aL, withValueExclusionDefaults as aM, wrapperProps as aN, createWrappers as aa, evaluateNonFieldDisabled as ab, evaluateNonFieldHidden as ac, field as ad, formConfig as ae, getArrayLength as af, groupFieldMapper as ag, hasFormValue as ah, interpolateParams as ai, isArrayField as aj, isCheckedField as ak, isContainerField as al, isContainerTypedField as am, isDisplayOnlyField as an, isFormStateCondition as ao, isLeafField as ap, isPageField as aq, isRowField as ar, isSimplifiedArrayField as as, isValueBearingField as at, isValueField as au, isWrapperTypeDefinition as av, isWrappersBundle as aw, omit as ax, pageFieldMapper as ay, provideDynamicForm as az, isSameWrapperChain as b, createFieldResolutionPipe as c, derivedFromDeferred as d, createWrapperChainController as e, DfFieldOutlet as f, isEqual as g, createSchemaFromFields as h, injectFieldRegistry as i, createRenderReadySignal as j, ARRAY_TEMPLATE_REGISTRY as k, ARRAY_ITEM_ID_GENERATOR as l, mapFieldToInputs as m, getNormalizedArrayMetadata as n, getFieldValueHandling as o, getFieldDefaultValue as p, isGroupField as q, resolveWrappers as r, createArrayItemIdGenerator as s, ComponentInitializedEvent as t, DynamicTextPipe as u, validatePageNesting as v, dynamicTextToObservable as w, AppendArrayItemEvent as x, ConsoleLogger as y, DEFAULT_PROPS as z };
-//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-DWPPLOrV.mjs.map
+export { ShiftArrayItemEvent as $, ARRAY_CONTEXT as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DynamicFormLogger as D, EventBus as E, FIELD_SIGNAL_CONTEXT as F, GROUP_CONTEXT as G, DEFAULT_VALIDATION_MESSAGES as H, DynamicForm as I, DynamicFormError as J, EventDispatcher as K, FIELD_REGISTRY as L, FORM_OPTIONS as M, FormClearEvent as N, FormResetEvent as O, INITIALIZATION_TIMEOUT_MS as P, InsertArrayItemEvent as Q, RootFormRegistryService as R, MoveArrayItemEvent as S, NextPageEvent as T, NoopLogger as U, PageChangeEvent as V, WRAPPER_AUTO_ASSOCIATIONS as W, PopArrayItemEvent as X, PrependArrayItemEvent as Y, PreviousPageEvent as Z, RemoveAtIndexEvent as _, DEFAULT_WRAPPERS as a, SubmitEvent as a0, WRAPPER_REGISTRY as a1, applyMetaToElement as a2, applyValidator as a3, applyValidators as a4, arrayEvent as a5, arrayFieldMapper as a6, baseFieldMapper as a7, buildBaseInputs as a8, containerFieldMapper as a9, provideDynamicForm as aA, resolveNextButtonDisabled as aB, resolveNonFieldDisabled as aC, resolveNonFieldHidden as aD, resolveSubmitButtonDisabled as aE, resolveTokens as aF, rowFieldMapper as aG, textFieldMapper as aH, toReadonlyFieldTree as aI, withEventFormValue as aJ, withLoggerConfig as aK, withPreviousValue as aL, withValidationExecutionDefaults as aM, withValueExclusionDefaults as aN, wrapperProps as aO, createField as aa, createWrappers as ab, evaluateNonFieldDisabled as ac, evaluateNonFieldHidden as ad, field as ae, formConfig as af, getArrayLength as ag, groupFieldMapper as ah, hasFormValue as ai, interpolateParams as aj, isArrayField as ak, isCheckedField as al, isContainerField as am, isContainerTypedField as an, isDisplayOnlyField as ao, isFormStateCondition as ap, isLeafField as aq, isPageField as ar, isRowField as as, isSimplifiedArrayField as at, isValueBearingField as au, isValueField as av, isWrapperTypeDefinition as aw, isWrappersBundle as ax, omit as ay, pageFieldMapper as az, isSameWrapperChain as b, createFieldResolutionPipe as c, derivedFromDeferred as d, createWrapperChainController as e, DfFieldOutlet as f, isEqual as g, createSchemaFromFields as h, injectFieldRegistry as i, createRenderReadySignal as j, ARRAY_TEMPLATE_REGISTRY as k, ARRAY_ITEM_ID_GENERATOR as l, mapFieldToInputs as m, getNormalizedArrayMetadata as n, getFieldValueHandling as o, getFieldDefaultValue as p, isGroupField as q, resolveWrappers as r, createArrayItemIdGenerator as s, ComponentInitializedEvent as t, DynamicTextPipe as u, validatePageNesting as v, dynamicTextToObservable as w, AppendArrayItemEvent as x, ConsoleLogger as y, DEFAULT_PROPS as z };
+//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-o3rJX4vG.mjs.map