@ng-forge/dynamic-forms 0.9.0 → 0.10.0-next.1

package/fesm2022/{ng-forge-dynamic-forms-ng-forge-dynamic-forms-Be1Lk0qR.mjs → ng-forge-dynamic-forms-ng-forge-dynamic-forms--PuL0AKc.mjs}

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { InjectionToken, inject, reflectComponentType, Injector, EnvironmentInjector, DestroyRef, computed, signal, input, ViewContainerRef, Directive, Injectable, isSignal, untracked, linkedSignal, ChangeDetectionStrategy, Component, resourceFromSnapshots, runInInjectionContext, afterNextRender, isWritableSignal, TemplateRef, model, contentChildren, makeEnvironmentProviders, Pipe } from '@angular/core';
 import { explicitEffect } from 'ngxtension/explicit-effect';
 import { takeUntilDestroyed, toObservable, toSignal, rxResource, outputFromObservable } from '@angular/core/rxjs-interop';
-import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, Subject, filter, TimeoutError, throwError, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, tap, startWith, scan as scan$1, Observable, concatMap, take as take$1, pairwise, takeUntil, combineLatestWith, auditTime, scheduled, queueScheduler, merge, timer } from 'rxjs';
+import { of, forkJoin, from, catchError, map, switchMap, isObservable, firstValueFrom, exhaustMap, EMPTY, Subject, filter, TimeoutError, throwError, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, tap, startWith, scan as scan$1, Observable, concatMap, take as take$1, merge, pairwise, combineLatestWith, auditTime, scheduled, queueScheduler, timer } from 'rxjs';
 import { submit, email, min, max, minLength, maxLength, pattern, required, validate, validateAsync, validateHttp, disabled, readonly, hidden, applyEach, applyWhenValue, applyWhen, apply, schema, validateStandardSchema, validateTree, form, provideSignalFormsConfig } from '@angular/forms/signals';
 import { scan, map as map$1, filter as filter$1, take, switchMap as switchMap$1, timeout, catchError as catchError$1, shareReplay } from 'rxjs/operators';
 import { HttpClient } from '@angular/common/http';
@@ -2010,10 +2010,16 @@ var TokenType;
     // Punctuation
     TokenType["DOT"] = "DOT";
     TokenType["COMMA"] = "COMMA";
+    TokenType["COLON"] = "COLON";
     TokenType["LPAREN"] = "LPAREN";
     TokenType["RPAREN"] = "RPAREN";
     TokenType["LBRACKET"] = "LBRACKET";
     TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["ARROW"] = "ARROW";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["OPTIONAL_DOT"] = "OPTIONAL_DOT";
     // Special
     TokenType["EOF"] = "EOF";
 })(TokenType || (TokenType = {}));
@@ -2193,6 +2199,12 @@ class Tokenizer {
             case '||':
                 this.position += 2;
                 return { type: TokenType.OR, value: '||', position: start };
+            case '=>':
+                this.position += 2;
+                return { type: TokenType.ARROW, value: '=>', position: start };
+            case '?.':
+                this.position += 2;
+                return { type: TokenType.OPTIONAL_DOT, value: '?.', position: start };
         }
         // Single-character operators and punctuation
         this.position++;
