@praxisui/core 10.0.0-rc.26 → 10.0.0-rc.27

package/README.md

@@ -57,9 +57,10 @@ const preview = await firstValueFrom(bulkClient.readProposalResults(contract, pr
 await session.confirm(idempotencyKeyForThisIntent);
 // On an uncertain HTTP failure, retain this session and retry with the same key.
 // The host schedules further authorized readbacks for an accepted nonterminal execution.
-if (!session.isTerminal()) await session.refreshExecution();
+const reads = new AbortController(); // This view owns GET lifetime, not confirmation custody.
+if (!session.isTerminal()) await session.refreshExecution(reads.signal);
 if (session.isTerminal()) {
-  const results = await session.readResults();
+  const results = await session.readResults(200, undefined, reads.signal);
 }
 ```
 
@@ -69,6 +70,24 @@ the descriptor. The caller controls when to read status again and presents each
 authorized page of results. This example is a service integration sketch, not a
 ready visual workflow or a deployment claim.
 
+`refreshExecution(signal?)` and `readResults(size?, after?, signal?)` retain their
+Promise API and optionally accept a standard `AbortSignal`. An already aborted
+signal dispatches no GET; abort unsubscribes the actual HTTP request, releases the
+read slot, and prevents a late Promise continuation from updating the session.
+Abort listeners are removed on success, failure and cancellation. A cancelled GET
+keeps the original proposal, confirmation key and accepted execution; it does not
+mark that execution terminal or prove rollback. A new authorized read may observe
+the same execution. Overlapping execution refreshes remain rejected, while an
+aborted generation cannot release the slot of its successor.
+
+The caller owns GET cancellation and its observation budget; the Core session does
+not invent a global read timeout. Use a fresh read lifetime for a fresh consultation
+and abort reads when the owning view closes. Do not race a Promise with a timer:
+connect the signal to the read itself so the HTTP subscription is torn down.
+`evaluate` and `confirm` do not accept this signal: a dispatched POST and its original
+key stay in intent custody across view teardown. GET failure/cancellation must never
+start a new evaluation or confirmation automatically.
+
 The backend is the authority on proposal expiry. A client clock hint must not
 block a same-key replay after an uncertain confirmation; the backend may return
 409 or 410 and the host must explain that state without inventing a new intent.

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-10-15T19:07:41.629Z",
+  "generatedAt": "2026-10-15T22:42:56.841Z",
   "packageName": "@praxisui/core",
-  "packageVersion": "10.0.0-rc.26",
+  "packageVersion": "10.0.0-rc.27",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 4,

package/fesm2022/praxisui-core.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { Component, InjectionToken, Injectable, inject, Inject, Optional, SkipSelf, makeEnvironmentProviders, signal, computed, APP_INITIALIZER, DestroyRef, ENVIRONMENT_INITIALIZER, ErrorHandler, isSignal, Input, Directive, input, booleanAttribute, ChangeDetectionStrategy, EventEmitter, Output, SecurityContext, ViewContainerRef, Injector, effect, SimpleChange, ElementRef, ChangeDetectorRef, afterEveryRender, contentChild, viewChild, HostBinding, output, afterNextRender, ViewChild, ViewEncapsulation, createEnvironmentInjector, EnvironmentInjector, reflectComponentType, HostListener, ViewChildren, TemplateRef, Renderer2 } from '@angular/core';
 import * as i1 from '@angular/common/http';
 import { HttpHeaders, HttpClient, HttpParams, HttpResponse, HttpContextToken, HttpErrorResponse, HTTP_INTERCEPTORS, withInterceptors } from '@angular/common/http';
-import { of, defer, throwError, from, EMPTY, BehaviorSubject, firstValueFrom, Subject, finalize as finalize$1, shareReplay as shareReplay$1, map as map$1, timer, switchMap as switchMap$1, catchError as catchError$1, forkJoin, isObservable, combineLatest, merge, Subscription, defaultIfEmpty, timeout as timeout$1 } from 'rxjs';
+import { of, defer, throwError, from, EMPTY, BehaviorSubject, firstValueFrom, Subject, finalize as finalize$1, shareReplay as shareReplay$1, map as map$1, Observable, timer, switchMap as switchMap$1, catchError as catchError$1, forkJoin, isObservable, combineLatest, merge, Subscription, defaultIfEmpty, timeout as timeout$1 } from 'rxjs';
 import { switchMap, map, take, catchError, concatMap, tap, shareReplay, takeUntil, toArray, finalize, exhaustMap, filter, timeout } from 'rxjs/operators';
 import * as i1$3 from '@angular/common';
 import { Location, DOCUMENT, NgTemplateOutlet, CommonModule, NgComponentOutlet } from '@angular/common';
@@ -15529,6 +15529,9 @@ class BulkSyncSession {
     }, ...(ngDevMode ? [{ debugName: "current" }] : /* istanbul ignore next */ []));
     confirmationKey = null;
     refreshInFlight = false;
+    refreshGeneration = 0;
+    refreshSignal;
+    resultsGeneration = 0;
     ownedContract;
     options;
     /** Return detached wire data while retaining the original technical error for UX mapping. */
@@ -15607,17 +15610,25 @@ class BulkSyncSession {
             throw error;
         }
     }
-    async refreshExecution() {
+    /** One cancellable consultation; the caller owns its deadline. POST custody is unchanged. */
+    async refreshExecution(signal) {
+        this.requireReadLifetime(signal);
         const current = this.current();
         if (!current.execution)
             throw new Error('No accepted execution is known to this session.');
         if (isBulkExecutionTerminal(current.execution.status))
             return structuredClone(current.execution);
-        if (this.refreshInFlight)
+        if (this.refreshInFlight && !this.refreshSignal?.aborted) {
             throw new Error('An execution readback is already in flight.');
+        }
+        const generation = ++this.refreshGeneration;
         this.refreshInFlight = true;
+        this.refreshSignal = signal;
         try {
-            const execution = await firstValueFrom(this.client.readExecution(this.ownedContract, current.execution.executionId, this.options));
+            const execution = await this.readValue(() => this.client.readExecution(this.ownedContract, current.execution.executionId, this.options), signal);
+            this.requireReadLifetime(signal);
+            if (generation !== this.refreshGeneration)
+                throw this.readAborted();
             if (execution.proposalId !== current.execution.proposalId) {
                 throw new Error('Execution readback changed the proposal identity.');
             }
@@ -15626,25 +15637,63 @@ class BulkSyncSession {
             return structuredClone(execution);
         }
         catch (error) {
-            this.fail(error);
+            if (generation === this.refreshGeneration && !signal?.aborted)
+                this.fail(error);
             throw error;
         }
         finally {
-            this.refreshInFlight = false;
+            if (generation === this.refreshGeneration) {
+                this.refreshInFlight = false;
+                this.refreshSignal = undefined;
+            }
         }
     }
-    async readResults(size = 200, after) {
+    /** Cancels only this results GET; an abort never discards the accepted execution. */
+    async readResults(size = 200, after, signal) {
+        this.requireReadLifetime(signal);
+        const generation = ++this.resultsGeneration;
         const execution = this.current().execution;
         if (!execution)
             throw new Error('Results require an accepted execution.');
         try {
-            return await firstValueFrom(this.client.readResults(this.ownedContract, execution.executionId, size, after, this.options));
+            return await this.readValue(() => this.client.readResults(this.ownedContract, execution.executionId, size, after, this.options), signal);
         }
         catch (error) {
-            this.current.set({ ...this.current(), error });
+            if (generation === this.resultsGeneration && !signal?.aborted) {
+                this.current.set({ ...this.current(), error });
+            }
             throw error;
         }
     }
+    readAborted() {
+        return new DOMException('Bulk observation was cancelled.', 'AbortError');
+    }
+    requireReadLifetime(signal) {
+        if (signal?.aborted)
+            throw this.readAborted();
+    }
+    /** Cancellation owns the HTTP subscription, not just its Promise observer. */
+    async readValue(read, signal) {
+        this.requireReadLifetime(signal);
+        const value = await firstValueFrom(new Observable(subscriber => {
+            if (signal?.aborted) {
+                subscriber.error(this.readAborted());
+                return;
+            }
+            const abort = () => subscriber.error(this.readAborted());
+            signal?.addEventListener('abort', abort, { once: true });
+            // defer converts a synchronous client failure into an Observable failure,
+            // so the listener is removed by the same teardown on every path.
+            const subscription = defer(read).subscribe(subscriber);
+            return () => {
+                subscription.unsubscribe();
+                signal?.removeEventListener('abort', abort);
+            };
+        }));
+        // Abort may occur after HTTP next but before this Promise continuation.
+        this.requireReadLifetime(signal);
+        return value;
+    }
     fail(error) {
         this.current.set({ ...this.current(), phase: 'error', error });
     }
@@ -27004,15 +27053,30 @@ function removeValueAtPath(target, path) {
     if (!segments.length) {
         return;
     }
+    const parents = [];
     let current = target;
     for (const segment of segments.slice(0, -1)) {
         const next = current[segment];
         if (!next || typeof next !== 'object' || Array.isArray(next)) {
             return;
         }
+        parents.push({ parent: current, key: segment });
         current = next;
     }
     delete current[segments[segments.length - 1]];
+    for (let i = parents.length - 1; i >= 0; i -= 1) {
+        const { parent, key } = parents[i];
+        const child = parent[key];
+        if (child &&
+            typeof child === 'object' &&
+            !Array.isArray(child) &&
+            Object.keys(child).length === 0) {
+            delete parent[key];
+        }
+        else {
+            break;
+        }
+    }
 }
 function normalizeEndpoint(endpoint) {
     if (endpoint.kind === 'component-port') {
@@ -39273,7 +39337,10 @@ class WidgetPageCompositionFactory {
         }
         const isStructured = typeof state === 'object'
             && !Array.isArray(state)
-            && ('values' in state || 'schema' in state || 'derived' in state);
+            && ('values' in state ||
+                'schema' in state ||
+                'derived' in state ||
+                'transientValues' in state);
         if (isStructured) {
             const structured = state;
             return {
@@ -39632,7 +39699,10 @@ class WidgetPageStateRuntimeService {
             return { values: {} };
         const isStructured = typeof state === 'object'
             && !Array.isArray(state)
-            && ('values' in state || 'schema' in state || 'derived' in state);
+            && ('values' in state ||
+                'schema' in state ||
+                'derived' in state ||
+                'transientValues' in state);
         if (isStructured) {
             const structured = state;
             const normalized = {
@@ -46069,6 +46139,9 @@ class DynamicWidgetPageComponent {
     injector = inject(Injector);
     settingsSessions = new Map();
     widgetSettingsSession;
+    activeSettingsPanelSession;
+    activeSettingsFocusReturnTarget = null;
+    pendingContextNavigationFocusTarget;
     settingsIdentityRevision = 0;
     acceptedPageIdentity;
     storage = inject(ASYNC_CONFIG_STORAGE);
@@ -46237,13 +46310,15 @@ class DynamicWidgetPageComponent {
         // Controlled hosts return pageChange through [page]. That acknowledgement
         // must not dispose the open settings provider or rebuild its size template.
         // Any other input change or different document still invalidates the editor.
-        if (this.widgetSettingsKey && changes['page'] && Object.keys(changes).length === 1
-            && this.authoredPageDefinition
-            && this.sameJsonStructure(this.parsePage(this.page), this.authoredPageDefinition))
+        if (this.widgetSettingsKey &&
+            changes['page'] &&
+            Object.keys(changes).length === 1 &&
+            this.isAcknowledgedCanonicalPage(incomingPage)) {
             return;
-        const acknowledgedPage = changes['page'] && Object.keys(changes).length === 1
-            && this.authoredPageDefinition
-            && this.sameJsonStructure(this.parsePage(this.page), this.authoredPageDefinition);
+        }
+        const acknowledgedPage = changes['page'] &&
+            Object.keys(changes).length === 1 &&
+            this.isAcknowledgedCanonicalPage(incomingPage);
         if (!acknowledgedPage && (changes['page'] || changes['context'] || changes['pageIdentity']
             || changes['componentInstanceId'] || changes['enableCustomization'] || changes['authoringCapabilities'])) {
             this.settingsIdentityRevision++;
@@ -46270,6 +46345,8 @@ class DynamicWidgetPageComponent {
         if (changes['page'] ||
             changes['context'] ||
             changes['pageIdentity']) {
+            const previousPageDefinition = this.pageDefinition;
+            const previousPageRuntime = this.pageRuntime;
             const parsed = this.parsePage(this.page);
             if (changes['page'] || !this.authoredPageDefinition) {
                 this.authoredPageDefinition = undefined;
@@ -46280,7 +46357,17 @@ class DynamicWidgetPageComponent {
                     })
                     : undefined;
             }
-            const resolvedPage = parsed ? this.resolvePagePresets(parsed) : parsed;
+            const shouldPreserveEphemeralState = !this.isHydrating &&
+                !changes['page']?.isFirstChange() &&
+                !changes['pageIdentity'] &&
+                !changes['componentInstanceId'] &&
+                this.samePageContextIdentity(this.pageDefinition, parsed);
+            const runtimeSeedPage = shouldPreserveEphemeralState && parsed
+                ? this.preserveEphemeralRuntimeState(parsed)
+                : parsed;
+            const resolvedPage = runtimeSeedPage
+                ? this.resolvePagePresets(runtimeSeedPage)
+                : runtimeSeedPage;
             this.assertNoLegacyConnections(resolvedPage);
             this.widgetDiagnostics = {};
             this.widgetDiagnosticsChange.emit({});
@@ -46300,6 +46387,10 @@ class DynamicWidgetPageComponent {
             }
             this.pageRuntime = this.buildStateRuntime(this.pageDefinition?.state, this.pageDefinition?.context);
             this.pageState = this.pageRuntime.state;
+            const resetNonPersistentPaths = this.collectResetNonPersistentStatePaths(previousPageDefinition, previousPageRuntime, this.pageDefinition, this.pageRuntime);
+            if (resetNonPersistentPaths.length > 0) {
+                this.clearMountedSourceSelectionsForNonPersistentState([previousPageDefinition, this.pageDefinition], resetNonPersistentPaths);
+            }
             const bootstrapSnapshot = this.bootstrapCompositionAdapter(this.pageDefinition);
             const rawWidgets = this.pageDefinition?.widgets || [];
             let widgets = this.applyEditShellActions(rawWidgets);
@@ -48251,6 +48342,10 @@ class DynamicWidgetPageComponent {
         return session;
     }
     releaseSettingsSession(session) {
+        if (this.activeSettingsPanelSession === session) {
+            this.activeSettingsPanelSession = undefined;
+            this.activeSettingsFocusReturnTarget = null;
+        }
         this.settingsSessions.delete(session);
         if (!session.destroyed)
             session.destroy();
@@ -48261,6 +48356,7 @@ class DynamicWidgetPageComponent {
                 this.releaseSettingsSession(session);
         }
         if (key === undefined) {
+            this.pendingContextNavigationFocusTarget = undefined;
             this.configEditorContextRequests.clear();
             this.pendingWidgetComponentSettings.set(new Set());
         }
@@ -48295,12 +48391,14 @@ class DynamicWidgetPageComponent {
                     label: this.widgetSettingsLabel(),
                     icon: 'settings',
                     disabled: !canWidget,
+                    editorGroup: 'widget-shell',
                 },
                 {
                     id: 'size',
                     label: this.sizeEditorLabel(),
                     icon: 'straighten',
                     disabled: !canSize,
+                    editorGroup: 'widget-shell',
                 },
             ],
             activeModeId: activeMode,
@@ -48344,6 +48442,9 @@ class DynamicWidgetPageComponent {
         else if (mode === 'size' && !canSize) {
             mode = canWidget ? 'widget' : canContent ? 'content' : 'size';
         }
+        this.pendingContextNavigationFocusTarget = {
+            target: this.activeSettingsFocusReturnTarget,
+        };
         if (mode === 'content') {
             void this.openWidgetComponentSettings(targetKey);
         }
@@ -48351,10 +48452,15 @@ class DynamicWidgetPageComponent {
             this.openWidgetSettingsPanel(targetKey, mode);
         }
     }
+    resolveSettingsFocusReturnTarget() {
+        const pending = this.pendingContextNavigationFocusTarget;
+        this.pendingContextNavigationFocusTarget = undefined;
+        return pending ? pending.target : this.captureFocusReturnTarget();
+    }
     openWidgetSettingsPanel(key, initialTab) {
         if (this.destroyed || !this.settingsPanel)
             return;
-        const focusReturnTarget = this.captureFocusReturnTarget();
+        const focusReturnTarget = this.resolveSettingsFocusReturnTarget();
         const page = this.ensurePageDefinition();
         const widget = page.widgets.find(item => item.key === key);
         if (!widget)
@@ -48365,6 +48471,10 @@ class DynamicWidgetPageComponent {
         const session = this.createSettingsSession(key);
         const owner = session.get(DestroyRef);
         const contextNavigation = this.buildWidgetSettingsContextNavigation(key, initialTab);
+        const previousActiveSession = this.activeSettingsPanelSession;
+        const previousFocusTarget = this.activeSettingsFocusReturnTarget;
+        this.activeSettingsPanelSession = session;
+        this.activeSettingsFocusReturnTarget = focusReturnTarget;
         let ref;
         try {
             ref = this.settingsPanel.open({
@@ -48377,7 +48487,10 @@ class DynamicWidgetPageComponent {
                         const page = this.ensurePageDefinition();
                         const widget = page.widgets.find(item => item.key === key);
                         const uiShell = this.mergedContext['ui']?.shell || {};
+                        this.activeSettingsPanelSession = session;
+                        this.activeSettingsFocusReturnTarget = focusReturnTarget;
                         this.closeSizeEditor(false);
+                        this.selectWidget(key);
                         this.prepareSizeEditor(key);
                         this.widgetSettingsKey = key;
                         this.widgetSettingsSession = session;
@@ -48407,6 +48520,10 @@ class DynamicWidgetPageComponent {
             });
         }
         catch (error) {
+            if (this.activeSettingsPanelSession === session) {
+                this.activeSettingsPanelSession = previousActiveSession;
+                this.activeSettingsFocusReturnTarget = previousFocusTarget;
+            }
             if (this.widgetSettingsSession === session)
                 this.closeSizeEditor(false);
             else
@@ -48416,15 +48533,27 @@ class DynamicWidgetPageComponent {
         ref.applied$.pipe(takeUntilDestroyed(owner)).subscribe(value => this.commitWidgetSettings(key, value, false));
         ref.saved$.pipe(takeUntilDestroyed(owner)).subscribe(value => this.commitWidgetSettings(key, value, true));
         ref.closed$?.pipe(take(1), takeUntilDestroyed(owner)).subscribe(() => {
-            const active = this.widgetSettingsSession === session;
-            if (active) {
+            const wasActiveWidgetSettings = this.widgetSettingsSession === session;
+            const wasActivePanelSession = this.activeSettingsPanelSession === session;
+            if (wasActivePanelSession &&
+                !wasActiveWidgetSettings &&
+                previousActiveSession &&
+                !previousActiveSession.destroyed) {
+                this.activeSettingsPanelSession = previousActiveSession;
+                this.activeSettingsFocusReturnTarget = previousFocusTarget;
+                this.releaseSettingsSession(session);
+                return;
+            }
+            if (wasActiveWidgetSettings) {
                 this.widgetSettingsSelectTab = undefined;
                 this.closeSizeEditor(false);
             }
-            else
+            else {
                 this.releaseSettingsSession(session);
-            if (active)
+            }
+            if (wasActivePanelSession) {
                 this.restoreFocus(focusReturnTarget);
+            }
         });
     }
     sizeEditorLayoutItems() {
@@ -48561,6 +48690,7 @@ class DynamicWidgetPageComponent {
                 } });
     }
     async openWidgetComponentSettings(key) {
+        const focusReturnTarget = this.resolveSettingsFocusReturnTarget();
         if (this.destroyed || !this.canOpenWidgetComponentSettings(key))
             return;
         if (!this.settingsPanel) {
@@ -48582,7 +48712,6 @@ class DynamicWidgetPageComponent {
         const materializedInputs = metadata.configEditor?.contextResolver
             ? this.readMaterializedInputsForWidget(metadata, key)
             : undefined;
-        const focusReturnTarget = this.captureFocusReturnTarget();
         const session = this.createSettingsSession(key);
         const owner = session.get(DestroyRef);
         let opened = false;
@@ -48602,6 +48731,12 @@ class DynamicWidgetPageComponent {
             const appliedValues = new Subject();
             owner.onDestroy(() => appliedValues.complete());
             const contextNavigation = this.buildWidgetSettingsContextNavigation(key, 'content');
+            const previousActiveSession = this.activeSettingsPanelSession;
+            const previousFocusTarget = this.activeSettingsFocusReturnTarget;
+            const previousSelectedWidgetKey = this.selectedWidgetKeyState();
+            this.activeSettingsPanelSession = session;
+            this.activeSettingsFocusReturnTarget = focusReturnTarget;
+            this.selectWidget(key);
             const ref = this.settingsPanel.open({
                 owner,
                 id: `dynamic-page-component:${key}`,
@@ -48631,8 +48766,22 @@ class DynamicWidgetPageComponent {
             });
             ref.saved$.pipe(takeUntilDestroyed(owner)).subscribe((result) => this.applyWidgetComponentInputs(key, result, true));
             ref.closed$?.pipe(take(1), takeUntilDestroyed(owner)).subscribe(() => {
+                const wasActivePanelSession = this.activeSettingsPanelSession === session;
+                if (wasActivePanelSession &&
+                    previousActiveSession &&
+                    !previousActiveSession.destroyed) {
+                    this.activeSettingsPanelSession = previousActiveSession;
+                    this.activeSettingsFocusReturnTarget = previousFocusTarget;
+                    if (previousSelectedWidgetKey) {
+                        this.selectWidget(previousSelectedWidgetKey);
+                    }
+                    this.releaseSettingsSession(session);
+                    return;
+                }
                 this.releaseSettingsSession(session);
-                this.restoreFocus(focusReturnTarget);
+                if (wasActivePanelSession) {
+                    this.restoreFocus(focusReturnTarget);
+                }
             });
         }
         finally {
@@ -48668,6 +48817,8 @@ class DynamicWidgetPageComponent {
     restoreFocus(target) {
         queueMicrotask(() => {
             if (!this.destroyed
+                && !this.activeSettingsPanelSession
+                && this.pendingWidgetComponentSettings().size === 0
                 && target?.isConnected
                 && !target.hasAttribute('disabled')
                 && target.getAttribute('aria-disabled') !== 'true') {
@@ -48977,6 +49128,7 @@ class DynamicWidgetPageComponent {
         return (endpoint.kind === 'component-port' && endpoint.ref.widget === widgetKey);
     }
     openPageSettings() {
+        const focusReturnTarget = this.resolveSettingsFocusReturnTarget();
         if (this.destroyed || !this.canInvokePageSettings())
             return;
         if (!this.settingsPanel)
@@ -48991,6 +49143,10 @@ class DynamicWidgetPageComponent {
         const owner = session.get(DestroyRef);
         const appliedValues = new Subject();
         owner.onDestroy(() => appliedValues.complete());
+        const previousActiveSession = this.activeSettingsPanelSession;
+        const previousFocusTarget = this.activeSettingsFocusReturnTarget;
+        this.activeSettingsPanelSession = session;
+        this.activeSettingsFocusReturnTarget = focusReturnTarget;
         const ref = this.settingsPanel.open({
             owner,
             id: 'dynamic-page-settings',
@@ -49020,7 +49176,21 @@ class DynamicWidgetPageComponent {
             appliedValues.next(accepted);
         });
         ref.saved$.pipe(takeUntilDestroyed(owner)).subscribe((result) => this.applyPageLayout(result, true));
-        ref.closed$?.pipe(take(1), takeUntilDestroyed(owner)).subscribe(() => this.releaseSettingsSession(session));
+        ref.closed$?.pipe(take(1), takeUntilDestroyed(owner)).subscribe(() => {
+            const wasActivePanelSession = this.activeSettingsPanelSession === session;
+            if (wasActivePanelSession &&
+                previousActiveSession &&
+                !previousActiveSession.destroyed) {
+                this.activeSettingsPanelSession = previousActiveSession;
+                this.activeSettingsFocusReturnTarget = previousFocusTarget;
+                this.releaseSettingsSession(session);
+                return;
+            }
+            this.releaseSettingsSession(session);
+            if (wasActivePanelSession) {
+                this.restoreFocus(focusReturnTarget);
+            }
+        });
     }
     canInvokePageSettings() {
         return this.isAuthoringCapabilityEnabled('pageSettings')
@@ -49153,11 +49323,227 @@ class DynamicWidgetPageComponent {
         }, persist);
     }
     applyAuthoringPageUpdate(next, persist = true, runtime, syncCompositionAdapter = true, skipStateWidgetProjection = false, emitUnchangedCanonicalPage = true) {
-        this.applyPageUpdate(next, persist, runtime, syncCompositionAdapter, skipStateWidgetProjection, emitUnchangedCanonicalPage);
+        const runtimeSeed = !runtime && !this.isHydrating
+            ? (this.preserveEphemeralRuntimeState(next) ?? next)
+            : next;
+        this.applyPageUpdate(runtimeSeed, persist, runtime, syncCompositionAdapter, skipStateWidgetProjection, emitUnchangedCanonicalPage);
         if (this.authoredPageDefinition) {
             this.pageAuthoringChange.emit(this.clonePageDefinition(this.authoredPageDefinition));
         }
     }
+    isAcknowledgedCanonicalPage(incomingPage) {
+        if (!incomingPage || !this.authoredPageDefinition) {
+            return false;
+        }
+        if (this.sameJsonStructure(incomingPage, this.authoredPageDefinition)) {
+            return true;
+        }
+        if (this.hasExplicitNonPersistentStateOverride(incomingPage)) {
+            return false;
+        }
+        const normalizedIncoming = this.toPersistedCanonicalPage({
+            ...incomingPage,
+            state: this.stateRuntime.normalizeState(incomingPage.state),
+        });
+        return this.sameJsonStructure(normalizedIncoming, this.authoredPageDefinition);
+    }
+    hasExplicitNonPersistentStateOverride(page) {
+        const schema = page?.state?.schema || {};
+        const values = page?.state?.values;
+        if (!values || typeof values !== 'object') {
+            return false;
+        }
+        for (const rawPath of Object.keys(schema)) {
+            const entry = schema[rawPath];
+            if (entry?.persist !== false) {
+                continue;
+            }
+            const path = rawPath.trim();
+            if (!path) {
+                continue;
+            }
+            const value = this.conn.extractByPath(values, path);
+            if (value !== undefined && !this.sameJsonStructure(value, entry.initial)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    collectResetNonPersistentStatePaths(previousPage, previousRuntime, nextPage, nextRuntime) {
+        if (!previousPage || !previousRuntime || !nextRuntime) {
+            return [];
+        }
+        const previousSchema = previousPage.state?.schema ?? {};
+        const nextSchema = nextPage?.state?.schema ?? {};
+        const candidatePaths = new Set([
+            ...Object.keys(previousSchema).filter((path) => previousSchema[path]?.persist === false),
+            ...Object.keys(nextSchema).filter((path) => nextSchema[path]?.persist === false),
+        ]);
+        const resetPaths = [];
+        for (const rawPath of candidatePaths) {
+            const path = rawPath.trim();
+            if (!path) {
+                continue;
+            }
+            const prevEntry = previousSchema[rawPath] ?? nextSchema[rawPath];
+            const nextEntry = nextSchema[rawPath] ?? previousSchema[rawPath];
+            const prevValue = this.conn.extractByPath(previousRuntime.primaryValues, path);
+            const hadLiveSelection = prevValue !== undefined &&
+                !this.sameJsonStructure(prevValue, prevEntry?.initial);
+            if (!hadLiveSelection) {
+                continue;
+            }
+            const nextValue = this.conn.extractByPath(nextRuntime.primaryValues, path);
+            const isNowReset = nextValue === undefined ||
+                this.sameJsonStructure(nextValue, nextEntry?.initial);
+            if (isNowReset) {
+                resetPaths.push(path);
+            }
+        }
+        return [...new Set(resetPaths)];
+    }
+    samePageContextIdentity(left, right) {
+        if (!left || !right) {
+            return false;
+        }
+        const leftPageId = left.context?.['pageId'] ?? null;
+        const rightPageId = right.context?.['pageId'] ?? null;
+        if (leftPageId !== rightPageId) {
+            return false;
+        }
+        if (leftPageId !== null) {
+            return true;
+        }
+        const leftKeys = new Set((left.widgets || []).map((w) => w.key));
+        const rightKeys = (right.widgets || []).map((w) => w.key);
+        if (leftKeys.size === 0 && rightKeys.length === 0) {
+            return true;
+        }
+        return rightKeys.some((key) => leftKeys.has(key));
+    }
+    preserveEphemeralRuntimeState(incomingPage) {
+        if (!incomingPage || !this.pageRuntime || this.isHydrating) {
+            return incomingPage;
+        }
+        const schema = incomingPage.state?.schema || {};
+        const nonPersistentPaths = Object.keys(schema)
+            .filter((path) => schema[path]?.persist === false)
+            .map((path) => path.trim())
+            .filter(Boolean);
+        if (!nonPersistentPaths.length) {
+            return incomingPage;
+        }
+        const incomingWidgets = new Set((incomingPage.widgets || []).map((widget) => widget.key));
+        const incomingLinks = incomingPage.composition?.links || [];
+        const previousLinks = this.pageDefinition?.composition?.links || incomingLinks;
+        let mergedValues = this.cloneStateValues(incomingPage.state?.values || {});
+        let preservedAny = false;
+        for (const path of nonPersistentPaths) {
+            const schemaEntry = schema[path];
+            const incomingValue = this.conn.extractByPath(mergedValues, path);
+            const hasExplicitIncomingOverride = incomingValue !== undefined &&
+                !this.sameJsonStructure(incomingValue, schemaEntry?.initial);
+            if (hasExplicitIncomingOverride) {
+                continue;
+            }
+            const previousWriterWidgets = previousLinks.filter((link) => link.from.kind === 'component-port' &&
+                link.to.kind === 'state' &&
+                this.isSameOrNestedStatePath(link.to.ref.path, path));
+            if (previousWriterWidgets.length > 0) {
+                const hasActiveWriter = incomingLinks.some((link) => link.from.kind === 'component-port' &&
+                    link.to.kind === 'state' &&
+                    this.isSameOrNestedStatePath(link.to.ref.path, path) &&
+                    incomingWidgets.has(link.from.ref.widget));
+                if (!hasActiveWriter) {
+                    continue;
+                }
+            }
+            const liveValue = this.conn.extractByPath(this.pageRuntime.primaryValues, path);
+            if (liveValue === undefined) {
+                continue;
+            }
+            mergedValues = this.conn.setValueAtPath(mergedValues, path, this.cloneStateValues(liveValue));
+            preservedAny = true;
+        }
+        if (!preservedAny) {
+            return incomingPage;
+        }
+        return {
+            ...incomingPage,
+            state: {
+                ...(incomingPage.state || {}),
+                values: mergedValues,
+            },
+        };
+    }
+    isSameOrNestedStatePath(candidate, base) {
+        const normalizedCandidate = String(candidate || '').trim();
+        const normalizedBase = String(base || '').trim();
+        if (!normalizedCandidate || !normalizedBase) {
+            return false;
+        }
+        return (normalizedCandidate === normalizedBase ||
+            normalizedCandidate.startsWith(`${normalizedBase}.`) ||
+            normalizedBase.startsWith(`${normalizedCandidate}.`));
+    }
+    clearMountedSourceSelectionsForNonPersistentState(pages, resetPaths) {
+        if (!this.widgetLoaders) {
+            return;
+        }
+        const matchesResetPath = (path) => !resetPaths || resetPaths.some((resetPath) => this.isSameOrNestedStatePath(path, resetPath));
+        const sourceWidgets = new Set();
+        for (const page of pages) {
+            if (!page) {
+                continue;
+            }
+            const schema = page.state?.schema || {};
+            const nonPersistentPaths = Object.keys(schema)
+                .filter((path) => schema[path]?.persist === false)
+                .map((path) => path.trim())
+                .filter((path) => path && matchesResetPath(path));
+            if (!nonPersistentPaths.length) {
+                continue;
+            }
+            const links = page.composition?.links || [];
+            for (const link of links) {
+                const fromRef = link.from?.ref;
+                const toRef = link.to?.ref;
+                const toPath = typeof toRef?.path === 'string' ? toRef.path : '';
+                if (link.from?.kind === 'component-port' &&
+                    link.to?.kind === 'state' &&
+                    typeof fromRef?.widget === 'string' &&
+                    toPath &&
+                    matchesResetPath(toPath) &&
+                    nonPersistentPaths.some((path) => this.isSameOrNestedStatePath(toPath, path))) {
+                    sourceWidgets.add(fromRef.widget);
+                }
+            }
+            for (const widget of page.widgets || []) {
+                const outputs = widget.definition?.outputs;
+                if (!outputs || typeof outputs !== 'object') {
+                    continue;
+                }
+                for (const rawActions of Object.values(outputs)) {
+                    const actions = Array.isArray(rawActions) ? rawActions : [rawActions];
+                    for (const action of actions) {
+                        const candidate = action;
+                        if (candidate?.type === 'setState' &&
+                            typeof candidate.path === 'string' &&
+                            matchesResetPath(candidate.path) &&
+                            nonPersistentPaths.some((path) => this.isSameOrNestedStatePath(candidate.path, path))) {
+                            sourceWidgets.add(widget.key);
+                        }
+                    }
+                }
+            }
+        }
+        for (const widgetKey of sourceWidgets) {
+            const loader = this.findWidgetLoader(widgetKey);
+            if (loader && typeof loader.clearSelection === 'function') {
+                loader.clearSelection();
+            }
+        }
+    }
     applyPageUpdate(next, persist = true, runtime, syncCompositionAdapter = true, skipStateWidgetProjection = false, emitUnchangedCanonicalPage = true) {
         this.assertNoLegacyConnections(next);
         if (this.getDataSourcesSignature(next.dataSources) !==
@@ -49182,7 +49568,7 @@ class DynamicWidgetPageComponent {
                         state: {
                             primaryValues: this.cloneStateValues(effectiveRuntime.primaryValues),
                             derivedValues: this.cloneStateValues(effectiveRuntime.derivedValues),
-                            transientValues: this.cloneStateValues(this.compositionRuntime.getSnapshot().state.transientValues),
+                            transientValues: {},
                             changedPaths: [],
                             diagnostics: [],
                         },
@@ -49266,7 +49652,7 @@ class DynamicWidgetPageComponent {
                 state: {
                     primaryValues: this.cloneStateValues(nextRuntime.primaryValues),
                     derivedValues: this.cloneStateValues(nextRuntime.derivedValues),
-                    transientValues: this.cloneStateValues(this.compositionRuntime.getSnapshot().state.transientValues),
+                    transientValues: {},
                     changedPaths: updates.map((u) => u.targetStatePath),
                     diagnostics: [],
                 },
@@ -52340,6 +52726,7 @@ class DynamicWidgetPageComponent {
                                         dataSources: stored.dataSources ?? baseline.dataSources,
                                     }
                                     : (stored ?? defaultPage);
+                                this.clearMountedSourceSelectionsForNonPersistentState([loaded]);
                                 this.authoredPageDefinition = this.clonePageDefinition(loaded);
                                 this.applyPageUpdate(loaded, false);
                             }
@@ -52414,6 +52801,7 @@ class DynamicWidgetPageComponent {
                         if (mutation.revision === this.persistenceRevision) {
                             this.isHydrating = true;
                             try {
+                                this.clearMountedSourceSelectionsForNonPersistentState([mutation.defaultPage]);
                                 this.authoredPageDefinition = this.clonePageDefinition(mutation.defaultPage);
                                 this.applyPageUpdate(mutation.defaultPage, false);
                             }
@@ -53799,7 +54187,42 @@ class PraxisSurfaceHostComponent {
         loader.renderNow();
     }
     enrichWidget(widget, widgetKey) {
-        if (!widget || widget.id !== 'praxis-rich-content') {
+        if (!widget) {
+            return widget;
+        }
+        if (widget.id === 'praxis-crud') {
+            const explicitContext = widget.inputs?.['context'] &&
+                typeof widget.inputs['context'] === 'object' &&
+                !Array.isArray(widget.inputs['context'])
+                ? widget.inputs['context']
+                : {};
+            const hostContext = this.context &&
+                typeof this.context === 'object' &&
+                !Array.isArray(this.context)
+                ? this.context
+                : {};
+            const mergedContext = {
+                ...hostContext,
+                ...explicitContext,
+            };
+            if ((!mergedContext['surfaceRuntime'] ||
+                typeof mergedContext['surfaceRuntime'] !== 'object') &&
+                hostContext['surfaceRuntime'] &&
+                typeof hostContext['surfaceRuntime'] === 'object') {
+                mergedContext['surfaceRuntime'] = hostContext['surfaceRuntime'];
+            }
+            if (Object.keys(mergedContext).length === 0) {
+                return widget;
+            }
+            return {
+                ...widget,
+                inputs: {
+                    ...(widget.inputs || {}),
+                    context: mergedContext,
+                },
+            };
+        }
+        if (widget.id !== 'praxis-rich-content') {
             return widget;
         }
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/core",
-  "version": "10.0.0-rc.26",
+  "version": "10.0.0-rc.27",
   "description": "Core library for Praxis UI Workspace: types, tokens, services and utilities shared across @praxisui/* packages.",
   "peerDependencies": {
     "@angular/cdk": "^21.0.0",

package/types/praxisui-core-schema.d.ts

@@ -1885,6 +1885,10 @@ interface FilteringConfig {
             selectedFieldIds?: string[];
             /** Exibir opções avançadas por padrão */
             showAdvanced?: boolean;
+            /** Exibir botão "Gerenciar campos" na barra do filtro (padrão: true) */
+            showAddButton?: boolean;
+            /** Exibir botão "Configurações do filtro" na barra quando customização estiver disponível (padrão: true) */
+            showFilterSettings?: boolean;
             /** Permitir salvar tags/atalhos de filtro */
             allowSaveTags?: boolean;
             /** Atalhos governados, somente leitura, aplicados como patch do DTO de filtro */

package/types/praxisui-core.d.ts

@@ -2959,6 +2959,10 @@ interface FilteringConfig {
             selectedFieldIds?: string[];
             /** Exibir opções avançadas por padrão */
             showAdvanced?: boolean;
+            /** Exibir botão "Gerenciar campos" na barra do filtro (padrão: true) */
+            showAddButton?: boolean;
+            /** Exibir botão "Configurações do filtro" na barra quando customização estiver disponível (padrão: true) */
+            showFilterSettings?: boolean;
             /** Permitir salvar tags/atalhos de filtro */
             allowSaveTags?: boolean;
             /** Atalhos governados, somente leitura, aplicados como patch do DTO de filtro */
@@ -11788,6 +11792,9 @@ declare class BulkSyncSession {
     private readonly current;
     private confirmationKey;
     private refreshInFlight;
+    private refreshGeneration;
+    private refreshSignal?;
+    private resultsGeneration;
     private readonly ownedContract;
     private readonly options?;
     /** Return detached wire data while retaining the original technical error for UX mapping. */
@@ -11804,8 +11811,14 @@ declare class BulkSyncSession {
     constructor(client: BulkOperationClientService, contract: BulkExecutionContract, options?: ResourceDiscoveryRequestOptions);
     evaluate<WI extends BulkWireId>(request: BulkSyncEvaluationRequest<WI>): Promise<BulkProposal>;
     confirm(idempotencyKey: string): Promise<BulkExecution>;
-    refreshExecution(): Promise<BulkExecution>;
-    readResults<WI extends BulkWireId>(size?: number, after?: string): Promise<BulkCursorPage<BulkItemResult<WI>>>;
+    /** One cancellable consultation; the caller owns its deadline. POST custody is unchanged. */
+    refreshExecution(signal?: AbortSignal): Promise<BulkExecution>;
+    /** Cancels only this results GET; an abort never discards the accepted execution. */
+    readResults<WI extends BulkWireId>(size?: number, after?: string, signal?: AbortSignal): Promise<BulkCursorPage<BulkItemResult<WI>>>;
+    private readAborted;
+    private requireReadLifetime;
+    /** Cancellation owns the HTTP subscription, not just its Promise observer. */
+    private readValue;
     private fail;
 }
 declare class BulkSyncStateService {
@@ -14778,6 +14791,12 @@ interface SettingsPanelContextMode {
     label: string;
     icon?: string;
     disabled?: boolean;
+    /**
+     * Optional logical group identifier. Modes sharing the same `editorGroup`
+     * operate on the same active editor instance (in-place tab/section switch)
+     * without triggering an intermediate `onApply()` before switching.
+     */
+    editorGroup?: string;
 }
 interface SettingsPanelContextNavigation {
     targets?: ReadonlyArray<SettingsPanelContextTarget>;
@@ -18876,6 +18895,9 @@ declare class DynamicWidgetPageComponent implements OnChanges, OnDestroy {
     private readonly injector;
     private readonly settingsSessions;
     private widgetSettingsSession?;
+    private activeSettingsPanelSession?;
+    private activeSettingsFocusReturnTarget;
+    private pendingContextNavigationFocusTarget?;
     private settingsIdentityRevision;
     private acceptedPageIdentity;
     private readonly storage;
@@ -19088,6 +19110,7 @@ declare class DynamicWidgetPageComponent implements OnChanges, OnDestroy {
     private widgetSettingsSelectTab?;
     private buildWidgetSettingsContextNavigation;
     private navigateToWidgetSettingsContext;
+    private resolveSettingsFocusReturnTarget;
     private openWidgetSettingsPanel;
     sizeEditorLayoutItems(): {
         key: string;
@@ -19125,6 +19148,13 @@ declare class DynamicWidgetPageComponent implements OnChanges, OnDestroy {
     private restoreWidgetShellFields;
     private applyPageLayout;
     private applyAuthoringPageUpdate;
+    private isAcknowledgedCanonicalPage;
+    private hasExplicitNonPersistentStateOverride;
+    private collectResetNonPersistentStatePaths;
+    private samePageContextIdentity;
+    private preserveEphemeralRuntimeState;
+    private isSameOrNestedStatePath;
+    private clearMountedSourceSelectionsForNonPersistentState;
     private applyPageUpdate;
     private handleDataSourceUpdate;
     private flushPendingDataSourceUpdates;