@praxisui/dynamic-form 9.0.5-rc.36 → 9.0.5-rc.37

package/README.md

@@ -31,15 +31,15 @@ Peer dependencies:
 
 ## Reactive backend determinations
 
-When the exact request schema from `/schemas/filtered` publishes root-level `x-ui.reactiveDeterminations`, the form can execute the Metadata-compiled backend capability after a valid source changes and apply server-derived draft values. The projection is backend-owned, tenant-neutral and transient: it is never copied to `FormConfig` and cannot be authored as a callback, URL or local write policy.
+When the exact request schema from `/schemas/filtered` publishes root-level `x-ui.reactiveDeterminations`, the form executes the Metadata-compiled backend capability after a valid source changes and applies server-derived draft values. After edit/create hydration, an already populated source is also validated before the draft can be reported as stable; an empty initial source settles as not applicable without an HTTP call. The projection is one closed graph: if any definition is malformed, the complete projection is rejected instead of partially executing. It remains backend-owned, tenant-neutral and transient: it is never copied to `FormConfig` and cannot be authored as a callback, URL or local write policy.
 
 Triggers, source fields and request/response bindings use JSON Pointer. The runtime supports nested object bindings, accepts at most 64 total input/output bindings and rejects duplicate or hierarchically overlapping pointers. It resolves the capability only against the configured API origin and rejects protocol-relative, encoded-separator or cross-origin targets. Output bindings have one closed meaning: server-derived draft values replace their targets. Metadata cannot select `if-pristine`, `if-empty` or another incidental UI policy.
 
-The runtime waits until hydration finishes and invalidates the previous generation as soon as a newer relevant value or validation status arrives, before the new debounce completes. `sourcePaths` is an intentional trigger subset of `inputs`: changing a non-trigger input invalidates the current draft, emits `input-changed-awaiting-trigger`, and blocks submit/navigation until a source trigger recalculates it. Every configured response path is resolved before target controls are written; all nested targets are populated before change observers are notified. Chained determinations receive one logical batch signal after the complete commit, rather than one execution per output control. Their dependency order uses hierarchical input/output JSON Pointer overlap, and the canonical projection rejects cycles and overlapping multi-writers. Downstream waits while upstream is pending and runs only after authoritative outputs or confirmed unchanged inputs. Null/undefined upstream outputs and failed, invalid or cancelled upstream generations settle downstream as skipped instead of invoking it with missing or stale data. If a control rejects a write, the runtime attempts to restore earlier writes and reports a terminal failure. This is a coordinated client-side batch, not a transaction or an ACID guarantee.
+The runtime waits until hydration finishes and invalidates the previous generation as soon as a newer relevant value or validation status arrives, before the new debounce completes. `sourcePaths` is an intentional trigger subset of `inputs`: changing a non-trigger input invalidates the current draft, emits `input-changed-awaiting-trigger`, and blocks submit/navigation until a source trigger recalculates it. Every configured response path is resolved before target controls are written; all nested targets are populated before change observers are notified. Chained determinations receive one logical batch signal after the complete commit, rather than one execution per output control. Their dependency order uses hierarchical input/output JSON Pointer overlap, and the canonical projection rejects cycles and overlapping multi-writers. Downstream waits while upstream is pending and runs only after authoritative outputs or confirmed unchanged inputs. Null/undefined upstream outputs and failed, invalid or cancelled upstream generations settle downstream as skipped instead of invoking it with missing or stale data. If a control rejects a write, the runtime attempts to restore earlier writes and reports a terminal failure. This is a coordinated client-side batch, not a transaction or an ACID guarantee. Each capability remains a separate HTTP request, so an activation may occur between two chained previews; only a host command that resolves and revalidates one aggregate can claim snapshot consistency for the complete business decision.
 
 A determination remains pending through debounce, asynchronous validation and capability execution. Submit attempts wait with a bounded timeout and repeat the stability check after hooks that may mutate controls. Output controls are disabled transiently as server-owned draft values, but remain present in `getRawValue()`, `valueChange` and submit payloads; this state is not persisted in `FormConfig`.
 
