@acorex-platform/framework-client 2.0.0-next.3 → 2.0.0-next.31

package/fesm2022/acorex-platform-framework-client-common.mjs

@@ -1,17 +1,17 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, Injector, signal, ApplicationRef, DestroyRef, makeEnvironmentProviders, NgModule, computed, input, ChangeDetectionStrategy, ViewEncapsulation, Component, output, effect, viewChild, afterNextRender, untracked, ErrorHandler, EventEmitter, Input, Output, Directive, Inject, runInInjectionContext, model, linkedSignal } from '@angular/core';
-import * as i5 from '@angular/router';
-import { Router, NavigationEnd, NavigationStart, ROUTES, RedirectCommand, UrlTree, RouterModule } from '@angular/router';
 import { AXPSessionService, AXPSessionStatus, AXPUnauthenticatedError, AXPAuthGuard, commandMessageTextForError } from '@acorex-platform/framework-client/auth';
 export { commandMessageTextForError } from '@acorex-platform/framework-client/auth';
-import { combineLatest, map, distinctUntilChanged, Subject, ReplaySubject, firstValueFrom, filter, take, timer, timeout, switchMap, from, of } from 'rxjs';
-import { unwrapValueProperty, isLocaleStringMap, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToBoolean, coerceUnknownToTrimmedString, AXPPlatformScope, runtimeQueryPayloadData, runtimeCommandPayloadData, AXPRegionalSetting, AXPWidgetsCatalog, axpResolveUserNotificationDelivery, resolveMultiLanguageString, coerceUnknownToMultiLanguageString, AXPKeyboardShortcutPriority, AXP_PLATFORM_ERROR_CODES, AXPRequestError, mapUnknownToAXPErrorBody, AXPSystemActionType, runtimeQueryCollectionData, createRandomUuid, runtimeCommandFailure, runtimeCommandSuccessObject, runtimeQuerySuccessObject } from '@acorex-platform/framework-shared/core';
 import * as i4$2 from '@acorex-platform/framework-client/core';
 import { AXPDebugService, AXPBroadcastEventService, AXP_SETTINGS_DEFINITION_DIALOG_OPENER, objectKeyValueTransforms, AXPDataGenerator, AXPKeyboardShortcutRegistry, normalizeKeyboardShortcuts, AXPDeviceService, provideAppStartUpTask, AXP_APP_STARTUP_PRIORITY, chordToKbdItemKeys, hasForegroundOverlayLayer, AXPExpressionEvaluatorService, AXPContextEvalFactory, AXPModuleManifestModule, AXPComponentSlotModule, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_LOGO_IMAGE_SRC_RESOLVER, AXPHookService, AXPPageContextRegistry } from '@acorex-platform/framework-client/core';
 export { AXPDebugService } from '@acorex-platform/framework-client/core';
+import { unwrapValueProperty, isLocaleStringMap, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToBoolean, coerceUnknownToTrimmedString, AXPPlatformScope, runtimeQueryPayloadData, runtimeCommandPayloadData, AXPRegionalSetting, AXPWidgetsCatalog, axpResolveUserNotificationDelivery, resolveMultiLanguageString, coerceUnknownToMultiLanguageString, AXPKeyboardShortcutPriority, AXP_PLATFORM_ERROR_CODES, AXPRequestError, mapUnknownToAXPErrorBody, AXPSystemActionType, runtimeQueryCollectionData, createRandomUuid, runtimeCommandFailure, runtimeCommandSuccessObject, runtimeQuerySuccessObject } from '@acorex-platform/framework-shared/core';
 import { merge, sortBy, isString, toString, isPlainObject, mergeWith, defaultTo, isEmpty, isEqual, cloneDeep, get, isNumber, isNil, isObject, omit, uniq } from 'lodash-es';
+import { combineLatest, map, distinctUntilChanged, Subject, ReplaySubject, firstValueFrom, filter, take, timer, timeout, switchMap, from, of } from 'rxjs';
 import { AXPQueryService, AXPCommandService, provideCommandSetups, provideQuerySetups } from '@acorex-platform/framework-client/runtime';
 import Dexie from 'dexie';
+import * as i5 from '@angular/router';
+import { Router, NavigationEnd, NavigationStart, ROUTES, RedirectCommand, UrlTree, RouterModule } from '@angular/router';
 import { AXDialogService } from '@acorex/components/dialog';
 import * as i6 from '@acorex/core/translation';
 import { AXTranslationService, AXTranslationModule, translateSync, resolveMultiLanguageString as resolveMultiLanguageString$1 } from '@acorex/core/translation';
@@ -34,7 +34,7 @@ import { AXProgressBarModule } from '@acorex/components/progress-bar';
 import * as i3$1 from '@acorex/core/format';
 import { AXFormatModule, AXFormatService } from '@acorex/core/format';
 import { AXNotificationService, AXNotificationModule } from '@acorex/components/notification';
-import { filter as filter$1 } from 'rxjs/operators';
+import { filter as filter$1, map as map$1, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs/operators';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
 import { AXPopupService, AXPopupModule } from '@acorex/components/popup';
 import { AXToastModule, AXToastService } from '@acorex/components/toast';
@@ -238,162 +238,109 @@ const ALL_DEFAULT_OPERATORS = [
     BETWEEN_OPER,
 ];
 
-const DEFAULT_DATE_FILTER_PRESETS = [
-    { id: 'today', title: '@general:terms.date-presets.today', kind: 'computed' },
-    { id: 'this-week', title: '@general:terms.date-presets.this-week', kind: 'computed' },
-    { id: 'this-month', title: '@general:terms.date-presets.this-month', kind: 'computed' },
-    { id: 'yesterday', title: '@general:terms.date-presets.yesterday', kind: 'computed' },
-    { id: 'last-week', title: '@general:terms.date-presets.last-week', kind: 'computed' },
-    { id: 'last-month', title: '@general:terms.date-presets.last-month', kind: 'computed' },
-    { id: 'tomorrow', title: '@general:terms.date-presets.tomorrow', kind: 'computed' },
-    { id: 'next-week', title: '@general:terms.date-presets.next-week', kind: 'computed' },
-    { id: 'next-month', title: '@general:terms.date-presets.next-month', kind: 'computed' },
-    { id: 'between', title: BETWEEN_OPER.title, kind: 'manual', operationType: 'between' },
-    { id: 'greater-than', title: '@general:terms.operators.greater-than', kind: 'manual', operationType: 'greaterThan' },
-    { id: 'less-than', title: '@general:terms.operators.less-than', kind: 'manual', operationType: 'lessThan' },
+//#endregion
+//#region ----- Catalog -----
+const I18N$1 = '@general:settings.experience.entity.filter-default-operators.widgets';
+/** Single-value choice filters. `in` stays on the multiple-selection path. */
+const EQUALITY_OPERATORS = [EQ_OPER, NOT_EQ_OPER];
+function toChoices(operators) {
+    return operators.map((operator) => ({ name: operator.name, titleKey: operator.title }));
+}
+/**
+ * One row per filter widget. `codeDefault` matches the widget config constant
+ * (`AXP_*_FILTER_DEFAULT_OPERATOR`). Stored settings keep only values that differ from it.
+ */
+const AXP_FILTER_DEFAULT_OPERATOR_WIDGETS = [
+    {
+        widgetName: 'string-filter',
+        titleKey: `${I18N$1}.string-filter`,
+        codeDefault: 'contains',
+        operators: toChoices(STRING_OPERATORS),
+    },
+    {
+        widgetName: 'number-filter',
+        titleKey: `${I18N$1}.number-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(NUMBER_OPERATORS),
+    },
+    {
+        widgetName: 'datetime-filter',
+        titleKey: `${I18N$1}.datetime-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(DATE_OPERATORS),
+    },
+    {
+        widgetName: 'boolean-filter',
+        titleKey: `${I18N$1}.boolean-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(BOOLEAN_OPERATORS),
+    },
+    {
+        widgetName: 'select-filter',
+        titleKey: `${I18N$1}.select-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(EQUALITY_OPERATORS),
+    },
+    {
+        widgetName: 'lookup-filter',
+        titleKey: `${I18N$1}.lookup-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(EQUALITY_OPERATORS),
+    },
+    {
+        widgetName: 'status-filter',
+        titleKey: `${I18N$1}.status-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(EQUALITY_OPERATORS),
+    },
+    {
+        widgetName: 'time-duration-filter',
+        titleKey: `${I18N$1}.time-duration-filter`,
+        codeDefault: 'equal',
+        operators: toChoices(NUMBER_OPERATORS),
+    },
 ];
-function resolveDateFilterPresets(customPresets, presetIds) {
-    let presets = customPresets?.length ? customPresets : DEFAULT_DATE_FILTER_PRESETS;
-    if (presetIds?.length) {
-        presets = presets.filter((p) => presetIds.includes(p.id));
+const AXP_FILTER_DEFAULT_OPERATORS_WIDGET_NAME = 'filter-default-operators';
+//#endregion
+//#region ----- Map helpers -----
+function readFilterDefaultOperatorMap(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
     }
-    return presets;
-}
-function applyDateFilterPreset(presetId, calendarService) {
-    const currentDate = calendarService.now().date;
-    const calendar = calendarService.calendar;
-    switch (presetId) {
-        case 'today':
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: calendar.startOf(currentDate, 'day').date.toISOString(),
-                    to: calendar.endOf(currentDate, 'day').date.toISOString(),
-                },
-            };
-        case 'this-week':
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: calendar.startOf(currentDate, 'week').date.toISOString(),
-                    to: calendar.endOf(currentDate, 'week').date.toISOString(),
-                },
-            };
-        case 'this-month':
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: calendar.startOf(currentDate, 'month').date.toISOString(),
-                    to: calendar.endOf(currentDate, 'month').date.toISOString(),
-                },
-            };
-        case 'yesterday': {
-            const yesterday = calendar.add(currentDate, 'day', -1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: yesterday.startOf('day').date.toISOString(),
-                    to: yesterday.endOf('day').date.toISOString(),
-                },
-            };
-        }
-        case 'last-week': {
-            const lastWeek = calendar.add(currentDate, 'week', -1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: lastWeek.startOf('week').date.toISOString(),
-                    to: lastWeek.endOf('week').date.toISOString(),
-                },
-            };
-        }
-        case 'last-month': {
-            const lastMonth = calendar.add(currentDate, 'month', -1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: lastMonth.startOf('month').date.toISOString(),
-                    to: lastMonth.endOf('month').date.toISOString(),
-                },
-            };
-        }
-        case 'tomorrow': {
-            const tomorrow = calendar.add(currentDate, 'day', 1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: tomorrow.startOf('day').date.toISOString(),
-                    to: tomorrow.endOf('day').date.toISOString(),
-                },
-            };
-        }
-        case 'next-week': {
-            const nextWeek = calendar.add(currentDate, 'week', 1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: nextWeek.startOf('week').date.toISOString(),
-                    to: nextWeek.endOf('week').date.toISOString(),
-                },
-            };
-        }
-        case 'next-month': {
-            const nextMonth = calendar.add(currentDate, 'month', 1);
-            return {
-                operation: { type: 'between' },
-                value: {
-                    from: nextMonth.startOf('month').date.toISOString(),
-                    to: nextMonth.endOf('month').date.toISOString(),
-                },
-            };
+    const result = {};
+    for (const [widgetName, operatorName] of Object.entries(value)) {
+        if (typeof operatorName === 'string' && operatorName.length > 0) {
+            result[widgetName] = operatorName;
         }
-        case 'between':
-            return { operation: { type: 'between' } };
-        case 'greater-than':
-            return { operation: { type: 'greaterThan' } };
-        case 'less-than':
-            return { operation: { type: 'lessThan' } };
-        default:
-            return {
-                operation: { type: 'between' },
-                value: { from: '', to: '' },
-            };
     }
+    return result;
 }