@@ -2217,6 +2229,8 @@ class Tokenizer {
                 return { type: TokenType.DOT, value: '.', position: start };
             case ',':
                 return { type: TokenType.COMMA, value: ',', position: start };
+            case ':':
+                return { type: TokenType.COLON, value: ':', position: start };
             case '(':
                 return { type: TokenType.LPAREN, value: '(', position: start };
             case ')':
@@ -2225,6 +2239,12 @@ class Tokenizer {
                 return { type: TokenType.LBRACKET, value: '[', position: start };
             case ']':
                 return { type: TokenType.RBRACKET, value: ']', position: start };
+            case '{':
+                return { type: TokenType.LBRACE, value: '{', position: start };
+            case '}':
+                return { type: TokenType.RBRACE, value: '}', position: start };
+            case '?':
+                return { type: TokenType.QUESTION, value: '?', position: start };
             default:
                 throw new ExpressionParserError(`Unexpected character: ${char}`, start, this.expression);
         }
@@ -2260,7 +2280,88 @@ class Parser {
         return result;
     }
     parseExpression() {
-        return this.parseLogicalOr();
+        // Try arrow function first — it has the lowest precedence and would otherwise
+        // be ambiguous with grouped expressions / bare identifiers.
+        const arrow = this.tryParseArrowFunction();
+        if (arrow)
+            return arrow;
+        return this.parseConditional();
+    }
+    /**
+     * Ternary `test ? consequent : alternate` — right-associative, sits between
+     * the arrow-function check and logical-or in precedence.
+     */
+    parseConditional() {
+        const test = this.parseLogicalOr();
+        if (!this.match(TokenType.QUESTION))
+            return test;
+        const consequent = this.parseExpression();
+        this.consume(TokenType.COLON, 'Expected ":" between ternary branches');
+        const alternate = this.parseExpression();
+        return { type: 'Conditional', test, consequent, alternate };
+    }
+    /**
+     * Attempts to parse an arrow function. Returns null and leaves position
+     * unchanged if the next tokens don't form an arrow function head.
+     *
+     * Supported shapes:
+     *   x => body
+     *   () => body
+     *   (x) => body
+     *   (x, y, ...) => body
+     *
+     * Body returning an object literal must be wrapped in parens: `d => ({...})`.
+     */
+    tryParseArrowFunction() {
+        const savedPos = this.current;
+        // Single unparenthesized param: IDENTIFIER =>
+        if (this.check(TokenType.IDENTIFIER) && this.checkAt(this.current + 1, TokenType.ARROW)) {
+            const param = this.advance().value;
+            this.advance(); // consume =>
+            const body = this.parseExpression();
+            return { type: 'ArrowFunction', params: [param], body };
+        }
+        // Parenthesized params: ( ) => or ( id (, id)* ) =>
+        if (this.check(TokenType.LPAREN)) {
+            this.advance(); // tentatively consume (
+            const params = [];
+            if (this.check(TokenType.RPAREN)) {
+                this.advance(); // )
+            }
+            else if (this.check(TokenType.IDENTIFIER)) {
+                params.push(this.advance().value);
+                while (this.check(TokenType.COMMA)) {
+                    this.advance(); // ,
+                    if (!this.check(TokenType.IDENTIFIER)) {
+                        this.current = savedPos;
+                        return null;
+                    }
+                    params.push(this.advance().value);
+                }
+                if (!this.check(TokenType.RPAREN)) {
+                    this.current = savedPos;
+                    return null;
+                }
+                this.advance(); // )
+            }
+            else {
+                this.current = savedPos;
+                return null;
+            }
+            if (!this.check(TokenType.ARROW)) {
+                this.current = savedPos;
+                return null;
+            }
+            this.advance(); // =>
+            const body = this.parseExpression();
+            return { type: 'ArrowFunction', params, body };
+        }
+        return null;
+    }
+    checkAt(index, type) {
+        if (index < 0 || index >= this.tokens.length)
+            return false;
+        return this.tokens[index].type === type;
     }
     parseLogicalOr() {
         let node = this.parseLogicalAnd();
@@ -2335,6 +2436,32 @@ class Parser {
                 const property = this.advance().value;
                 node = { type: 'MemberAccess', object: node, property };
             }
+            else if (this.match(TokenType.OPTIONAL_DOT)) {
+                // Optional chain — supports `?.prop`, `?.[expr]`, and `?.(args)`.
+                if (this.match(TokenType.LBRACKET)) {
+                    const property = this.parseExpression();
+                    this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                    node = { type: 'ComputedMemberAccess', object: node, property, optional: true };
+                }
+                else if (this.match(TokenType.LPAREN)) {
+                    const args = this.parseArgumentList();
+                    this.consume(TokenType.RPAREN, 'Expected ")" after arguments');
+                    node = { type: 'CallExpression', callee: node, arguments: args, optional: true };
+                }
+                else if (this.check(TokenType.IDENTIFIER)) {
+                    const property = this.advance().value;
+                    node = { type: 'MemberAccess', object: node, property, optional: true };
+                }
+                else {
+                    throw new ExpressionParserError('Expected property name, "[", or "(" after "?."', this.peek().position, this.expression);
+                }
+            }
+            else if (this.match(TokenType.LBRACKET)) {
+                // Computed member access: obj[expr]
+                const property = this.parseExpression();
+                this.consume(TokenType.RBRACKET, 'Expected "]" after computed property');
+                node = { type: 'ComputedMemberAccess', object: node, property };
+            }
             else if (this.match(TokenType.LPAREN)) {
                 // Function call: func()
                 const args = this.parseArgumentList();
@@ -2373,6 +2500,12 @@ class Parser {
             this.consume(TokenType.RBRACKET, 'Expected "]" after array elements');
             return { type: 'ArrayLiteral', elements };
         }
+        // Object literal
+        if (this.match(TokenType.LBRACE)) {
+            const properties = this.parseObjectProperties();
+            this.consume(TokenType.RBRACE, 'Expected "}" after object properties');
+            return { type: 'ObjectLiteral', properties };
+        }
         // Identifier
         if (this.match(TokenType.IDENTIFIER)) {
             return { type: 'Identifier', name: this.previous().value };
@@ -2403,6 +2536,28 @@ class Parser {
         }
         return elements;
     }
+    parseObjectProperties() {
+        const properties = [];
+        if (this.check(TokenType.RBRACE)) {
+            return properties;
+        }
+        do {
+            // Trailing comma support: `{ a: 1, }`
+            if (this.check(TokenType.RBRACE))
+                break;
+            let key;
+            if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.STRING)) {
+                key = this.advance().value;
+            }
+            else {
+                throw new ExpressionParserError(`Expected property name (identifier or string) in object literal, got '${this.peek().value}'`, this.peek().position, this.expression);
+            }
+            this.consume(TokenType.COLON, 'Expected ":" after property name in object literal');
+            const value = this.parseExpression();
+            properties.push({ key, value });
+        } while (this.match(TokenType.COMMA));
+        return properties;
+    }
     match(...types) {
         for (const type of types) {
             if (this.check(type)) {
@@ -2577,14 +2732,22 @@ class Evaluator {
                 return this.evaluateIdentifier(node.name);
             case 'MemberAccess':
                 return this.evaluateMemberAccess(node);
+            case 'ComputedMemberAccess':
+                return this.evaluateComputedMemberAccess(node);
             case 'BinaryOp':
                 return this.evaluateBinaryOp(node);
             case 'UnaryOp':
                 return this.evaluateUnaryOp(node);
             case 'CallExpression':
                 return this.evaluateCallExpression(node);
+            case 'Conditional':
+                return this.evaluate(node.test) ? this.evaluate(node.consequent) : this.evaluate(node.alternate);
             case 'ArrayLiteral':
                 return this.evaluateArrayLiteral(node);
+            case 'ObjectLiteral':
+                return this.evaluateObjectLiteral(node);
+            case 'ArrowFunction':
+                return this.evaluateArrowFunction(node);
             default:
                 throw new ExpressionParserError(`Unknown node type: ${node.type}`, 0, this.expression);
         }
@@ -2610,6 +2773,27 @@ class Evaluator {
         }
         return undefined;
     }
+    evaluateComputedMemberAccess(node) {
+        const obj = this.evaluate(node.object);
+        if (obj === null || obj === undefined) {
+            // Both `obj?.[expr]` and `obj[expr]` short-circuit on null/undefined —
+            // matches the safe-access behavior of dotted member access above.
+            return undefined;
+        }
+        const rawKey = this.evaluate(node.property);
+        if (rawKey === null || rawKey === undefined)
+            return undefined;
+        const key = String(rawKey);
+        // Same blocklist as dotted access — `obj['__proto__']` must be rejected
+        // even though the property name was computed.
+        if (BLOCKED_PROPERTIES.has(key)) {
+            throw new ExpressionParserError(`Property "${key}" is not accessible for security reasons`, 0, this.expression);
+        }
+        if (typeof obj === 'object' || typeof obj === 'string' || typeof obj === 'number') {
+            return obj[key];
+        }
+        return undefined;
+    }
     evaluateBinaryOp(node) {
         // Handle short-circuit evaluation for logical operators
         if (node.operator === '&&') {
@@ -2674,11 +2858,21 @@ class Evaluator {
         }
     }
     evaluateCallExpression(node) {
-        // Only allow method calls (member access), not arbitrary function calls
+        // Only allow method calls (member access). Computed access (`obj['method']()`)
+        // is also rejected — the security model whitelists method names statically.
         if (node.callee.type !== 'MemberAccess') {
             throw new ExpressionParserError('Only method calls are allowed, not arbitrary function calls', 0, this.expression);
         }
         const obj = this.evaluate(node.callee.object);
+        // Calling a method on a nullish receiver silently returns undefined —
+        // consistent with how dotted member access (`obj.prop`) treats nullish
+        // receivers above. This means `a?.b()`, `a?.b.c()`, and `nullable.method()`
+        // all short-circuit to undefined rather than tripping the whitelist check
+        // with a misleading "method not allowed" error. The whitelist still
+        // enforces strictly on non-nullish receivers.
+        if (obj === null || obj === undefined) {
+            return undefined;
+        }
         const methodName = node.callee.property;
         // Block access to dangerous properties (must check before method call)
         if (BLOCKED_PROPERTIES.has(methodName)) {
@@ -2701,6 +2895,28 @@ class Evaluator {
     evaluateArrayLiteral(node) {
         return node.elements.map((element) => this.evaluate(element));
     }
+    evaluateObjectLiteral(node) {
+        const result = {};
+        for (const { key, value } of node.properties) {
+            if (BLOCKED_PROPERTIES.has(key)) {
+                throw new ExpressionParserError(`Property "${key}" is not allowed in object literals for security reasons`, 0, this.expression);
+            }
+            result[key] = this.evaluate(value);
+        }
+        return result;
+    }
+    evaluateArrowFunction(node) {
+        const parentScope = this.scope;
+        const expression = this.expression;
+        return (...args) => {
+            const childScope = { ...parentScope };
+            for (let i = 0; i < node.params.length; i++) {
+                childScope[node.params[i]] = args[i];
+            }
+            const childEvaluator = new Evaluator(childScope, expression);
+            return childEvaluator.evaluate(node.body);
+        };
+    }
     isMethodSafe(obj, methodName) {
         if (obj === null || obj === undefined) {
             return false;
@@ -4241,9 +4457,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-n4KTMOTm.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-n4KTMOTm.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-Bz2RpleR.mjs').then(m => m.default)], () => [import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs').then(m => m.default)]] });
 }
-i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-n4KTMOTm.mjs').then(m => m.default)], resolveMetadata: PageFieldComponent => ({ decorators: [{
+i0.ɵɵngDeclareClassMetadataAsync({ minVersion: "18.0.0", version: "21.2.14", ngImport: i0, type: PageOrchestratorComponent, resolveDeferredDeps: () => [import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.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) {
@@ -13413,21 +13629,67 @@ function validateNoCycles(collection, logger) {
 }
 
 /**
- * Creates a staleness guard for HTTP/async derivation streams.
+ * Compares two entry lists as multisets of content signatures. Order-insensitive
+ * — entries reordered with the same content compare equal, so topological-sort
+ * reorderings triggered by unrelated entries don't churn downstream stream
+ * lifecycles.
+ *
+ * Multiset (not set) semantics: two distinct entries with identical signatures
+ * are counted separately, so `[A, B]` does NOT equal `[A, A]` even though both
+ * have length 2 and both contain `A` as a signature.
  *
- * - Call `invalidate()` when tearing down the current generation of streams.
- * - Pipe HTTP requests through `takeUntil(guard$)` to automatically discard
- *   in-flight responses that arrive after the generation has been invalidated.
+ * Used by the value-derivation and property-derivation orchestrators to gate
+ * `distinctUntilChanged` over HTTP- and async-function-entry sets.
+ *
+ * @internal
  */
-function createStreamGuard() {
-    const subject = new Subject();
-    return {
-        invalidate: () => subject.next(),
-        guard$: subject.asObservable().pipe(take$1(1)),
-    };
+function entrySetsEqual(prev, next, sig) {
+    if (prev.length !== next.length)
+        return false;
+    const counts = new Map();
+    for (const item of prev) {
+        const key = sig(item);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    for (const item of next) {
+        const key = sig(item);
+        const remaining = counts.get(key);
+        if (!remaining)
+            return false;
+        if (remaining === 1)
+            counts.delete(key);
+        else
+            counts.set(key, remaining - 1);
+    }
+    return counts.size === 0;
 }
-const LOG_PREFIX$1 = 'HTTP Derivation -';
-const DEFAULT_HTTP_DEBOUNCE_MS = 300;
+/**
+ * Declarative pipeline shared by both derivation orchestrators:
+ *
+ * 1. Project the collection down to a typed entry list.
+ * 2. Skip rebuilds when the entry set hasn't changed (multiset comparison).
+ * 3. `switchMap` cancels the previous merged inner streams and creates fresh
+ *    ones from the new entries; in-flight HTTP / async work is cancelled via
+ *    ordinary RxJS unsubscribe semantics.
+ *
+ * No mutable subscription bookkeeping; the caller pipes through
+ * `takeUntilDestroyed` for unmount cleanup.
+ *
+ * @internal
+ */
+function buildEntryStreamPipeline(config) {
+    return config.collection$.pipe(map((collection) => config.selectEntries(collection)), distinctUntilChanged((prev, next) => entrySetsEqual(prev, next, config.entrySignature)), switchMap((entries) => {
+        if (entries.length === 0)
+            return EMPTY;
+        const streams = entries.map((entry) => config.createStream(entry)).filter((stream) => stream !== null);
+        if (streams.length === 0)
+            return EMPTY;
+        return merge(...streams);
+    }));
+}
+
+const LOG_PREFIX$3 = 'HTTP Derivation -';
+const DEFAULT_HTTP_DEBOUNCE_MS$1 = 300;
 /**
  * Creates an RxJS Observable stream that processes an HTTP derivation entry.
  *
@@ -13451,7 +13713,7 @@ const DEFAULT_HTTP_DEBOUNCE_MS = 300;
 function createHttpDerivationStream(entry, formValue$, context) {
     // Guard: no array support for HTTP derivations
     if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX$1} HTTP derivation for array field '${entry.fieldKey}' is not supported. ` +
+        context.logger.warn(`${LOG_PREFIX$3} HTTP derivation for array field '${entry.fieldKey}' is not supported. ` +
             `Array HTTP derivations will be supported in a future release.`);
         return EMPTY;
     }
@@ -13460,7 +13722,7 @@ function createHttpDerivationStream(entry, formValue$, context) {
     }
     // Capture after the guard — TS narrows this to `string` here
     const responseExpression = entry.responseExpression;
-    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS;
+    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS$1;
     return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
         current: current,
         changedFields: getChangedKeys(previous, current),
@@ -13554,15 +13816,16 @@ function createHttpDerivationStream(entry, formValue$, context) {
                 subscriber.complete();
                 return;
             }
-            // Make the HTTP request. takeUntil(guard$) automatically discards responses
-            // that arrive after the config has changed and the guard has been invalidated.
+            // Cancellation is handled declaratively by the orchestrator's outer
+            // switchMap: when the entry set changes, the outer stream unsubscribes
+            // from this inner observable, the cleanup callback below runs, and
+            // the in-flight HTTP request is cancelled.
             const method = (resolvedRequest.method ?? 'GET').toUpperCase();
             const httpSub = context.httpClient
                 .request(method, resolvedRequest.url, {
                 body: resolvedRequest.body,
                 headers: resolvedRequest.headers,
             })
-                .pipe(takeUntil(context.guard$))
                 .subscribe({
                 next: (response) => {
                     try {
@@ -13597,13 +13860,13 @@ function createHttpDerivationStream(entry, formValue$, context) {
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX$1} Failed to process response for '${entry.fieldKey}': ${message}`);
+                        context.logger.warn(`${LOG_PREFIX$3} Failed to process response for '${entry.fieldKey}': ${message}`);
                         subscriber.complete();
                     }
                 },
                 error: (error) => {
                     const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX$1} HTTP request failed for '${entry.fieldKey}': ${message}`);
+                    context.logger.warn(`${LOG_PREFIX$3} HTTP request failed for '${entry.fieldKey}': ${message}`);
                     subscriber.complete();
                 },
             });
@@ -13617,13 +13880,13 @@ function createHttpDerivationStream(entry, formValue$, context) {
     }), catchError$1((error) => {
         // Safety net — should not normally be reached since inner errors are caught
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}': ${message}`);
+        context.logger.warn(`${LOG_PREFIX$3} Unexpected stream error for '${entry.fieldKey}': ${message}`);
         return EMPTY;
     }));
 }
 
-const LOG_PREFIX = 'Async Derivation -';
-const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
+const LOG_PREFIX$2 = 'Async Derivation -';
+const DEFAULT_ASYNC_DEBOUNCE_MS$1 = 300;
 /**
  * Creates an RxJS Observable stream that processes an async derivation entry.
  *
@@ -13642,22 +13905,22 @@ const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
 function createAsyncDerivationStream(entry, formValue$, context) {
     // Guard: no array support for async derivations
     if (isArrayPlaceholderPath(entry.fieldKey)) {
-        context.logger.warn(`${LOG_PREFIX} Async derivation for array field '${entry.fieldKey}' is not supported. ` +
+        context.logger.warn(`${LOG_PREFIX$2} Async derivation for array field '${entry.fieldKey}' is not supported. ` +
             `Array async derivations will be supported in a future release.`);
         return EMPTY;
     }
     if (!entry.asyncFunctionName && !entry.asyncFn) {
-        context.logger.warn(`${LOG_PREFIX} Derivation for '${entry.fieldKey}' has neither "asyncFunctionName" nor "asyncFn". ` +
+        context.logger.warn(`${LOG_PREFIX$2} Derivation for '${entry.fieldKey}' has neither "asyncFunctionName" nor "asyncFn". ` +
             `One of the two is required for source: 'asyncFunction'.`);
         return EMPTY;
     }
     if (entry.asyncFn && entry.asyncFunctionName) {
-        context.logger.warn(`${LOG_PREFIX} Both "asyncFn" and "asyncFunctionName" are set on derivation for '${entry.fieldKey}'. ` +
+        context.logger.warn(`${LOG_PREFIX$2} Both "asyncFn" and "asyncFunctionName" are set on derivation for '${entry.fieldKey}'. ` +
             `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
     }
     const inlineAsyncFn = entry.asyncFn;
     const asyncFunctionName = entry.asyncFunctionName;
-    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
+    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS$1;
     // startWith(null) → pairwise() causes all fields to appear "changed" on the
     // first emission (null vs actual form value), so every dependsOn field matches.
     // This intentionally fires the async derivation on initial form load — same
@@ -13704,7 +13967,7 @@ function createAsyncDerivationStream(entry, formValue$, context) {
             // 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}'. ` +
+                context.logger.warn(`${LOG_PREFIX$2} Async derivation function '${asyncFunctionName}' not found for field '${entry.fieldKey}'. ` +
                     `Register it in customFnConfig.asyncDerivations.`);
                 subscriber.complete();
                 return;
@@ -13772,13 +14035,13 @@ function createAsyncDerivationStream(entry, formValue$, context) {
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}': ${message}`);
+                        context.logger.warn(`${LOG_PREFIX$2} Failed to process result for '${entry.fieldKey}': ${message}`);
                         subscriber.complete();
                     }
                 },
                 error: (error) => {
                     const message = error instanceof Error ? error.message : String(error);
-                    context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}': ${message}`);
+                    context.logger.warn(`${LOG_PREFIX$2} Async function failed for '${entry.fieldKey}': ${message}`);
                     subscriber.complete();
                 },
                 complete: () => {
@@ -13795,7 +14058,7 @@ function createAsyncDerivationStream(entry, formValue$, context) {
     }), catchError$1((error) => {
         // Safety net — should not normally be reached since inner errors are caught
         const message = error instanceof Error ? error.message : String(error);
-        context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}': ${message}`);
+        context.logger.warn(`${LOG_PREFIX$2} Unexpected stream error for '${entry.fieldKey}': ${message}`);
         return EMPTY;
     }));
 }
@@ -13873,20 +14136,6 @@ class DerivationOrchestrator {
     functionRegistry = inject(FunctionRegistryService);
     formOptions = inject(FORM_OPTIONS);
     httpClient = inject(HttpClient, { optional: true });
-    /** Active HTTP derivation stream subscriptions */
-    httpSubscriptions = [];
-    /** Identity keys of current HTTP entries for smart teardown comparison */
-    lastHttpEntryKeys = null;
-    /** Active async function derivation stream subscriptions */
-    asyncFunctionSubscriptions = [];
-    /** Identity keys of current async entries for smart teardown comparison */
-    lastAsyncEntryKeys = null;
-    /**
-     * Guard for detecting stale HTTP responses. Call `invalidate()` on teardown to cancel
-     * in-flight requests from the previous generation. Each HTTP stream subscribes via
-     * `takeUntil(guard$)` — when `invalidate()` fires, all in-flight requests are discarded.
-     */
-    streamGuard = createStreamGuard();
     /**
      * Computed signal containing the collected and validated derivations.
      * Returns null if no derivations are defined.
@@ -14042,36 +14291,33 @@ class DerivationOrchestrator {
         }
     }
     /**
-     * Sets up reactive HTTP derivation streams that react to collection changes.
+     * Builds a declarative stream that reacts to changes in the set of HTTP
+     * derivation entries and emits per-entry streams merged together.
      *
-     * Subscribes to derivationCollection changes and creates per-entry HTTP streams.
-     * Uses smart teardown: only recreates streams when HTTP entries actually change.
+     * - `distinctUntilChanged` over the set of entry signatures skips rebuilds
+     *   when the HTTP entries haven't actually changed. The comparison is
+     *   order-insensitive — `topologicalSort` in the collector can reorder
+     *   existing entries when unrelated entries are added/removed, and we
+     *   don't want to tear down healthy streams in that case.
+     * - `switchMap` cancels the previous merged stream when entries change,
+     *   which propagates into each `createHttpDerivationStream` and cancels
+     *   any in-flight HTTP requests via ordinary RxJS unsubscribe semantics.
+     *
+     * No mutable subscription bookkeeping or stream guard — `takeUntilDestroyed`
+     * on the outer subscription handles unmount.
      */
     setupHttpStreams() {
-        toObservable(this.derivationCollection, { injector: this.injector })
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe((collection) => {
-            const httpEntries = collection?.entries.filter((entry) => entry.http) ?? [];
-            if (httpEntries.length === 0) {
-                this.teardownHttpStreams();
-                this.lastHttpEntryKeys = null;
-                return;
-            }
-            // Smart teardown: compare entry identity keys to avoid redundant stream recreation
-            const newKeys = this.computeHttpEntryKeys(httpEntries);
-            if (this.lastHttpEntryKeys && this.setsEqual(this.lastHttpEntryKeys, newKeys)) {
-                return; // No change in HTTP entries — keep existing streams
-            }
-            // Validate HttpClient availability
-            if (!this.httpClient) {
-                this.logger.error('HTTP Derivation: HttpClient is not available. ' + 'Ensure provideHttpClient() is included in your application providers.');
-                return;
-            }
-            // Tear down previous streams and create new ones
-            this.teardownHttpStreams();
-            this.lastHttpEntryKeys = newKeys;
-            const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-            for (const entry of httpEntries) {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.derivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
+            entrySignature: httpEntrySignature$1,
+            createStream: (entry) => {
+                if (!this.httpClient) {
+                    this.logger.error('HTTP Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
+                    return null;
+                }
                 const context = {
                     formValue: this.config.formValue,
                     form: this.config.form,
@@ -14081,119 +14327,77 @@ class DerivationOrchestrator {
                     customFunctions: () => this.functionRegistry.getCustomFunctions(),
                     externalData: () => resolveExternalData(this.config.externalData),
                     warningTracker: this.warningTracker,
-                    guard$: this.streamGuard.guard$,
                 };
-                const stream = createHttpDerivationStream(entry, formValue$, context).pipe(takeUntilDestroyed(this.destroyRef));
-                this.httpSubscriptions.push(stream.subscribe({
-                    error: (err) => this.logger.error(`HTTP Derivation: Stream error for '${entry.fieldKey}'`, err),
-                }));
-            }
-        });
-    }
-    /**
-     * Tears down all active HTTP derivation streams. Invalidating the stream guard
-     * cancels any in-flight HTTP responses from the old generation via `takeUntil`.
-     */
-    teardownHttpStreams() {
-        this.streamGuard.invalidate();
-        for (const sub of this.httpSubscriptions) {
-            sub.unsubscribe();
-        }
-        this.httpSubscriptions = [];
-    }
-    /**
-     * Computes a set of identity keys for HTTP entries.
-     * Used for smart teardown comparison.
-     */
-    computeHttpEntryKeys(entries) {
-        return new Set(entries.map((entry) => `${entry.fieldKey}:${JSON.stringify(entry.http, Object.keys(entry.http ?? {}).sort())}`));
-    }
-    /**
-     * Compares two sets for equality.
-     */
-    setsEqual(a, b) {
-        if (a.size !== b.size)
-            return false;
-        for (const item of a) {
-            if (!b.has(item))
-                return false;
-        }
-        return true;
+                return createHttpDerivationStream(entry, formValue$, context);
+            },
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('HTTP Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
     }
-    /**
-     * Sets up reactive async function derivation streams that react to collection changes.
-     *
-     * Subscribes to derivationCollection changes and creates per-entry async streams.
-     * Uses smart teardown: only recreates streams when async entries actually change.
-     */
     setupAsyncFunctionStreams() {
-        toObservable(this.derivationCollection, { injector: this.injector })
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe((collection) => {
-            const asyncEntries = collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [];
-            if (asyncEntries.length === 0) {
-                this.teardownAsyncFunctionStreams();
-                this.lastAsyncEntryKeys = null;
-                return;
-            }
-            // Smart teardown: compare entry identity keys to avoid redundant stream recreation
-            const newKeys = this.computeAsyncEntryKeys(asyncEntries);
-            if (this.lastAsyncEntryKeys && this.setsEqual(this.lastAsyncEntryKeys, newKeys)) {
-                return; // No change in async entries — keep existing streams
-            }
-            // Tear down previous streams and create new ones
-            this.teardownAsyncFunctionStreams();
-            this.lastAsyncEntryKeys = newKeys;
-            const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
-            for (const entry of asyncEntries) {
-                const context = {
-                    formValue: this.config.formValue,
-                    form: this.config.form,
-                    logger: this.logger,
-                    derivationLogger: this.config.derivationLogger,
-                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
-                    asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
-                    externalData: () => resolveExternalData(this.config.externalData),
-                    warningTracker: this.warningTracker,
-                };
-                const stream = createAsyncDerivationStream(entry, formValue$, context).pipe(takeUntilDestroyed(this.destroyRef));
-                this.asyncFunctionSubscriptions.push(stream.subscribe({
-                    error: (err) => this.logger.error(`Async Derivation: Stream error for '${entry.fieldKey}'`, err),
-                }));
-            }
-        });
-    }
-    /**
-     * Tears down all active async function derivation streams.
-     */
-    teardownAsyncFunctionStreams() {
-        for (const sub of this.asyncFunctionSubscriptions) {
-            sub.unsubscribe();
-        }
-        this.asyncFunctionSubscriptions = [];
-    }
-    /**
-     * Computes a set of identity keys for async entries.
-     * 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,
-                reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
-            };
-            return `${entry.fieldKey}:${JSON.stringify(config, Object.keys(config).sort())}`;
-        }));
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.derivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
+            entrySignature: asyncEntrySignature$1,
+            createStream: (entry) => createAsyncDerivationStream(entry, formValue$, {
+                formValue: this.config.formValue,
+                form: this.config.form,
+                logger: this.logger,
+                derivationLogger: this.config.derivationLogger,
+                customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
+                externalData: () => resolveExternalData(this.config.externalData),
+                warningTracker: this.warningTracker,
+            }),
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('Async Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
     }
 }
+/**
+ * Identity signature for an HTTP derivation entry. Includes every field that
+ * drives the inner stream's behavior — changing any of them must tear down
+ * and rebuild the stream. Stable across topological reorderings because the
+ * consumer ({@link entrySetsEqual}) compares as a multiset.
+ */
+function httpEntrySignature$1(entry) {
+    const config = {
+        http: entry.http,
+        responseExpression: entry.responseExpression,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+        stopOnUserOverride: entry.stopOnUserOverride,
+        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
+    };
+    return `${entry.fieldKey}:${JSON.stringify(config)}`;
+}
+function asyncEntrySignature$1(entry) {
+    // For inline `asyncFn` entries we tag the signature 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.
+    const config = {
+        asyncFunctionName: entry.asyncFunctionName,
+        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}` : undefined,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+        stopOnUserOverride: entry.stopOnUserOverride,
+        reEngageOnDependencyChange: entry.reEngageOnDependencyChange,
+    };
+    return `${entry.fieldKey}:${JSON.stringify(config)}`;
+}
 /**
  * Creates a DerivationOrchestrator for a dynamic form.
  * Must be called within an injection context.
@@ -14501,6 +14705,27 @@ function withLoggerConfig(config = true) {
     return createFeature('logger', providers);
 }
 
+/**
+ * Creates an empty property derivation collection.
+ *
+ * @returns Empty collection
+ *
+ * @internal
+ */
+function createEmptyPropertyDerivationCollection() {
+    return { entries: [] };
+}
+/**
+ * Returns true when the entry's value source is async (HTTP or async function)
+ * and therefore must be processed by a dedicated stream subscription rather
+ * than the synchronous applicator pipeline.
+ *
+ * @internal
+ */
+function isAsyncPropertyDerivationEntry(entry) {
+    return Boolean(entry.http) || Boolean(entry.asyncFunctionName) || Boolean(entry.asyncFn);
+}
+
 /** @internal */
 const ERROR_PREFIX = '[PropertyDerivation]';
 /**
@@ -14521,7 +14746,10 @@ function applyPropertyDerivations(collection, context, changedFields) {
     let appliedCount = 0;
     let skippedCount = 0;
     let errorCount = 0;
-    const entriesToProcess = changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries;
+    const baseEntries = changedFields ? getEntriesForChangedFields(collection.entries, changedFields) : collection.entries;
+    // Async entries (HTTP / asyncFn / asyncFunctionName) are processed by dedicated
+    // stream subscriptions in the orchestrator, not by this synchronous applicator.
+    const entriesToProcess = baseEntries.filter((entry) => !isAsyncPropertyDerivationEntry(entry));
     for (const entry of entriesToProcess) {
         try {
             const applied = tryApplyPropertyDerivation(entry, context);
@@ -14766,6 +14994,78 @@ function collectFromField(field, entries, context) {
  */
 function createPropertyDerivationEntryFromDerivation(fieldKey, config, context) {
     const effectiveFieldKey = buildPropertyOverrideKey(context.arrayPath, context.arrayPath ? PLACEHOLDER_INDEX : undefined, fieldKey, context.groupPath);
+    // HTTP and async function property derivations require explicit, non-wildcard
+    // dependencies — mirrors the same guards on value-derivation HTTP/async sources.
+    //
+    // Type-level discriminants require these fields, but JSON-loaded configs can
+    // bypass that — so we defensively guard against missing arrays and missing
+    // HTTP fields here to fail fast with `DynamicFormError` instead of throwing
+    // an opaque `TypeError` later.
+    //
+    // `targetProperty` is captured up front and `untypedConfig` is used inside
+    // the source-narrowed blocks because TypeScript narrows `config` to `never`
+    // once we negate a discriminant-required field (e.g. `!config.http` when
+    // `source: 'http'` requires `http`).
+    const errorLocation = `'${effectiveFieldKey}.${config.targetProperty}'`;
+    const untypedConfig = config;
+    // Reject configs that mix value-source fields with an explicit async source.
+    // TypeScript's discriminated union already enforces this XOR for inline
+    // configs; the runtime check guards JSON-loaded configs (API/OpenAPI/MCP)
+    // where the wrong combination would silently degrade — async entries are
+    // routed to the stream pipeline while sync fields would be ignored.
+    if (untypedConfig.source === 'http' || untypedConfig.source === 'asyncFunction') {
+        const conflictingSyncSources = [];
+        if (untypedConfig.value !== undefined)
+            conflictingSyncSources.push('value');
+        if (untypedConfig.expression !== undefined)
+            conflictingSyncSources.push('expression');
+        if (untypedConfig.functionName !== undefined)
+            conflictingSyncSources.push('functionName');
+        if (untypedConfig.fn !== undefined)
+            conflictingSyncSources.push('fn');
+        if (conflictingSyncSources.length > 0) {
+            throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: ${JSON.stringify(untypedConfig.source)}' alongside ` +
+                `sync value source(s) [${conflictingSyncSources.join(', ')}]. These are mutually exclusive — remove either ` +
+                `the sync fields or the async source.`);
+        }
+    }
+    // Reject HTTP + asyncFunction-field combinations as well (TS already
+    // enforces this; runtime guard for JSON-loaded configs).
+    if (untypedConfig.source === 'http' && (untypedConfig.asyncFunctionName !== undefined || untypedConfig.asyncFn !== undefined)) {
+        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "http"' alongside an async function — these are mutually exclusive.`);
+    }
+    if (untypedConfig.source === 'asyncFunction' && (untypedConfig.http !== undefined || untypedConfig.responseExpression !== undefined)) {
+        throw new DynamicFormError(`Property derivation for ${errorLocation} sets 'source: "asyncFunction"' alongside HTTP fields — these are mutually exclusive.`);
+    }
+    if (untypedConfig.source === 'http') {
+        if (!untypedConfig.http) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires an 'http' config object.`);
+        }
+        if (typeof untypedConfig.responseExpression !== 'string' || untypedConfig.responseExpression.trim() === '') {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires a non-empty 'responseExpression'.`);
+        }
+        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
+                `Wildcard dependencies would trigger HTTP requests on every form change.`);
+        }
+        if (untypedConfig.dependsOn.includes('*')) {
+            throw new DynamicFormError(`HTTP property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
+                `Wildcards would trigger HTTP requests on every form change. Specify explicit field dependencies instead.`);
+        }
+    }
+    if (untypedConfig.source === 'asyncFunction') {
+        if (!untypedConfig.asyncFunctionName && !untypedConfig.asyncFn) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires either 'asyncFunctionName' or 'asyncFn'.`);
+        }
+        if (!Array.isArray(untypedConfig.dependsOn) || untypedConfig.dependsOn.length === 0) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} requires explicit 'dependsOn'. ` +
+                `Wildcard dependencies would trigger async functions on every form change.`);
+        }
+        if (untypedConfig.dependsOn.includes('*')) {
+            throw new DynamicFormError(`Async property derivation for ${errorLocation} cannot use wildcard ('*') in 'dependsOn'. ` +
+                `Wildcards would trigger async functions on every form change. Specify explicit field dependencies instead.`);
+        }
+    }
     const dependsOn = extractDependenciesFromConfig(config);
     const condition = config.condition ?? true;
     const trigger = config.trigger ?? 'onChange';
@@ -14779,6 +15079,10 @@ function createPropertyDerivationEntryFromDerivation(fieldKey, config, context)
         expression: config.expression,
         functionName: config.functionName,
         fn: extractInlineFn(config),
+        http: config.http,
+        responseExpression: config.responseExpression,
+        asyncFunctionName: config.asyncFunctionName,
+        asyncFn: extractInlineAsyncFn(config),
         trigger,
         debounceMs,
         debugName: config.debugName,
@@ -14786,6 +15090,204 @@ function createPropertyDerivationEntryFromDerivation(fieldKey, config, context)
     };
 }
 
+const LOG_PREFIX$1 = 'HTTP Property Derivation -';
+const DEFAULT_HTTP_DEBOUNCE_MS = 300;
+/**
+ * Creates an RxJS Observable stream that processes an HTTP property-derivation entry.
+ *
+ * Mirrors `createHttpDerivationStream` (value pipeline) but writes the result via
+ * `store.setOverride(fieldKey, targetProperty, value)` instead of patching the form.
+ *
+ * The stream uses `startWith(null) → pairwise()` so the first emission fires a
+ * request for all `dependsOn` fields, populating the derived property on initial
+ * form load. Subsequent emissions only fire when a `dependsOn` field changes.
+ *
+ * @internal
+ */
+function createHttpPropertyDerivationStream(entry, formValue$, context) {
+    // Guard: no array support yet for HTTP property derivations (mirrors value pipeline).
+    if (isArrayPlaceholderPath(entry.fieldKey)) {
+        context.logger.warn(`${LOG_PREFIX$1} HTTP property derivation for array field '${entry.fieldKey}' is not supported. ` +
+            `Array HTTP property derivations will be supported in a future release.`);
+        return EMPTY;
+    }
+    if (!entry.http || !entry.responseExpression) {
+        return EMPTY;
+    }
+    const responseExpression = entry.responseExpression;
+    const debounceMs = entry.debounceMs ?? DEFAULT_HTTP_DEBOUNCE_MS;
+    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
+        current: current,
+        changedFields: getChangedKeys(previous, current),
+    })), filter(({ changedFields }) => {
+        if (changedFields.size === 0)
+            return false;
+        return entry.dependsOn.some((dep) => changedFields.has(dep));
+    }), debounceTime(debounceMs), switchMap(({ current }) => {
+        return new Observable((subscriber) => {
+            const customFunctions = context.customFunctions?.();
+            const externalData = context.externalData?.();
+            const fieldValue = getNestedValue(current, entry.fieldKey);
+            const evalContext = {
+                fieldValue,
+                formValue: current,
+                fieldPath: entry.fieldKey,
+                customFunctions,
+                externalData,
+                logger: context.logger,
+            };
+            // Evaluate condition — skip if false
+            if (entry.condition !== true) {
+                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
+                if (!conditionMet) {
+                    subscriber.complete();
+                    return;
+                }
+            }
+            // Returns null when a path param is undefined — suppress the request
+            const resolvedRequest = resolveHttpRequest(entry.http, evalContext);
+            if (!resolvedRequest) {
+                subscriber.complete();
+                return;
+            }
+            const method = (resolvedRequest.method ?? 'GET').toUpperCase();
+            // Inner cancellation is handled declaratively by the orchestrator's
+            // outer switchMap: when the entry set changes, the outer stream
+            // unsubscribes from this inner observable, which triggers the
+            // cleanup callback below and cancels the in-flight HTTP request.
+            const httpSub = context.httpClient
+                .request(method, resolvedRequest.url, {
+                body: resolvedRequest.body,
+                headers: resolvedRequest.headers,
+            })
+                .subscribe({
+                next: (response) => {
+                    try {
+                        const newValue = ExpressionParser.evaluate(responseExpression, { response });
+                        // `setOverride` performs its own deep-equality check, so we don't need to
+                        // compare with the current store value here.
+                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
+                        subscriber.complete();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        context.logger.warn(`${LOG_PREFIX$1} Failed to process response for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                        subscriber.complete();
+                    }
+                },
+                error: (error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    context.logger.warn(`${LOG_PREFIX$1} HTTP request failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                httpSub.unsubscribe();
+            };
+        });
+    }), catchError$1((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        context.logger.warn(`${LOG_PREFIX$1} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+        return EMPTY;
+    }));
+}
+
+const LOG_PREFIX = 'Async Property Derivation -';
+const DEFAULT_ASYNC_DEBOUNCE_MS = 300;
+/**
+ * Creates an RxJS Observable stream that processes an async-function property-derivation entry.
+ *
+ * Mirrors `createAsyncDerivationStream` (value pipeline) but writes the result via
+ * `store.setOverride(fieldKey, targetProperty, value)` instead of patching the form.
+ *
+ * @internal
+ */
+function createAsyncPropertyDerivationStream(entry, formValue$, context) {
+    if (isArrayPlaceholderPath(entry.fieldKey)) {
+        context.logger.warn(`${LOG_PREFIX} Async property derivation for array field '${entry.fieldKey}' is not supported. ` +
+            `Array async property derivations will be supported in a future release.`);
+        return EMPTY;
+    }
+    if (!entry.asyncFunctionName && !entry.asyncFn) {
+        context.logger.warn(`${LOG_PREFIX} Property derivation for '${entry.fieldKey}.${entry.targetProperty}' has neither "asyncFunctionName" nor "asyncFn". ` +
+            `One of the two is required for source: 'asyncFunction'.`);
+        return EMPTY;
+    }
+    if (entry.asyncFn && entry.asyncFunctionName) {
+        context.logger.warn(`${LOG_PREFIX} Both "asyncFn" and "asyncFunctionName" are set on property derivation for '${entry.fieldKey}.${entry.targetProperty}'. ` +
+            `Inline "asyncFn" takes precedence; "asyncFunctionName" is ignored.`);
+    }
+    const inlineAsyncFn = entry.asyncFn;
+    const asyncFunctionName = entry.asyncFunctionName;
+    const debounceMs = entry.debounceMs ?? DEFAULT_ASYNC_DEBOUNCE_MS;
+    return formValue$.pipe(startWith(null), pairwise(), map(([previous, current]) => ({
+        current: current,
+        changedFields: getChangedKeys(previous, current),
+    })), filter(({ changedFields }) => {
+        if (changedFields.size === 0)
+            return false;
+        return entry.dependsOn.some((dep) => changedFields.has(dep));
+    }), debounceTime(debounceMs), switchMap(({ current }) => {
+        return new Observable((subscriber) => {
+            const customFunctions = context.customFunctions?.();
+            const asyncDerivationFunctions = context.asyncDerivationFunctions?.();
+            const externalData = context.externalData?.();
+            const asyncFn = inlineAsyncFn ?? (asyncFunctionName ? asyncDerivationFunctions?.[asyncFunctionName] : undefined);
+            if (!asyncFn) {
+                context.logger.warn(`${LOG_PREFIX} Async derivation function '${asyncFunctionName}' not found for '${entry.fieldKey}.${entry.targetProperty}'. ` +
+                    `Register it in customFnConfig.asyncDerivations.`);
+                subscriber.complete();
+                return;
+            }
+            const fieldValue = getNestedValue(current, entry.fieldKey);
+            const evalContext = {
+                fieldValue,
+                formValue: current,
+                fieldPath: entry.fieldKey,
+                customFunctions,
+                externalData,
+                logger: context.logger,
+            };
+            if (entry.condition !== true) {
+                const conditionMet = typeof entry.condition === 'boolean' ? entry.condition : evaluateCondition(entry.condition, evalContext);
+                if (!conditionMet) {
+                    subscriber.complete();
+                    return;
+                }
+            }
+            const result$ = from(asyncFn(evalContext));
+            const asyncSub = result$.subscribe({
+                next: (newValue) => {
+                    try {
+                        untracked(() => context.store.setOverride(entry.fieldKey, entry.targetProperty, newValue));
+                        subscriber.complete();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        context.logger.warn(`${LOG_PREFIX} Failed to process result for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                        subscriber.complete();
+                    }
+                },
+                error: (error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    context.logger.warn(`${LOG_PREFIX} Async function failed for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+                    subscriber.complete();
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+            });
+            return () => {
+                asyncSub.unsubscribe();
+            };
+        });
+    }), catchError$1((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        context.logger.warn(`${LOG_PREFIX} Unexpected stream error for '${entry.fieldKey}.${entry.targetProperty}': ${message}`);
+        return EMPTY;
+    }));
+}
+
 /**
  * Orchestrates property derivation processing for a dynamic form.
  *
@@ -14805,6 +15307,7 @@ class PropertyDerivationOrchestrator {
     deprecationTracker = inject(DEPRECATION_WARNING_TRACKER);
     functionRegistry = inject(FunctionRegistryService);
     formOptions = inject(FORM_OPTIONS);
+    httpClient = inject(HttpClient, { optional: true });
     /**
      * Computed signal containing the collected property derivations.
      * Returns null if no property derivations are defined.
@@ -14840,6 +15343,8 @@ class PropertyDerivationOrchestrator {
         });
         this.setupOnChangeStream();
         this.setupDebouncedStream();
+        this.setupHttpStreams();
+        this.setupAsyncFunctionStreams();
     }
     setupOnChangeStream() {
         const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
@@ -14909,6 +15414,103 @@ class PropertyDerivationOrchestrator {
         };
         applyPropertyDerivationsForTrigger(filteredCollection, 'debounced', applicatorContext, changedFields);
     }
+    /**
+     * Declarative pipeline for HTTP property-derivation entries. Delegates the
+     * collection-watching / dedup / cancellation plumbing to
+     * {@link buildEntryStreamPipeline} so both orchestrators share one
+     * implementation.
+     *
+     * Errors inside `createStream` invocations are isolated via the inner
+     * stream's own `catchError`; we additionally wrap the outer pipeline so a
+     * synchronous throw during stream construction (e.g., evaluation of a
+     * `condition`) doesn't tear the whole pipeline down for the lifetime of
+     * the form.
+     */
+    setupHttpStreams() {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.http) ?? [],
+            entrySignature: httpEntrySignature,
+            createStream: (entry) => {
+                if (!this.httpClient) {
+                    this.logger.error('HTTP Property Derivation: HttpClient is not available. Ensure provideHttpClient() is included in your application providers.');
+                    return null;
+                }
+                return createHttpPropertyDerivationStream(entry, formValue$, {
+                    formValue: this.config.formValue,
+                    store: this.config.store,
+                    httpClient: this.httpClient,
+                    logger: this.logger,
+                    customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                    externalData: () => resolveExternalData(this.config.externalData),
+                });
+            },
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('HTTP Property Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    setupAsyncFunctionStreams() {
+        const formValue$ = toObservable(this.config.formValue, { injector: this.injector });
+        const collection$ = toObservable(this.propertyDerivationCollection, { injector: this.injector });
+        buildEntryStreamPipeline({
+            collection$,
+            selectEntries: (collection) => collection?.entries.filter((entry) => entry.asyncFunctionName || entry.asyncFn) ?? [],
+            entrySignature: asyncEntrySignature,
+            createStream: (entry) => createAsyncPropertyDerivationStream(entry, formValue$, {
+                formValue: this.config.formValue,
+                store: this.config.store,
+                logger: this.logger,
+                customFunctions: () => this.functionRegistry.getCustomFunctions(),
+                asyncDerivationFunctions: () => this.functionRegistry.getAsyncDerivationFunctions(),
+                externalData: () => resolveExternalData(this.config.externalData),
+            }),
+        })
+            .pipe(catchError((err) => {
+            this.logger.error('Async Property Derivation: outer stream error', err);
+            return EMPTY;
+        }), takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+}
+/**
+ * Identity signature for an HTTP property-derivation entry. Includes every
+ * field that drives the inner stream's behavior — changing any of them must
+ * tear down and rebuild the stream. Stable across topological reorderings
+ * because the consumer ({@link entrySetsEqual}) compares as a multiset.
+ */
+function httpEntrySignature(entry) {
+    const config = {
+        http: entry.http,
+        responseExpression: entry.responseExpression,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+    };
+    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
+}
+/**
+ * Identity signature for an async-function property-derivation entry. Same
+ * principle as {@link httpEntrySignature}: include every field the inner
+ * stream closes over so changes force a rebuild. Inline `asyncFn`s use the
+ * `fieldKey.targetProperty` path as a stable identifier — function identity
+ * isn't JSON-serializable.
+ */
+function asyncEntrySignature(entry) {
+    const config = {
+        asyncFunctionName: entry.asyncFunctionName,
+        asyncFnId: entry.asyncFn ? `inline:${entry.fieldKey}.${entry.targetProperty}` : undefined,
+        dependsOn: entry.dependsOn,
+        debounceMs: entry.debounceMs,
+        trigger: entry.trigger,
+        condition: entry.condition,
+    };
+    return `${entry.fieldKey}.${entry.targetProperty}:${JSON.stringify(config)}`;
 }
 /**
  * Creates a PropertyDerivationOrchestrator for a dynamic form.
@@ -16326,35 +16928,35 @@ 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-CrOIZEL_.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-C554hOxN.mjs'),
         mapper: rowFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'group',
-        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-DqnhddRH.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-group-field.component-BJ8j7Sh0.mjs'),
         mapper: groupFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'array',
-        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-Tw49K5kz.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-array-field.component-GiaVHO9N.mjs'),
         mapper: arrayFieldMapper,
         valueHandling: 'include',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'page',
-        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-n4KTMOTm.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-page-field.component-Bz2RpleR.mjs'),
         mapper: pageFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
     },
     {
         name: 'text',
-        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-C14mlROS.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-text-field.component-BGw6T-4h.mjs'),
         mapper: textFieldMapper,
         valueHandling: 'exclude',
         ...DISPLAY_FIELD_TYPES_BASE,
@@ -16366,7 +16968,7 @@ const BUILT_IN_FIELDS = [
     },
     {
         name: 'container',
-        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-CrOIZEL_.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-container-field.component-C554hOxN.mjs'),
         mapper: containerFieldMapper,
         valueHandling: 'flatten',
         ...CONTAINER_FIELD_TYPES_BASE,
@@ -16375,7 +16977,7 @@ const BUILT_IN_FIELDS = [
 const BUILT_IN_WRAPPERS = [
     {
         wrapperName: 'css',
-        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-Q2g56KUM.mjs'),
+        loadComponent: () => import('./ng-forge-dynamic-forms-css-wrapper.component-CnJgFWLB.mjs'),
     },
     {
         wrapperName: 'row',
@@ -18168,4 +18770,4 @@ function extractErrorParams(error) {
  */
 
 export { arrayFieldMapper as $, ADDON_ACTION_HANDLERS as A, BUILT_IN_FIELDS as B, CONTAINER_FIELD_PROCESSORS as C, DEFAULT_PROPS as D, EventBus as E, FIELD_REGISTRY as F, GROUP_CONTEXT as G, NoopLogger as H, INITIALIZATION_TIMEOUT_MS as I, PopArrayItemEvent as J, PrependArrayItemEvent as K, PreviousPageEvent as L, MoveArrayItemEvent as M, NextPageEvent as N, RootFormRegistryService as O, PageChangeEvent as P, SubmitEvent as Q, RemoveAtIndexEvent as R, ShiftArrayItemEvent as S, TemplateAddonComponent as T, TextAddonComponent as U, WRAPPER_REGISTRY as V, WRAPPER_AUTO_ASSOCIATIONS as W, applyMetaToElement as X, applyValidator as Y, applyValidators as Z, arrayEvent as _, ADDON_ACTION_REGISTRY as a, textFieldMapper as a$, baseFieldMapper as a0, buildBaseInputs as a1, containerFieldMapper as a2, createField as a3, createFieldResolutionPipe as a4, createHiddenSignal as a5, createRenderReadySignal as a6, createSchemaFromFields as a7, createWrapperChainController as a8, createWrappers as a9, isGroupField as aA, isLeafField as aB, isPageField as aC, isRowField as aD, isSameWrapperChain as aE, isSimplifiedArrayField as aF, isValueBearingField as aG, isValueField as aH, isWrapperTypeDefinition as aI, isWrappersBundle as aJ, logAddonWarnings as aK, mapFieldToInputs as aL, omit as aM, pageFieldMapper as aN, provideAddonActions as aO, provideDynamicForm as aP, resolveDynamicValue as aQ, resolveNextButtonDisabled as aR, resolveNonFieldDisabled as aS, resolveNonFieldHidden as aT, resolveSubmitButtonDisabled as aU, resolveTokens as aV, resolveWrappers as aW, rowFieldMapper as aX, runPresetAction as aY, sanitizeFormConfig as aZ, sanitizeFormConfigPure as a_, derivedFromDeferred as aa, dynamicTextToObservable as ab, evaluateNonFieldDisabled as ac, evaluateNonFieldHidden as ad, field as ae, formConfig as af, formatAddonWarning as ag, getArrayLength as ah, getFieldDefaultValue as ai, getFieldValueHandling as aj, getNormalizedArrayMetadata as ak, groupFieldMapper as al, hasFormValue as am, injectAddonKindRegistry as an, injectFieldRegistry as ao, injectFieldSignalContext as ap, injectFieldsSupportingAddons as aq, interpolateParams as ar, isArrayField as as, isCheckedField as at, isContainerField as au, isContainerTypedField as av, isDisplayOnlyField as aw, isEqual as ax, isFieldBoundContext as ay, isFormStateCondition as az, ADDON_KIND_COMPONENT_CACHE as b, toReadonlyFieldTree as b0, validateFieldAddons as b1, validatePageNesting as b2, walkAndValidateAddons as b3, withCustomAddon as b4, withEventFormValue as b5, withLegacyStatusClasses as b6, withLoggerConfig as b7, withPreviousValue as b8, withValidationExecutionDefaults as b9, withValueExclusionDefaults as ba, wrapperProps as bb, writeToFieldValue as bc, ADDON_KIND_DEFINITIONS as c, ADDON_KIND_REGISTRY as d, ARRAY_CONTEXT as e, AppendArrayItemEvent as f, ArrayItemRegistryService as g, ComponentAddonComponent as h, ComponentInitializedEvent as i, ConsoleLogger as j, DEFAULT_VALIDATION_MESSAGES as k, DEFAULT_WRAPPERS as l, DF_FIELD_TEMPLATES as m, DfAddonSlot as n, DfFieldOutlet as o, DfTemplate as p, DynamicForm as q, DynamicFormError as r, DynamicFormLogger as s, DynamicTextPipe as t, EventDispatcher as u, FIELD_SIGNAL_CONTEXT as v, FORM_OPTIONS as w, FormClearEvent as x, FormResetEvent as y, InsertArrayItemEvent as z };
-//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms-Be1Lk0qR.mjs.map
+//# sourceMappingURL=ng-forge-dynamic-forms-ng-forge-dynamic-forms--PuL0AKc.mjs.map