-Hosts can observe metadata-only evidence through `reactiveDeterminationExecuted` and aggregate state through `reactiveDeterminationPendingChange`. Before navigating or closing a composed surface, inspect `hasPendingReactiveDeterminations()` and `hasUnsatisfiedReactiveDeterminations()` and await `waitForReactiveDeterminations(timeoutMs?)`; `false` means timeout or that the latest generation did not produce a current authoritative draft, and must block the transition. Cancelled pending correlations terminate as `skipped/superseded`. No event or method exposes form or response values.
+Hosts can observe metadata-only evidence through `reactiveDeterminationExecuted` and aggregate state through `reactiveDeterminationPendingChange`. Before navigating or closing a composed surface, inspect `hasPendingReactiveDeterminations()` and `hasUnsatisfiedReactiveDeterminations()` and await `waitForReactiveDeterminations(timeoutMs?)`; `false` means timeout or that the latest generation did not produce a current authoritative draft, and must block the transition. A programmatic change to an owned output invalidates the previous authority and triggers a new determination. Cancelled pending correlations terminate as `skipped/superseded`. No event or method exposes form or response values.
 
 Use `optionSource.dependsOn` for dependent option lists and workflow actions for persistent transitions. Recommendations, side-effect refresh and backend validation are separate capabilities. The final backend command must still authorize, recompute or validate fiscal, pricing, eligibility, compliance and approval outcomes.
 

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-08-19T00:10:40.048Z",
+  "generatedAt": "2026-08-19T01:49:06.767Z",
   "packageName": "@praxisui/dynamic-form",
-  "packageVersion": "9.0.5-rc.36",
+  "packageVersion": "9.0.5-rc.37",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 2,

package/fesm2022/praxisui-dynamic-form.mjs

@@ -20,7 +20,7 @@ import * as i9 from '@angular/material/snack-bar';
 import { MatSnackBarModule } from '@angular/material/snack-bar';
 import * as i19 from '@angular/material/badge';
 import { MatBadgeModule } from '@angular/material/badge';
-import { map, Subscription, merge, timer, NEVER, EMPTY, defer, TimeoutError, of, Subject, firstValueFrom, BehaviorSubject, throwError, combineLatest, debounceTime as debounceTime$1, takeUntil as takeUntil$1 } from 'rxjs';
+import { map, Subscription, merge, of, timer, NEVER, EMPTY, defer, TimeoutError, Subject, firstValueFrom, BehaviorSubject, throwError, combineLatest, debounceTime as debounceTime$1, takeUntil as takeUntil$1 } from 'rxjs';
 import { filter, map as map$1, switchMap, take, timeout, throwIfEmpty, tap, catchError, ignoreElements, finalize, takeUntil, skip, debounceTime, startWith } from 'rxjs/operators';
 import * as i1 from '@praxisui/core';
 import { serializeEntityLookupValueForPayload, PraxisI18nService, PraxisIconButtonComponent, PraxisIconDirective, providePraxisI18nConfig, RULE_PROPERTY_SCHEMA, FIELD_METADATA_CAPABILITIES, migrateFormLayoutRule, PraxisJsonLogicService, normalizeFormLayoutItems, deepMerge, createDefaultFormConfig, normalizeFormConfig as normalizeFormConfig$1, ensureIds, createEmptyRichContentDocument, resolveHidden, resolveOrder, resolveSpan, projectGroupedCommandPartialRows, isPraxisRuntimeGlobalActionEffect, ASYNC_CONFIG_STORAGE, withFormConfigSections, createFieldLayoutItem, getFormLayoutFieldNames, LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, ResourceDiscoveryService, GlobalActionService, ResourceQuickConnectComponent, composeHeadersWithVersion, buildApiUrl, mapFieldDefinitionsToMetadata, reconcileFormConfig, materializeFormLayoutFromMetadata, syncWithServerMetadata, PRAXIS_LOADING_CTX, evaluateFieldAccess, normalizeControlTypeKey, normalizePraxisEffectPolicy, buildPraxisEffectDistinctKey, getFormColumnFieldNames, resolveGroupedCommandPartialRowSpans, resolveOffset, buildSchemaIdStorageKeySegment, buildSchemaId, fetchWithETag, resolveControlTypeAlias, getTextTransformer, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, normalizeReactiveDeterminations, CONNECTION_STORAGE, API_URL, PRAXIS_LOADING_RENDERER, FORM_HOOKS_PRESETS, EmptyStateCardComponent, isValidFormConfig, ComponentMetadataRegistry, FieldControlType, isRequiredGlobalActionPayloadMissing, GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, SURFACE_OPEN_I18N_NAMESPACE, getGlobalActionUiSchema, getRequiredGlobalActionPayloadKeys, hasMeaningfulGlobalActionPayloadValue, SurfaceOpenActionEditorComponent, SURFACE_OPEN_I18N_CONFIG, validateGlobalActionRefs, normalizeFormMetadata } from '@praxisui/core';