-function findManualPresetIdByOperation(operationType, presets) {
-    if (!operationType) {
-        return undefined;
-    }
-    return presets.find((p) => p.kind === 'manual' && p.operationType === operationType)?.id;
+function findFilterDefaultOperatorWidget(widgetName) {
+    return AXP_FILTER_DEFAULT_OPERATOR_WIDGETS.find((widget) => widget.widgetName === widgetName);
 }
-
-const AXP_HOME_PAGES = new InjectionToken('AXP_HOME_PAGES');
-const AXP_HOME_PAGE_DEFAULT_KEY = new InjectionToken('AXP_HOME_PAGE_DEFAULT_KEY', {
-    factory: () => 'home'
-});
-
-/** Strict descendants allowed to override a setting owned at `scope`. */
-const AXP_SETTING_SCOPE_DESCENDANTS = {
-    P: ['T', 'U'],
-    T: ['U'],
-    U: [],
-};
-function normalizeOverridableAt(ownerScope, overridableAt) {
-    const scopes = overridableAt ?? [];
-    const allowed = AXP_SETTING_SCOPE_DESCENDANTS[ownerScope];
-    for (const scope of scopes) {
-        if (!allowed.includes(scope)) {
-            throw new Error(`Setting at scope "${ownerScope}" cannot be overridable at "${scope}". Allowed: [${allowed.join(', ')}].`);
-        }
+/** Stored operator when it belongs to that widget; otherwise the code default. */
+function resolveStoredFilterDefaultOperator(widgetName, stored, codeDefault) {
+    const selected = readFilterDefaultOperatorMap(stored)[widgetName];
+    if (!selected) {
+        return codeDefault;
     }
-    return scopes;
+    const widget = findFilterDefaultOperatorWidget(widgetName);
+    if (widget && !widget.operators.some((operator) => operator.name === selected)) {
+        return codeDefault;
+    }
+    return selected;
 }
-function isSettingVisibleOnScope(setting, pageScope) {
-    if (setting.scope === pageScope) {
-        return true;
+/** Persist a change only when it differs from the widget's code default. */
+function writeFilterDefaultOperatorOverride(current, widgetName, operatorName, codeDefault) {
+    const next = { ...readFilterDefaultOperatorMap(current) };
+    if (!operatorName || operatorName === codeDefault) {
+        delete next[widgetName];
+        return next;
     }
-    return (setting.overridableAt ?? []).includes(pageScope);
+    next[widgetName] = operatorName;
+    return next;
 }
+//#endregion
 
 var AXPCommonSettings;
 (function (AXPCommonSettings) {
@@ -413,6 +360,11 @@ var AXPCommonSettings;
      * IndexedDB platform-settings cache. When false, bootstrap redirects to /auth/unavailable.
      */
     AXPCommonSettings["AllowWorkingOffline"] = "Common:Setting:Offline.AllowWorkingOffline";
+    /**
+     * Platform (P): when false, hide user availability (account menu, avatar dot, user card).
+     * Products without a status surface turn this off.
+     */
+    AXPCommonSettings["UserStatusEnabled"] = "Common:Setting:Presence.UserStatusEnabled";
     AXPCommonSettings["ShowRowIndexColumn"] = "Common:Setting:Entity.ShowRowIndexColumn";
     /** When true, the entity master-list table derives header bands from entity sections (property groups). */
     AXPCommonSettings["EntityMultiLevelHeaders"] = "Common:Setting:Entity.MultiLevelHeaders";
@@ -423,6 +375,8 @@ var AXPCommonSettings;
     AXPCommonSettings["MaxOpenTabs"] = "Common:Setting:Navigation.MaxOpenTabs";
     /** When true with entity list quick-search input, filters emit {@link AXP_QUERY_QUICK_SEARCH_FIELD} instead of inline OR. */
     AXPCommonSettings["QuickSearchEnabled"] = "Common:Setting:Entity.QuickSearchEnabled";
+    /** Platform map of filter widget name → operator. Only overrides are stored. */
+    AXPCommonSettings["FilterDefaultOperators"] = "Common:Setting:Entity.FilterDefaultOperators";
 })(AXPCommonSettings || (AXPCommonSettings = {}));
 /**
  * File-chooser keys live here so `common` can register Experience settings
@@ -445,6 +399,31 @@ const AXP_RUNTIME_QUERY_CACHE_DEFAULTS = {
 };
 /** Default entity list presentation when the user has not chosen a layout. */
 const AXP_ENTITY_LIST_DISPLAY_MODE_DEFAULT = 'table';
+/** User status stays visible until a platform setting turns it off. */
+const AXP_USER_STATUS_ENABLED_DEFAULT = true;
+
+/** Strict descendants allowed to override a setting owned at `scope`. */
+const AXP_SETTING_SCOPE_DESCENDANTS = {
+    P: ['T', 'U'],
+    T: ['U'],
+    U: [],
+};
+function normalizeOverridableAt(ownerScope, overridableAt) {
+    const scopes = overridableAt ?? [];
+    const allowed = AXP_SETTING_SCOPE_DESCENDANTS[ownerScope];
+    for (const scope of scopes) {
+        if (!allowed.includes(scope)) {
+            throw new Error(`Setting at scope "${ownerScope}" cannot be overridable at "${scope}". Allowed: [${allowed.join(', ')}].`);
+        }
+    }
+    return scopes;
+}
+function isSettingVisibleOnScope(setting, pageScope) {
+    if (setting.scope === pageScope) {
+        return true;
+    }
+    return (setting.overridableAt ?? []).includes(pageScope);
+}
 
 class AXPSettingDefinitionProviderContext {
     constructor() {
@@ -584,24 +563,64 @@ const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITI
 class AXPSettingDefinitionProviderService {
     constructor() {
         this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
+        this.sessionService = inject(AXPSessionService);
         this.cache = null;
+        /**
+         * Tenant, application, and enabled edition features.
+         * Providers such as Telegram gate sections on `isModuleEnabled` at build time,
+         * so a catalog built before login must be rebuilt once features arrive.
+         */
+        this.cacheAvailabilityKey = null;
         this.loadPromise = null;
     }
+    /** Same identity permissions use when deciding the definition cache is still valid. */
+    getAvailabilityKey() {
+        return this.buildAvailabilityKey();
+    }
+    buildAvailabilityKey() {
+        const enabled = this.sessionService.features
+            .filter((feature) => feature.value === true && !!feature.name)
+            .map((feature) => feature.name)
+            .sort();
+        const applicationId = this.sessionService.application?.id ?? '';
+        const tenantId = this.sessionService.tenant?.id ?? '';
+        return `${tenantId}|${applicationId}|${enabled.join(',')}`;
+    }
     async load() {
-        if (this.cache) {
-            return;
-        }
-        if (!this.loadPromise) {
-            this.loadPromise = this.loadDefinitions().finally(() => {
-                this.loadPromise = null;
+        while (true) {
+            const availabilityKey = this.buildAvailabilityKey();
+            if (this.cache && this.cacheAvailabilityKey === availabilityKey) {
+                return;
+            }
+            if (this.loadPromise) {
+                await this.loadPromise;
+                continue;
+            }
+            const keyAtStart = availabilityKey;
+            this.cache = null;
+            this.cacheAvailabilityKey = null;
+            let resolveLoad;
+            this.loadPromise = new Promise((resolve) => {
+                resolveLoad = resolve;
             });
+            try {
+                await this.loadDefinitions();
+                if (this.buildAvailabilityKey() === keyAtStart) {
+                    this.cacheAvailabilityKey = keyAtStart;
+                }
+                else {
+                    // Features changed while providers ran. Drop the catalog and rebuild.
+                    this.cache = null;
+                    this.cacheAvailabilityKey = null;
+                }
+            }
+            finally {
+                this.loadPromise = null;
+                resolveLoad();
+            }
         }
-        await this.loadPromise;
     }
     async loadDefinitions() {
-        if (this.cache) {
-            return;
-        }
         const context = new AXPSettingDefinitionProviderContext();
         // Load providers from DI tokens — isolate failures so one provider cannot block bootstrap.
         const providerList = this.normalizeProviders(this.providers);
@@ -629,6 +648,12 @@ class AXPSettingDefinitionProviderService {
     }
     async reload() {
         this.cache = null;
+        this.cacheAvailabilityKey = null;
+        if (this.loadPromise) {
+            await this.loadPromise;
+            this.cache = null;
+            this.cacheAvailabilityKey = null;
+        }
         await this.load();
     }
     async getListAsync(scope) {
@@ -2781,36 +2806,217 @@ class ScopedSettingService {
     }
 }
 
-const DEFAULT_APPLY_DEFAULT_MULTILANGUAGE = true;
-/**
- * Synchronous access to default multi-language behavior for named entity fields and widget
- * property bindings. Mirrors {@link AXPLayoutOrderingConfigService}: avoids async in entity
- * modifiers and startup deadlocks.
- */
-class AXPDefaultMultiLanguageConfigService {
+//#region ----- Service -----
+class AXPFilterDefaultOperatorService {
+    //#endregion
+    //#region ----- Lifecycle -----
     constructor() {
-        this.settingsService = inject(AXPSettingsService);
-        this._applyDefault = signal(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "_applyDefault" }] : /* istanbul ignore next */ []));
-        this.syncScheduled = false;
-        this.settingsService.onLoaded.subscribe(() => this.syncFromSettings());
-        this.settingsService.onChanged.subscribe(() => this.syncFromSettings());
+        //#region ----- Services & Dependencies -----
+        this.settings = inject(AXPSettingsService);
+        //#endregion
+        //#region ----- State Signals -----
+        this.overrides = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "overrides" }] : /* istanbul ignore next */ []));
+        this.refresh();
+        this.settings.onChanged.subscribe(() => {
+            this.refresh();
+        });
     }
-    getApplyDefaultMultiLanguage() {
-        if (!this.syncScheduled) {
-            this.syncScheduled = true;
-            this.settingsService
-                .get(AXPRegionalSetting.MultiLanguageSupport)
-                .then((value) => this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE))
-                .catch(() => this._applyDefault.set(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE));
-        }
-        return this._applyDefault();
+    //#endregion
+    //#region ----- Resolve -----
+    /** Platform override for this filter widget, or `codeDefault` when unset. */
+    resolve(widgetName, codeDefault) {
+        return resolveStoredFilterDefaultOperator(widgetName, this.overrides(), codeDefault);
     }
-    async syncFromSettings() {
-        try {
-            const value = await this.settingsService.get(AXPRegionalSetting.MultiLanguageSupport);
-            this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE);
-        }
+    //#endregion
+    //#region ----- Cache -----
+    refresh() {
+        this.overrides.set(readFilterDefaultOperatorMap(this.settings.peekCached(AXPCommonSettings.FilterDefaultOperators)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPFilterDefaultOperatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPFilterDefaultOperatorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPFilterDefaultOperatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//#endregion
+//#region ----- Widget lookup overlay -----
+function withFilterDefaultOperator(service, widgetName, widget) {
+    if (!widget?.defaultFilterOperator) {
+        return widget;
+    }
+    const resolved = service.resolve(widgetName, widget.defaultFilterOperator);
+    if (resolved === widget.defaultFilterOperator) {
+        return widget;
+    }
+    return { ...widget, defaultFilterOperator: resolved };
+}
+
+const DEFAULT_DATE_FILTER_PRESETS = [
+    { id: 'today', title: '@general:terms.date-presets.today', kind: 'computed' },
+    { id: 'this-week', title: '@general:terms.date-presets.this-week', kind: 'computed' },
+    { id: 'this-month', title: '@general:terms.date-presets.this-month', kind: 'computed' },
+    { id: 'yesterday', title: '@general:terms.date-presets.yesterday', kind: 'computed' },
+    { id: 'last-week', title: '@general:terms.date-presets.last-week', kind: 'computed' },
+    { id: 'last-month', title: '@general:terms.date-presets.last-month', kind: 'computed' },
+    { id: 'tomorrow', title: '@general:terms.date-presets.tomorrow', kind: 'computed' },
+    { id: 'next-week', title: '@general:terms.date-presets.next-week', kind: 'computed' },
+    { id: 'next-month', title: '@general:terms.date-presets.next-month', kind: 'computed' },
+    { id: 'between', title: BETWEEN_OPER.title, kind: 'manual', operationType: 'between' },
+    { id: 'greater-than', title: '@general:terms.operators.greater-than', kind: 'manual', operationType: 'greaterThan' },
+    { id: 'less-than', title: '@general:terms.operators.less-than', kind: 'manual', operationType: 'lessThan' },
+];
+function resolveDateFilterPresets(customPresets, presetIds) {
+    let presets = customPresets?.length ? customPresets : DEFAULT_DATE_FILTER_PRESETS;
+    if (presetIds?.length) {
+        presets = presets.filter((p) => presetIds.includes(p.id));
+    }
+    return presets;
+}
+function applyDateFilterPreset(presetId, calendarService) {
+    const currentDate = calendarService.now().date;
+    const calendar = calendarService.calendar;
+    switch (presetId) {
+        case 'today':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'day').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'day').date.toISOString(),
+                },
+            };
+        case 'this-week':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'week').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'week').date.toISOString(),
+                },
+            };
+        case 'this-month':
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: calendar.startOf(currentDate, 'month').date.toISOString(),
+                    to: calendar.endOf(currentDate, 'month').date.toISOString(),
+                },
+            };
+        case 'yesterday': {
+            const yesterday = calendar.add(currentDate, 'day', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: yesterday.startOf('day').date.toISOString(),
+                    to: yesterday.endOf('day').date.toISOString(),
+                },
+            };
+        }
+        case 'last-week': {
+            const lastWeek = calendar.add(currentDate, 'week', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: lastWeek.startOf('week').date.toISOString(),
+                    to: lastWeek.endOf('week').date.toISOString(),
+                },
+            };
+        }
+        case 'last-month': {
+            const lastMonth = calendar.add(currentDate, 'month', -1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: lastMonth.startOf('month').date.toISOString(),
+                    to: lastMonth.endOf('month').date.toISOString(),
+                },
+            };
+        }
+        case 'tomorrow': {
+            const tomorrow = calendar.add(currentDate, 'day', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: tomorrow.startOf('day').date.toISOString(),
+                    to: tomorrow.endOf('day').date.toISOString(),
+                },
+            };
+        }
+        case 'next-week': {
+            const nextWeek = calendar.add(currentDate, 'week', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: nextWeek.startOf('week').date.toISOString(),
+                    to: nextWeek.endOf('week').date.toISOString(),
+                },
+            };
+        }
+        case 'next-month': {
+            const nextMonth = calendar.add(currentDate, 'month', 1);
+            return {
+                operation: { type: 'between' },
+                value: {
+                    from: nextMonth.startOf('month').date.toISOString(),
+                    to: nextMonth.endOf('month').date.toISOString(),
+                },
+            };
+        }
+        case 'between':
+            return { operation: { type: 'between' } };
+        case 'greater-than':
+            return { operation: { type: 'greaterThan' } };
+        case 'less-than':
+            return { operation: { type: 'lessThan' } };
+        default:
+            return {
+                operation: { type: 'between' },
+                value: { from: '', to: '' },
+            };
+    }
+}
+function findManualPresetIdByOperation(operationType, presets) {
+    if (!operationType) {
+        return undefined;
+    }
+    return presets.find((p) => p.kind === 'manual' && p.operationType === operationType)?.id;
+}
+
+const AXP_HOME_PAGES = new InjectionToken('AXP_HOME_PAGES');
+const AXP_HOME_PAGE_DEFAULT_KEY = new InjectionToken('AXP_HOME_PAGE_DEFAULT_KEY', {
+    factory: () => 'home'
+});
+
+const DEFAULT_APPLY_DEFAULT_MULTILANGUAGE = true;
+/**
+ * Synchronous access to default multi-language behavior for named entity fields and widget
+ * property bindings. Mirrors {@link AXPLayoutOrderingConfigService}: avoids async in entity
+ * modifiers and startup deadlocks.
+ */
+class AXPDefaultMultiLanguageConfigService {
+    constructor() {
+        this.settingsService = inject(AXPSettingsService);
+        this._applyDefault = signal(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "_applyDefault" }] : /* istanbul ignore next */ []));
+        this.syncScheduled = false;
+        this.settingsService.onLoaded.subscribe(() => this.syncFromSettings());
+        this.settingsService.onChanged.subscribe(() => this.syncFromSettings());
+    }
+    getApplyDefaultMultiLanguage() {
+        if (!this.syncScheduled) {
+            this.syncScheduled = true;
+            this.settingsService
+                .get(AXPRegionalSetting.MultiLanguageSupport)
+                .then((value) => this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE))
+                .catch(() => this._applyDefault.set(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE));
+        }
+        return this._applyDefault();
+    }
+    async syncFromSettings() {
+        try {
+            const value = await this.settingsService.get(AXPRegionalSetting.MultiLanguageSupport);
+            this._applyDefault.set(value ?? DEFAULT_APPLY_DEFAULT_MULTILANGUAGE);
+        }
         catch {
             this._applyDefault.set(DEFAULT_APPLY_DEFAULT_MULTILANGUAGE);
         }
@@ -2977,6 +3183,52 @@ function withDefaultMultiLanguageOnWidgetProperty(prop, applyDefault) {
 }
 //#endregion
 
+//#region ----- User status feature -----
+/**
+ * Platform switch for showing user availability.
+ * Stays on until {@link AXPCommonSettings.UserStatusEnabled} is false.
+ */
+class AXPUserStatusFeatureService {
+    //#endregion
+    //#region ----- Lifecycle -----
+    constructor() {
+        //#region ----- Services & Dependencies -----
+        this.settingsService = inject(AXPSettingsService);
+        //#endregion
+        //#region ----- State Signals -----
+        this.enabledSignal = signal(AXP_USER_STATUS_ENABLED_DEFAULT, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "enabledSignal" }] : /* istanbul ignore next */ []));
+        /** Live platform flag. True until settings say otherwise. */
+        this.enabled = this.enabledSignal.asReadonly();
+        this.settingsService.onLoaded.subscribe(() => {
+            void this.refresh();
+        });
+        this.settingsService.onChanged.subscribe((event) => {
+            if (!event.keys.includes(AXPCommonSettings.UserStatusEnabled)) {
+                return;
+            }
+            void this.refresh();
+        });
+    }
+    //#endregion
+    //#region ----- Public API -----
+    async isEnabled() {
+        return this.refresh();
+    }
+    async refresh() {
+        const value = await this.settingsService.get(AXPCommonSettings.UserStatusEnabled);
+        const enabled = value !== false;
+        this.enabledSignal.set(enabled);
+        return enabled;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUserStatusFeatureService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUserStatusFeatureService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUserStatusFeatureService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
 //#region ----- Platform settings load state -----
 /**
  * Tracks fatal failure / offline-continue of the public platform (P) settings bootstrap.
@@ -3382,65 +3634,273 @@ class AXPUnsavedChangesPopstateService {
             }
         });
     }
-    //#endregion
-    //#region ----   Registry   ----
-    registerSource(source) {
-        this.sources = this.sources.filter((entry) => entry.id !== source.id);
-        this.sources.push(source);
+    //#endregion
+    //#region ----   Registry   ----
+    registerSource(source) {
+        this.sources = this.sources.filter((entry) => entry.id !== source.id);
+        this.sources.push(source);
+    }
+    unregisterSource(id) {
+        this.sources = this.sources.filter((entry) => entry.id !== id);
+    }
+    //#endregion
+    //#region ----   Popstate Handler   ----
+    /** True while a popstate back/forward is being intercepted or confirmed. */
+    isHandlingPopstate() {
+        return this.handling;
+    }
+    async handlePopstateNavigation(start) {
+        if (this.handling) {
+            return;
+        }
+        if (this.confirm.hasLeaveConfirmed()) {
+            return;
+        }
+        const dirty = this.isDirty();
+        if (!dirty) {
+            return;
+        }
+        const stayUrl = this.committedUrl;
+        const targetUrl = start.url;
+        if (!stayUrl || stayUrl === targetUrl) {
+            return;
+        }
+        this.handling = true;
+        try {
+            this.location.go(stayUrl);
+            const allowed = await this.confirm.confirmIfDirty(true);
+            if (!allowed) {
+                await this.router.navigateByUrl(stayUrl, { replaceUrl: true });
+                return;
+            }
+            window.history.back();
+        }
+        finally {
+            this.handling = false;
+        }
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    isDirty() {
+        return this.sources.some((source) => source.isDirty());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#endregion
+//#region ----   App Path Navigation   ----
+/**
+ * Splits an absolute app path (`/app/m/module/e/Entity/id/view`) into router command segments.
+ * Prefer this over `navigate([fullPath])` or ambiguous single-segment navigation so browser history stays correct.
+ */
+function axpParseAppPath(path) {
+    const trimmed = path.trim();
+    const withoutLeadingSlash = trimmed.startsWith('/') ? trimmed.slice(1) : trimmed;
+    const [pathAndFragment, queryString] = withoutLeadingSlash.split('?');
+    const [pathPart, fragment] = pathAndFragment.split('#');
+    const segments = pathPart.split('/').filter(Boolean);
+    const queryParams = queryString
+        ? queryString.split('&').reduce((params, pair) => {
+            const [key, value = ''] = pair.split('=');
+            if (key) {
+                params[decodeURIComponent(key)] = decodeURIComponent(value);
+            }
+            return params;
+        }, {})
+        : undefined;
+    return {
+        segments,
+        queryParams,
+        fragment: fragment || undefined,
+    };
+}
+/** Navigates using explicit path segments (same pattern as entity preload filters). */
+function axpNavigateAppPath(router, path, extras) {
+    const { segments, queryParams, fragment } = axpParseAppPath(path);
+    return router.navigate(segments, {
+        ...extras,
+        queryParams,
+        fragment,
+    });
+}
+/** True when a URL path is an entity master list route (`.../e/{Entity}/list`). */
+function axpIsEntityListPath(url) {
+    const path = url.split('?')[0].split('#')[0];
+    return /\/e\/[^/]+\/list$/.test(path);
+}
+/** True when the current browser URL is an entity master list route (`.../e/{Entity}/list`). */
+function axpIsEntityListRoute(router) {
+    return axpIsEntityListPath(router.url);
+}
+/** True when a URL path is an entity details view route (`.../e/{Entity}/{id}/view`). */
+function axpIsEntityDetailsPath(url) {
+    const path = url.split('?')[0].split('#')[0];
+    return /\/e\/[^/]+\/[^/]+\/view$/.test(path);
+}
+/**
+ * Entity key (`module.entity`) for `/{app}/m/{module}/e/{entity}/{id}/view`.
+ * Query and hash are ignored. Returns null for every other path.
+ */
+function axpEntityKeyFromDetailsPath(url) {
+    const path = url.split('?')[0]?.split('#')[0] ?? '';
+    const match = /\/m\/([^/]+)\/e\/([^/]+)\/[^/]+\/view$/.exec(path);
+    const moduleName = match?.[1];
+    const entityName = match?.[2];
+    if (!moduleName || !entityName) {
+        return null;
+    }
+    return `${moduleName}.${entityName}`;
+}
+/** True when the current browser URL is an entity details view route (`.../e/{Entity}/{id}/view`). */
+function axpIsEntityDetailsViewRoute(router) {
+    return axpIsEntityDetailsPath(router.url);
+}
+/**
+ * Merges query params on the current entity list route without pushing history.
+ * Uses absolute path segments so a stale `relativeTo` cannot rewrite the active URL after navigating away.
+ */
+function axpReplaceEntityListRouteQueryParams(router, queryParams) {
+    const url = router.url;
+    if (!axpIsEntityListPath(url)) {
+        return;
+    }
+    const parsed = router.parseUrl(url);
+    const pathOnly = url.split('?')[0].split('#')[0];
+    const { segments } = axpParseAppPath(pathOnly);
+    const mergedQueryParams = { ...parsed.queryParams, ...queryParams };
+    void router.navigate(segments, {
+        queryParams: mergedQueryParams,
+        replaceUrl: true,
+    });
+}
+//#endregion
+
+//#region ----- Constants -----
+/** Query param that distinguishes two menus pointing at the same entity list. */
+const ENTITY_LIST_INSTANCE_QUERY_PARAM = 'list';
+/** Used when the list is opened without a menu (command, deep link). */
+const ENTITY_LIST_DEFAULT_INSTANCE_ID = 'default';
+//#endregion
+//#region ----- Instance id -----
+function axpNormalizeEntityListInstanceId(value) {
+    if (typeof value !== 'string') {
+        return ENTITY_LIST_DEFAULT_INSTANCE_ID;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : ENTITY_LIST_DEFAULT_INSTANCE_ID;
+}
+function axpGetEntityListInstanceIdFromQueryString(queryString) {
+    const params = new URLSearchParams(queryString.startsWith('?') ? queryString.slice(1) : queryString);
+    return axpNormalizeEntityListInstanceId(params.get(ENTITY_LIST_INSTANCE_QUERY_PARAM));
+}
+function axpGetEntityListInstanceIdFromParamMap(queryParamMap) {
+    return axpNormalizeEntityListInstanceId(queryParamMap.get(ENTITY_LIST_INSTANCE_QUERY_PARAM));
+}
+function axpGetEntityListInstanceIdFromPath(path) {
+    const queryString = path.split('#')[0].split('?')[1] ?? '';
+    return axpGetEntityListInstanceIdFromQueryString(queryString);
+}
+//#endregion
+//#region ----- Menu / URL stamping -----
+/**
+ * Appends `list={instanceId}` to an entity-list path when missing.
+ * Named menu entries get a stable identity so Angular reuses the list route
+ * while filter persistence can still isolate each menu.
+ */
+function axpEnsureEntityListInstanceQueryParam(path, instanceId) {
+    if (!path || !instanceId || !axpIsEntityListPath(path)) {
+        return path;
+    }
+    const normalized = axpNormalizeEntityListInstanceId(instanceId);
+    if (normalized === ENTITY_LIST_DEFAULT_INSTANCE_ID) {
+        return path;
     }
-    unregisterSource(id) {
-        this.sources = this.sources.filter((entry) => entry.id !== id);
+    const { segments, queryParams, fragment } = axpParseAppPath(path);
+    if (queryParams?.[ENTITY_LIST_INSTANCE_QUERY_PARAM]) {
+        return path;
     }
-    //#endregion
-    //#region ----   Popstate Handler   ----
-    /** True while a popstate back/forward is being intercepted or confirmed. */
-    isHandlingPopstate() {
-        return this.handling;
+    const nextQuery = new URLSearchParams({
+        ...(queryParams ?? {}),
+        [ENTITY_LIST_INSTANCE_QUERY_PARAM]: normalized,
+    });
+    const base = `/${segments.join('/')}`;
+    const withQuery = `${base}?${nextQuery.toString()}`;
+    return fragment ? `${withQuery}#${fragment}` : withQuery;
+}
+/**
+ * Query keys the list page rewrites while the user stays on the same menu
+ * (`view`, `filters`, layout, refresh). They must not open another tab.
+ */
+const ENTITY_LIST_PAGE_STATE_QUERY_KEYS = new Set(['view', 'layout', 'filters', '_ts']);
+function pushEntityListNavigationPair(pairs, key, raw) {
+    if (!key || ENTITY_LIST_PAGE_STATE_QUERY_KEYS.has(key)) {
+        return;
     }
-    async handlePopstateNavigation(start) {
-        if (this.handling) {
-            return;
-        }
-        if (this.confirm.hasLeaveConfirmed()) {
-            return;
-        }
-        const dirty = this.isDirty();
-        if (!dirty) {
-            return;
-        }
-        const stayUrl = this.committedUrl;
-        const targetUrl = start.url;
-        if (!stayUrl || stayUrl === targetUrl) {
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (typeof value !== 'string') {
+        return;
+    }
+    if (key === ENTITY_LIST_INSTANCE_QUERY_PARAM) {
+        const normalized = axpNormalizeEntityListInstanceId(value);
+        if (normalized === ENTITY_LIST_DEFAULT_INSTANCE_ID) {
             return;
         }
-        this.handling = true;
-        try {
-            this.location.go(stayUrl);
-            const allowed = await this.confirm.confirmIfDirty(true);
-            if (!allowed) {
-                await this.router.navigateByUrl(stayUrl, { replaceUrl: true });
-                return;
-            }
-            window.history.back();
-        }
-        finally {
-            this.handling = false;
-        }
+        pairs.push([key, normalized]);
+        return;
     }
-    //#endregion
-    //#region ----   Utility Methods   ----
-    isDirty() {
-        return this.sources.some((source) => source.isDirty());
+    pairs.push([key, value]);
+}
+function readEntityListNavigationPairs(query) {
+    const pairs = [];
+    if (!query) {
+        return pairs;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, providedIn: 'root' }); }
+    if (typeof query === 'string') {
+        const hashless = query.split('#')[0];
+        const queryMarker = hashless.indexOf('?');
+        // A path with no "?" is not a query. Parsing it makes the path itself a key and opens a second tab.
+        const queryString = queryMarker >= 0 ? hashless.slice(queryMarker + 1) : hashless.startsWith('/') ? '' : hashless;
+        const params = new URLSearchParams(queryString);
+        params.forEach((value, key) => pushEntityListNavigationPair(pairs, key, value));
+        return pairs;
+    }
+    if (typeof URLSearchParams !== 'undefined' && query instanceof URLSearchParams) {
+        query.forEach((value, key) => pushEntityListNavigationPair(pairs, key, value));
+        return pairs;
+    }
+    for (const [key, value] of Object.entries(query)) {
+        pushEntityListNavigationPair(pairs, key, value);
+    }
+    return pairs;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnsavedChangesPopstateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
+/**
+ * Tab and route-cache identity for an entity list.
+ * Navigation query params (`mode=cm`, `mode=pm`, non-default `list`, …) keep each menu distinct,
+ * the same way simple navigation does. Page-state params stay on the URL and do not split the tab.
+ */
+function axpEntityListNavigationTabKey(path, query) {
+    const base = path.split('?')[0].split('#')[0].replace(/\/+$/, '') || '/';
+    if (!axpIsEntityListPath(base)) {
+        return base;
+    }
+    const pairs = readEntityListNavigationPairs(query);
+    if (!pairs.length) {
+        return base;
+    }
+    pairs.sort((left, right) => left[0].localeCompare(right[0]) || left[1].localeCompare(right[1]));
+    const queryString = pairs
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join('&');
+    return `${base}?${queryString}`;
+}
+//#endregion
 
 //#endregion
 /**
@@ -3458,6 +3918,10 @@ class AXPTabRouteCacheRegistry {
         this.openKeys = new Set();
         this.enabled = false;
         this.deactivateGuardSuspended = false;
+        /** While true, cached pages stay stored but must not be attached to a navigation. */
+        this.attachSuspended = false;
+        /** Session that owns cached pages. Null means signed out: never keep another user's components. */
+        this.ownerKey = null;
     }
     //#endregion
     //#region ---- Deactivate Guard Suspension ----
@@ -3481,6 +3945,35 @@ class AXPTabRouteCacheRegistry {
     }
     //#endregion
     //#region ---- Mode ----
+    /** True while a signed-in session may keep detached pages. */
+    canCache() {
+        return this.ownerKey !== null;
+    }
+    /** True while a session transition must not reattach a cached page. */
+    isAttachSuspended() {
+        return this.attachSuspended;
+    }
+    /**
+     * Keeps cached pages for a failed switch, but blocks attaching them until the transition settles.
+     */
+    suspendAttach() {
+        this.attachSuspended = true;
+    }
+    /** Allows attach again. Does not destroy the stored pages. */
+    resumeAttach() {
+        this.attachSuspended = false;
+    }
+    /**
+     * Binds cached pages to one session. A sign-out or a different user destroys every cached
+     * component so the next session cannot reattach the previous user's data.
+     */
+    bindOwner(ownerKey) {
+        if (this.ownerKey === ownerKey) {
+            return;
+        }
+        this.ownerKey = ownerKey;
+        this.clear();
+    }
     /** Enables caching (tabular mode). Disabling clears and destroys every cached component. */
     setEnabled(enabled) {
         if (this.enabled === enabled) {
@@ -3502,7 +3995,11 @@ class AXPTabRouteCacheRegistry {
      */
     syncOpenKeys(scopedKeys, activeTabUrls = []) {
         const scopedSet = new Set(scopedKeys);
-        const activePathSet = new Set(activeTabUrls.map((url) => url.split('?')[0].split('#')[0].replace(/\/+$/, '') || '/'));
+        const activePathSet = new Set(activeTabUrls.flatMap((url) => {
+            const pathOnly = url.split('?')[0].split('#')[0].replace(/\/+$/, '') || '/';
+            const withNavigation = axpEntityListNavigationTabKey(pathOnly, url);
+            return withNavigation === pathOnly ? [pathOnly] : [pathOnly, withNavigation];
+        }));
         for (const cacheKey of [...this.handles.keys()]) {
             const normalizedCacheKey = cacheKey.replace(/\/+$/, '') || '/';
             const keepsScopedKey = scopedSet.has(normalizedCacheKey);
@@ -3544,6 +4041,10 @@ class AXPTabRouteCacheRegistry {
      * destroying the old one would destroy the live component and corrupt the view (NG0922).
      */
     store(key, handle) {
+        if (!this.ownerKey) {
+            this.destroyHandle(handle);
+            return;
+        }
         this.handles.set(key, handle);
     }
     /**
@@ -3553,6 +4054,9 @@ class AXPTabRouteCacheRegistry {
      * `store(snapshot, null)`.
      */
     retrieve(key) {
+        if (this.attachSuspended) {
+            return null;
+        }
         return this.handles.get(key) ?? null;
     }
     /**
@@ -3832,6 +4336,7 @@ const AXP_EXPERIENCE_SETTINGS_SECTIONS = {
     Performance: 'performance',
     Entity: 'entity',
     Offline: 'offline',
+    Presence: 'presence',
     FileChooser: 'file-chooser',
 };
 //#endregion
@@ -5329,7 +5834,7 @@ class AXPBackgroundOperationSlotComponent {
         this.popover()?.close();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPBackgroundOperationSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPBackgroundOperationSlotComponent, isStandalone: true, selector: "axp-background-operation-slot", viewQueries: [{ propertyName: "popover", first: true, predicate: AXPopoverComponent, descendants: true, isSignal: true }], ngImport: i0, template: "@if (showSlot()) {\n  <!-- ----- Footer tray trigger ----- -->\n  <button type=\"button\" class=\"operation-slot__trigger\" #operationTrigger (click)=\"onTriggerClick(panel)\">\n    @if (badgeDisplay()) {\n      <!-- ----- Count badge ----- -->\n      <ax-badge class=\"operation-slot__badge\" [class.--xs]=\"badgeDisplay().length > 2\" color=\"danger\" [text]=\"badgeDisplay()\"></ax-badge>\n    }\n    @if (slotShowsFailureOnly()) {\n      <!-- ----- Failed tasks ----- -->\n      <ax-icon class=\"operation-slot__icon\">\n        <i class=\"fa-light fa-circle-exclamation\"></i>\n      </ax-icon>\n    }\n    <!--->\n    <!-- ----- In-progress spinner (no icon for completed) ----- -->\n    @else if (!slotShowsRetainedOnly()) {\n      <ax-icon class=\"operation-slot__icon\">\n        <i class=\"fa-light fa-spinner fa-spin\"></i>\n      </ax-icon>\n    }\n    <span class=\"operation-slot__text\">\n      {{ slotLabelKey() | translate | async }}\n    </span>\n  </button>\n\n  <ax-popover\n    [target]=\"operationTrigger\"\n    [openOn]=\"'toggle'\"\n    [closeOn]=\"'clickOut'\"\n    [adaptivityEnabled]=\"true\"\n    (onOpened)=\"onPopoverOpened(panel)\"\n  >\n    <axp-background-operation-panel\n      #panel\n      (onClosePopover)=\"closePopover()\"\n    ></axp-background-operation-panel>\n  </ax-popover>\n}\n", styles: ["@layer properties;axp-background-operation-slot{display:inline-flex}.operation-slot__trigger{display:inline-flex;cursor:pointer;align-items:center;gap:calc(var(--spacing, .25rem) * 1.5);border-radius:var(--radius-md, .375rem);border-style:var(--tw-border-style);border-width:0px;background-color:transparent;padding-inline:calc(var(--spacing, .25rem) * 2);padding-block:var(--spacing, .25rem);color:var(--color-text-default);--ax-sys-size: ax-sm;--ax-sys-size-base: calc(var(--ax-sys-size-md) - var(--ax-sys-size-step));--spacing: calc(var(--ax-sys-spacing-base) - .25 * var(--ax-sys-padding-step));--ax-sys-border-radius: var(--ax-sys-border-radius-base);--text-xs: calc(var(--ax-sys-text-xs-base) * 11 / 12);--text-sm: calc(var(--ax-sys-text-sm-base) * 6 / 7);--text-base: calc(var(--ax-sys-body-font-size) * .875);--text-lg: calc(var(--ax-sys-text-lg-base) * 8 / 9);--text-xl: calc(var(--ax-sys-text-xl-base) * .9);--leading-3: calc(var(--ax-sys-leading-3-base) * 7 / 6);--leading-4: var(--ax-sys-leading-4-base);--leading-5: calc(var(--ax-sys-leading-5-base) * .9);--leading-6: calc(var(--ax-sys-leading-6-base) * 11 / 12)}@media(hover:hover){.operation-slot__trigger:hover{background-color:rgba(var(--ax-sys-color-light-surface))}}.operation-slot__icon{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)))}.operation-slot__text{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500)}.operation-slot__badge{flex-shrink:0}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i4$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i3$2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "disablePanelClass", "visualContextScope", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "closeOnScroll", "closeOnNavigation", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "component", type: AXPBackgroundOperationPanelComponent, selector: "axp-background-operation-panel", outputs: ["onActiveCountChange", "onClosePopover"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPBackgroundOperationSlotComponent, isStandalone: true, selector: "axp-background-operation-slot", viewQueries: [{ propertyName: "popover", first: true, predicate: AXPopoverComponent, descendants: true, isSignal: true }], ngImport: i0, template: "@if (showSlot()) {\n  <!-- ----- Footer tray trigger ----- -->\n  <button type=\"button\" class=\"operation-slot__trigger\" #operationTrigger (click)=\"onTriggerClick(panel)\">\n    @if (badgeDisplay()) {\n      <!-- ----- Count badge ----- -->\n      <ax-badge class=\"operation-slot__badge\" [class.--xs]=\"badgeDisplay().length > 2\" color=\"danger\" [text]=\"badgeDisplay()\"></ax-badge>\n    }\n    @if (slotShowsFailureOnly()) {\n      <!-- ----- Failed tasks ----- -->\n      <ax-icon class=\"operation-slot__icon\">\n        <i class=\"fa-light fa-circle-exclamation\"></i>\n      </ax-icon>\n    }\n    <!--->\n    <!-- ----- In-progress spinner (no icon for completed) ----- -->\n    @else if (!slotShowsRetainedOnly()) {\n      <ax-icon class=\"operation-slot__icon\">\n        <i class=\"fa-light fa-spinner fa-spin\"></i>\n      </ax-icon>\n    }\n    <span class=\"operation-slot__text\">\n      {{ slotLabelKey() | translate | async }}\n    </span>\n  </button>\n\n  <ax-popover\n    [target]=\"operationTrigger\"\n    [openOn]=\"'toggle'\"\n    [closeOn]=\"'clickOut'\"\n    [adaptivityEnabled]=\"true\"\n    (onOpened)=\"onPopoverOpened(panel)\"\n  >\n    <axp-background-operation-panel\n      #panel\n      (onClosePopover)=\"closePopover()\"\n    ></axp-background-operation-panel>\n  </ax-popover>\n}\n", styles: ["@layer properties;axp-background-operation-slot{display:inline-flex}.operation-slot__trigger{display:inline-flex;cursor:pointer;align-items:center;gap:calc(var(--spacing, .25rem) * 1.5);border-radius:var(--radius-md, .375rem);border-style:var(--tw-border-style);border-width:0px;background-color:transparent;padding-inline:calc(var(--spacing, .25rem) * 2);padding-block:var(--spacing, .25rem);color:var(--color-text-default);--ax-sys-size: ax-sm;--ax-sys-size-base: calc(var(--ax-sys-size-md) - var(--ax-sys-size-step));--spacing: calc(var(--ax-sys-spacing-base) - .25 * var(--ax-sys-padding-step));--ax-sys-border-radius: var(--ax-sys-border-radius-base);--text-xs: calc(var(--ax-sys-text-xs-base) * 11 / 12);--text-sm: calc(var(--ax-sys-text-sm-base) * 6 / 7);--text-base: calc(var(--ax-sys-body-font-size) * .875);--text-lg: calc(var(--ax-sys-text-lg-base) * 8 / 9);--text-xl: calc(var(--ax-sys-text-xl-base) * .9);--leading-3: calc(var(--ax-sys-leading-3-base) * 7 / 6);--leading-4: var(--ax-sys-leading-4-base);--leading-5: calc(var(--ax-sys-leading-5-base) * .9);--leading-6: calc(var(--ax-sys-leading-6-base) * 11 / 12)}@media(hover:hover){.operation-slot__trigger:hover{background-color:rgba(var(--ax-sys-color-light-surface))}}.operation-slot__icon{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)))}.operation-slot__text{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500)}.operation-slot__badge{flex-shrink:0}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i4$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i3$2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "disablePanelClass", "visualContextScope", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "restoreFocusOnClose", "openAfter", "closeAfter", "closeOnScroll", "closeOnNavigation", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "component", type: AXPBackgroundOperationPanelComponent, selector: "axp-background-operation-panel", outputs: ["onActiveCountChange", "onClosePopover"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPBackgroundOperationSlotComponent, decorators: [{
             type: Component,
@@ -5600,148 +6105,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-//#endregion
-//#region ----   App Path Navigation   ----
-/**
- * Splits an absolute app path (`/app/m/module/e/Entity/id/view`) into router command segments.
- * Prefer this over `navigate([fullPath])` or ambiguous single-segment navigation so browser history stays correct.
- */
-function axpParseAppPath(path) {
-    const trimmed = path.trim();
-    const withoutLeadingSlash = trimmed.startsWith('/') ? trimmed.slice(1) : trimmed;
-    const [pathAndFragment, queryString] = withoutLeadingSlash.split('?');
-    const [pathPart, fragment] = pathAndFragment.split('#');
-    const segments = pathPart.split('/').filter(Boolean);
-    const queryParams = queryString
-        ? queryString.split('&').reduce((params, pair) => {
-            const [key, value = ''] = pair.split('=');
-            if (key) {
-                params[decodeURIComponent(key)] = decodeURIComponent(value);
-            }
-            return params;
-        }, {})
-        : undefined;
-    return {
-        segments,
-        queryParams,
-        fragment: fragment || undefined,
-    };
-}
-/** Navigates using explicit path segments (same pattern as entity preload filters). */
-function axpNavigateAppPath(router, path, extras) {
-    const { segments, queryParams, fragment } = axpParseAppPath(path);
-    return router.navigate(segments, {
-        ...extras,
-        queryParams,
-        fragment,
-    });
-}
-/** True when a URL path is an entity master list route (`.../e/{Entity}/list`). */
-function axpIsEntityListPath(url) {
-    const path = url.split('?')[0].split('#')[0];
-    return /\/e\/[^/]+\/list$/.test(path);
-}
-/** True when the current browser URL is an entity master list route (`.../e/{Entity}/list`). */
-function axpIsEntityListRoute(router) {
-    return axpIsEntityListPath(router.url);
-}
-/** True when a URL path is an entity details view route (`.../e/{Entity}/{id}/view`). */
-function axpIsEntityDetailsPath(url) {
-    const path = url.split('?')[0].split('#')[0];
-    return /\/e\/[^/]+\/[^/]+\/view$/.test(path);
-}
-/**
- * Entity key (`module.entity`) for `/{app}/m/{module}/e/{entity}/{id}/view`.
- * Query and hash are ignored. Returns null for every other path.
- */
-function axpEntityKeyFromDetailsPath(url) {
-    const path = url.split('?')[0]?.split('#')[0] ?? '';
-    const match = /\/m\/([^/]+)\/e\/([^/]+)\/[^/]+\/view$/.exec(path);
-    const moduleName = match?.[1];
-    const entityName = match?.[2];
-    if (!moduleName || !entityName) {
-        return null;
-    }
-    return `${moduleName}.${entityName}`;
-}
-/** True when the current browser URL is an entity details view route (`.../e/{Entity}/{id}/view`). */
-function axpIsEntityDetailsViewRoute(router) {
-    return axpIsEntityDetailsPath(router.url);
-}
-/**
- * Merges query params on the current entity list route without pushing history.
- * Uses absolute path segments so a stale `relativeTo` cannot rewrite the active URL after navigating away.
- */
-function axpReplaceEntityListRouteQueryParams(router, queryParams) {
-    const url = router.url;
-    if (!axpIsEntityListPath(url)) {
-        return;
-    }
-    const parsed = router.parseUrl(url);
-    const pathOnly = url.split('?')[0].split('#')[0];
-    const { segments } = axpParseAppPath(pathOnly);
-    const mergedQueryParams = { ...parsed.queryParams, ...queryParams };
-    void router.navigate(segments, {
-        queryParams: mergedQueryParams,
-        replaceUrl: true,
-    });
-}
-//#endregion
-
-//#region ----- Constants -----
-/** Query param that distinguishes two menus pointing at the same entity list. */
-const ENTITY_LIST_INSTANCE_QUERY_PARAM = 'list';
-/** Used when the list is opened without a menu (command, deep link). */
-const ENTITY_LIST_DEFAULT_INSTANCE_ID = 'default';
-//#endregion
-//#region ----- Instance id -----
-function axpNormalizeEntityListInstanceId(value) {
-    if (typeof value !== 'string') {
-        return ENTITY_LIST_DEFAULT_INSTANCE_ID;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : ENTITY_LIST_DEFAULT_INSTANCE_ID;
-}
-function axpGetEntityListInstanceIdFromQueryString(queryString) {
-    const params = new URLSearchParams(queryString.startsWith('?') ? queryString.slice(1) : queryString);
-    return axpNormalizeEntityListInstanceId(params.get(ENTITY_LIST_INSTANCE_QUERY_PARAM));
-}
-function axpGetEntityListInstanceIdFromParamMap(queryParamMap) {
-    return axpNormalizeEntityListInstanceId(queryParamMap.get(ENTITY_LIST_INSTANCE_QUERY_PARAM));
-}
-function axpGetEntityListInstanceIdFromPath(path) {
-    const queryString = path.split('#')[0].split('?')[1] ?? '';
-    return axpGetEntityListInstanceIdFromQueryString(queryString);
-}
-//#endregion
-//#region ----- Menu / URL stamping -----
-/**
- * Appends `list={instanceId}` to an entity-list path when missing.
- * Named menu entries get a stable identity so Angular reuses the list route
- * while filter persistence can still isolate each menu.
- */
-function axpEnsureEntityListInstanceQueryParam(path, instanceId) {
-    if (!path || !instanceId || !axpIsEntityListPath(path)) {
-        return path;
-    }
-    const normalized = axpNormalizeEntityListInstanceId(instanceId);
-    if (normalized === ENTITY_LIST_DEFAULT_INSTANCE_ID) {
-        return path;
-    }
-    const { segments, queryParams, fragment } = axpParseAppPath(path);
-    if (queryParams?.[ENTITY_LIST_INSTANCE_QUERY_PARAM]) {
-        return path;
-    }
-    const nextQuery = new URLSearchParams({
-        ...(queryParams ?? {}),
-        [ENTITY_LIST_INSTANCE_QUERY_PARAM]: normalized,
-    });
-    const base = `/${segments.join('/')}`;
-    const withQuery = `${base}?${nextQuery.toString()}`;
-    return fragment ? `${withQuery}#${fragment}` : withQuery;
-}
-//#endregion
-
 //#region ----- Menu instance identity -----
 /** Prefers the stamped `list` query param, then the menu item name. */
 function axpMenuItemListInstanceId(item) {
@@ -7051,6 +7414,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
 function axpMenuItemNeedsUpdate(item, updates) {
     return Object.keys(updates).some((key) => item[key] !== updates[key]);
 }
+/** True when the menu command itself navigates. A path on the same item must not navigate again. */
+function axpMenuCommandIsNavigation(command) {
+    if (!command || typeof command !== 'object') {
+        return false;
+    }
+    if ('type' in command && command.type === 'router') {
+        return true;
+    }
+    return 'name' in command && command.name === 'navigate';
+}
 /** Immutably patches the first menu item with the given name. */
 function axpUpdateMenuItemByName(items, name, updates) {
     let changed = false;
@@ -7124,18 +7497,22 @@ withMethods((store, router = inject(Router), commandService = inject(AXPCommandS
             });
         },
         executeCommand(item) {
-            if (item.path) {
-                const path = item.name
+            const path = item.path
+                ? item.name
                     ? axpEnsureEntityListInstanceQueryParam(item.path, item.name)
-                    : item.path;
+                    : item.path
+                : undefined;
+            if (path) {
                 void commandService.execute('navigate', { path });
                 patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
             }
-            if (item.command) {
-                const command = item.command;
-                if (commandService.exists(command?.name)) {
-                    void commandService.execute(command.name, command.options ?? {});
-                }
+            const command = item.command;
+            if (!command || (path && axpMenuCommandIsNavigation(command))) {
+                return;
+            }
+            const executeCommand = command;
+            if (executeCommand.name && commandService.exists(executeCommand.name)) {
+                void commandService.execute(executeCommand.name, executeCommand.options ?? {});
             }
         },
         isItemOpen(item) {
@@ -7248,13 +7625,14 @@ withMethods((store, router = inject(Router), commandService = inject(AXPCommandS
 const IGNORED_QUERY_KEYS = new Set(['_ts']);
 /**
  * Builds a stable tab key from a router URL.
- * Path segments define identity; query params are excluded so the same entity record
- * or list reuses one tab even when filters or refresh tokens change.
+ * Path segments define the page. Entity-list navigation query params (`mode`, `list`, …)
+ * stay in the key so two menus of the same entity stay distinct, matching simple navigation.
+ * Page-state params (`view`, `filters`, `_ts`) stay on the URL and do not open another tab.
  */
 function axpBuildTabKey(url) {
     const normalized = normalizeRouterUrl(url);
     const pathOnly = normalized.split('?')[0].split('#')[0];
-    return pathOnly;
+    return axpEntityListNavigationTabKey(pathOnly, normalized);
 }
 /** Normalizes a router URL for storage and navigation. */
 function normalizeRouterUrl(url) {
@@ -7299,6 +7677,73 @@ function axpFallbackTabTitle(url) {
 }
 //#endregion
 
+//#region ---- Constants ----
+/** Query param that keeps the failed route as the tab identity. */
+const AXP_IN_TAB_ERROR_FROM_PARAM = 'from';
+const IN_TAB_ERROR_PATHS = new Set(['/error/401', '/error/404', '/error/offline', '/401', '/404']);
+//#endregion
+//#region ---- URL Helpers ----
+/**
+ * Original page URL carried on an in-shell error route.
+ * Null when the URL is not an error page or `from` is missing.
+ */
+function axpInTabErrorSourceUrl(url) {
+    const normalized = normalizeRouterUrl(url);
+    const pathOnly = normalized.split('?')[0].split('#')[0];
+    if (!IN_TAB_ERROR_PATHS.has(pathOnly)) {
+        return null;
+    }
+    const params = new URLSearchParams(normalized.split('?')[1] ?? '');
+    const from = params.get(AXP_IN_TAB_ERROR_FROM_PARAM);
+    if (!from?.startsWith('/')) {
+        return null;
+    }
+    const fromPath = from.split('?')[0].split('#')[0];
+    if (IN_TAB_ERROR_PATHS.has(fromPath)) {
+        return null;
+    }
+    return normalizeRouterUrl(from);
+}
+/** URL a tab should open again. An in-tab error page retries its `from` route. */
+function axpInTabErrorRetryUrl(url) {
+    return axpInTabErrorSourceUrl(url) ?? normalizeRouterUrl(url);
+}
+/** In-shell error URL whose tab identity is `sourceUrl`, not a single app-wide error route. */
+function axpInTabErrorLocation(kind, sourceUrl) {
+    const path = inTabErrorPath(kind);
+    const source = axpInTabErrorSourceUrl(sourceUrl) ?? sourceUrl;
+    const params = new URLSearchParams();
+    params.set(AXP_IN_TAB_ERROR_FROM_PARAM, source);
+    return `${path}?${params.toString()}`;
+}
+/** UrlTree for guards and resolvers. The shell stays mounted; the tab key stays the source route. */
+function axpInTabErrorUrlTree(router, kind, sourceUrl) {
+    return router.parseUrl(axpInTabErrorLocation(kind, sourceUrl));
+}
+//#endregion
+//#region ---- Unknown Route Guard ----
+/**
+ * Sends an unmatched URL to the in-shell 404 without dropping the root layout.
+ * `from` keeps that URL as its own tab.
+ */
+const axpRedirectUnknownToNotFound = (_route, state) => {
+    const router = inject(Router);
+    return axpInTabErrorUrlTree(router, '404', state.url);
+};
+//#endregion
+//#region ---- Helpers ----
+function inTabErrorPath(kind) {
+    switch (kind) {
+        case '401':
+            return '/error/401';
+        case '404':
+            return '/error/404';
+        case 'offline':
+            return '/error/offline';
+    }
+}
+//#endregion
+
 //#region ---- Types ----
 const AXP_HOME_TAB_KEY = 'axp:home';
 /** Route `data` key for tab-navigation behavior (`data.tab`). */
@@ -7306,9 +7751,20 @@ const AXP_TAB_ROUTE_DATA_KEY = 'tab';
 //#endregion
 
 //#region ---- Route Data ----
-/** True when the route declares itself as a scoped tab root (`data.tab = true`). */
+/**
+ * True when this route node itself sets `data.tab = true`.
+ * Pass the route's own config data. Activated snapshots merge parent `data`, so `snapshot.data`
+ * is not a declaration — a child would look like its own tab root.
+ */
 function axpHasTabScope(data) {
-    return data?.[AXP_TAB_ROUTE_DATA_KEY] === true;
+    if (!data) {
+        return false;
+    }
+    return data[AXP_TAB_ROUTE_DATA_KEY] === true;
+}
+/** True when this snapshot's route config declares `data.tab`, ignoring data inherited from parents. */
+function axpSnapshotDeclaresTabScope(snapshot) {
+    return axpHasTabScope(snapshot.routeConfig?.data);
 }
 //#endregion
 //#region ---- Snapshot Resolution ----
@@ -7328,19 +7784,27 @@ function axpGetLeafRouteSnapshot(root) {
     return route;
 }
 /**
- * Resolves the tab dedupe key from an activated route tree.
- * Uses the nearest ancestor with `data.tab = true`; otherwise the leaf path.
+ * Path identity from an activated route tree, without query params.
+ * Uses the nearest ancestor whose own route config sets `data.tab = true`; otherwise the leaf path.
+ * Child navigations under that boundary (settings groups, profile sections) stay on the same tab.
  */
-function axpResolveTabKeyFromSnapshot(leaf) {
+function axpTabScopePathFromSnapshot(leaf) {
     const chain = leaf.pathFromRoot;
     for (let index = chain.length - 1; index >= 0; index--) {
         const snapshot = chain[index];
-        if (axpHasTabScope(snapshot.data)) {
+        if (axpSnapshotDeclaresTabScope(snapshot)) {
             return axpPathFromSnapshot(snapshot);
         }
     }
     return axpPathFromSnapshot(leaf);
 }
+/**
+ * Resolves the tab dedupe key from an activated route tree.
+ * Entity list routes also include navigation query params (`mode`, `list`, …), same as simple navigation.
+ */
+function axpResolveTabKeyFromSnapshot(leaf) {
+    return axpEntityListNavigationTabKey(axpTabScopePathFromSnapshot(leaf), leaf.queryParams);
+}
 //#endregion
 //#region ---- Router / URL Resolution ----
 /**
@@ -7349,17 +7813,29 @@ function axpResolveTabKeyFromSnapshot(leaf) {
  */
 function axpResolveTabKey(router, url) {
     const normalized = normalizeRouterUrl(url ?? router.url);
+    const errorSource = axpInTabErrorSourceUrl(normalized);
+    if (errorSource) {
+        return axpResolveTabKey(router, errorSource);
+    }
     const pathOnly = normalized.split('?')[0].split('#')[0];
+    // Entity lists key off the URL itself. Route-config matching and the live snapshot can
+    // disagree until navigation finishes, and that split was opening a second tab for one click.
+    // `mode` and `list` stay in the key; `view`, `layout`, `filters`, and `_ts` do not.
+    if (axpIsEntityListPath(pathOnly)) {
+        return axpEntityListNavigationTabKey(pathOnly, normalized);
+    }
     const currentPath = normalizeRouterUrl(router.url).split('?')[0].split('#')[0];
+    let basePath;
     if (!url || pathOnly === currentPath) {
         const leaf = axpGetLeafRouteSnapshot(router.routerState.snapshot.root);
-        return axpResolveTabKeyFromSnapshot(leaf);
+        basePath = axpTabScopePathFromSnapshot(leaf);
     }
-    const fromConfig = axpResolveTabKeyFromRouteConfig(router.config, pathOnly);
-    if (fromConfig) {
-        return fromConfig;
+    else {
+        basePath =
+            axpResolveTabKeyFromRouteConfig(router.config, pathOnly) ??
+                (pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`);
     }
-    return pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`;
+    return axpEntityListNavigationTabKey(basePath, normalized);
 }
 /**
  * Matches a URL path against registered routes and resolves the tab key from `data.tab`.
@@ -7367,19 +7843,19 @@ function axpResolveTabKey(router, url) {
 function axpResolveTabKeyFromRouteConfig(routes, pathOnly) {
     const normalized = pathOnly.startsWith('/') ? pathOnly.replace(/\/+$/, '') || '/' : `/${pathOnly}`.replace(/\/+$/, '') || '/';
     const segments = normalized === '/' ? [] : normalized.split('/').filter(Boolean);
-    const chain = matchRouteConfigChain(routes, segments, 0, {}, []);
+    const chain = matchRouteConfigChain(routes, segments, 0, []);
     if (!chain?.length) {
         return null;
     }
     for (let index = chain.length - 1; index >= 0; index--) {
         const level = chain[index];
-        if (axpHasTabScope(level.mergedData)) {
+        if (axpHasTabScope(level.ownData)) {
             return level.path;
         }
     }
     return chain[chain.length - 1]?.path ?? null;
 }
-function matchRouteConfigChain(routes, segments, startIndex, inheritedData, chain) {
+function matchRouteConfigChain(routes, segments, startIndex, chain) {
     let bestMatch = null;
     for (const route of routes) {
         if (route.redirectTo) {
@@ -7391,12 +7867,12 @@ function matchRouteConfigChain(routes, segments, startIndex, inheritedData, chai
         }
         const pathSegments = [...segments.slice(0, startIndex), ...segments.slice(startIndex, startIndex + segmentMatch.consumed)];
         const path = pathSegments.length ? `/${pathSegments.join('/')}` : '/';
-        const mergedData = { ...inheritedData, ...(route.data ?? {}) };
-        const level = { mergedData, path };
+        const ownData = { ...(route.data ?? {}) };
+        const level = { ownData, path };
         const nextChain = [...chain, level];
         const nextIndex = startIndex + segmentMatch.consumed;
         if (route.children?.length) {
-            const childMatch = matchRouteConfigChain(route.children, segments, nextIndex, mergedData, nextChain);
+            const childMatch = matchRouteConfigChain(route.children, segments, nextIndex, nextChain);
             if (childMatch && (!bestMatch || childMatch.length > bestMatch.length)) {
                 bestMatch = childMatch;
             }
@@ -7552,6 +8028,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
 //#region ----- Command sub-flow navigation (session) -----
 const SUPPRESS_TAB_RESTORE_KEY = 'axp:command-subflow-suppress-tab-restore';
 const RETURN_URL_KEY = 'axp:command-subflow-return-url';
+const subFlowEndedListeners = new Set();
+/** Fires after a command sub-flow releases tab restore. Returns an unsubscribe function. */
+function axpOnCommandSubFlowNavigationEnded(listener) {
+    subFlowEndedListeners.add(listener);
+    return () => {
+        subFlowEndedListeners.delete(listener);
+    };
+}
 /** Marks an in-flight command sub-flow (file picker, crop, dialog) so tab restore must not hijack the route. */
 function axpBeginCommandSubFlowNavigation(returnUrl) {
     const trimmed = returnUrl.trim();
@@ -7591,11 +8075,14 @@ function axpEndCommandSubFlowNavigation() {
     catch {
         // sessionStorage may be unavailable
     }
+    for (const listener of subFlowEndedListeners) {
+        listener();
+    }
 }
 //#endregion
 
 //#region ---- Tab Route Policy ----
-const EXCLUDED_PATH_PREFIXES = ['/auth', '/error'];
+const EXCLUDED_PATH_PREFIXES = ['/auth'];
 const EXCLUDED_PATH_PATTERNS = [
     /^\/assessment\/fill\//i,
     /^\/forms\//i,
@@ -7647,7 +8134,28 @@ class AXPTabNavigationService {
         ...(ngDevMode ? [{ debugName: "tabs" }] : /* istanbul ignore next */ []));
         this.activeTabKey = signal(null, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "activeTabKey" }] : /* istanbul ignore next */ []));
-        this.suppressNavigationSync = false;
+        /** Nested navigations (menu + route `replaceUrl`) must not clear each other's sync guard. */
+        this.navigationSyncSuppressDepth = 0;
+        this.navigationSettingsChain = Promise.resolve();
+        /** `tenantId:applicationId:userId` while the tab strip belongs to that session. Null after sign-out. */
+        this.tabsOwnerStamp = null;
+        /** False until the first session emission. A later stamp change must not restore saved tabs. */
+        this.sessionTabsBound = false;
+        /** Set when the user actually signs out, so the next sign-in does not reopen that list. */
+        this.closedTabsForSessionChange = false;
+        /** Storage key of the session that owned the strip. Survives sign-out, when the user id is already gone. */
+        this.ownedStorageKey = null;
+        /**
+         * Stamp captured when readiness dropped but the user was still signed in.
+         * A failed tenant/application switch returns to this stamp and must keep the saved list.
+         */
+        this.pendingReadinessGap = null;
+        /** False until the saved list has been read, so an earlier route sync cannot overwrite it. */
+        this.sessionTabsHydrated = false;
+        /** Restore was skipped because a command sub-flow was open. Resumed when that sub-flow ends. */
+        this.restoreDeferred = false;
+        /** Incremented on every session emission. A queued task stops when a newer emission exists. */
+        this.sessionSyncGeneration = 0;
         //#endregion
         //#region ---- Computed ----
         /** Effective mode: mobile always uses simple navigation. */
@@ -7667,6 +8175,10 @@ class AXPTabNavigationService {
         this.bindSettingsChanges();
         this.bindSessionChanges();
         this.bindRouteCacheSync();
+        const stopSubFlowWatch = axpOnCommandSubFlowNavigationEnded(() => {
+            void this.enqueueNavigationSettingsSync(() => this.resumeDeferredTabRestore());
+        });
+        this.destroyRef.onDestroy(stopSubFlowWatch);
     }
     //#endregion
     //#region ---- Public API ----
@@ -7706,10 +8218,9 @@ class AXPTabNavigationService {
             return;
         }
         // Navigate first so scoped tab keys (`data.tab`) resolve from the live route snapshot.
-        this.suppressNavigationSync = true;
-        try {
+        await this.runWithSuppressedNavigationSync(async () => {
             await axpNavigateAppPath(this.router, normalizedUrl);
-            const key = axpResolveTabKey(this.router);
+            const key = axpResolveTabKey(this.router, normalizedUrl);
             const postNavExisting = this.findTabForUrl(normalizedUrl);
             if (postNavExisting) {
                 if (postNavExisting.key !== key) {
@@ -7724,10 +8235,7 @@ class AXPTabNavigationService {
             this.insertTab(this.createTabDescriptor(normalizedUrl, title, key));
             this.activeTabKey.set(key);
             this.persistSession();
-        }
-        finally {
-            this.suppressNavigationSync = false;
-        }
+        });
     }
     /**
      * Activates a tab and navigates to its URL. The previously active page is detached and cached by
@@ -7742,18 +8250,15 @@ class AXPTabNavigationService {
         if (!tab) {
             return;
         }
-        const targetUrl = urlOverride ?? tab.url;
+        const targetUrl = axpInTabErrorRetryUrl(urlOverride ?? tab.url);
+        if (tab.url !== targetUrl) {
+            this.updateTabUrl(key, targetUrl);
+        }
         this.touchTab(key);
         this.activeTabKey.set(key);
         this.persistSession();
         const navigate = async () => {
-            this.suppressNavigationSync = true;
-            try {
-                await this.router.navigateByUrl(targetUrl);
-            }
-            finally {
-                this.suppressNavigationSync = false;
-            }
+            await this.runWithSuppressedNavigationSync(() => this.router.navigateByUrl(targetUrl));
         };
         if (suspendDeactivateGuard) {
             await this.routeCacheRegistry.runWithSuspendedDeactivateGuards(navigate);
@@ -7765,6 +8270,24 @@ class AXPTabNavigationService {
     async closeTab(key) {
         await this.closeTabs([key]);
     }
+    /**
+     * Drops the active error tab without opening a neighbor.
+     * Home stays. The caller navigates to the real home page afterwards.
+     */
+    closeActiveErrorTab() {
+        if (this.effectiveMode() !== 'tabular') {
+            return;
+        }
+        const activeKey = this.activeTabKey();
+        const tab = this.tabs().find((item) => item.key === activeKey);
+        if (!tab || tab.key === AXP_HOME_TAB_KEY) {
+            return;
+        }
+        this.tabs.update((items) => items.filter((item) => item.key !== tab.key));
+        this.tabPreviewService.clearPreviews(new Set([tab.key]));
+        this.activeTabKey.set(AXP_HOME_TAB_KEY);
+        this.persistSession();
+    }
     /** Closes every closable tab except the given key (pinned tabs are kept). */
     async closeOtherTabs(keepKey) {
         const keys = this.tabs()
@@ -7946,15 +8469,9 @@ class AXPTabNavigationService {
             targetKey = home.key;
             targetUrl = home.url;
         }
-        this.suppressNavigationSync = true;
-        try {
-            const navigated = await this.router.navigateByUrl(targetUrl);
-            if (!navigated) {
-                return false;
-            }
-        }
-        finally {
-            this.suppressNavigationSync = false;
+        const navigated = await this.runWithSuppressedNavigationSync(() => this.router.navigateByUrl(targetUrl));
+        if (!navigated) {
+            return false;
         }
         this.activeTabKey.set(targetKey);
         this.touchTab(targetKey);
@@ -7984,6 +8501,16 @@ class AXPTabNavigationService {
     }
     //#endregion
     //#region ---- Router Sync ----
+    /** Holds route-sync until every nested navigation in this turn has finished. */
+    async runWithSuppressedNavigationSync(action) {
+        this.navigationSyncSuppressDepth += 1;
+        try {
+            return await action();
+        }
+        finally {
+            this.navigationSyncSuppressDepth = Math.max(0, this.navigationSyncSuppressDepth - 1);
+        }
+    }
     bindRouterEvents() {
         this.router.events
             .pipe(filter$1((event) => event instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
@@ -7992,7 +8519,7 @@ class AXPTabNavigationService {
         });
     }
     async handleNavigationEnd(url) {
-        if (this.suppressNavigationSync) {
+        if (this.navigationSyncSuppressDepth > 0) {
             return;
         }
         if (this.effectiveMode() === 'simple') {
@@ -8003,67 +8530,292 @@ class AXPTabNavigationService {
             return;
         }
         await this.ensureHomeTab();
-        if (this.isHomePageUrl(normalizedUrl)) {
-            this.activateHomeTabForUrl(normalizedUrl);
+        const errorSource = axpInTabErrorSourceUrl(normalizedUrl);
+        const storedUrl = errorSource ?? normalizedUrl;
+        if (this.isHomePageUrl(storedUrl)) {
+            this.activateHomeTabForUrl(storedUrl);
             return;
         }
-        const key = axpResolveTabKey(this.router, normalizedUrl);
-        const existing = this.findTabForUrl(normalizedUrl);
+        const key = axpResolveTabKey(this.router, storedUrl);
+        const existing = this.findTabForUrl(storedUrl);
         if (existing) {
             if (existing.key !== key) {
                 this.migrateTabKey(existing.key, key);
             }
-            this.updateTabUrl(key, normalizedUrl);
+            this.updateTabUrl(key, storedUrl);
             this.touchTab(key);
             this.activeTabKey.set(key);
             this.persistSession();
             return;
         }
-        this.insertTab(this.createTabDescriptor(normalizedUrl, undefined, key));
+        this.insertTab(this.createTabDescriptor(storedUrl, errorSource ? this.resolveTabTitle(errorSource) : undefined, key));
         this.activeTabKey.set(key);
         this.persistSession();
     }
     //#endregion
     //#region ---- Settings ----
     async loadSettings() {
-        const [mode, maxTabs] = await Promise.all([
-            this.settingsService.get(AXPCommonSettings.NavigationMode),
-            this.settingsService.get(AXPCommonSettings.MaxOpenTabs),
-        ]);
-        this.navigationMode.set(mode === 'tabular' ? 'tabular' : 'simple');
-        this.maxOpenTabs.set(this.normalizeMaxTabs(maxTabs));
-        await this.restoreSessionIfNeeded();
+        await this.enqueueNavigationSettingsSync(async () => {
+            const maxTabs = await this.settingsService.get(AXPCommonSettings.MaxOpenTabs);
+            this.maxOpenTabs.set(this.normalizeMaxTabs(maxTabs));
+            await this.applyEffectiveNavigationMode();
+        });
     }
     bindSettingsChanges() {
+        this.settingsService.onLoaded.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            void this.enqueueNavigationSettingsSync(() => this.applyEffectiveNavigationMode());
+        });
         this.settingsService.onChanged.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((event) => {
-            if (event.keys.includes(AXPCommonSettings.NavigationMode)) {
-                const raw = event.values[AXPCommonSettings.NavigationMode];
-                const newMode = raw === 'tabular' ? 'tabular' : 'simple';
-                if (newMode !== this.navigationMode()) {
-                    this.navigationMode.set(newMode);
-                    if (this.effectiveMode() === 'simple') {
-                        this.clearSession();
-                    }
-                    else {
-                        void this.ensureHomeTab().then(() => this.syncCurrentRouteAsTab());
-                    }
-                }
-            }
-            if (event.keys.includes(AXPCommonSettings.MaxOpenTabs)) {
-                this.maxOpenTabs.set(this.normalizeMaxTabs(event.values[AXPCommonSettings.MaxOpenTabs]));
-                this.enforceMaxTabs();
-                this.persistSession();
+            const modeChanged = event.keys.includes(AXPCommonSettings.NavigationMode);
+            const maxChanged = event.keys.includes(AXPCommonSettings.MaxOpenTabs);
+            if (!modeChanged && !maxChanged) {
+                return;
             }
+            void this.enqueueNavigationSettingsSync(async () => {
+                if (modeChanged) {
+                    await this.applyEffectiveNavigationMode();
+                }
+                if (maxChanged) {
+                    const maxTabs = await this.settingsService.get(AXPCommonSettings.MaxOpenTabs);
+                    this.maxOpenTabs.set(this.normalizeMaxTabs(maxTabs));
+                    this.enforceMaxTabs();
+                    this.persistSession();
+                }
+            });
         });
     }
     bindSessionChanges() {
-        this.sessionService.user$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
-            if (axpIsCommandSubFlowNavigationSuspended()) {
-                return;
+        combineLatest([
+            this.sessionService.user$.pipe(map$1((user) => user?.id ?? null)),
+            this.sessionService.tenant$.pipe(map$1((tenant) => tenant?.id ?? null)),
+            this.sessionService.application$.pipe(map$1((application) => application?.id ?? null)),
+            this.sessionService.isReadyForAppScopedApi$,
+        ])
+            .pipe(distinctUntilChanged$1((previous, next) => previous[0] === next[0] &&
+            previous[1] === next[1] &&
+            previous[2] === next[2] &&
+            previous[3] === next[3]), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            const context = this.captureSessionSyncContext();
+            if (this.tabsOwnerStamp != null && (context.sessionEnded || context.stamp !== this.tabsOwnerStamp)) {
+                this.routeCacheRegistry.suspendAttach();
             }
-            void this.restoreSessionIfNeeded();
+            void this.enqueueNavigationSettingsSync(() => this.syncTabsToSession(context));
         });
     }
+    /** Reads the session once, so a later user cannot replace this event's storage key. */
+    captureSessionSyncContext() {
+        return {
+            generation: ++this.sessionSyncGeneration,
+            stamp: this.sessionStamp(),
+            sessionEnded: !this.sessionService.user?.id || !this.sessionService.hasSessionCredentials(),
+            storageKey: this.sessionStorageKey(),
+            url: normalizeRouterUrl(this.router.url),
+        };
+    }
+    isCurrentSessionSync(context) {
+        return context.generation === this.sessionSyncGeneration;
+    }
+    /**
+     * Closes every tab when the signed-in user, tenant, or application actually changes, including sign-out.
+     * The saved list is deleted only for that real change, so a failed switch can restore it.
+     * The context is the session at enqueue time. A newer emission stops this task, including after an await.
+     */
+    async syncTabsToSession(context) {
+        // Only a bound signed-in owner is a real sign-out. Startup publishes the user
+        // before Authenticated; treating that as sign-out deletes the saved tab list.
+        // A queued sign-out still deletes its captured key after a newer sign-in.
+        if (context.sessionEnded) {
+            if (this.tabsOwnerStamp != null) {
+                this.applyCapturedSignOut(context);
+            }
+            return;
+        }
+        if (!this.isCurrentSessionSync(context)) {
+            return;
+        }
+        if (!this.sessionTabsBound) {
+            this.sessionTabsBound = true;
+            this.tabsOwnerStamp = context.stamp;
+            this.ownedStorageKey = context.storageKey;
+            if (!context.stamp) {
+                return;
+            }
+            this.routeCacheRegistry.bindOwner(context.stamp);
+            await this.applyEffectiveNavigationMode();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
+            await this.restoreSessionIfNeeded(context);
+            return;
+        }
+        if (context.stamp === this.tabsOwnerStamp &&
+            this.pendingReadinessGap == null &&
+            !this.closedTabsForSessionChange) {
+            this.routeCacheRegistry.resumeAttach();
+            return;
+        }
+        if (context.stamp == null) {
+            if (this.tabsOwnerStamp != null) {
+                this.pendingReadinessGap = this.tabsOwnerStamp;
+            }
+            return;
+        }
+        const gap = this.pendingReadinessGap;
+        this.pendingReadinessGap = null;
+        if (gap != null && gap === context.stamp && !this.closedTabsForSessionChange) {
+            this.tabsOwnerStamp = context.stamp;
+            this.routeCacheRegistry.resumeAttach();
+            return;
+        }
+        const previous = gap ?? this.tabsOwnerStamp;
+        const identityChanged = previous != null && previous !== context.stamp;
+        if (identityChanged || this.closedTabsForSessionChange) {
+            this.closedTabsForSessionChange = false;
+            this.restoreDeferred = false;
+            this.forgetPersistedTabs(this.ownedStorageKey);
+            this.tabsOwnerStamp = context.stamp;
+            this.ownedStorageKey = context.storageKey;
+            this.sessionTabsHydrated = false;
+            this.discardRuntimeTabs();
+            this.routeCacheRegistry.bindOwner(context.stamp);
+            this.routeCacheRegistry.resumeAttach();
+            await this.applyEffectiveNavigationMode();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
+            this.sessionTabsHydrated = true;
+            await this.syncSettledDestination(context);
+            return;
+        }
+        if (this.tabsOwnerStamp == null && context.stamp != null) {
+            this.tabsOwnerStamp = context.stamp;
+            this.ownedStorageKey = context.storageKey;
+            this.routeCacheRegistry.bindOwner(context.stamp);
+            this.routeCacheRegistry.resumeAttach();
+            await this.applyEffectiveNavigationMode();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
+            await this.restoreSessionIfNeeded(context);
+        }
+    }
+    /**
+     * Sign-out cleanup uses the captured storage key and still runs when a newer sign-in
+     * has already superseded this event. It does not read the live session.
+     */
+    applyCapturedSignOut(context) {
+        this.pendingReadinessGap = null;
+        this.restoreDeferred = false;
+        this.forgetPersistedTabs(context.storageKey ?? this.ownedStorageKey);
+        this.tabsOwnerStamp = null;
+        this.discardRuntimeTabs();
+        this.routeCacheRegistry.resumeAttach();
+        this.closedTabsForSessionChange = true;
+        this.sessionTabsHydrated = false;
+    }
+    /**
+     * Opens Home for the settled session. The current route is added only after the router
+     * has left the URL captured with the event, so the previous context is not reopened.
+     * Home is created even when that URL is unchanged, including when it is already Home.
+     */
+    async syncSettledDestination(context) {
+        if (!this.isCurrentSessionSync(context) || this.effectiveMode() !== 'tabular') {
+            return;
+        }
+        await this.ensureHomeTab();
+        if (!this.isCurrentSessionSync(context)) {
+            return;
+        }
+        const destination = normalizeRouterUrl(this.router.url);
+        const routeBelongsToSettledSession = !!destination && destination !== context.url && axpIsTabEligibleUrl(destination);
+        if (routeBelongsToSettledSession || (!!destination && this.isHomePageUrl(destination))) {
+            await this.syncCurrentRouteAsTab();
+            return;
+        }
+        if (this.tabs().some((tab) => tab.key === AXP_HOME_TAB_KEY)) {
+            this.activeTabKey.set(AXP_HOME_TAB_KEY);
+        }
+        this.persistSession();
+    }
+    /** Continues a restore that was skipped while a command sub-flow held the router. */
+    async resumeDeferredTabRestore() {
+        if (!this.restoreDeferred || axpIsCommandSubFlowNavigationSuspended()) {
+            return;
+        }
+        const context = {
+            generation: this.sessionSyncGeneration,
+            stamp: this.tabsOwnerStamp,
+            sessionEnded: false,
+            storageKey: this.ownedStorageKey,
+            url: normalizeRouterUrl(this.router.url),
+        };
+        this.restoreDeferred = false;
+        if (!context.stamp) {
+            return;
+        }
+        await this.restoreSessionIfNeeded(context);
+    }
+    /** Identity of the session that may own open tabs. Null when the app session is not ready. */
+    sessionStamp() {
+        if (!this.sessionService.isReadyForAppScopedApi) {
+            return null;
+        }
+        const userId = this.sessionService.user?.id;
+        const tenantId = this.sessionService.tenant?.id;
+        const applicationId = this.sessionService.application?.id;
+        if (!userId || !tenantId || !applicationId) {
+            return null;
+        }
+        return `${tenantId}:${applicationId}:${userId}`;
+    }
+    /** Deletes one captured tab list. A newer user's key is left untouched. */
+    forgetPersistedTabs(storageKey) {
+        if (!storageKey) {
+            return;
+        }
+        sessionStorage.removeItem(storageKey);
+        if (this.ownedStorageKey === storageKey) {
+            this.ownedStorageKey = null;
+        }
+    }
+    /** Closes every tab and destroys cached page components. */
+    discardRuntimeTabs() {
+        this.tabs.set([]);
+        this.activeTabKey.set(null);
+        this.tabPreviewService.clearAll();
+        this.routeCacheRegistry.bindOwner(this.tabsOwnerStamp);
+    }
+    /**
+     * Reads the effective NavigationMode (User, then Tenant, then Platform, then the definition default).
+     * Scope reloads update the settings cache without `onChanged`, so callers must use this instead of
+     * treating a partial event value as "switch to simple".
+     */
+    async applyEffectiveNavigationMode() {
+        if (!this.sessionService.isReadyForAppScopedApi) {
+            return;
+        }
+        const mode = await this.settingsService.get(AXPCommonSettings.NavigationMode);
+        const next = mode === 'tabular' ? 'tabular' : 'simple';
+        const previous = this.navigationMode();
+        if (next === previous) {
+            return;
+        }
+        this.navigationMode.set(next);
+        if (previous === 'tabular' && next === 'simple') {
+            this.clearSession();
+            return;
+        }
+        if (next === 'tabular' && this.effectiveMode() === 'tabular' && this.sessionTabsHydrated) {
+            await this.ensureHomeTab();
+            await this.syncCurrentRouteAsTab();
+        }
+    }
+    enqueueNavigationSettingsSync(task) {
+        const run = this.navigationSettingsChain.then(task, task);
+        this.navigationSettingsChain = run.then(() => undefined, () => undefined);
+        return run;
+    }
     //#endregion
     //#region ---- Tab Management ----
     async ensureHomeTab() {
@@ -8105,7 +8857,7 @@ class AXPTabNavigationService {
         }
         this.tabs.update((items) => {
             const withoutDuplicate = items.filter((item) => {
-                if (item.key === tab.key) {
+                if (item.key === tab.key || this.isSameEntityListTab(item, tab)) {
                     return false;
                 }
                 return axpResolveTabKey(this.router, item.url) !== tab.key;
@@ -8165,14 +8917,29 @@ class AXPTabNavigationService {
             lastActivatedAt: now,
         };
     }
-    /** Finds a tab by scoped key or legacy full-path key for the same URL. */
+    /** Finds a tab by scoped key, or by entity-list identity when an older key drifted. */
     findTabForUrl(url) {
         if (this.isHomePageUrl(url)) {
             return this.tabs().find((tab) => tab.key === AXP_HOME_TAB_KEY);
         }
         const resolvedKey = axpResolveTabKey(this.router, url);
-        return this.tabs().find((tab) => tab.key !== AXP_HOME_TAB_KEY &&
+        const byKey = this.tabs().find((tab) => tab.key !== AXP_HOME_TAB_KEY &&
             (tab.key === resolvedKey || axpResolveTabKey(this.router, tab.url) === resolvedKey));
+        if (byKey) {
+            return byKey;
+        }
+        if (!axpIsEntityListPath(url)) {
+            return undefined;
+        }
+        const identity = axpBuildTabKey(normalizeRouterUrl(url));
+        return this.tabs().find((tab) => tab.key !== AXP_HOME_TAB_KEY && axpIsEntityListPath(tab.url) && axpBuildTabKey(tab.url) === identity);
+    }
+    /** Same list menu (`mode`, `list`, …). Page-state query params do not make a new tab. */
+    isSameEntityListTab(left, right) {
+        if (!axpIsEntityListPath(left.url) || !axpIsEntityListPath(right.url)) {
+            return false;
+        }
+        return axpBuildTabKey(left.url) === axpBuildTabKey(right.url);
     }
     /** True when the URL is the configured application home page (e.g. dashboard). */
     isHomePageUrl(url) {
@@ -8317,8 +9084,12 @@ class AXPTabNavigationService {
         return `${SESSION_STORAGE_PREFIX}(${userId})`;
     }
     persistSession() {
-        const key = this.sessionStorageKey();
-        if (!key || this.effectiveMode() === 'simple') {
+        const key = this.ownedStorageKey;
+        if (!key ||
+            key !== this.sessionStorageKey() ||
+            this.tabsOwnerStamp !== this.sessionStamp() ||
+            !this.sessionTabsHydrated ||
+            this.effectiveMode() === 'simple') {
             return;
         }
         const payload = {
@@ -8335,31 +9106,54 @@ class AXPTabNavigationService {
         this.tabs.set([]);
         this.activeTabKey.set(null);
         this.tabPreviewService.clearAll();
+        this.routeCacheRegistry.clear();
     }
-    async restoreSessionIfNeeded() {
+    async restoreSessionIfNeeded(context) {
+        if (!this.isCurrentSessionSync(context)) {
+            return;
+        }
         if (this.effectiveMode() === 'simple') {
+            this.sessionTabsHydrated = true;
             return;
         }
         if (axpIsCommandSubFlowNavigationSuspended()) {
+            this.restoreDeferred = true;
             return;
         }
-        const storageKey = this.sessionStorageKey();
+        const storageKey = context.storageKey;
         if (!storageKey) {
-            await this.ensureHomeTab();
-            await this.syncCurrentRouteAsTab();
+            this.tabs.set([]);
+            this.activeTabKey.set(null);
+            this.tabPreviewService.clearAll();
+            this.sessionTabsHydrated = true;
             return;
         }
         const raw = sessionStorage.getItem(storageKey);
         if (!raw) {
+            this.tabs.set([]);
+            this.activeTabKey.set(null);
+            this.sessionTabsHydrated = true;
             await this.ensureHomeTab();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
             await this.syncCurrentRouteAsTab();
             return;
         }
         try {
             const parsed = JSON.parse(raw);
-            const restoredTabs = this.removeDuplicateHomeUrlTabs(this.normalizeRestoredTabKeys(defaultTo(parsed.tabs, []).filter((tab) => tab?.key && tab?.url)));
+            const restoredTabs = this.removeDuplicateHomeUrlTabs(this.normalizeRestoredTabKeys(defaultTo(parsed.tabs, [])
+                .filter((tab) => tab?.key && tab?.url)
+                .map((tab) => ({ ...tab, url: axpInTabErrorRetryUrl(tab.url) }))));
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
+            this.sessionTabsHydrated = true;
             this.tabs.set(this.ensureHomeTabFirst(restoredTabs));
             await this.ensureHomeTab();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
             const activeKey = parsed.activeTabKey ?? this.tabs()[this.tabs().length - 1]?.key ?? AXP_HOME_TAB_KEY;
             this.activeTabKey.set(activeKey);
             const activeTab = this.tabs().find((tab) => tab.key === activeKey);
@@ -8367,17 +9161,18 @@ class AXPTabNavigationService {
             if (activeTab &&
                 currentUrl !== normalizeRouterUrl(activeTab.url) &&
                 axpIsTabEligibleUrl(currentUrl)) {
-                this.suppressNavigationSync = true;
-                try {
-                    await this.router.navigateByUrl(activeTab.url);
-                }
-                finally {
-                    this.suppressNavigationSync = false;
-                }
+                await this.runWithSuppressedNavigationSync(() => this.router.navigateByUrl(activeTab.url));
             }
         }
         catch {
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
+            this.sessionTabsHydrated = true;
             await this.ensureHomeTab();
+            if (!this.isCurrentSessionSync(context)) {
+                return;
+            }
             await this.syncCurrentRouteAsTab();
         }
     }
@@ -8627,7 +9422,12 @@ class AXPLocalEntityOutboxService {
         this.handlers.delete(entityKey);
     }
     pendingFor(entityKey) {
-        return this.pendingOps().filter((op) => op.entityKey === entityKey);
+        const userKey = this.resolveUserKey();
+        return this.pendingOps().filter((op) => op.entityKey === entityKey && op.userKey === userKey);
+    }
+    /** Await durable operations before a feature overlays pending rows after reload. */
+    hydrate() {
+        return this.refreshPending();
     }
     async enqueue(input) {
         const userKey = this.resolveUserKey();
@@ -8638,10 +9438,7 @@ class AXPLocalEntityOutboxService {
         }
         const recordIds = [...new Set((input.recordIds ?? []).map((id) => id?.trim()).filter(Boolean))];
         const existing = await this.loadUserOps(userKey);
-        const duplicate = existing.find((op) => op.entityKey === entityKey &&
-            op.action === action &&
-            sameIdSet(op.recordIds, recordIds) &&
-            stablePayload(op.payload) === stablePayload(input.payload));
+        const duplicate = existing.find((op) => op.entityKey === entityKey && op.action === action && sameIdSet(op.recordIds, recordIds) && stablePayload(op.payload) === stablePayload(input.payload));
         if (duplicate) {
             return;
         }
@@ -8652,7 +9449,8 @@ class AXPLocalEntityOutboxService {
             action,
             recordIds,
             payload: input.payload,
-            queuedAt: new Date().toISOString(),
+            // Keep dependent operations ordered even if send and edit enqueue in the same millisecond.
+            queuedAt: new Date(Math.max(Date.now(), ...existing.map((op) => Date.parse(op.queuedAt) + 1))).toISOString(),
             attempts: 0,
             lastError: null,
         };
@@ -8690,6 +9488,10 @@ class AXPLocalEntityOutboxService {
         }
         const ops = (await this.loadUserOps(userKey)).sort((left, right) => left.queuedAt.localeCompare(right.queuedAt));
         for (const op of ops) {
+            // A queued batch must never continue under another account after an awaited HTTP call.
+            if (userKey !== this.resolveUserKey() || !this.sessionService.isReadyForAppScopedApi) {
+                break;
+            }
             const handler = this.handlers.get(op.entityKey);
             if (!handler) {
                 continue;
@@ -8745,6 +9547,8 @@ class AXPLocalEntityOutboxService {
             return;
         }
         const ops = await this.loadUserOps(userKey);
+        if (userKey !== this.resolveUserKey())
+            return;
         ops.sort((left, right) => left.queuedAt.localeCompare(right.queuedAt));
         this.pendingOps.set(ops);
     }
@@ -9268,6 +10072,23 @@ class AXPNotFoundError extends Error {
     }
 }
 
+/**
+ * Placeholder for a wildcard route whose guard always redirects into the shell.
+ * The component is not shown.
+ */
+class AXPUnreachableRouteComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnreachableRouteComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXPUnreachableRouteComponent, isStandalone: true, selector: "axp-unreachable-route", ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUnreachableRouteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-unreachable-route',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+
 /** Canonical route path for the platform 404 page. */
 const AXP_NOT_FOUND_ROUTE = '/error/404';
 /**
@@ -9276,7 +10097,8 @@ const AXP_NOT_FOUND_ROUTE = '/error/404';
  */
 const AXP_NOT_FOUND_CATCH_ALL_ROUTE = {
     path: '**',
-    redirectTo: AXP_NOT_FOUND_ROUTE,
+    canActivate: [axpRedirectUnknownToNotFound],
+    component: AXPUnreachableRouteComponent,
 };
 /**
  * Registers the platform catch-all 404 route.
@@ -9300,8 +10122,8 @@ function axpIsEntityRecordNotFound(data) {
 /**
  * Creates an Angular redirect command to the platform 404 page.
  */
-function axpRedirectToNotFound(router = inject(Router)) {
-    return new RedirectCommand(router.parseUrl(AXP_NOT_FOUND_ROUTE));
+function axpRedirectToNotFound(router = inject(Router), sourceUrl) {
+    return new RedirectCommand(axpInTabErrorUrlTree(router, '404', sourceUrl ?? router.url));
 }
 
 /** Canonical route path for the platform 401 page. */
@@ -9309,8 +10131,8 @@ const AXP_UNAUTHORIZED_ROUTE = '/error/401';
 /**
  * Creates an Angular redirect command to the platform 401 page.
  */
-function axpRedirectToUnauthorized(router = inject(Router)) {
-    return new RedirectCommand(router.parseUrl(AXP_UNAUTHORIZED_ROUTE));
+function axpRedirectToUnauthorized(router = inject(Router), sourceUrl) {
+    return new RedirectCommand(axpInTabErrorUrlTree(router, '401', sourceUrl ?? router.url));
 }
 
 //#endregion
@@ -10078,15 +10900,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
 const AXP_ENTITY_VIEW_ACCESS = new InjectionToken('AXP_ENTITY_VIEW_ACCESS');
 
 const APP_CHOOSER_ROUTE = '/auth/account/app-chooser';
-/** In-app navigations (e.g. Open Details) stay put instead of redirecting to 401. */
-function axpShouldStayOnCurrentPage(router, targetUrl) {
-    const currentPath = router.url.split('#')[0]?.split('?')[0] ?? '';
-    const targetPath = targetUrl.split('#')[0]?.split('?')[0] ?? '';
-    if (!currentPath || currentPath === '/' || currentPath === targetPath) {
-        return false;
-    }
-    return !currentPath.startsWith('/auth') && !currentPath.startsWith('/error');
-}
 /**
 
  * Blocks navigation when the target route is not accessible for the current user.
@@ -10114,10 +10927,7 @@ const AXPMenuRouteGuard = (route, state) => {
         if (isAllowed instanceof UrlTree) {
             return isAllowed;
         }
-        if (axpShouldStayOnCurrentPage(router, state.url)) {
-            return false;
-        }
-        return router.parseUrl(AXP_UNAUTHORIZED_ROUTE);
+        return axpInTabErrorUrlTree(router, '401', state.url);
     }));
 };
 
@@ -11175,7 +11985,7 @@ class AXPCommonModule {
                 provide: AXP_SETTING_DEFINITION_PROVIDER,
                 useFactory: async () => {
                     const injector = inject(Injector);
-                    const provider = (await import('./acorex-platform-framework-client-common-common-settings.provider-ChU2tvyt.mjs')).AXPCommonSettingProvider;
+                    const provider = (await import('./acorex-platform-framework-client-common-common-settings.provider-Biu0_ryw.mjs')).AXPCommonSettingProvider;
                     return new provider(injector);
                 },
                 multi: true,
@@ -11298,7 +12108,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
                             provide: AXP_SETTING_DEFINITION_PROVIDER,
                             useFactory: async () => {
                                 const injector = inject(Injector);
-                                const provider = (await import('./acorex-platform-framework-client-common-common-settings.provider-ChU2tvyt.mjs')).AXPCommonSettingProvider;
+                                const provider = (await import('./acorex-platform-framework-client-common-common-settings.provider-Biu0_ryw.mjs')).AXPCommonSettingProvider;
                                 return new provider(injector);
                             },
                             multi: true,
@@ -11343,20 +12153,38 @@ const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
 
 /**
  * Opens the native file picker and always settles — including when the user cancels.
- * `AXFileService.choose()` can hang on cancel because no `change` event fires.
+ * `AXFileService.choose()` only listens for `change`, so dismissing the dialog leaves that promise pending.
  */
 function chooseSystemFiles(options = {}) {
-    const document = inject(DOCUMENT);
+    return openSystemFileDialog(inject(DOCUMENT), options);
+}
+/**
+ * Same picker as {@link chooseSystemFiles}, with the document passed in so callers can `await` before opening it.
+ */
+function openSystemFileDialog(doc, options = {}) {
+    const view = doc.defaultView;
+    if (!view) {
+        return Promise.resolve([]);
+    }
     const accept = options.accept ?? '';
     const multiple = options.multiple ?? false;
     return new Promise((resolve) => {
-        const input = document.createElement('input');
+        const input = doc.createElement('input');
         input.type = 'file';
         input.accept = accept;
         input.multiple = multiple;
         input.style.display = 'none';
-        document.body.appendChild(input);
+        doc.body.appendChild(input);
         let settled = false;
+        let dialogOpened = false;
+        let watchFocus = false;
+        const cleanup = () => {
+            input.removeEventListener('change', onChange);
+            input.removeEventListener('cancel', onCancel);
+            view.removeEventListener('blur', onBlur);
+            view.removeEventListener('focus', onFocus);
+            input.remove();
+        };
         const settle = (files) => {
             if (settled) {
                 return;
@@ -11365,21 +12193,37 @@ function chooseSystemFiles(options = {}) {
             cleanup();
             resolve(files);
         };
-        const cleanup = () => {
-            input.removeEventListener('change', onChange);
-            window.removeEventListener('focus', onWindowFocus);
-            input.remove();
-        };
         const onChange = () => {
             settle(Array.from(input.files ?? []));
         };
-        const onWindowFocus = () => {
-            // Allow `change` to fire first when the user confirms a selection.
-            window.setTimeout(() => settle([]), 300);
+        const onCancel = () => {
+            settle([]);
+        };
+        const onBlur = () => {
+            if (watchFocus) {
+                dialogOpened = true;
+            }
+        };
+        const onFocus = () => {
+            if (!watchFocus || !dialogOpened) {
+                return;
+            }
+            // `change` fires before this timeout when the user confirms a file.
+            view.setTimeout(() => {
+                if (!settled) {
+                    settle(Array.from(input.files ?? []));
+                }
+            }, 300);
         };
         input.addEventListener('change', onChange);
-        window.addEventListener('focus', onWindowFocus, { once: true });
+        input.addEventListener('cancel', onCancel);
+        view.addEventListener('blur', onBlur);
+        view.addEventListener('focus', onFocus);
         input.click();
+        // Ignore blur/focus caused by opening the dialog itself. Cancel still settles via the `cancel` event.
+        view.setTimeout(() => {
+            watchFocus = true;
+        }, 0);
     });
 }
 //#endregion
@@ -12213,8 +13057,11 @@ class AXPLocalEntityEngine {
             return bucket.syncInFlight;
         }
         bucket.syncInFlight = (async () => {
+            const userKey = this.resolveUserKey();
             const result = await fetchHot();
-            await this.replaceAll(entityKey, result.items ?? []);
+            if (userKey === this.resolveUserKey()) {
+                await this.replaceAll(entityKey, result.items ?? []);
+            }
         })().finally(() => {
             bucket.syncInFlight = null;
         });
@@ -12289,6 +13136,8 @@ class AXPLocalEntityEngine {
         await axpLocalEntityIndexedDb.transaction('rw', axpLocalEntityIndexedDb.items, async () => {
             await axpLocalEntityIndexedDb.items.bulkDelete(storageIds);
         });
+        if (userKey !== this.resolveUserKey())
+            return;
         bucket.items.set(next);
         bucket.hydrated.set(true);
         this.publish({ type: 'store-changed', entityKey, userKey, originId: this.originId });
@@ -12347,10 +13196,9 @@ class AXPLocalEntityEngine {
             bucket.hydrated.set(true);
             return;
         }
-        const stored = await axpLocalEntityIndexedDb.items
-            .where('[entityKey+userKey]')
-            .equals([entityKey, userKey])
-            .toArray();
+        const stored = await axpLocalEntityIndexedDb.items.where('[entityKey+userKey]').equals([entityKey, userKey]).toArray();
+        if (userKey !== this.resolveUserKey())
+            return;
         const items = this.prune(entityKey, stored.map((row) => row.payload));
         this.userKeySignal.set(userKey);
         bucket.items.set(items);
@@ -12373,10 +13221,7 @@ class AXPLocalEntityEngine {
         const keepIds = new Set(stored.map((row) => row.storageId));
         const metaId = buildLocalEntityMetaId(entityKey, userKey);
         await axpLocalEntityIndexedDb.transaction('rw', axpLocalEntityIndexedDb.items, axpLocalEntityIndexedDb.meta, async () => {
-            const existing = await axpLocalEntityIndexedDb.items
-                .where('[entityKey+userKey]')
-                .equals([entityKey, userKey])
-                .primaryKeys();
+            const existing = await axpLocalEntityIndexedDb.items.where('[entityKey+userKey]').equals([entityKey, userKey]).primaryKeys();
             const staleIds = existing.filter((id) => !keepIds.has(String(id)));
             if (staleIds.length > 0) {
                 await axpLocalEntityIndexedDb.items.bulkDelete(staleIds);
@@ -12391,6 +13236,8 @@ class AXPLocalEntityEngine {
                 lastSyncedAt: new Date().toISOString(),
             });
         });
+        if (userKey !== this.resolveUserKey())
+            return;
         this.userKeySignal.set(userKey);
         bucket.items.set(items);
         bucket.hydrated.set(true);
@@ -12412,6 +13259,8 @@ class AXPLocalEntityEngine {
             }
             this.userKeySignal.set(userKey);
             for (const [entityKey, bucket] of this.buckets) {
+                bucket.items.set([]);
+                bucket.hydrated.set(false);
                 bucket.bootstrapPromise = null;
                 bucket.hydratePromise = null;
                 bucket.syncInFlight = null;
@@ -14054,5 +14903,5 @@ const axpPageGetContextQueryDefinition = defineQuery({
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXPAcorexFileTypeBridgeProvider, AXPAcorexFileTypeModule, AXPAppVersionService, AXPBackgroundOperationCompletionService, AXPBackgroundOperationEntityStoreService, AXPBackgroundOperationHandler, AXPBackgroundOperationNotificationService, AXPBackgroundOperationProvider, AXPBackgroundOperationRootConfig, AXPBackgroundOperationService, AXPBackgroundOperationSlotComponent, AXPBrowserTitleService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDefaultMultiLanguageConfigService, AXPEntityDetailsNavTrailService, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileChooserSettings, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPIndexedDbSettingValueProvider, AXPIntegrationDomainProviderContext, AXPIntegrationDomainRegistryFacade, AXPIntegrationDomainRegistryService, AXPIntegrationOAuthService, AXPIntegrationProviderContext, AXPIntegrationProviderRegistryService, AXPIntegrationRuntimeService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLocalEntityEngine, AXPLocalEntityIndexedDb, AXPLocalEntityOfflineRuntime, AXPLocalEntityOutboxService, AXPLocalEntityRealtimeBridge, AXPLockService, AXPLogoImageSrcResolverService, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateCommand, AXPNetworkConnectivityService, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPageGetContextQuery, AXPPageRunActionCommand, AXPPlatformBrandingService, AXPPlatformDefaultConfigs, AXPPlatformSettingsLoadState, AXPPlatformSettingsOfflineBootstrapService, AXPQueryEvaluatorScopeProvider, AXPQueryParamsEvaluatorScopeProvider, AXPRegionalCalendarService, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsBulkSyncService, AXPSettingsEvaluatorScopeProvider, AXPSettingsIndexedDb, AXPSettingsService, AXPStateMessageComponent, AXPStatusDefinitionProviderService, AXPStickyDirective, AXPTabNavigationService, AXPTabPreviewService, AXPTabRouteCacheRegistry, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPTranslateFormatter, AXPUnsavedChangesConfirmService, AXPUnsavedChangesPopstateService, AXPUserNotificationService, AXPVersioningService, AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES, AXP_APP_VERSION_PROVIDER, AXP_BACKGROUND_OPERATION_ENTITY_STORAGE, AXP_BACKGROUND_OPERATION_HANDLERS, AXP_BACKGROUND_OPERATION_PROVIDERS, AXP_BREADCRUMB_COLLAPSE_HEAD_COUNT, AXP_BREADCRUMB_COLLAPSE_TAIL_COUNT, AXP_DOCUMENT_FILE_TYPE_PURPOSES, AXP_ENTITY_LIST_DISPLAY_MODE_DEFAULT, AXP_ENTITY_VIEW_ACCESS, AXP_EXPERIENCE_SETTINGS_GROUP, AXP_EXPERIENCE_SETTINGS_SECTIONS, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_HOME_TAB_KEY, AXP_INTEGRATION_CONNECTION_ESTABLISHED, AXP_INTEGRATION_CONNECTION_LIFECYCLE, AXP_INTEGRATION_DOMAIN_PROVIDER, AXP_INTEGRATION_OAUTH_SERVICE, AXP_INTEGRATION_PROVIDER, AXP_INTEGRATION_RUNTIME_PROVIDER, AXP_INTEGRATION_SECRET_STORE, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_LOCALE_MANAGEMENT_PORT, AXP_LOCAL_ENTITY_BROADCAST_CHANNEL, AXP_LOCAL_ENTITY_DEFAULT_MAX_ITEMS, AXP_LOCAL_ENTITY_OUTBOX_LOCK, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_NOT_FOUND_CATCH_ALL_ROUTE, AXP_NOT_FOUND_ROUTE, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, AXP_PLATFORM_BRANDING_SETTING_KEYS, AXP_PLATFORM_CONFIG_TOKEN, AXP_PROTECTED_ROUTE_GUARDS, AXP_ROOT_CONFIG_TOKEN, AXP_RUNTIME_QUERY_CACHE_DEFAULTS, AXP_SEARCH_DEFINITION_LAZY_RESOLVER, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTINGS_CACHE_SYNC, AXP_SETTINGS_SYNC_DEBOUNCE_MS, AXP_SETTINGS_SYNC_KEYS, AXP_SETTINGS_SYNC_RETRY_BACKOFF_MS, AXP_SETTINGS_SYNC_TTL_MS, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_SCOPE_DESCENDANTS, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TAB_BREADCRUMB_JOIN_SEPARATOR, AXP_TAB_ROUTE_DATA_KEY, AXP_TOKEN_DEFINITION_PROVIDER, AXP_UNAUTHORIZED_ROUTE, AXP_USER_NOTIFICATION_SERVICE, AXVChangeType, AX_FILE_TYPE_METADATA_SUPPORT_BY_FILE_VIEWER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENTITY_LIST_DEFAULT_INSTANCE_ID, ENTITY_LIST_INSTANCE_QUERY_PARAM, ENVIRONMENT, EQ_OPER, FILE_VIEWER_PREVIEW_EXTENSIONS, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, MULTILANGUAGE_CAPABLE_WIDGET_TYPES, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, SETTINGS_TRACE_NS, SETTINGS_TRACE_TITLE, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationDurationMs, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationStatusTextParams, axpBackgroundOperationToEntityModel, axpBeginCommandSubFlowNavigation, axpBuildBackgroundOperation, axpBuildTabKey, axpClearEntityDetailsNavTrail, axpCloneBreadcrumbItems, axpCoerceBackgroundOperationDate, axpComposeEntityDetailsNavTrail, axpCreateBackgroundOperationId, axpEndCommandSubFlowNavigation, axpEnsureEntityListInstanceQueryParam, axpEntityKeyFromDetailsPath, axpFallbackTabTitle, axpFindMenuItemByRoute, axpFormatBackgroundOperationDurationMs, axpGetBreadcrumbNavigatePath, axpGetEntityDetailsNavTrail, axpGetEntityListInstanceIdFromParamMap, axpGetEntityListInstanceIdFromPath, axpGetEntityListInstanceIdFromQueryString, axpGetEntityListReturnUrl, axpGetLeafRouteSnapshot, axpHasTabScope, axpInterpolateNavigatePath, axpIsActiveBackgroundOperationStatus, axpIsBackgroundOperationI18nText, axpIsCommandSubFlowNavigationSuspended, axpIsCompletedBackgroundOperationStatus, axpIsCompletedPanelBackgroundOperation, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpIsInProgressPanelBackgroundOperation, axpIsLikelyNetworkFailure, axpIsSameEntityDetailsRecord, axpIsTabEligibleUrl, axpIsTrayVisibleBackgroundOperation, axpJoinTabTitleSegments, axpLocalEntityCanServeListLocally, axpLocalEntityHotListRequest, axpLocalEntityIndexedDb, axpLocalEntityRecordId, axpLocalEntitySortAt, axpLocalEntitySupportsOfflineWrite, axpLocalEntityToPayload, axpMenuItemListInstanceId, axpMenuPathsMatch, axpNavigateAppPath, axpNavigateCommandDefinition, axpNormalizeEntityListInstanceId, axpPageGetContextQueryDefinition, axpPageRunActionCommandDefinition, axpParseAppPath, axpParseEntityDetailsRoute, axpParseEntityListRoute, axpPathFromSnapshot, axpPeekCommandSubFlowReturnUrl, axpPlatformSettingsAvailableGuard, axpPrepareOriginNavTrail, axpRedirectToNotFound, axpRedirectToUnauthorized, axpReplaceEntityListRouteQueryParams, axpResolveNavigatePath, axpResolveTabKey, axpResolveTabKeyFromRouteConfig, axpResolveTabKeyFromSnapshot, axpResolveTabTitleParts, axpSaveEntityDetailsNavTrail, axpSaveEntityListReturnUrl, axpSetEntityDetailsPageQuery, axpSettingsIndexedDb, axpSplitCollapsedBreadcrumbs, axpStampEntityListMenuInstancePaths, axpStripHomeBreadcrumb, axpStripTrailingCommandlessCrumbs, axpTrimNavTrailBeforeTarget, backgroundOperationEntityFactory, buildFileStorageDownloadUrl, buildLocalEntityMetaId, buildLocalEntityStorageId, buildScopedSettingsSnapshotId, chooseSystemFiles, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createBackgroundOperationStore, createDefaultSettingValueProviders, createEmptyScopedSettingsSnapshot, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createFileTypeOpenContext, createIndexedDbSettingValueProviders, createMenuContext, createMenuMiddleware, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, extractFileExtension, extractHttpRequestErrorInfo, extractRequestErrorInfo, findManualPresetIdByOperation, formatEntityRowDisplayTitle, formatRequestError, hasFileTypeOpenHandler, hydrateSettingsValuesFromIndexedDb, inferSettingCoercionKind, isFileNameShownInViewer, isFileTypeShownInViewer, isFileViewerPreviewExtension, isOneWaySettingsIndexedDbCache, isPendingCascadeFilter, isSettingKeyCacheable, isSettingVisibleOnScope, isStoredImageFileId, normalizeAvailableLanguageCodes, normalizeDocumentFileTypePurposes, normalizeDocumentToFileListItem, normalizeOverridableAt, normalizePositiveNumberOption, normalizeRouterUrl, normalizeStoredImageRef, peelSettingValueKey, platformErrorI18nKey, primaryLanguageSubtag, printGraphicFromElement, projectSettingsValuesForIndexedDb, provideAXPUserNotificationService, provideDynamicHomePage, provideLocalEntityOfflineRuntime, provideMenuMiddleware, purgeLegacyTenantScopedSettingsSnapshots, resolveDateFilterPresets, resolveEffectiveAvailableLanguageCodes, resolveEntityCreateListBehavior, resolveEntityDetailsRouteAccess, resolveEntityModifyPopupTitle, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntitySearchTitleFallback, resolveExplorerFileDisplayName, resolveFileTypeDisplay, resolveFileViewerType, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, resolveStoredImageDisplayUrl, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, shouldPersistSettingsInIndexedDb, stripAccidentalNestedSettingParents, throwIfCommandFailed, toAXPRequestError, toExecuteCommandFailureResult, traceSettingsAppStartupLoadComplete, traceSettingsAppStartupLoadStarted, traceSettingsClientTool, traceSettingsFlush, traceSettingsLocalPersist, traceSettingsPageLoadComplete, traceSettingsPageLoadStarted, traceSettingsPageRouteLoad, traceSettingsRetryScheduled, traceSettingsRevalidateFailed, traceSettingsServerApiCall, traceSettingsServiceLoadComplete, traceSettingsServiceLoadFailed, traceSettingsServiceLoadStarted, traceSettingsServiceReload, traceSettingsSyncFailed, triggerBrowserDownload, tryOpenFileByCatalogType, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+export { ALL_DEFAULT_OPERATORS, AXPAcorexFileTypeBridgeProvider, AXPAcorexFileTypeModule, AXPAppVersionService, AXPBackgroundOperationCompletionService, AXPBackgroundOperationEntityStoreService, AXPBackgroundOperationHandler, AXPBackgroundOperationNotificationService, AXPBackgroundOperationProvider, AXPBackgroundOperationRootConfig, AXPBackgroundOperationService, AXPBackgroundOperationSlotComponent, AXPBrowserTitleService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDefaultMultiLanguageConfigService, AXPEntityDetailsNavTrailService, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileChooserSettings, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterDefaultOperatorService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPIndexedDbSettingValueProvider, AXPIntegrationDomainProviderContext, AXPIntegrationDomainRegistryFacade, AXPIntegrationDomainRegistryService, AXPIntegrationOAuthService, AXPIntegrationProviderContext, AXPIntegrationProviderRegistryService, AXPIntegrationRuntimeService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLocalEntityEngine, AXPLocalEntityIndexedDb, AXPLocalEntityOfflineRuntime, AXPLocalEntityOutboxService, AXPLocalEntityRealtimeBridge, AXPLockService, AXPLogoImageSrcResolverService, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateCommand, AXPNetworkConnectivityService, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPageGetContextQuery, AXPPageRunActionCommand, AXPPlatformBrandingService, AXPPlatformDefaultConfigs, AXPPlatformSettingsLoadState, AXPPlatformSettingsOfflineBootstrapService, AXPQueryEvaluatorScopeProvider, AXPQueryParamsEvaluatorScopeProvider, AXPRegionalCalendarService, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsBulkSyncService, AXPSettingsEvaluatorScopeProvider, AXPSettingsIndexedDb, AXPSettingsService, AXPStateMessageComponent, AXPStatusDefinitionProviderService, AXPStickyDirective, AXPTabNavigationService, AXPTabPreviewService, AXPTabRouteCacheRegistry, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPTranslateFormatter, AXPUnreachableRouteComponent, AXPUnsavedChangesConfirmService, AXPUnsavedChangesPopstateService, AXPUserNotificationService, AXPUserStatusFeatureService, AXPVersioningService, AXP_AGENT_OUTPUT_CONTRACT_DEFAULT_STRUCTURED_RETRIES, AXP_APP_VERSION_PROVIDER, AXP_BACKGROUND_OPERATION_ENTITY_STORAGE, AXP_BACKGROUND_OPERATION_HANDLERS, AXP_BACKGROUND_OPERATION_PROVIDERS, AXP_BREADCRUMB_COLLAPSE_HEAD_COUNT, AXP_BREADCRUMB_COLLAPSE_TAIL_COUNT, AXP_DOCUMENT_FILE_TYPE_PURPOSES, AXP_ENTITY_LIST_DISPLAY_MODE_DEFAULT, AXP_ENTITY_VIEW_ACCESS, AXP_EXPERIENCE_SETTINGS_GROUP, AXP_EXPERIENCE_SETTINGS_SECTIONS, AXP_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_FILTER_DEFAULT_OPERATORS_WIDGET_NAME, AXP_FILTER_DEFAULT_OPERATOR_WIDGETS, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_HOME_TAB_KEY, AXP_INTEGRATION_CONNECTION_ESTABLISHED, AXP_INTEGRATION_CONNECTION_LIFECYCLE, AXP_INTEGRATION_DOMAIN_PROVIDER, AXP_INTEGRATION_OAUTH_SERVICE, AXP_INTEGRATION_PROVIDER, AXP_INTEGRATION_RUNTIME_PROVIDER, AXP_INTEGRATION_SECRET_STORE, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_IN_TAB_ERROR_FROM_PARAM, AXP_LOCALE_MANAGEMENT_PORT, AXP_LOCAL_ENTITY_BROADCAST_CHANNEL, AXP_LOCAL_ENTITY_DEFAULT_MAX_ITEMS, AXP_LOCAL_ENTITY_OUTBOX_LOCK, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_NOT_FOUND_CATCH_ALL_ROUTE, AXP_NOT_FOUND_ROUTE, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, AXP_PLATFORM_BRANDING_SETTING_KEYS, AXP_PLATFORM_CONFIG_TOKEN, AXP_PROTECTED_ROUTE_GUARDS, AXP_ROOT_CONFIG_TOKEN, AXP_RUNTIME_QUERY_CACHE_DEFAULTS, AXP_SEARCH_DEFINITION_LAZY_RESOLVER, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTINGS_CACHE_SYNC, AXP_SETTINGS_SYNC_DEBOUNCE_MS, AXP_SETTINGS_SYNC_KEYS, AXP_SETTINGS_SYNC_RETRY_BACKOFF_MS, AXP_SETTINGS_SYNC_TTL_MS, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_SCOPE_DESCENDANTS, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TAB_BREADCRUMB_JOIN_SEPARATOR, AXP_TAB_ROUTE_DATA_KEY, AXP_TOKEN_DEFINITION_PROVIDER, AXP_UNAUTHORIZED_ROUTE, AXP_USER_NOTIFICATION_SERVICE, AXP_USER_STATUS_ENABLED_DEFAULT, AXVChangeType, AX_FILE_TYPE_METADATA_SUPPORT_BY_FILE_VIEWER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENTITY_LIST_DEFAULT_INSTANCE_ID, ENTITY_LIST_INSTANCE_QUERY_PARAM, ENVIRONMENT, EQ_OPER, FILE_VIEWER_PREVIEW_EXTENSIONS, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, MULTILANGUAGE_CAPABLE_WIDGET_TYPES, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, SETTINGS_TRACE_NS, SETTINGS_TRACE_TITLE, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationDurationMs, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationStatusTextParams, axpBackgroundOperationToEntityModel, axpBeginCommandSubFlowNavigation, axpBuildBackgroundOperation, axpBuildTabKey, axpClearEntityDetailsNavTrail, axpCloneBreadcrumbItems, axpCoerceBackgroundOperationDate, axpComposeEntityDetailsNavTrail, axpCreateBackgroundOperationId, axpEndCommandSubFlowNavigation, axpEnsureEntityListInstanceQueryParam, axpEntityKeyFromDetailsPath, axpEntityListNavigationTabKey, axpFallbackTabTitle, axpFindMenuItemByRoute, axpFormatBackgroundOperationDurationMs, axpGetBreadcrumbNavigatePath, axpGetEntityDetailsNavTrail, axpGetEntityListInstanceIdFromParamMap, axpGetEntityListInstanceIdFromPath, axpGetEntityListInstanceIdFromQueryString, axpGetEntityListReturnUrl, axpGetLeafRouteSnapshot, axpHasTabScope, axpInTabErrorLocation, axpInTabErrorRetryUrl, axpInTabErrorSourceUrl, axpInTabErrorUrlTree, axpInterpolateNavigatePath, axpIsActiveBackgroundOperationStatus, axpIsBackgroundOperationI18nText, axpIsCommandSubFlowNavigationSuspended, axpIsCompletedBackgroundOperationStatus, axpIsCompletedPanelBackgroundOperation, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpIsInProgressPanelBackgroundOperation, axpIsLikelyNetworkFailure, axpIsSameEntityDetailsRecord, axpIsTabEligibleUrl, axpIsTrayVisibleBackgroundOperation, axpJoinTabTitleSegments, axpLocalEntityCanServeListLocally, axpLocalEntityHotListRequest, axpLocalEntityIndexedDb, axpLocalEntityRecordId, axpLocalEntitySortAt, axpLocalEntitySupportsOfflineWrite, axpLocalEntityToPayload, axpMenuItemListInstanceId, axpMenuPathsMatch, axpNavigateAppPath, axpNavigateCommandDefinition, axpNormalizeEntityListInstanceId, axpOnCommandSubFlowNavigationEnded, axpPageGetContextQueryDefinition, axpPageRunActionCommandDefinition, axpParseAppPath, axpParseEntityDetailsRoute, axpParseEntityListRoute, axpPathFromSnapshot, axpPeekCommandSubFlowReturnUrl, axpPlatformSettingsAvailableGuard, axpPrepareOriginNavTrail, axpRedirectToNotFound, axpRedirectToUnauthorized, axpRedirectUnknownToNotFound, axpReplaceEntityListRouteQueryParams, axpResolveNavigatePath, axpResolveTabKey, axpResolveTabKeyFromRouteConfig, axpResolveTabKeyFromSnapshot, axpResolveTabTitleParts, axpSaveEntityDetailsNavTrail, axpSaveEntityListReturnUrl, axpSetEntityDetailsPageQuery, axpSettingsIndexedDb, axpSnapshotDeclaresTabScope, axpSplitCollapsedBreadcrumbs, axpStampEntityListMenuInstancePaths, axpStripHomeBreadcrumb, axpStripTrailingCommandlessCrumbs, axpTabScopePathFromSnapshot, axpTrimNavTrailBeforeTarget, backgroundOperationEntityFactory, buildFileStorageDownloadUrl, buildLocalEntityMetaId, buildLocalEntityStorageId, buildScopedSettingsSnapshotId, chooseSystemFiles, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createBackgroundOperationStore, createDefaultSettingValueProviders, createEmptyScopedSettingsSnapshot, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createFileTypeOpenContext, createIndexedDbSettingValueProviders, createMenuContext, createMenuMiddleware, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, extractFileExtension, extractHttpRequestErrorInfo, extractRequestErrorInfo, findFilterDefaultOperatorWidget, findManualPresetIdByOperation, formatEntityRowDisplayTitle, formatRequestError, hasFileTypeOpenHandler, hydrateSettingsValuesFromIndexedDb, inferSettingCoercionKind, isFileNameShownInViewer, isFileTypeShownInViewer, isFileViewerPreviewExtension, isOneWaySettingsIndexedDbCache, isPendingCascadeFilter, isSettingKeyCacheable, isSettingVisibleOnScope, isStoredImageFileId, normalizeAvailableLanguageCodes, normalizeDocumentFileTypePurposes, normalizeDocumentToFileListItem, normalizeOverridableAt, normalizePositiveNumberOption, normalizeRouterUrl, normalizeStoredImageRef, openSystemFileDialog, peelSettingValueKey, platformErrorI18nKey, primaryLanguageSubtag, printGraphicFromElement, projectSettingsValuesForIndexedDb, provideAXPUserNotificationService, provideDynamicHomePage, provideLocalEntityOfflineRuntime, provideMenuMiddleware, purgeLegacyTenantScopedSettingsSnapshots, readFilterDefaultOperatorMap, resolveDateFilterPresets, resolveEffectiveAvailableLanguageCodes, resolveEntityCreateListBehavior, resolveEntityDetailsRouteAccess, resolveEntityModifyPopupTitle, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntitySearchTitleFallback, resolveExplorerFileDisplayName, resolveFileTypeDisplay, resolveFileViewerType, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, resolveStoredFilterDefaultOperator, resolveStoredImageDisplayUrl, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, shouldPersistSettingsInIndexedDb, stripAccidentalNestedSettingParents, throwIfCommandFailed, toAXPRequestError, toExecuteCommandFailureResult, traceSettingsAppStartupLoadComplete, traceSettingsAppStartupLoadStarted, traceSettingsClientTool, traceSettingsFlush, traceSettingsLocalPersist, traceSettingsPageLoadComplete, traceSettingsPageLoadStarted, traceSettingsPageRouteLoad, traceSettingsRetryScheduled, traceSettingsRevalidateFailed, traceSettingsServerApiCall, traceSettingsServiceLoadComplete, traceSettingsServiceLoadFailed, traceSettingsServiceLoadStarted, traceSettingsServiceReload, traceSettingsSyncFailed, triggerBrowserDownload, tryOpenFileByCatalogType, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty, withFilterDefaultOperator, writeFilterDefaultOperatorOverride };
 //# sourceMappingURL=acorex-platform-framework-client-common.mjs.map