@@ -265,6 +265,7 @@ class ReactiveDeterminationRuntimeService {
             const determinationKey = determinationKeyFor(definitionIndex, definition);
             let generation = 0;
             let lastSuccessfulFingerprint = null;
+            let lastSuccessfulOutputFingerprint = null;
             const triggerControls = this.resolveControls(form, definition.trigger.sourcePaths);
             const inputControls = this.resolveControls(form, definition.inputs.map((binding) => binding.fieldPath));
             const targetControls = this.resolveControls(form, definition.outputs.map((binding) => binding.fieldPath));
@@ -296,11 +297,24 @@ class ReactiveDeterminationRuntimeService {
             }
             composite.add(this.claimTargets(form, targetControls));
             const triggerControlSet = new Set(triggerControls);
-            const observedControls = [...new Set([...triggerControls, ...inputControls])];
+            const targetControlSet = new Set(targetControls);
+            const dependencyObservedControls = [...new Set([...triggerControls, ...inputControls])];
+            const directlyObservedControls = [
+                ...new Set([...dependencyObservedControls, ...targetControls]),
+            ];
             const committedControls$ = this.getOrCreateCommittedControls(form);
-            const changes$ = merge(...observedControls.flatMap((control) => [control.valueChanges, control.statusChanges].map((changes) => changes.pipe(filter(() => !this.publishingCommitByForm.has(form)), map$1(() => triggerControlSet.has(control))))), committedControls$.pipe(filter((committedControls) => observedControls.some((control) => committedControls.has(control))), map$1((committedControls) => triggerControls.some((control) => committedControls.has(control)))));
+            const changes$ = merge(of({
+                shouldExecute: triggerControls.some((control) => hasMeaningfulSourceValue(control.value)),
+                initial: true,
+            }), ...directlyObservedControls.flatMap((control) => [control.valueChanges, control.statusChanges].map((changes) => changes.pipe(filter(() => !this.publishingCommitByForm.has(form)), map$1(() => ({
+                shouldExecute: triggerControlSet.has(control) || targetControlSet.has(control),
+                initial: false,
+            }))))), committedControls$.pipe(filter((committedControls) => dependencyObservedControls.some((control) => committedControls.has(control))), map$1((committedControls) => ({
+                shouldExecute: triggerControls.some((control) => committedControls.has(control)),
+                initial: false,
+            }))));
             const determinationSubscription = changes$
-                .pipe(map$1((shouldExecute) => {
+                .pipe(map$1(({ shouldExecute, initial }) => {
                 const currentGeneration = ++generation;
                 const correlationId = createCorrelationId();
                 // Publish the new authority before switchMap finalizes the old one.
@@ -308,6 +322,10 @@ class ReactiveDeterminationRuntimeService {
                 if (shouldExecute) {
                     publishEvent(this.event(definition, 'pending', correlationId, 0));
                 }
+                else if (initial) {
+                    this.satisfyGeneration(form, determinationKey, currentGeneration);
+                    publishEvent(this.event(definition, 'skipped', correlationId, 0, 'initial-source-empty'));
+                }
                 else {
                     publishEvent(this.event(definition, 'skipped', correlationId, 0, 'input-changed-awaiting-trigger'));
                 }
@@ -340,7 +358,10 @@ class ReactiveDeterminationRuntimeService {
                             publishEvent(this.event(definition, 'error', signal.correlationId, 0, 'request-binding-invalid'));
                             return EMPTY;
                         }
-                        if (invocation.fingerprint === lastSuccessfulFingerprint) {
+                        const currentOutputFingerprint = this.buildOutputFingerprint(form, definition);
+                        if (invocation.fingerprint === lastSuccessfulFingerprint &&
+                            currentOutputFingerprint !== null &&
+                            currentOutputFingerprint === lastSuccessfulOutputFingerprint) {
                             this.satisfyGeneration(form, determinationKey, signal.generation);
                             publishEvent(this.event(definition, 'skipped', signal.correlationId, 0, 'unchanged-inputs'));
                             return EMPTY;
@@ -358,6 +379,7 @@ class ReactiveDeterminationRuntimeService {
                             this.commit(form, commit);
                             this.satisfyGeneration(form, determinationKey, signal.generation);
                             lastSuccessfulFingerprint = invocation.fingerprint;
+                            lastSuccessfulOutputFingerprint = this.buildOutputFingerprint(form, definition);
                             publishEvent(this.event(definition, 'success', signal.correlationId, Date.now() - startedAt, undefined, commit.map((entry) => entry.targetPath)));
                         }), catchError((error) => {
                             if (this.isCurrentGeneration(form, determinationKey, signal.generation)) {
@@ -467,6 +489,16 @@ class ReactiveDeterminationRuntimeService {
         }
         return entries;
     }
+    buildOutputFingerprint(form, definition) {
+        const values = [];
+        for (const binding of definition.outputs) {
+            const control = form.get(jsonPointerSegments(binding.fieldPath));
+            if (!control)
+                return null;
+            values.push(control.value);
+        }
+        return stableFingerprint(values);
+    }
     commit(form, entries) {
         // Reactive Determination outputs have one closed semantic: server-derived
         // draft values. Metadata cannot choose an overwrite policy.
@@ -703,6 +735,15 @@ function stableFingerprint(value) {
         return String(value);
     }
 }
+function hasMeaningfulSourceValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'string')
+        return value.trim().length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
 function createCorrelationId() {
     const runtimeCrypto = globalThis.crypto;
     if (runtimeCrypto && typeof runtimeCrypto.randomUUID === 'function') {
@@ -11112,6 +11153,12 @@ class PraxisDynamicFormDestroyedError extends Error {
 const FORM_CONFIG_LOAD_TIMEOUT_MS = 1200;
 const FORM_INPUT_PREFS_LOAD_TIMEOUT_MS = 1200;
 const SCHEMA_GLOBAL_CONFIG_READY_TIMEOUT_MS = 1200;
+class InvalidReactiveDeterminationProjectionError extends Error {
+    constructor() {
+        super('Invalid x-ui.reactiveDeterminations projection.');
+        this.name = 'InvalidReactiveDeterminationProjectionError';
+    }
+}
 const PRAXIS_DYNAMIC_FORM_FALLBACK_LOGGER = new LoggerService(createCorporateLoggerConfig('dev'), [new ConsoleLoggerSink()]);
 class PraxisDynamicForm {
     crud;
@@ -20058,15 +20105,24 @@ class PraxisDynamicForm {
                 if (hooks && typeof hooks === 'object') {
                     this.schemaRootHooks = hooks;
                 }
+                const rawDeterminations = rootUi && typeof rootUi === 'object'
+                    ? rootUi.reactiveDeterminations
+                    : undefined;
                 const normalizedDeterminations = ctx.schemaType === 'request'
-                    ? normalizeReactiveDeterminations(rootUi && typeof rootUi === 'object'
-                        ? rootUi.reactiveDeterminations
-                        : undefined)
+                    ? normalizeReactiveDeterminations(rawDeterminations)
                     : [];
+                if (ctx.schemaType === 'request' && rawDeterminations !== undefined && (!Array.isArray(rawDeterminations)
+                    || normalizedDeterminations.length !== rawDeterminations.length)) {
+                    throw new InvalidReactiveDeterminationProjectionError();
+                }
                 this.schemaRootReactiveDeterminations = normalizedDeterminations.filter((definition) => !this.schemaRootOperationId
                     || definition.scope.schemaOperationId === this.schemaRootOperationId);
             }
-            catch { }
+            catch (error) {
+                if (error instanceof InvalidReactiveDeterminationProjectionError) {
+                    throw error;
+                }
+            }
             const schemaId = buildSchemaId(schemaContext);
             this.lastSchemaMeta = { schemaId, serverHash: entry.schemaHash, context: schemaContext };
             this.schemaCache = defs;
@@ -20091,6 +20147,9 @@ class PraxisDynamicForm {
             return defs;
         }
         catch (error) {
+            if (error instanceof InvalidReactiveDeterminationProjectionError) {
+                throw error;
+            }
             if (this.isDestroyed || error instanceof PraxisDynamicFormDestroyedError) {
                 throw new PraxisDynamicFormDestroyedError();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/dynamic-form",
-  "version": "9.0.5-rc.36",
+  "version": "9.0.5-rc.37",
   "description": "Angular dynamic form engine for Praxis UI: metadata-driven forms, hooks, and services integrating @praxisui/* packages.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
@@ -9,13 +9,13 @@
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "@praxisui/ai": "^9.0.5-rc.36",
-    "@praxisui/dynamic-fields": "^9.0.5-rc.36",
-    "@praxisui/metadata-editor": "^9.0.5-rc.36",
-    "@praxisui/rich-content": "^9.0.5-rc.36",
-    "@praxisui/settings-panel": "^9.0.5-rc.36",
-    "@praxisui/visual-builder": "^9.0.5-rc.36",
-    "@praxisui/core": "^9.0.5-rc.36",
+    "@praxisui/ai": "^9.0.5-rc.37",
+    "@praxisui/dynamic-fields": "^9.0.5-rc.37",
+    "@praxisui/metadata-editor": "^9.0.5-rc.37",
+    "@praxisui/rich-content": "^9.0.5-rc.37",
+    "@praxisui/settings-panel": "^9.0.5-rc.37",
+    "@praxisui/visual-builder": "^9.0.5-rc.37",
+    "@praxisui/core": "^9.0.5-rc.37",
     "rxjs": "^7.8.0"
   },
   "dependencies": {

package/src/lib/praxis-dynamic-form.json-api.md

@@ -78,13 +78,13 @@ Este documento e a referencia canonica da API JSON de praxis-dynamic-form.
 ## Backend-owned reactive determinations
 
 - `x-ui.reactiveDeterminations` e lido exclusivamente do request schema exato retornado por `/schemas/filtered`; nao integra nem e persistido em `FormConfig`.
-- O runtime aceita somente o contrato fechado normalizado por `normalizeReactiveDeterminations`: trigger `on-change`, scope de create/edit, capability `POST`, no maximo 64 bindings totais, JSON Pointers sem duplicidade ou sobreposicao hierarquica e provenance estrutural.
+- O runtime aceita somente o contrato fechado normalizado por `normalizeReactiveDeterminations`: trigger `on-change`, scope de create/edit, capability `POST`, no maximo 64 bindings totais, JSON Pointers sem duplicidade ou sobreposicao hierarquica e provenance estrutural. A lista e um unico grafo canonico: uma definicao invalida rejeita a projecao inteira, sem execucao parcial.
 - `href`, request/response schemas e bindings sao compilados pelo Praxis Metadata. O Angular nao aceita callback, headers, method, URL ou write policy autorados pelo host/editor/LLM.
 - Cada valor ou status relevante invalida imediatamente a geracao anterior, antes do debounce da proxima chamada; somente a geracao ainda autoritativa pode aplicar a resposta.
 - Hrefs protocol-relative, com separadores codificados ou resolvidos fora da origem configurada da API falham de forma fechada.
 - A resposta so e aplicada quando todos os bindings existem. Os controles alvo aninhados sao preenchidos antes da notificacao dos observers; determinacoes encadeadas recebem um unico sinal logico depois do commit completo, nao um disparo por output. A ordem da cadeia e derivada dos bindings existentes: downstream aguarda a geracao upstream e so executa apos outputs autoritativos ou inputs confirmados como inalterados. Output upstream `null`/`undefined` e geracao upstream com erro, invalida ou cancelada encerram downstream como `skipped`, sem chamada com dado ausente ou obsoleto. Se um controle rejeitar a escrita, o runtime tenta restaurar os anteriores e emite falha terminal. O resultado tem semantica fechada server-derived e substitui o draft alvo; o commit e um batch coordenado no cliente, sem promessa de transacao ACID.
 - O estado permanece pending durante debounce, validacao assincrona e execucao. Uma tentativa de submit aguarda estabilizacao com timeout e repete a espera depois de hooks que podem alterar controles.
-- Controles de output sao desabilitados transitoriamente como valores server-derived, sem mutar/persistir `FormConfig`; seus valores continuam em `getRawValue()`, `valueChange` e no payload de submit.
+- Controles de output sao desabilitados transitoriamente como valores server-derived, sem mutar/persistir `FormConfig`; seus valores continuam em `getRawValue()`, `valueChange` e no payload de submit. Depois da hidratacao, fonte inicialmente preenchida entra em `pending` e e determinada antes de o draft ser considerado estavel; fonte inicial vazia encerra como `skipped/initial-source-empty`, satisfeita e sem HTTP. Alteracao programatica posterior em output owned invalida a autoridade anterior e reexecuta a capability.
 - `reactiveDeterminationExecuted` publica apenas IDs, paths, provenance, estado (`pending`, `success`, `skipped` ou `error`), duracao, correlation ID e motivo. Valores do formulario e da resposta nao participam da evidencia.
 - Hosts compostos recebem estado agregado por `reactiveDeterminationPendingChange`. Antes de navegar ou fechar, devem consultar `hasPendingReactiveDeterminations()` e `hasUnsatisfiedReactiveDeterminations()` e aguardar `waitForReactiveDeterminations(timeoutMs?)`; retorno `false` indica timeout ou geração mais recente sem draft autoritativo e bloqueia a transição. Correlações canceladas recebem terminal `skipped/superseded`.
 - Cascatas de opcoes continuam em `optionSource.dependsOn`; recommendations, side-effect refresh, backend validation e workflow actions permanecem capacidades separadas.

package/types/praxisui-dynamic-form.d.ts

@@ -380,6 +380,7 @@ declare class ReactiveDeterminationRuntimeService {
     private claimTargets;
     private buildInvocation;
     private buildCommit;
+    private buildOutputFingerprint;
     private commit;
     private getOrCreateCommittedControls;
     private event;