@acorex/platform 21.0.0-next.75 → 21.0.0-next.76

package/fesm2022/acorex-platform-common.mjs

@@ -1,15 +1,17 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, Injector, signal, DestroyRef, makeEnvironmentProviders, NgModule, computed, input, output, ViewEncapsulation, ChangeDetectionStrategy, Component, viewChild, ErrorHandler, EventEmitter, Input, Output, Directive, Inject, runInInjectionContext, model, linkedSignal, afterNextRender } from '@angular/core';
-import { kebabCase, merge, sortBy, cloneDeep, get, isNumber, isPlainObject, omit } from 'lodash-es';
+import { InjectionToken, inject, Injectable, Injector, signal, DestroyRef, makeEnvironmentProviders, NgModule, computed, input, output, ViewEncapsulation, ChangeDetectionStrategy, Component, viewChild, ErrorHandler, EventEmitter, Input, Output, Directive, effect, Inject, runInInjectionContext, model, linkedSignal, afterNextRender } from '@angular/core';
+import { AXPRegionalSetting } from '@acorex/platform/contracts';
+export * from '@acorex/platform/contracts';
 import { Router, NavigationEnd, NavigationStart, ROUTES, RedirectCommand, RouterModule } from '@angular/router';
 import { AXPSessionService, AXPSessionStatus, AXPAuthGuard } from '@acorex/platform/auth';
 import { Subject, distinctUntilChanged, merge as merge$1, first, switchMap, from, map } from 'rxjs';
-import * as i2$1 from '@acorex/platform/core';
-import { unwrapValueProperty, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToBoolean, coerceUnknownToTrimmedString, AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPDataGenerator, AXPKeyboardShortcutRegistry, chordToKbdItemKeys, hasForegroundOverlayLayer, AXPKeyboardShortcutPriority, normalizeKeyboardShortcuts, AXPSystemActionType, isLocaleStringMap, AXPExpressionEvaluatorService, AXPModuleManifestModule, AXPComponentSlotModule, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPHookService, AXPModuleManifestRegistry } from '@acorex/platform/core';
+import * as i3$1 from '@acorex/platform/core';
+import { unwrapValueProperty, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToBoolean, coerceUnknownToTrimmedString, AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPDataGenerator, AXPKeyboardShortcutRegistry, chordToKbdItemKeys, hasForegroundOverlayLayer, AXPKeyboardShortcutPriority, normalizeKeyboardShortcuts, AXPSystemActionType, normalizeExpressionTemplate, isLocaleStringMap, AXPExpressionEvaluatorService, AXPContextEvalFactory, AXPDeviceService, AXPModuleManifestModule, AXPComponentSlotModule, AXPAppStartUpProvider, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPHookService, AXPModuleManifestRegistry } from '@acorex/platform/core';
+import { merge, sortBy, cloneDeep, get, isNumber, isNil, isObject, isString, isPlainObject, omit, defaultTo } from 'lodash-es';
 import { AXCalendarService, AXDateTimeModule } from '@acorex/core/date-time';
 import { AXDialogService } from '@acorex/components/dialog';
 import * as i5 from '@acorex/core/translation';
-import { AXTranslationService, AXTranslationModule, resolveMultiLanguageString } from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule, translateSync, resolveMultiLanguageString } from '@acorex/core/translation';
 import * as i4$1 from '@angular/common';
 import { Location, CommonModule, AsyncPipe, DOCUMENT } from '@angular/common';
 import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
@@ -24,13 +26,15 @@ import * as i3 from '@acorex/components/progress-bar';
 import { AXProgressBarModule } from '@acorex/components/progress-bar';
 import { AXPopupService, AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
-import * as i3$1 from '@acorex/platform/workflow';
+import * as i2$1 from '@acorex/core/format';
+import { AXFormatService } from '@acorex/core/format';
+import * as i4$2 from '@acorex/platform/workflow';
 import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
 import { AXKBDComponent, AXKBDItemComponent } from '@acorex/components/kbd';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPCommandExecutor, AXPCommandService } from '@acorex/platform/runtime';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
-import { AXFormatService } from '@acorex/core/format';
+import { filter } from 'rxjs/operators';
 import { AXFileService } from '@acorex/core/file';
 import { AXCheckBoxModule } from '@acorex/components/check-box';
 import * as i6 from '@acorex/components/color-box';
@@ -164,110 +168,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-var AXPRelationshipKind;
-(function (AXPRelationshipKind) {
-    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
-    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
-    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
-})(AXPRelationshipKind || (AXPRelationshipKind = {}));
-var AXPRelationshipCardinality;
-(function (AXPRelationshipCardinality) {
-    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
-    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
-    AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
-})(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
-var AXPEntityCommandScope;
-(function (AXPEntityCommandScope) {
-    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
-    AXPEntityCommandScope["Selected"] = "selected";
-    AXPEntityCommandScope["Individual"] = "individual";
-    AXPEntityCommandScope["Section"] = "section";
-})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
-var AXPEntityQueryType;
-(function (AXPEntityQueryType) {
-    AXPEntityQueryType["Single"] = "single";
-    AXPEntityQueryType["List"] = "list";
-})(AXPEntityQueryType || (AXPEntityQueryType = {}));
-/** Whether the card field is shown as a header badge (not in the card body). */
-function isCardFieldBadgeDisplay(display) {
-    if (display === 'badge') {
-        return true;
-    }
-    return typeof display === 'object' && display !== null && display.type === 'badge';
-}
-/** Resolves static badge color config from {@link AXPCardField.display} and legacy {@link AXPCardField.badgeColor}. */
-function resolveCardFieldBadgeColor(field) {
-    if (typeof field.display === 'object' && field.display.type === 'badge') {
-        return field.display.options?.color ?? field.badgeColor;
-    }
-    if (field.display === 'badge') {
-        return field.badgeColor;
-    }
-    return undefined;
-}
-function getEntityInfo(entity) {
-    return {
-        source: `${entity.module}.${entity.name}`,
-        module: {
-            route: kebabCase(entity.module),
-        },
-        entity: {
-            route: kebabCase(entity.name),
-        },
-    };
-}
-function createQueryView(name, title, fixed, params = {
-    columns: [],
-    conditions: [],
-    sorts: [],
-}) {
-    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
-    return {
-        name,
-        title,
-        fixed,
-        columns: params.columns ?? [],
-        conditions: params.conditions ?? [],
-        sorts: params.sorts ?? [],
-    };
-}
-function createAllQueryView(params = {
-    columns: [],
-    sorts: [],
-    conditions: [],
-}) {
-    params = Object.assign({ columns: [], sorts: [], conditions: [] }, params);
-    return createQueryView('all', '@general:terms.interface.selection.all-items', true, {
-        columns: params.columns ?? [],
-        conditions: params.conditions ?? [],
-        sorts: params.sorts ?? [],
-    });
-}
-/** Resolves master list layouts that are currently enabled. */
-function resolveEnabledMasterListLayouts(layouts) {
-    if (!layouts) {
-        return ['table'];
-    }
-    const enabled = [];
-    if (layouts.table?.enabled !== false) {
-        enabled.push('table');
-    }
-    if (layouts.card && layouts.card.enabled !== false) {
-        enabled.push('card');
-    }
-    return enabled.length > 0 ? enabled : ['table'];
-}
-/** First enabled layout; used as the default when no user preference is stored. */
-function resolveDefaultMasterListLayout(layouts) {
-    return resolveEnabledMasterListLayouts(layouts)[0];
-}
-// new version
-var AXPEntityType;
-(function (AXPEntityType) {
-    AXPEntityType[AXPEntityType["Entity"] = 0] = "Entity";
-    AXPEntityType[AXPEntityType["AggregateRoot"] = 1] = "AggregateRoot";
-    AXPEntityType[AXPEntityType["ValueObject"] = 2] = "ValueObject";
-})(AXPEntityType || (AXPEntityType = {}));
+/**
+ * Entity definition types, query views, and related helpers.
+ * Canonical definitions live in @acorex/platform/contracts.
+ */
 
 const EQ_OPER = { name: 'equal', title: '@general:terms.operators.equal', hasValue: true };
 const NOT_EQ_OPER = { name: 'notEqual', title: '@general:terms.operators.not-equal', hasValue: true };
@@ -472,38 +376,6 @@ const AXP_HOME_PAGE_DEFAULT_KEY = new InjectionToken('AXP_HOME_PAGE_DEFAULT_KEY'
     factory: () => 'home'
 });
 
-/**
- * Regional and locale-related setting keys used by platform widgets and components.
- * Most values use the `LocaleManagement:Setting:Regional.*` prefix; definitions live in the locale-management module where applicable.
- */
-var AXPRegionalSetting;
-(function (AXPRegionalSetting) {
-    AXPRegionalSetting["LocaleProfile"] = "LocaleManagement:Setting:Regional.LocaleProfile";
-    AXPRegionalSetting["TimeZone"] = "LocaleManagement:Setting:Regional.TimeZone";
-    AXPRegionalSetting["Language"] = "LocaleManagement:Setting:Regional.Language";
-    AXPRegionalSetting["Country"] = "LocaleManagement:Setting:Regional.Country";
-    AXPRegionalSetting["Calendar"] = "LocaleManagement:Setting:Regional.Calendar";
-    /** User-selected holiday calendars shown on the task board and other calendar views. */
-    AXPRegionalSetting["CalendarEvents"] = "LocaleManagement:Setting:Regional.CalendarEvents";
-    AXPRegionalSetting["FirstDayOfWeek"] = "LocaleManagement:Setting:Regional.FirstDayOfWeek";
-    AXPRegionalSetting["WeekendDays"] = "LocaleManagement:Setting:Regional.WeekendDays";
-    AXPRegionalSetting["ShortDate"] = "LocaleManagement:Setting:Regional.ShortDate";
-    AXPRegionalSetting["MediumDate"] = "LocaleManagement:Setting:Regional.MediumDate";
-    AXPRegionalSetting["LongDate"] = "LocaleManagement:Setting:Regional.LongDate";
-    AXPRegionalSetting["ShortTime"] = "LocaleManagement:Setting:Regional.ShortTime";
-    AXPRegionalSetting["MediumTime"] = "LocaleManagement:Setting:Regional.MediumTime";
-    AXPRegionalSetting["LongTime"] = "LocaleManagement:Setting:Regional.LongTime";
-    AXPRegionalSetting["MeasurementUnits"] = "LocaleManagement:Setting:Regional.MeasurementUnits";
-    AXPRegionalSetting["TemperatureUnits"] = "LocaleManagement:Setting:Regional.TemperatureUnits";
-    AXPRegionalSetting["DistanceUnits"] = "LocaleManagement:Setting:Regional.DistanceUnits";
-    AXPRegionalSetting["WeightUnits"] = "LocaleManagement:Setting:Regional.WeightUnits";
-    AXPRegionalSetting["VolumeUnits"] = "LocaleManagement:Setting:Regional.VolumeUnits";
-    AXPRegionalSetting["SpeedUnits"] = "LocaleManagement:Setting:Regional.SpeedUnits";
-    AXPRegionalSetting["AreaUnits"] = "LocaleManagement:Setting:Regional.AreaUnits";
-    /** Default multi-language behavior for standard text field names; defined in locale-management `AXMRegionalSettingProvider`. */
-    AXPRegionalSetting["MultiLanguageSupport"] = "LocaleManagement:Setting:Regional.MultiLanguageSupport";
-})(AXPRegionalSetting || (AXPRegionalSetting = {}));
-
 class AXPSettingDefinitionProviderContext {
     constructor() {
         this.rootGroups = [];
@@ -601,6 +473,7 @@ class AXPSettingDefinitionSectionBuilder {
             isRequired: setting.isRequired ?? false,
             isInherited: setting.isInherited ?? false,
             isEncrypted: setting.isEncrypted ?? false,
+            requiresPageRefresh: setting.requiresPageRefresh ?? false,
             defaultValue: setting.defaultValue,
             scope: setting.scope ?? 'P',
             layout: setting.widget.layout,
@@ -735,6 +608,26 @@ class AXPSettingDefinitionProviderService {
         collect(this.cache);
         return scopes;
     }
+    async requiresPageRefreshByKey() {
+        const refreshByKey = {};
+        const collect = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        if (setting.requiresPageRefresh) {
+                            refreshByKey[setting.name] = true;
+                        }
+                    });
+                });
+                collect(group.groups);
+            });
+        };
+        if (!this.cache) {
+            await this.load();
+        }
+        collect(this.cache);
+        return refreshByKey;
+    }
     findGroup(scope, groupName) {
         return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
@@ -1425,6 +1318,8 @@ var AXPCommonSettings;
     AXPCommonSettings["DebugMode"] = "PlatformDevTools:Setting:Developer.DebugMode";
     AXPCommonSettings["ShowRowIndexColumn"] = "Common:Setting:Entity.ShowRowIndexColumn";
     AXPCommonSettings["EntityListPersistenceMode"] = "Common:Setting:Entity.ListPersistenceMode";
+    AXPCommonSettings["NavigationMode"] = "Common:Setting:Navigation.Mode";
+    AXPCommonSettings["MaxOpenTabs"] = "Common:Setting:Navigation.MaxOpenTabs";
 })(AXPCommonSettings || (AXPCommonSettings = {}));
 
 //#endregion
@@ -1611,9 +1506,176 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
+//#endregion
+/**
+ * Holds detached Angular route component instances keyed by tab key so tabular navigation can
+ * preserve a page's full state (data-table selection, scroll, unsaved form values, etc.) while it
+ * is in the background, then reattach it without re-rendering.
+ *
+ * The registry has no `Router` dependency on purpose: it is consumed by the {@link RouteReuseStrategy}
+ * implementation, so depending on `Router` here would create a construction-time cycle.
+ */
+class AXPTabRouteCacheRegistry {
+    constructor() {
+        //#region ---- State ----
+        this.handles = new Map();
+        this.openKeys = new Set();
+        this.enabled = false;
+        this.deactivateGuardSuspended = false;
+    }
+    //#endregion
+    //#region ---- Deactivate Guard Suspension ----
+    /**
+     * Runs `action` while unsaved-changes `canDeactivate` guards are suspended, so switching between
+     * tabs preserves a dirty page without prompting. Closing a tab does not use this path, so the
+     * prompt still appears there.
+     */
+    async runWithSuspendedDeactivateGuards(action) {
+        const previous = this.deactivateGuardSuspended;
+        this.deactivateGuardSuspended = true;
+        try {
+            return await action();
+        }
+        finally {
+            this.deactivateGuardSuspended = previous;
+        }
+    }
+    isDeactivateGuardSuspended() {
+        return this.deactivateGuardSuspended;
+    }
+    //#endregion
+    //#region ---- Mode ----
+    /** Enables caching (tabular mode). Disabling clears and destroys every cached component. */
+    setEnabled(enabled) {
+        if (this.enabled === enabled) {
+            return;
+        }
+        this.enabled = enabled;
+        if (!enabled) {
+            this.clear();
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    //#endregion
+    //#region ---- Open Keys Sync ----
+    /**
+     * Reconciles open scoped tab keys and active tab URLs. Cached handles whose key is not an open
+     * scoped tab key, an active tab URL, or a child path under an open scoped tab are destroyed.
+     */
+    syncOpenKeys(scopedKeys, activeTabUrls = []) {
+        const scopedSet = new Set(scopedKeys);
+        const activePathSet = new Set(activeTabUrls.map((url) => url.split('?')[0].split('#')[0].replace(/\/+$/, '') || '/'));
+        for (const cacheKey of [...this.handles.keys()]) {
+            const normalizedCacheKey = cacheKey.replace(/\/+$/, '') || '/';
+            const keepsScopedKey = scopedSet.has(normalizedCacheKey);
+            const keepsActiveUrl = activePathSet.has(normalizedCacheKey);
+            const keepsUnderScopedTab = [...scopedSet].some((scopedKey) => normalizedCacheKey === scopedKey || normalizedCacheKey.startsWith(`${scopedKey}/`));
+            if (!keepsScopedKey && !keepsActiveUrl && !keepsUnderScopedTab) {
+                this.destroyHandle(this.handles.get(cacheKey));
+                this.handles.delete(cacheKey);
+            }
+        }
+        this.openKeys = scopedSet;
+    }
+    isOpen(key) {
+        return this.openKeys.has(key);
+    }
+    /**
+     * Returns the live component instance for a cached background tab, when available.
+     * Matches the tab key directly or any cached handle under a scoped tab prefix.
+     */
+    getComponentInstance(key) {
+        const normalizedKey = key.replace(/\/+$/, '') || '/';
+        const direct = this.handles.get(normalizedKey) ?? this.handles.get(key);
+        if (direct) {
+            return this.readComponentInstance(direct);
+        }
+        for (const [cacheKey, handle] of this.handles) {
+            const normalizedCacheKey = cacheKey.replace(/\/+$/, '') || '/';
+            if (normalizedCacheKey === normalizedKey || normalizedCacheKey.startsWith(`${normalizedKey}/`)) {
+                return this.readComponentInstance(handle);
+            }
+        }
+        return null;
+    }
+    //#endregion
+    //#region ---- Handle Store ----
+    /**
+     * Caches a detached background handle. Overwrites without destroying the previous handle: on a
+     * repeat visit Angular hands back a new handle object wrapping the same live `componentRef`, so
+     * destroying the old one would destroy the live component and corrupt the view (NG0922).
+     */
+    store(key, handle) {
+        this.handles.set(key, handle);
+    }
+    /**
+     * Returns the cached handle without mutating the map. Angular reads a handle twice per
+     * navigation (once while building the future state, once while attaching), so `retrieve` must be
+     * idempotent; the handle is released afterwards via {@link release} when Angular calls
+     * `store(snapshot, null)`.
+     */
+    retrieve(key) {
+        return this.handles.get(key) ?? null;
+    }
+    /**
+     * Drops a handle that the router has just reattached (it is now a live foreground view, so it
+     * must not be destroyed). The map keeps only truly backgrounded handles.
+     */
+    release(key) {
+        this.handles.delete(key);
+    }
+    has(key) {
+        return this.handles.has(key);
+    }
+    /** Destroys and removes a single cached handle (used when a tab closes). */
+    evict(key) {
+        this.destroyHandle(this.handles.get(key));
+        this.handles.delete(key);
+    }
+    /** Destroys and removes every cached handle. */
+    clear() {
+        for (const handle of this.handles.values()) {
+            this.destroyHandle(handle);
+        }
+        this.handles.clear();
+        this.openKeys.clear();
+    }
+    //#endregion
+    //#region ---- Utility Methods ----
+    readComponentInstance(handle) {
+        const componentRef = handle.componentRef;
+        return componentRef?.instance ?? null;
+    }
+    destroyHandle(handle) {
+        if (!handle) {
+            return;
+        }
+        const componentRef = handle.componentRef;
+        componentRef?.destroy?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabRouteCacheRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabRouteCacheRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabRouteCacheRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 //#region ----   Unsaved Changes Can Deactivate Guard Factory   ----
 function createUnsavedChangesCanDeactivateGuard() {
-    return (component) => component.canDeactivate();
+    return (component) => {
+        // Tab switches keep the page alive in the background, so skip the prompt; closing a tab does not
+        // suspend guards and still prompts.
+        const tabCache = inject(AXPTabRouteCacheRegistry, { optional: true });
+        if (tabCache?.isDeactivateGuardSuspended()) {
+            return true;
+        }
+        return component.canDeactivate();
+    };
 }
 //#endregion
 
@@ -2991,6 +3053,56 @@ function axpRedirectToUnauthorized(router = inject(Router)) {
     return new RedirectCommand(router.parseUrl(AXP_UNAUTHORIZED_ROUTE));
 }
 
+//#endregion
+/**
+ * Platform formatter for display text: resolves ML objects, i18n keys (`@scope:key`), and primitives.
+ * Register via {@link AXPCommonModule} (auto) or `AXFormatModule.forRoot({ formatters: [AXPTranslateFormatter] })`.
+ */
+class AXPTranslateFormatter {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.translationService = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ---- AXFormatter ----
+    get name() {
+        return 'translate';
+    }
+    format(value, options) {
+        if (isNil(value) || value === '') {
+            return '';
+        }
+        if (isObject(value) && !Array.isArray(value) && !(value instanceof Date)) {
+            const resolved = this.translationService.resolve(value);
+            return resolved?.trim() ?? '';
+        }
+        if (isString(value)) {
+            const text = value.trim();
+            if (!text) {
+                return '';
+            }
+            if (text.startsWith('@')) {
+                const translateOptions = typeof options === 'object' ? options : undefined;
+                const translated = translateSync(text, translateOptions);
+                return translated?.trim() ?? text;
+            }
+            return text;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value).trim();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTranslateFormatter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTranslateFormatter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTranslateFormatter, decorators: [{
+            type: Injectable
+        }] });
+
 class AXPFileStorageService {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPFileStorageService }); }
@@ -4756,6 +4868,8 @@ class AXPMenuSearchDefinitionProvider {
     }
 }
 
+const AXP_SEARCH_DEFINITION_LAZY_RESOLVER = new InjectionToken('AXP_SEARCH_DEFINITION_LAZY_RESOLVER');
+
 class AXPSearchDefinitionProviderContext {
     constructor() {
         this.definitions = [];
@@ -4830,6 +4944,7 @@ const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION
 class AXPSearchDefinitionProviderService {
     constructor() {
         this.providers = inject(AXP_SEARCH_DEFINITION_PROVIDER, { optional: true });
+        this.lazyResolver = inject(AXP_SEARCH_DEFINITION_LAZY_RESOLVER, { optional: true });
         this.cache = null;
     }
     async load() {
@@ -4860,12 +4975,29 @@ class AXPSearchDefinitionProviderService {
         }
     }
     findDefinition(definitionName) {
-        const definition = this.getList().find((definition) => definition.name === definitionName);
+        const definition = this.getList().find((item) => item.name === definitionName);
         if (!definition) {
             throw new Error(`Definition with name ${definitionName} not found`);
         }
         return definition;
     }
+    async findDefinitionAsync(definitionName) {
+        await this.load();
+        const existing = this.getList().find((item) => item.name === definitionName);
+        if (existing) {
+            return existing;
+        }
+        const lazy = this.lazyResolver;
+        if (!lazy) {
+            return null;
+        }
+        const resolved = await lazy.resolve(definitionName);
+        if (!resolved) {
+            return null;
+        }
+        this.cache = [...(this.cache ?? []), resolved];
+        return resolved;
+    }
     findDefinitionByGroup(definitionGroup) {
         const definition = this.getList().find((definition) => definition.group === definitionGroup);
         if (!definition) {
@@ -4884,17 +5016,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 //#region ---- Imports ----
 //#endregion
 //#region ---- Template normalization ----
-/**
- * Normalizes entity display templates for {@link AXPExpressionEvaluatorService}.
- * Converts `context.eval('path')`, single braces, and simple dot paths to `context.eval` segments.
- */
-function normalizeEntityDisplayTemplate(template) {
-    let normalized = template.replace(/\{\{\s*context\.eval\(['"]([^'"]+)['"]\)\s*\}\}/g, '{{ context.eval("$1") }}');
-    if (!normalized.includes('{{')) {
-        normalized = normalized.replace(/\{/g, '{{').replace(/\}/g, '}}');
-    }
-    return normalized.replace(/\{\{\s*(?!context\.)([\w]+(?:\.[\w]+)*)\s*\}\}/g, '{{ context.eval("$1") }}');
-}
+/** @see normalizeExpressionTemplate */
+const normalizeEntityDisplayTemplate = normalizeExpressionTemplate;
 /** True when formatted text still contains unresolved template markers. */
 function isUnresolvedEntityDisplayTemplate(value) {
     return /\{\{/.test(value) || /context\.eval\s*\(/.test(value) || value === '[object Object]';
@@ -5025,17 +5148,55 @@ function resolveEntityRowTitleTemplate(entity) {
     }
     return undefined;
 }
+/**
+ * Record title template for modify popups: `interfaces.master.update.title` → `single.title`.
+ */
+function resolveEntityModifyRecordTitleTemplate(entity) {
+    if (!entity) {
+        return undefined;
+    }
+    const updateTitle = entity.interfaces?.master?.update?.title?.trim();
+    if (updateTitle && isRowBoundTemplate(updateTitle)) {
+        return normalizeEntityDisplayTemplate(updateTitle);
+    }
+    const singleTitle = entity.interfaces?.master?.single?.title?.trim();
+    if (singleTitle && isRowBoundTemplate(singleTitle)) {
+        return normalizeEntityDisplayTemplate(singleTitle);
+    }
+    return undefined;
+}
+/**
+ * Modify/edit popup chrome: `{action} {individual} ({update.title ?? single.title})` when a record template exists.
+ */
+async function resolveEntityModifyPopupTitle(entity, recordData, translationService, formatService, expressionEvaluator, contextEvalFactory, actionTitleKey = '@general:actions.modify.title') {
+    const actionPrefix = translationService.translateSync(actionTitleKey);
+    const entityLabel = translationService.translateSync(entity.formats.individual);
+    const baseTitle = `${actionPrefix} ${entityLabel}`.trim();
+    const recordTemplate = resolveEntityModifyRecordTitleTemplate(entity);
+    if (!recordTemplate) {
+        return baseTitle;
+    }
+    const locale = translationService.getActiveLang();
+    const resolved = await resolveSearchDisplayTemplate(recordTemplate, recordData, locale, translationService, formatService, expressionEvaluator, contextEvalFactory);
+    const recordTitle = sanitizeResolvedEntityDisplayTitle(typeof resolved === 'string'
+        ? resolved
+        : resolveSearchableText(resolved, locale, translationService));
+    if (!isMeaningfulEntityDisplayTitle(recordTitle)) {
+        return baseTitle;
+    }
+    return `${baseTitle} (${recordTitle})`;
+}
 //#endregion
 //#region ---- Runtime resolution ----
 /**
  * Resolves an entity row title using entity-driven fallback templates and property paths.
  */
-async function resolveEntitySearchTitleFallback(format, data, locale, translationService, formatService, expressionEvaluator) {
+async function resolveEntitySearchTitleFallback(format, data, locale, translationService, formatService, expressionEvaluator, contextEvalFactory) {
     if (data == null) {
         return '';
     }
     for (const template of format.titleFallbackTemplates ?? []) {
-        const resolved = await resolveSearchDisplayTemplate(template, data, locale, translationService, formatService, expressionEvaluator);
+        const resolved = await resolveSearchDisplayTemplate(template, data, locale, translationService, formatService, expressionEvaluator, contextEvalFactory);
         const text = sanitizeResolvedEntityDisplayTitle(typeof resolved === 'string'
             ? resolved
             : resolveSearchableText(resolved, locale, translationService));
@@ -5076,13 +5237,8 @@ function resolveSearchableText(value, locale, translationService) {
         }
         return trimmed;
     }
-    if (isLocaleStringMap(value)) {
-        return Object.values(value)
-            .filter((entry) => (entry ?? '').trim() !== '')
-            .join(' ');
-    }
-    if (translationService.isValidMultiLanguageObject(value)) {
-        return resolveMultiLanguageString(value, locale);
+    if (isLocaleStringMap(value) || translationService.isValidMultiLanguageObject(value)) {
+        return resolveMultiLanguageString(value, locale).trim();
     }
     return '';
 }
@@ -5094,6 +5250,11 @@ function searchInSearchableValue(value, query, locale, translationService) {
     if (!q) {
         return true;
     }
+    if (isLocaleStringMap(value)) {
+        return Object.values(value)
+            .filter((entry) => typeof entry === 'string' && entry.trim() !== '')
+            .some((entry) => entry.toLocaleLowerCase(locale).includes(q));
+    }
     const text = resolveSearchableText(value, locale, translationService).toLocaleLowerCase(locale);
     return text.includes(q);
 }
@@ -5126,26 +5287,31 @@ function searchInRecordValues(value, query, locale, translationService, depth =
 function countMustacheExpressions(template) {
     return (template.match(/\{\{/g) ?? []).length;
 }
-/** Standard row scope for entity title/search templates. */
-function createEntityRowExpressionScope(data) {
+/** Standard display-tier row scope for entity title/search templates. */
+function createEntityRowExpressionScope(data, contextEvalFactory) {
     return {
-        context: {
-            eval: (path) => get(data, path),
-        },
+        context: contextEvalFactory.createScope((data ?? {})),
     };
 }
+/**
+ * Coerces an evaluated display segment to plain text.
+ * Piped eval returns strings; unpiped MLS still resolves via compat fallback.
+ */
+function formatDisplaySegment(segment, locale, translationService) {
+    if (segment === false || segment == null) {
+        return '';
+    }
+    if (isString(segment)) {
+        return segment.trim();
+    }
+    return resolveSearchableText(segment, locale, translationService);
+}
 /**
  * Evaluates a normalized entity display template via {@link AXPExpressionEvaluatorService}.
  */
-async function evaluateEntityDisplayTemplate(template, data, expressionEvaluator, locale, translationService) {
+async function evaluateEntityDisplayTemplate(template, data, expressionEvaluator, locale, translationService, contextEvalFactory) {
     const normalized = normalizeEntityDisplayTemplate(template);
-    const scope = createEntityRowExpressionScope(data);
-    const formatSegment = (segment) => {
-        if (segment === false || segment == null) {
-            return '';
-        }
-        return resolveSearchableText(segment, locale, translationService);
-    };
+    const scope = createEntityRowExpressionScope(data, contextEvalFactory);
     if (!normalized.includes('{{')) {
         return normalized;
     }
@@ -5159,7 +5325,7 @@ async function evaluateEntityDisplayTemplate(template, data, expressionEvaluator
     for (const match of normalized.matchAll(regex)) {
         result += normalized.slice(lastIndex, match.index);
         const segment = await expressionEvaluator.evaluate(`{{ ${match[1].trim()} }}`, scope);
-        result += formatSegment(segment);
+        result += formatDisplaySegment(segment, locale, translationService);
         lastIndex = (match.index ?? 0) + match[0].length;
     }
     result += normalized.slice(lastIndex);
@@ -5206,7 +5372,7 @@ function resolveQueryMatchingDisplayText(value, query, locale, translationServic
 /**
  * Resolves entity search display templates; coerces multi-language field values to readable text.
  */
-async function resolveSearchDisplayTemplate(template, data, locale, translationService, formatService, expressionEvaluator) {
+async function resolveSearchDisplayTemplate(template, data, locale, translationService, formatService, expressionEvaluator, contextEvalFactory) {
     if (!template) {
         return '';
     }
@@ -5217,7 +5383,7 @@ async function resolveSearchDisplayTemplate(template, data, locale, translationS
         const formatted = formatService.format(template, 'string', data);
         return sanitizeResolvedEntityDisplayTitle(typeof formatted === 'string' ? formatted : String(formatted ?? ''));
     }
-    const evaluated = await evaluateEntityDisplayTemplate(template, data, expressionEvaluator, locale, translationService);
+    const evaluated = await evaluateEntityDisplayTemplate(template, data, expressionEvaluator, locale, translationService, contextEvalFactory);
     return sanitizeResolvedEntityDisplayTitle(resolveSearchableText(evaluated, locale, translationService));
 }
 //#endregion
@@ -5242,6 +5408,7 @@ class AXPSearchService {
         this.formatService = inject(AXFormatService);
         this.translationService = inject(AXTranslationService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.contextEvalFactory = inject(AXPContextEvalFactory);
     }
     async search(text) {
         //TODO better handle this
@@ -5271,20 +5438,23 @@ class AXPSearchService {
         for (const resultArray of results) {
             for (const result of resultArray) {
                 try {
-                    const definition = this.definitionService.findDefinition(result.group);
+                    const definition = await this.definitionService.findDefinitionAsync(result.group);
+                    if (!definition) {
+                        continue;
+                    }
                     const resolvedTitle = result.title ??
                         (definition.format.title
-                            ? await resolveSearchDisplayTemplate(definition.format.title, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator)
+                            ? await resolveSearchDisplayTemplate(definition.format.title, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator, this.contextEvalFactory)
                             : '');
                     const resolvedDescription = result.description ??
                         (definition.format.description
-                            ? await resolveSearchDisplayTemplate(definition.format.description, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator)
+                            ? await resolveSearchDisplayTemplate(definition.format.description, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator, this.contextEvalFactory)
                             : undefined);
                     let titleText = sanitizeResolvedEntityDisplayTitle(typeof resolvedTitle === 'string'
                         ? resolvedTitle
                         : resolveSearchableText(resolvedTitle, locale, this.translationService));
                     if (!isMeaningfulEntityDisplayTitle(titleText)) {
-                        titleText = await resolveEntitySearchTitleFallback(definition.format, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator);
+                        titleText = await resolveEntitySearchTitleFallback(definition.format, result.data, locale, this.translationService, this.formatService, this.expressionEvaluator, this.contextEvalFactory);
                     }
                     if (!isMeaningfulEntityDisplayTitle(titleText)) {
                         continue;
@@ -5779,62 +5949,1116 @@ function axpReplaceEntityListRouteQueryParams(router, queryParams) {
 }
 //#endregion
 
-//TODO Loading, Redirect, Drawer, Show toast
-const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
-const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
-const AXPReloadEvent = createWorkFlowEvent('Reload Event Fired');
-class AXPWorkflowNavigateAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.router = inject(Router);
+//#region ---- Tab Key ----
+/** Query params ignored when building a tab dedupe key. */
+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.
+ */
+function axpBuildTabKey(url) {
+    const normalized = normalizeRouterUrl(url);
+    const pathOnly = normalized.split('?')[0].split('#')[0];
+    return pathOnly;
+}
+/** Normalizes a router URL for storage and navigation. */
+function normalizeRouterUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed.length) {
+        return '/';
+    }
+    const withLeadingSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    const [pathAndFragment, queryString = ''] = withLeadingSlash.split('?');
+    const [pathPart, fragment = ''] = pathAndFragment.split('#');
+    const normalizedPath = pathPart.replace(/\/+$/, '') || '/';
+    const filteredQuery = filterQueryString(queryString);
+    let result = normalizedPath;
+    if (filteredQuery) {
+        result += `?${filteredQuery}`;
+    }
+    if (fragment) {
+        result += `#${fragment}`;
     }
-    async execute(context) {
-        const payload = context.getVariable('payload');
-        if (Array.isArray(payload.commands)) {
-            await this.router.navigate(payload.commands, payload.extras);
-            return;
-        }
-        const path = payload.commands;
-        if (!path) {
-            return;
-        }
-        if (path.toLowerCase().startsWith('http') || payload.target === 'blank') {
-            window.open(path, '_blank');
-            return;
-        }
-        await axpNavigateAppPath(this.router, path, payload.extras);
+    return result;
+}
+function filterQueryString(queryString) {
+    if (!queryString) {
+        return '';
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction }); }
+    const params = new URLSearchParams(queryString);
+    const kept = [];
+    params.forEach((value, key) => {
+        if (!IGNORED_QUERY_KEYS.has(key)) {
+            kept.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+        }
+    });
+    kept.sort();
+    return kept.join('&');
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPDialogConfirmAction extends AXPWorkflowAction {
+/** Human-readable fallback title from the URL path. */
+function axpFallbackTabTitle(url) {
+    const pathOnly = url.split('?')[0].split('#')[0];
+    const segments = pathOnly.split('/').filter(Boolean);
+    const last = defaultTo(segments[segments.length - 1], 'Page');
+    return decodeURIComponent(last);
+}
+//#endregion
+
+//#region ---- Types ----
+const AXP_HOME_TAB_KEY = 'axp:home';
+/** Route `data` key for tab-navigation behavior (`data.tab`). */
+const AXP_TAB_ROUTE_DATA_KEY = 'tab';
+//#endregion
+
+//#region ---- Tab Preview Service ----
+/**
+ * In-memory structured previews for tab hover cards and dirty indicators.
+ * Populated by active/cached pages via {@link AXPPageLayoutBaseComponent}.
+ */
+class AXPTabPreviewService {
     constructor() {
-        super(...arguments);
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-        this.defaultAction = 'cancel';
+        //#region ---- State ----
+        this.previewMap = signal({}, ...(ngDevMode ? [{ debugName: "previewMap" }] : /* istanbul ignore next */ []));
+        this.previews = this.previewMap.asReadonly();
     }
-    async execute(context) {
-        console.log('AXPDialogConfirmAction', this.title, this.message, this.type);
-        context.setOutput('result', false);
-        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync(this.title), await this.translationService.translateAsync(this.message), (await this.translationService.translateAsync(this.type)), 'horizontal', false, 'cancel');
-        context.setOutput('result', dialogResult.result);
+    //#endregion
+    //#region ---- Public API ----
+    setPreview(key, preview) {
+        this.previewMap.update((current) => ({
+            ...current,
+            [key]: preview,
+        }));
+    }
+    patchPreview(key, patch) {
+        this.previewMap.update((current) => {
+            const existing = current[key];
+            if (!existing) {
+                if (!patch.url) {
+                    return current;
+                }
+                return {
+                    ...current,
+                    [key]: {
+                        title: patch.title ?? '',
+                        url: patch.url,
+                        icon: patch.icon,
+                        subtitle: patch.subtitle,
+                        isDirty: patch.isDirty ?? false,
+                        breadcrumbTrail: patch.breadcrumbTrail ?? [],
+                    },
+                };
+            }
+            return {
+                ...current,
+                [key]: {
+                    ...existing,
+                    ...patch,
+                },
+            };
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPToastAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
-        this.settingsService = inject(AXPSettingsService);
+    getPreview(key) {
+        return this.previewMap()[key];
+    }
+    isTabDirty(key) {
+        return !!this.previewMap()[key]?.isDirty;
+    }
+    clearPreview(key) {
+        this.previewMap.update((current) => {
+            if (!(key in current)) {
+                return current;
+            }
+            const next = { ...current };
+            delete next[key];
+            return next;
+        });
+    }
+    clearPreviews(keys) {
+        const keySet = new Set(keys);
+        if (!keySet.size) {
+            return;
+        }
+        this.previewMap.update((current) => {
+            const next = { ...current };
+            let changed = false;
+            for (const key of keySet) {
+                if (key in next) {
+                    delete next[key];
+                    changed = true;
+                }
+            }
+            return changed ? next : current;
+        });
+    }
+    clearAll() {
+        this.previewMap.set({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabPreviewService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabPreviewService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabPreviewService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ---- Tab Route Policy ----
+const EXCLUDED_PATH_PREFIXES = ['/auth', '/error'];
+const EXCLUDED_PATH_PATTERNS = [
+    /^\/assessment\/fill\//i,
+    /^\/forms\//i,
+];
+/**
+ * Returns true when the URL represents an in-app page that may appear in the tab bar.
+ */
+function axpIsTabEligibleUrl(url) {
+    const pathOnly = url.split('?')[0].split('#')[0].trim();
+    if (!pathOnly || pathOnly === '/') {
+        return false;
+    }
+    const normalized = pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`;
+    if (EXCLUDED_PATH_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+        return false;
+    }
+    if (EXCLUDED_PATH_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    return true;
+}
+//#endregion
+
+//#region ---- Route Data ----
+/** True when the route declares itself as a scoped tab root (`data.tab = true`). */
+function axpHasTabScope(data) {
+    return data?.[AXP_TAB_ROUTE_DATA_KEY] === true;
+}
+//#endregion
+//#region ---- Snapshot Resolution ----
+/** Resolved URL path for a snapshot (no query or fragment). */
+function axpPathFromSnapshot(snapshot) {
+    const segments = snapshot.pathFromRoot
+        .flatMap((entry) => entry.url.map((segment) => segment.path))
+        .filter(Boolean);
+    return segments.length ? `/${segments.join('/')}` : '/';
+}
+/** Returns the leaf snapshot under the router state root. */
+function axpGetLeafRouteSnapshot(root) {
+    let route = root;
+    while (route.firstChild) {
+        route = route.firstChild;
+    }
+    return route;
+}
+/**
+ * Resolves the tab dedupe key from an activated route tree.
+ * Uses the nearest ancestor with `data.tab = true`; otherwise the leaf path.
+ */
+function axpResolveTabKeyFromSnapshot(leaf) {
+    const chain = leaf.pathFromRoot;
+    for (let index = chain.length - 1; index >= 0; index--) {
+        const snapshot = chain[index];
+        if (axpHasTabScope(snapshot.data)) {
+            return axpPathFromSnapshot(snapshot);
+        }
+    }
+    return axpPathFromSnapshot(leaf);
+}
+//#endregion
+//#region ---- Router / URL Resolution ----
+/**
+ * Resolves a tab key for the given URL (or the current router URL).
+ * Prefers the live route snapshot when it matches the target URL; otherwise matches route config.
+ */
+function axpResolveTabKey(router, url) {
+    const normalized = normalizeRouterUrl(url ?? router.url);
+    const pathOnly = normalized.split('?')[0].split('#')[0];
+    const currentPath = normalizeRouterUrl(router.url).split('?')[0].split('#')[0];
+    if (!url || pathOnly === currentPath) {
+        const leaf = axpGetLeafRouteSnapshot(router.routerState.snapshot.root);
+        return axpResolveTabKeyFromSnapshot(leaf);
+    }
+    const fromConfig = axpResolveTabKeyFromRouteConfig(router.config, pathOnly);
+    if (fromConfig) {
+        return fromConfig;
+    }
+    return pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`;
+}
+/**
+ * Matches a URL path against registered routes and resolves the tab key from `data.tab`.
+ */
+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, {}, []);
+    if (!chain?.length) {
+        return null;
+    }
+    for (let index = chain.length - 1; index >= 0; index--) {
+        const level = chain[index];
+        if (axpHasTabScope(level.mergedData)) {
+            return level.path;
+        }
+    }
+    return chain[chain.length - 1]?.path ?? null;
+}
+function matchRouteConfigChain(routes, segments, startIndex, inheritedData, chain) {
+    let bestMatch = null;
+    for (const route of routes) {
+        if (route.redirectTo) {
+            continue;
+        }
+        const segmentMatch = matchRoutePath(route.path ?? '', segments, startIndex);
+        if (!segmentMatch) {
+            continue;
+        }
+        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 nextChain = [...chain, level];
+        const nextIndex = startIndex + segmentMatch.consumed;
+        if (route.children?.length) {
+            const childMatch = matchRouteConfigChain(route.children, segments, nextIndex, mergedData, nextChain);
+            if (childMatch && (!bestMatch || childMatch.length > bestMatch.length)) {
+                bestMatch = childMatch;
+            }
+        }
+        if (nextIndex === segments.length) {
+            if (!bestMatch || nextChain.length > bestMatch.length) {
+                bestMatch = nextChain;
+            }
+        }
+    }
+    return bestMatch;
+}
+function matchRoutePath(routePath, segments, startIndex) {
+    if (routePath === '**') {
+        return { consumed: Math.max(0, segments.length - startIndex) };
+    }
+    const parts = routePath.split('/').filter(Boolean);
+    if (!parts.length) {
+        return { consumed: 0 };
+    }
+    let consumed = 0;
+    for (const part of parts) {
+        const segment = segments[startIndex + consumed];
+        if (segment === undefined) {
+            return null;
+        }
+        if (part.startsWith(':') || part === segment) {
+            consumed++;
+            continue;
+        }
+        return null;
+    }
+    return { consumed };
+}
+//#endregion
+
+//#region ---- Constants ----
+const SESSION_STORAGE_PREFIX = 'AXP_TAB_NAV';
+//#endregion
+class AXPTabNavigationService {
+    //#endregion
+    //#region ---- Lifecycle ----
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.router = inject(Router);
+        this.settingsService = inject(AXPSettingsService);
+        this.deviceService = inject(AXPDeviceService);
+        this.menuService = inject(AXPMenuService);
+        this.homePageService = inject(AXPHomePageService);
+        this.sessionService = inject(AXPSessionService);
+        this.routeCacheRegistry = inject(AXPTabRouteCacheRegistry);
+        this.tabPreviewService = inject(AXPTabPreviewService);
+        this.unsavedChangesConfirm = inject(AXPUnsavedChangesConfirmService);
+        this.destroyRef = inject(DestroyRef);
+        //#endregion
+        //#region ---- State ----
+        this.navigationMode = signal('simple', ...(ngDevMode ? [{ debugName: "navigationMode" }] : /* istanbul ignore next */ []));
+        this.maxOpenTabs = signal(5, ...(ngDevMode ? [{ debugName: "maxOpenTabs" }] : /* istanbul ignore next */ []));
+        this.tabs = signal([], ...(ngDevMode ? [{ debugName: "tabs" }] : /* istanbul ignore next */ []));
+        this.activeTabKey = signal(null, ...(ngDevMode ? [{ debugName: "activeTabKey" }] : /* istanbul ignore next */ []));
+        this.suppressNavigationSync = false;
+        //#endregion
+        //#region ---- Computed ----
+        /** Effective mode: mobile always uses simple navigation. */
+        this.effectiveMode = computed(() => {
+            if (this.deviceService.isSmall()) {
+                return 'simple';
+            }
+            return this.navigationMode();
+        }, ...(ngDevMode ? [{ debugName: "effectiveMode" }] : /* istanbul ignore next */ []));
+        this.isTabBarVisible = computed(() => this.effectiveMode() === 'tabular' && this.tabs().length > 0, ...(ngDevMode ? [{ debugName: "isTabBarVisible" }] : /* istanbul ignore next */ []));
+        this.tabList = this.tabs.asReadonly();
+        this.activeKey = this.activeTabKey.asReadonly();
+        void this.loadSettings();
+        this.bindRouterEvents();
+        this.bindSettingsChanges();
+        this.bindSessionChanges();
+        this.bindRouteCacheSync();
+    }
+    //#endregion
+    //#region ---- Public API ----
+    /** Navigates to a path, opening or activating a tab when tabular mode is active. */
+    async navigate(path, extras) {
+        const normalizedPath = normalizeRouterUrl(path);
+        if (this.effectiveMode() === 'simple' || !axpIsTabEligibleUrl(normalizedPath)) {
+            return axpNavigateAppPath(this.router, normalizedPath, extras);
+        }
+        await this.openOrActivateTab(normalizedPath);
+        return true;
+    }
+    /** Opens a tab or activates an existing tab with the same key. */
+    async openOrActivateTab(url, title) {
+        if (this.effectiveMode() === 'simple') {
+            await axpNavigateAppPath(this.router, url);
+            return;
+        }
+        const normalizedUrl = normalizeRouterUrl(url);
+        if (!axpIsTabEligibleUrl(normalizedUrl)) {
+            await axpNavigateAppPath(this.router, normalizedUrl);
+            return;
+        }
+        await this.ensureHomeTab();
+        if (this.isHomePageUrl(normalizedUrl)) {
+            await this.activateTabKey(AXP_HOME_TAB_KEY, normalizedUrl);
+            return;
+        }
+        const resolvedKey = axpResolveTabKey(this.router, normalizedUrl);
+        const existing = this.findTabForUrl(normalizedUrl);
+        if (existing) {
+            if (existing.key !== resolvedKey) {
+                this.migrateTabKey(existing.key, resolvedKey);
+            }
+            this.updateTabUrl(resolvedKey, normalizedUrl);
+            await this.activateTabKey(resolvedKey, normalizedUrl);
+            return;
+        }
+        // Navigate first so scoped tab keys (`data.tab`) resolve from the live route snapshot.
+        this.suppressNavigationSync = true;
+        try {
+            await axpNavigateAppPath(this.router, normalizedUrl);
+            const key = axpResolveTabKey(this.router);
+            const postNavExisting = this.findTabForUrl(normalizedUrl);
+            if (postNavExisting) {
+                if (postNavExisting.key !== key) {
+                    this.migrateTabKey(postNavExisting.key, key);
+                }
+                this.updateTabUrl(key, normalizedUrl);
+                this.touchTab(key);
+                this.activeTabKey.set(key);
+                this.persistSession();
+                return;
+            }
+            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
+     * the reuse strategy, so its state is preserved; this tab's cached instance is reattached when
+     * available instead of being re-rendered.
+     *
+     * @param suspendDeactivateGuard When true (default for tab switches), unsaved-changes prompts are
+     * skipped so switching tabs keeps a dirty page alive. Closing a tab passes false to keep the prompt.
+     */
+    async activateTabKey(key, urlOverride, suspendDeactivateGuard = true) {
+        const tab = this.tabs().find((item) => item.key === key);
+        if (!tab) {
+            return;
+        }
+        const targetUrl = urlOverride ?? tab.url;
+        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;
+            }
+        };
+        if (suspendDeactivateGuard) {
+            await this.routeCacheRegistry.runWithSuspendedDeactivateGuards(navigate);
+            return;
+        }
+        await navigate();
+    }
+    /** Closes a tab and navigates to a neighbor when the active tab is closed. */
+    async closeTab(key) {
+        await this.closeTabs([key]);
+    }
+    /** Closes every closable tab except the given key (pinned tabs are kept). */
+    async closeOtherTabs(keepKey) {
+        const keys = this.tabs()
+            .filter((tab) => tab.closable && !tab.pinned && tab.key !== keepKey)
+            .map((tab) => tab.key);
+        await this.closeTabs(keys);
+    }
+    /** Closes all closable tabs (pinned tabs are kept). */
+    async closeAllTabs() {
+        const keys = this.tabs()
+            .filter((tab) => tab.closable && !tab.pinned)
+            .map((tab) => tab.key);
+        await this.closeTabs(keys);
+    }
+    /** Toggles whether a tab stays pinned in the strip (home tab is always pinned). */
+    toggleTabPinned(key) {
+        if (key === AXP_HOME_TAB_KEY) {
+            return;
+        }
+        this.tabs.update((items) => {
+            const updated = items.map((tab) => {
+                if (tab.key !== key) {
+                    return tab;
+                }
+                const pinned = !tab.pinned;
+                return {
+                    ...tab,
+                    pinned,
+                    closable: !pinned,
+                };
+            });
+            return this.normalizeTabOrder(updated);
+        });
+        this.persistSession();
+    }
+    /**
+     * Reorders tabs after drag-and-drop. Home stays first; pinned and unpinned tabs cannot cross groups.
+     */
+    reorderTabs(previousIndex, currentIndex) {
+        if (previousIndex === currentIndex) {
+            return;
+        }
+        const items = this.tabs();
+        if (previousIndex < 0 || currentIndex < 0 || previousIndex >= items.length || currentIndex >= items.length) {
+            return;
+        }
+        const moving = items[previousIndex];
+        if (moving.key === AXP_HOME_TAB_KEY) {
+            return;
+        }
+        const lastPinnedIndex = this.getLastPinnedTabIndex(items);
+        let targetIndex = currentIndex;
+        if (moving.pinned) {
+            if (targetIndex === 0) {
+                return;
+            }
+            targetIndex = Math.max(1, Math.min(targetIndex, lastPinnedIndex));
+        }
+        else {
+            const firstUnpinnedIndex = lastPinnedIndex + 1;
+            if (firstUnpinnedIndex >= items.length) {
+                return;
+            }
+            targetIndex = Math.max(firstUnpinnedIndex, Math.min(targetIndex, items.length - 1));
+        }
+        if (previousIndex === targetIndex) {
+            return;
+        }
+        const next = [...items];
+        const [removed] = next.splice(previousIndex, 1);
+        next.splice(targetIndex, 0, removed);
+        this.tabs.set(next);
+        this.persistSession();
+    }
+    /** Updates a tab title from the current page chrome (e.g. breadcrumb trail). */
+    syncTabTitle(key, title) {
+        if (this.effectiveMode() === 'simple') {
+            return;
+        }
+        if (!this.tabs().some((tab) => tab.key === key)) {
+            return;
+        }
+        const normalized = title.trim();
+        if (!normalized || this.isGenericHomeTitle(normalized)) {
+            return;
+        }
+        this.updateTabTitle(key, normalized);
+    }
+    /** Updates a tab icon from the current page chrome or menu metadata. */
+    syncTabIcon(key, icon) {
+        if (this.effectiveMode() === 'simple') {
+            return;
+        }
+        if (!this.tabs().some((tab) => tab.key === key)) {
+            return;
+        }
+        const normalized = icon.trim();
+        if (!normalized) {
+            return;
+        }
+        this.updateTabIcon(key, normalized);
+    }
+    //#endregion
+    //#region ---- Bulk Tab Close ----
+    /** Closes multiple tabs in one update; navigates once when the active tab is closed. */
+    async closeTabs(keys) {
+        const uniqueKeys = [...new Set(keys)];
+        if (!uniqueKeys.length) {
+            return;
+        }
+        const closableKeySet = new Set(uniqueKeys.filter((key) => {
+            const tab = this.tabs().find((item) => item.key === key);
+            return !!tab?.closable && !tab.pinned;
+        }));
+        if (!closableKeySet.size) {
+            return;
+        }
+        const activeKey = this.activeTabKey();
+        const backgroundKeys = [...closableKeySet].filter((key) => key !== activeKey);
+        for (const key of backgroundKeys) {
+            if (!(await this.confirmBackgroundTabClose(key))) {
+                closableKeySet.delete(key);
+            }
+        }
+        if (!closableKeySet.size) {
+            return;
+        }
+        const currentTabs = this.tabs();
+        const wasActiveClosed = !!activeKey && closableKeySet.has(activeKey);
+        const closedActiveIndex = wasActiveClosed ? currentTabs.findIndex((item) => item.key === activeKey) : -1;
+        const nextTabs = currentTabs.filter((item) => !closableKeySet.has(item.key));
+        if (wasActiveClosed) {
+            const navigated = await this.navigateAwayBeforeClosingActiveTab(closedActiveIndex, nextTabs);
+            if (!navigated) {
+                return;
+            }
+        }
+        this.tabs.set(nextTabs);
+        this.tabPreviewService.clearPreviews(closableKeySet);
+        this.persistSession();
+    }
+    //#endregion
+    //#region ---- Tab Close Helpers ----
+    /**
+     * Prompts before closing a cached background tab. Uses the page's {@link AXPTabCloseConfirm}
+     * hook when available, otherwise falls back to the tab preview dirty flag.
+     */
+    async confirmBackgroundTabClose(key) {
+        const instance = this.routeCacheRegistry.getComponentInstance(key);
+        if (instance && typeof instance.onBeforeTabClose === 'function') {
+            return instance.onBeforeTabClose();
+        }
+        return this.unsavedChangesConfirm.confirmIfDirty(this.tabPreviewService.isTabDirty(key), {
+            approveLeaveOnConfirm: false,
+        });
+    }
+    //#endregion
+    //#region ---- Tab Close Navigation ----
+    /**
+     * Navigates away from the active tab before it is removed so canDeactivate runs while the tab is still visible.
+     * Returns false when navigation was cancelled (e.g. unsaved-changes confirmation declined).
+     */
+    async navigateAwayBeforeClosingActiveTab(closedActiveIndex, remainingTabs) {
+        const fallbackIndex = this.resolveFallbackTabIndex(closedActiveIndex, remainingTabs);
+        const fallback = fallbackIndex >= 0 ? remainingTabs[fallbackIndex] : undefined;
+        let targetKey;
+        let targetUrl;
+        if (fallback) {
+            targetKey = fallback.key;
+            targetUrl = fallback.url;
+        }
+        else {
+            await this.ensureHomeTab();
+            const home = this.tabs().find((item) => item.key === AXP_HOME_TAB_KEY);
+            if (!home) {
+                return false;
+            }
+            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;
+        }
+        this.activeTabKey.set(targetKey);
+        this.touchTab(targetKey);
+        return true;
+    }
+    /** Prefers the tab to the right after removal, then the tab to the left (browser-like). */
+    resolveFallbackTabIndex(closedIndex, remainingTabs) {
+        if (!remainingTabs.length) {
+            return -1;
+        }
+        if (closedIndex < remainingTabs.length) {
+            return closedIndex;
+        }
+        return closedIndex - 1;
+    }
+    //#endregion
+    //#region ---- Route Cache Sync ----
+    /**
+     * Keeps the route cache registry aligned with the current navigation mode and the set of open
+     * tabs. Cached page instances for closed/evicted tabs are destroyed by the registry.
+     */
+    bindRouteCacheSync() {
+        effect(() => {
+            this.routeCacheRegistry.setEnabled(this.effectiveMode() === 'tabular');
+            this.routeCacheRegistry.syncOpenKeys(this.tabs().map((tab) => tab.key), this.tabs().map((tab) => tab.url));
+        });
+    }
+    //#endregion
+    //#region ---- Router Sync ----
+    bindRouterEvents() {
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe((event) => {
+            void this.handleNavigationEnd(event.urlAfterRedirects);
+        });
+    }
+    async handleNavigationEnd(url) {
+        if (this.suppressNavigationSync) {
+            return;
+        }
+        if (this.effectiveMode() === 'simple') {
+            return;
+        }
+        const normalizedUrl = normalizeRouterUrl(url);
+        if (!axpIsTabEligibleUrl(normalizedUrl)) {
+            return;
+        }
+        await this.ensureHomeTab();
+        if (this.isHomePageUrl(normalizedUrl)) {
+            this.activateHomeTabForUrl(normalizedUrl);
+            return;
+        }
+        const key = axpResolveTabKey(this.router, normalizedUrl);
+        const existing = this.findTabForUrl(normalizedUrl);
+        if (existing) {
+            if (existing.key !== key) {
+                this.migrateTabKey(existing.key, key);
+            }
+            this.updateTabUrl(key, normalizedUrl);
+            this.touchTab(key);
+            this.activeTabKey.set(key);
+            this.persistSession();
+            return;
+        }
+        this.insertTab(this.createTabDescriptor(normalizedUrl, 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();
+    }
+    bindSettingsChanges() {
+        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();
+            }
+        });
+    }
+    bindSessionChanges() {
+        this.sessionService.user$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            void this.restoreSessionIfNeeded();
+        });
+    }
+    //#endregion
+    //#region ---- Tab Management ----
+    async ensureHomeTab() {
+        const homePath = this.resolveHomePath();
+        if (!homePath) {
+            return;
+        }
+        const homeUrl = normalizeRouterUrl(homePath);
+        const homeKey = AXP_HOME_TAB_KEY;
+        const existing = this.tabs().find((tab) => tab.key === homeKey);
+        if (existing) {
+            this.tabs.update((items) => items.map((tab) => tab.key === homeKey
+                ? {
+                    ...tab,
+                    url: homeUrl,
+                    title: this.isGenericHomeTitle(tab.title) ? this.resolveHomeTitle() : tab.title,
+                    icon: this.resolveTabIcon(homeUrl, 'fa-light fa-house'),
+                }
+                : tab));
+            return;
+        }
+        const now = Date.now();
+        const homeTab = {
+            key: homeKey,
+            url: homeUrl,
+            title: this.resolveHomeTitle(),
+            icon: this.resolveTabIcon(homeUrl, 'fa-light fa-house'),
+            pinned: true,
+            closable: false,
+            openedAt: now,
+            lastActivatedAt: now,
+        };
+        this.tabs.update((items) => this.normalizeTabOrder([homeTab, ...items.filter((tab) => tab.key !== homeKey)]));
+    }
+    insertTab(tab) {
+        if (this.isHomePageUrl(tab.url)) {
+            this.activateHomeTabForUrl(tab.url);
+            return;
+        }
+        this.tabs.update((items) => {
+            const withoutDuplicate = items.filter((item) => {
+                if (item.key === tab.key) {
+                    return false;
+                }
+                return axpResolveTabKey(this.router, item.url) !== tab.key;
+            });
+            return this.normalizeTabOrder([...withoutDuplicate, tab]);
+        });
+        this.enforceMaxTabs();
+    }
+    /** Home first; preserves session order for the remaining tabs. */
+    ensureHomeTabFirst(items) {
+        const home = items.find((tab) => tab.key === AXP_HOME_TAB_KEY);
+        const others = items.filter((tab) => tab.key !== AXP_HOME_TAB_KEY);
+        return home ? [home, ...others] : items;
+    }
+    getLastPinnedTabIndex(items) {
+        for (let index = items.length - 1; index >= 0; index -= 1) {
+            if (items[index]?.pinned) {
+                return index;
+            }
+        }
+        return 0;
+    }
+    /** Home first, then other pinned tabs, then unpinned tabs (stable by openedAt within each group). */
+    normalizeTabOrder(items) {
+        const home = items.find((tab) => tab.key === AXP_HOME_TAB_KEY);
+        const pinned = items.filter((tab) => tab.key !== AXP_HOME_TAB_KEY && tab.pinned);
+        const unpinned = items.filter((tab) => tab.key !== AXP_HOME_TAB_KEY && !tab.pinned);
+        const byOpenedAt = (a, b) => a.openedAt - b.openedAt;
+        return [...(home ? [home] : []), ...pinned.sort(byOpenedAt), ...unpinned.sort(byOpenedAt)];
+    }
+    enforceMaxTabs() {
+        const limit = this.maxOpenTabs();
+        let current = this.tabs();
+        while (current.length > limit) {
+            const evictionCandidate = [...current]
+                .filter((tab) => tab.closable && !tab.pinned && tab.key !== this.activeTabKey())
+                .filter((tab) => !this.tabPreviewService.isTabDirty(tab.key))
+                .sort((a, b) => a.lastActivatedAt - b.lastActivatedAt)[0];
+            if (!evictionCandidate) {
+                break;
+            }
+            current = current.filter((tab) => tab.key !== evictionCandidate.key);
+        }
+        this.tabs.set(current);
+    }
+    createTabDescriptor(url, title, keyOverride) {
+        const now = Date.now();
+        const key = keyOverride ?? axpResolveTabKey(this.router, url);
+        return {
+            key,
+            url,
+            title: title ?? this.resolveTabTitle(url),
+            icon: this.resolveTabIcon(url),
+            pinned: false,
+            closable: true,
+            openedAt: now,
+            lastActivatedAt: now,
+        };
+    }
+    /** Finds a tab by scoped key or legacy full-path key for the same URL. */
+    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 &&
+            (tab.key === resolvedKey || axpResolveTabKey(this.router, tab.url) === resolvedKey));
+    }
+    /** True when the URL is the configured application home page (e.g. dashboard). */
+    isHomePageUrl(url) {
+        const homeUrl = this.resolveHomeUrl();
+        if (!homeUrl) {
+            return false;
+        }
+        return normalizeRouterUrl(url) === homeUrl;
+    }
+    resolveHomeUrl() {
+        const homePath = this.resolveHomePath();
+        if (!homePath) {
+            return null;
+        }
+        return normalizeRouterUrl(homePath);
+    }
+    /** Activates the pinned home tab for a home-page URL instead of opening a duplicate tab. */
+    activateHomeTabForUrl(url) {
+        this.updateTabUrl(AXP_HOME_TAB_KEY, normalizeRouterUrl(url));
+        this.touchTab(AXP_HOME_TAB_KEY);
+        this.activeTabKey.set(AXP_HOME_TAB_KEY);
+        this.persistSession();
+    }
+    /** Drops non-home tabs that duplicate the home page URL after session restore. */
+    removeDuplicateHomeUrlTabs(tabs) {
+        const homeUrl = this.resolveHomeUrl();
+        if (!homeUrl) {
+            return tabs;
+        }
+        return tabs.filter((tab) => tab.key === AXP_HOME_TAB_KEY || normalizeRouterUrl(tab.url) !== homeUrl);
+    }
+    /** Rewrites a tab key when route-scope resolution changes (e.g. profile sub-routes). */
+    migrateTabKey(fromKey, toKey) {
+        if (fromKey === toKey) {
+            return;
+        }
+        if (this.activeTabKey() === fromKey) {
+            this.activeTabKey.set(toKey);
+        }
+        this.tabs.update((items) => {
+            const tab = items.find((item) => item.key === fromKey);
+            if (!tab) {
+                return items;
+            }
+            const without = items.filter((item) => item.key !== fromKey && item.key !== toKey);
+            return this.normalizeTabOrder([...without, { ...tab, key: toKey }]);
+        });
+    }
+    /** Collapses restored tabs that share the same scoped route key. */
+    normalizeRestoredTabKeys(tabs) {
+        const byResolvedKey = new Map();
+        for (const tab of tabs) {
+            if (tab.key === AXP_HOME_TAB_KEY) {
+                byResolvedKey.set(AXP_HOME_TAB_KEY, tab);
+                continue;
+            }
+            const resolvedKey = axpResolveTabKey(this.router, tab.url);
+            const normalized = { ...tab, key: resolvedKey };
+            const existing = byResolvedKey.get(resolvedKey);
+            if (!existing || normalized.lastActivatedAt > existing.lastActivatedAt) {
+                byResolvedKey.set(resolvedKey, normalized);
+            }
+        }
+        return [...byResolvedKey.values()];
+    }
+    updateTabUrl(key, url) {
+        this.tabs.update((items) => items.map((tab) => (tab.key === key ? { ...tab, url } : tab)));
+    }
+    updateTabTitle(key, title) {
+        this.tabs.update((items) => items.map((tab) => (tab.key === key && tab.title !== title ? { ...tab, title } : tab)));
+        this.persistSession();
+    }
+    updateTabIcon(key, icon) {
+        this.tabs.update((items) => items.map((tab) => (tab.key === key && tab.icon !== icon ? { ...tab, icon } : tab)));
+        this.persistSession();
+    }
+    touchTab(key) {
+        const now = Date.now();
+        this.tabs.update((items) => items.map((tab) => (tab.key === key ? { ...tab, lastActivatedAt: now } : tab)));
+    }
+    resolveTabTitle(url, fallback) {
+        const match = axpFindMenuItemByRoute(this.menuService.items(), url);
+        if (match?.item.text) {
+            return match.item.text;
+        }
+        return fallback ?? axpFallbackTabTitle(url);
+    }
+    resolveTabIcon(url, fallback = 'fa-light fa-window') {
+        const match = axpFindMenuItemByRoute(this.menuService.items(), url);
+        if (match?.item.icon?.trim()) {
+            return match.item.icon.trim();
+        }
+        return fallback;
+    }
+    resolveHomePath() {
+        const current = this.homePageService.getCurrent();
+        return current.path ? normalizeRouterUrl(current.path) : '';
+    }
+    resolveHomeTitle() {
+        const current = this.homePageService.getCurrent();
+        return current.title || 'Home';
+    }
+    isGenericHomeTitle(title) {
+        if (title === '@general:terms.interface.navigation.home') {
+            return true;
+        }
+        const homeTitle = this.resolveHomeTitle().trim();
+        return title === homeTitle;
+    }
+    async syncCurrentRouteAsTab() {
+        if (this.effectiveMode() === 'simple') {
+            return;
+        }
+        await this.ensureHomeTab();
+        await this.handleNavigationEnd(this.router.url);
+    }
+    normalizeMaxTabs(value) {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed)) {
+            return 5;
+        }
+        return Math.min(20, Math.max(2, Math.round(parsed)));
+    }
+    //#endregion
+    //#region ---- Session Persistence ----
+    sessionStorageKey() {
+        const userId = this.sessionService.user?.id;
+        if (!userId) {
+            return null;
+        }
+        return `${SESSION_STORAGE_PREFIX}(${userId})`;
+    }
+    persistSession() {
+        const key = this.sessionStorageKey();
+        if (!key || this.effectiveMode() === 'simple') {
+            return;
+        }
+        const payload = {
+            tabs: cloneDeep(this.tabs()),
+            activeTabKey: this.activeTabKey(),
+        };
+        sessionStorage.setItem(key, JSON.stringify(payload));
+    }
+    clearSession() {
+        const key = this.sessionStorageKey();
+        if (key) {
+            sessionStorage.removeItem(key);
+        }
+        this.tabs.set([]);
+        this.activeTabKey.set(null);
+        this.tabPreviewService.clearAll();
+    }
+    async restoreSessionIfNeeded() {
+        if (this.effectiveMode() === 'simple') {
+            return;
+        }
+        const storageKey = this.sessionStorageKey();
+        if (!storageKey) {
+            await this.ensureHomeTab();
+            await this.syncCurrentRouteAsTab();
+            return;
+        }
+        const raw = sessionStorage.getItem(storageKey);
+        if (!raw) {
+            await this.ensureHomeTab();
+            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)));
+            this.tabs.set(this.ensureHomeTabFirst(restoredTabs));
+            await this.ensureHomeTab();
+            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);
+            if (activeTab && normalizeRouterUrl(this.router.url) !== normalizeRouterUrl(activeTab.url)) {
+                this.suppressNavigationSync = true;
+                try {
+                    await this.router.navigateByUrl(activeTab.url);
+                }
+                finally {
+                    this.suppressNavigationSync = false;
+                }
+            }
+        }
+        catch {
+            await this.ensureHomeTab();
+            await this.syncCurrentRouteAsTab();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabNavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabNavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTabNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//TODO Loading, Redirect, Drawer, Show toast
+const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
+const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
+const AXPReloadEvent = createWorkFlowEvent('Reload Event Fired');
+class AXPWorkflowNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
+        this.tabNavigation = inject(AXPTabNavigationService);
+    }
+    async execute(context) {
+        const payload = context.getVariable('payload');
+        if (Array.isArray(payload.commands)) {
+            await this.router.navigate(payload.commands, payload.extras);
+            return;
+        }
+        const path = payload.commands;
+        if (!path) {
+            return;
+        }
+        if (path.toLowerCase().startsWith('http') || payload.target === 'blank') {
+            window.open(path, '_blank');
+            return;
+        }
+        await this.tabNavigation.navigate(path, payload.extras);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPDialogConfirmAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
+        this.defaultAction = 'cancel';
+    }
+    async execute(context) {
+        console.log('AXPDialogConfirmAction', this.title, this.message, this.type);
+        context.setOutput('result', false);
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync(this.title), await this.translationService.translateAsync(this.message), (await this.translationService.translateAsync(this.type)), 'horizontal', false, 'cancel');
+        context.setOutput('result', dialogResult.result);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+        this.settingsService = inject(AXPSettingsService);
     }
     async execute(context) {
         const showResult = await this.settingsService.get(AXPCommonSettings.EnableOperationToasts);
@@ -5869,7 +7093,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
     constructor() {
         super(...arguments);
-        this.router = inject(Router);
+        this.tabNavigation = inject(AXPTabNavigationService);
     }
     async execute(context) {
         const command = context.getVariable();
@@ -5882,7 +7106,7 @@ class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
             window.open(path, '_blank');
         }
         else {
-            await axpNavigateAppPath(this.router, path, command.options.extras);
+            await this.tabNavigation.navigate(path, command.options.extras);
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRouterNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -5956,13 +7180,14 @@ class AXPCommonModule {
     /**
      * @ignore
      */
-    constructor(instances, _keyboardShortcutsHelp) {
+    constructor(instances, _keyboardShortcutsHelp, formatterRegistry) {
+        formatterRegistry.register(AXPTranslateFormatter);
         instances.forEach((f) => {
             f();
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPKeyboardShortcutsHelpService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, imports: [i2$1.AXPComponentSlotModule, i3$1.AXPWorkflowModule, AXPopupModule,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPKeyboardShortcutsHelpService }, { token: i2$1.AXFormatterRegistryService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPCommonModule, imports: [i3$1.AXPComponentSlotModule, i4$2.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule,
             AXPModuleManifestModule], exports: [RouterModule] }); }
@@ -6009,7 +7234,7 @@ class AXPCommonModule {
                 provide: AXP_SETTING_DEFINITION_PROVIDER,
                 useFactory: async () => {
                     const injector = inject(Injector);
-                    const provider = (await import('./acorex-platform-common-common-settings.provider-Ytey9uhY.mjs')).AXPCommonSettingProvider;
+                    const provider = (await import('./acorex-platform-common-common-settings.provider-ChoT4m4k.mjs')).AXPCommonSettingProvider;
                     return new provider(injector);
                 },
                 multi: true,
@@ -6110,7 +7335,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                             provide: AXP_SETTING_DEFINITION_PROVIDER,
                             useFactory: async () => {
                                 const injector = inject(Injector);
-                                const provider = (await import('./acorex-platform-common-common-settings.provider-Ytey9uhY.mjs')).AXPCommonSettingProvider;
+                                const provider = (await import('./acorex-platform-common-common-settings.provider-ChoT4m4k.mjs')).AXPCommonSettingProvider;
                                 return new provider(injector);
                             },
                             multi: true,
@@ -6120,7 +7345,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['AXPCommonModuleFactory']
-                }] }, { type: AXPKeyboardShortcutsHelpService }] });
+                }] }, { type: AXPKeyboardShortcutsHelpService }, { type: i2$1.AXFormatterRegistryService }] });
 
 const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
 const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
@@ -6335,18 +7560,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }] });
 
-/**
- * Status Definition Types
- * Defines the structure for status definitions and their transitions
- */
-/**
- * Abstract class for status providers
- * Similar to AXPTaskBadgeProvider pattern
- */
-class AXPStatusProvider {
-}
-//#endregion
-
 //#region ----   Injection Token   ----
 /**
  * Injection token for status providers
@@ -6558,356 +7771,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-/**
- * Standard system status types
- * These are the predefined status values used across the platform
- */
-var AXPSystemStatusType;
-(function (AXPSystemStatusType) {
-    AXPSystemStatusType["Todo"] = "todo";
-    AXPSystemStatusType["InProgress"] = "in-progress";
-    AXPSystemStatusType["InReview"] = "in-review";
-    AXPSystemStatusType["Open"] = "open";
-    AXPSystemStatusType["Closed"] = "closed";
-    AXPSystemStatusType["Blocked"] = "blocked";
-    AXPSystemStatusType["Done"] = "done";
-    AXPSystemStatusType["Cancelled"] = "cancelled";
-    AXPSystemStatusType["Draft"] = "draft";
-    AXPSystemStatusType["PendingReview"] = "pending-review";
-    AXPSystemStatusType["WaitingSignOff"] = "waiting-sign-off";
-    AXPSystemStatusType["WaitingApproval"] = "waiting-approval";
-    AXPSystemStatusType["Approved"] = "approved";
-    AXPSystemStatusType["Published"] = "published";
-    AXPSystemStatusType["Archived"] = "archived";
-    AXPSystemStatusType["Rejected"] = "rejected";
-    AXPSystemStatusType["Active"] = "active";
-    AXPSystemStatusType["Inactive"] = "inactive";
-    AXPSystemStatusType["Pending"] = "pending";
-    AXPSystemStatusType["Completed"] = "completed";
-    AXPSystemStatusType["Suspended"] = "suspended";
-    AXPSystemStatusType["Failed"] = "failed";
-    AXPSystemStatusType["Review"] = "review";
-    AXPSystemStatusType["Expired"] = "expired";
-})(AXPSystemStatusType || (AXPSystemStatusType = {}));
-const i18n = (key) => `@general:statuses.${key}`;
-/**
- * Standard system status definitions
- * Provides consistent status definitions across the platform
- * Uses AXPStatusDefinition interface from status-definition.types.ts
- */
-const AXPSystemStatuses = Object.freeze({
-    Open: {
-        name: AXPSystemStatusType.Open,
-        title: i18n('open.title'),
-        icon: 'fa-light fa-circle',
-        color: 'secondary',
-        description: i18n('open.description'),
-        order: 1,
-        isInitial: true,
-        isFinal: false,
-    },
-    Closed: {
-        name: AXPSystemStatusType.Closed,
-        title: i18n('closed.title'),
-        icon: 'fa-light fa-circle',
-        color: 'danger',
-        description: i18n('closed.description'),
-        order: 2,
-        isInitial: false,
-        isFinal: true,
-    },
-    Todo: {
-        name: AXPSystemStatusType.Todo,
-        title: i18n('todo.title'),
-        icon: 'fa-light fa-circle',
-        color: 'secondary',
-        description: i18n('todo.description'),
-        order: 1,
-        isInitial: true,
-        isFinal: false,
-    },
-    InProgress: {
-        name: AXPSystemStatusType.InProgress,
-        title: i18n('in-progress.title'),
-        icon: 'fa-light fa-play',
-        color: 'info',
-        description: i18n('in-progress.description'),
-        order: 2,
-        isInitial: false,
-        isFinal: false,
-    },
-    InReview: {
-        name: AXPSystemStatusType.InReview,
-        title: i18n('in-review.title'),
-        icon: 'fa-light fa-eye',
-        color: 'info',
-        description: i18n('in-review.description'),
-        order: 3,
-        isInitial: false,
-        isFinal: false,
-    },
-    Blocked: {
-        name: AXPSystemStatusType.Blocked,
-        title: i18n('blocked.title'),
-        icon: 'fa-light fa-ban',
-        color: 'danger',
-        description: i18n('blocked.description'),
-        order: 4,
-        isInitial: false,
-        isFinal: false,
-    },
-    Done: {
-        name: AXPSystemStatusType.Done,
-        title: i18n('done.title'),
-        icon: 'fa-light fa-check-circle',
-        color: 'success',
-        description: i18n('done.description'),
-        order: 5,
-        isInitial: false,
-        isFinal: true,
-    },
-    Cancelled: {
-        name: AXPSystemStatusType.Cancelled,
-        title: i18n('cancelled.title'),
-        icon: 'fa-light fa-times-circle',
-        color: 'neutral',
-        description: i18n('cancelled.description'),
-        order: 6,
-        isInitial: false,
-        isFinal: true,
-    },
-    Draft: {
-        name: AXPSystemStatusType.Draft,
-        title: i18n('draft.title'),
-        icon: 'fa-light fa-file-pen',
-        color: 'neutral',
-        description: i18n('draft.description'),
-        order: 1,
-        isInitial: true,
-        isFinal: false,
-    },
-    PendingReview: {
-        name: AXPSystemStatusType.PendingReview,
-        title: i18n('pending-review.title'),
-        icon: 'fa-light fa-clock',
-        color: 'warning',
-        description: i18n('pending-review.description'),
-        order: 2,
-        isInitial: false,
-        isFinal: false,
-    },
-    WaitingSignOff: {
-        name: AXPSystemStatusType.WaitingSignOff,
-        title: i18n('waiting-sign-off.title'),
-        icon: 'fa-light fa-clock',
-        color: 'warning',
-        description: i18n('waiting-sign-off.description'),
-        order: 3,
-        isInitial: false,
-        isFinal: false,
-    },
-    WaitingApproval: {
-        name: AXPSystemStatusType.WaitingApproval,
-        title: i18n('waiting-approval.title'),
-        icon: 'fa-light fa-clock',
-        color: 'warning',
-        description: i18n('waiting-approval.description'),
-        order: 1,
-        isInitial: true,
-        isFinal: false,
-    },
-    Approved: {
-        name: AXPSystemStatusType.Approved,
-        title: i18n('approved.title'),
-        icon: 'fa-light fa-check-circle',
-        color: 'success',
-        description: i18n('approved.description'),
-        order: 3,
-        isInitial: false,
-        isFinal: false,
-    },
-    Published: {
-        name: AXPSystemStatusType.Published,
-        title: i18n('published.title'),
-        icon: 'fa-light fa-globe',
-        color: 'primary',
-        description: i18n('published.description'),
-        order: 4,
-        isInitial: false,
-        isFinal: false,
-    },
-    Archived: {
-        name: AXPSystemStatusType.Archived,
-        title: i18n('archived.title'),
-        icon: 'fa-light fa-archive',
-        color: 'danger',
-        description: i18n('archived.description'),
-        order: 5,
-        isInitial: false,
-        isFinal: true,
-    },
-    Rejected: {
-        name: AXPSystemStatusType.Rejected,
-        title: i18n('rejected.title'),
-        icon: 'fa-light fa-times-circle',
-        color: 'danger',
-        description: i18n('rejected.description'),
-        order: 6,
-        isInitial: false,
-        isFinal: true,
-    },
-    Active: {
-        name: AXPSystemStatusType.Active,
-        title: i18n('active.title'),
-        icon: 'fa-light fa-check-circle',
-        color: 'success',
-        description: i18n('active.description'),
-        order: 1,
-        isInitial: false,
-        isFinal: false,
-    },
-    Inactive: {
-        name: AXPSystemStatusType.Inactive,
-        title: i18n('inactive.title'),
-        icon: 'fa-light fa-circle',
-        color: 'secondary',
-        description: i18n('inactive.description'),
-        order: 2,
-        isInitial: false,
-        isFinal: false,
-    },
-    Pending: {
-        name: AXPSystemStatusType.Pending,
-        title: i18n('pending.title'),
-        icon: 'fa-light fa-clock',
-        color: 'warning',
-        description: i18n('pending.description'),
-        order: 1,
-        isInitial: true,
-        isFinal: false,
-    },
-    Completed: {
-        name: AXPSystemStatusType.Completed,
-        title: i18n('completed.title'),
-        icon: 'fa-light fa-check-circle',
-        color: 'success',
-        description: i18n('completed.description'),
-        order: 10,
-        isInitial: false,
-        isFinal: true,
-    },
-    Suspended: {
-        name: AXPSystemStatusType.Suspended,
-        title: i18n('suspended.title'),
-        icon: 'fa-light fa-pause-circle',
-        color: 'neutral',
-        description: i18n('suspended.description'),
-        order: 5,
-        isInitial: false,
-        isFinal: false,
-    },
-    Failed: {
-        name: AXPSystemStatusType.Failed,
-        title: i18n('failed.title'),
-        icon: 'fa-light fa-xmark-circle',
-        color: 'danger',
-        description: i18n('failed.description'),
-        order: 10,
-        isInitial: false,
-        isFinal: true,
-    },
-    Review: {
-        name: AXPSystemStatusType.Review,
-        title: i18n('review.title'),
-        icon: 'fa-light fa-eye',
-        color: 'info',
-        description: i18n('review.description'),
-        order: 3,
-    },
-    Expired: {
-        name: AXPSystemStatusType.Expired,
-        title: i18n('expired.title'),
-        icon: 'fa-light fa-clock',
-        color: 'danger',
-        description: i18n('expired.description'),
-        order: 10,
-        isInitial: false,
-        isFinal: true,
-    },
-});
-/**
- * Get system status definition by type
- * @param type - Status type
- * @returns System status definition or undefined
- */
-function getSystemStatus(type) {
-    return Object.values(AXPSystemStatuses).find(status => status.name === type);
-}
-/**
- * Resolves the visual appearance (color and icon) for status
- * using the system statuses from the core module.
- * @param statusType - Status type string
- * @returns Color and icon for the status
- */
-function resolveStatusLook(statusType) {
-    // Try to get system status first
-    const systemStatusType = statusType;
-    if (systemStatusType) {
-        const systemStatus = getSystemStatus(systemStatusType);
-        if (systemStatus) {
-            // Convert hex color to semantic color type if needed
-            // For now, return as-is and let the UI handle it
-            return {
-                color: systemStatus.color,
-                icon: systemStatus.icon || ''
-            };
-        }
-    }
-    // Fallback for unknown statuses
-    return {
-        color: 'secondary',
-        icon: ''
-    };
-}
-/**
- * Resolves the complete status information (title, description, icon, color) for a status
- * using the system statuses from the core module.
- * @param statusType - Status type string
- * @returns Complete status information as AXPStatusDefinition
- */
-function getStatusInfo(statusType) {
-    const systemStatusType = statusType;
-    if (systemStatusType) {
-        const systemStatus = getSystemStatus(systemStatusType);
-        if (systemStatus) {
-            return systemStatus;
-        }
-    }
-    // Fallback for unknown statuses
-    return {
-        name: statusType,
-        title: statusType,
-        description: `Status: ${statusType}`,
-        icon: '',
-        color: 'secondary'
-    };
-}
-/**
- * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
- * @param statusType - Status type
- * @param overrides - Optional overrides for the status definition
- * @returns AXPStatusDefinition
- */
-function systemStatusToDefinition(statusType, overrides) {
-    const systemStatus = getSystemStatus(statusType);
-    if (!systemStatus) {
-        throw new Error(`System status ${statusType} not found`);
-    }
-    return {
-        ...systemStatus,
-        ...overrides,
-    };
-}
+//#region ---- Types ----
+//#endregion
 
 class AXPClipBoardService {
     constructor() {
@@ -7590,5 +8455,5 @@ class AXPVersioningService {
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPBackgroundOperationCompletionService, AXPBackgroundOperationEntityStoreService, AXPBackgroundOperationHandler, AXPBackgroundOperationNotificationService, AXPBackgroundOperationProvider, AXPBackgroundOperationRootConfig, AXPBackgroundOperationService, AXPBackgroundOperationSlotComponent, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPEntityType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPlatformCommonDataSourceKeys, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalCalendarService, AXPRegionalSetting, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsEvaluatorScopeProvider, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPStickyDirective, AXPSystemStatusType, AXPSystemStatuses, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPUnsavedChangesConfirmService, AXPUnsavedChangesPopstateService, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, 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_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_LOCALE_MANAGEMENT_PORT, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_NOT_FOUND_CATCH_ALL_ROUTE, AXP_NOT_FOUND_ROUTE, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_PROTECTED_ROUTE_GUARDS, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TOKEN_DEFINITION_PROVIDER, AXP_UNAUTHORIZED_ROUTE, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENTITY_LAYOUT_SINGLE_TITLE_PATH, ENTITY_ROW_POPUP_TITLE_OPTION, ENTITY_ROW_TITLE_TEMPLATE_OPTION, ENVIRONMENT, EQ_OPER, 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, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationToEntityModel, axpBuildBackgroundOperation, axpCoerceBackgroundOperationDate, axpCreateBackgroundOperationId, axpFindMenuItemByRoute, axpIsActiveBackgroundOperationStatus, axpIsCompletedBackgroundOperationStatus, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpMenuPathsMatch, axpNavigateAppPath, axpParseAppPath, axpRedirectToNotFound, axpRedirectToUnauthorized, axpReplaceEntityListRouteQueryParams, backgroundOperationEntityFactory, buildEntitySearchTitleContext, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createAllQueryView, createBackgroundOperationStore, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createQueryView, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, findManualPresetIdByOperation, formatEntityRowDisplayTitle, getEntityInfo, getStatusInfo, getSystemStatus, inferSettingCoercionKind, isCardFieldBadgeDisplay, isMeaningfulEntityDisplayTitle, isUnresolvedEntityDisplayTemplate, normalizeEntityDisplayTemplate, normalizePositiveNumberOption, peelSettingValueKey, printGraphicFromElement, provideDynamicHomePage, provideMenuMiddleware, resolveCardFieldBadgeColor, resolveDateFilterPresets, resolveDefaultMasterListLayout, resolveEnabledMasterListLayouts, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntityRowTitleTemplate, resolveEntitySearchTitleFallback, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, resolveStatusLook, sanitizeResolvedEntityDisplayTitle, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, systemStatusToDefinition, triggerBrowserDownload, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPBackgroundOperationCompletionService, AXPBackgroundOperationEntityStoreService, AXPBackgroundOperationHandler, AXPBackgroundOperationNotificationService, AXPBackgroundOperationProvider, AXPBackgroundOperationRootConfig, AXPBackgroundOperationService, AXPBackgroundOperationSlotComponent, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDebugService, AXPDefaultMultiLanguageConfigService, AXPDialogConfirmAction, AXPErrorHandlerRegistryService, AXPExportService, AXPFileActionsService, AXPFileStorageEvaluatorScopeProvider, AXPFileStorageService, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPHomePageModule, AXPHomePageService, AXPKeyboardShortcutsHelpComponent, AXPKeyboardShortcutsHelpService, AXPLockService, AXPMenuItemsDataSourceDefinition, AXPMenuKeyboardShortcutService, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuRouteAccessService, AXPMenuRouteGuard, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPMenuVisibilityService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPNotFoundCatchAllRoute, AXPNotFoundError, AXPOutputContractTranscriptSegmentService, AXPPlatformCommonDataSourceKeys, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalCalendarService, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingsEvaluatorScopeProvider, AXPSettingsService, AXPStatusDefinitionProviderService, AXPStickyDirective, AXPTabNavigationService, AXPTabPreviewService, AXPTabRouteCacheRegistry, AXPToastAction, AXPTokenDefinitionService, AXPTokenEvaluatorScopeProvider, AXPTranslateFormatter, AXPUnsavedChangesConfirmService, AXPUnsavedChangesPopstateService, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, 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_FILE_ACTION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_HOME_TAB_KEY, AXP_IN_APP_NOTIFICATION_SERVICE, AXP_LOCALE_MANAGEMENT_PORT, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_NOT_FOUND_CATCH_ALL_ROUTE, AXP_NOT_FOUND_ROUTE, AXP_OUTPUT_CONTRACT_TRANSCRIPT_SEGMENT_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_PROTECTED_ROUTE_GUARDS, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_LAZY_RESOLVER, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TAB_ROUTE_DATA_KEY, AXP_TOKEN_DEFINITION_PROVIDER, AXP_UNAUTHORIZED_ROUTE, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, DEFAULT_DATE_FILTER_PRESETS, DEFAULT_MULTILANGUAGE_FIELD_NAMES, ENDS_WITH_OPER, ENTITY_LAYOUT_SINGLE_TITLE_PATH, ENTITY_ROW_POPUP_TITLE_OPTION, ENTITY_ROW_TITLE_TEMPLATE_OPTION, ENVIRONMENT, EQ_OPER, 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, STARTS_WITH_OPER, STRING_OPERATORS, UploadFromComputerActionProvider, applyDateFilterPreset, axpBackgroundOperationCapabilities, axpBackgroundOperationDisplayTime, axpBackgroundOperationEntityName, axpBackgroundOperationEstimateEndDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationFromEntityModel, axpBackgroundOperationRemainingMs, axpBackgroundOperationToEntityModel, axpBuildBackgroundOperation, axpBuildTabKey, axpCoerceBackgroundOperationDate, axpCreateBackgroundOperationId, axpFallbackTabTitle, axpFindMenuItemByRoute, axpGetLeafRouteSnapshot, axpHasTabScope, axpIsActiveBackgroundOperationStatus, axpIsCompletedBackgroundOperationStatus, axpIsEntityDetailsPath, axpIsEntityDetailsViewRoute, axpIsEntityListPath, axpIsEntityListRoute, axpIsEntityRecordNotFound, axpIsTabEligibleUrl, axpMenuPathsMatch, axpNavigateAppPath, axpParseAppPath, axpPathFromSnapshot, axpRedirectToNotFound, axpRedirectToUnauthorized, axpReplaceEntityListRouteQueryParams, axpResolveTabKey, axpResolveTabKeyFromRouteConfig, axpResolveTabKeyFromSnapshot, backgroundOperationEntityFactory, buildEntitySearchTitleContext, coerceAXPSettingRawValue, coerceAXPSettingRawValueByKind, configPlatform, createBackgroundOperationStore, createEntityCommandOptions, createEntityRowExpressionScope, createEntitySearchCommand, createMenuContext, createMenuMiddleware, createUnsavedChangesCanDeactivateGuard, downloadGraphicFromElement, evaluateEntityDisplayTemplate, findManualPresetIdByOperation, formatEntityRowDisplayTitle, inferSettingCoercionKind, isMeaningfulEntityDisplayTitle, isUnresolvedEntityDisplayTemplate, normalizeEntityDisplayTemplate, normalizePositiveNumberOption, normalizeRouterUrl, peelSettingValueKey, printGraphicFromElement, provideDynamicHomePage, provideMenuMiddleware, resolveDateFilterPresets, resolveEntityModifyPopupTitle, resolveEntityModifyRecordTitleTemplate, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle, resolveEntityRowDisplayTitleFromColumnContext, resolveEntityRowTitleTemplate, resolveEntitySearchTitleFallback, resolveGraphicElementSize, resolveGraphicPrintContent, resolveQueryMatchingDisplayText, resolveSearchDisplayTemplate, resolveSearchableText, sanitizeResolvedEntityDisplayTitle, searchInRecordValues, searchInSearchableValue, serializeSvgElement, shouldApplyDefaultMultiLanguageToEntityProperty, shouldApplyDefaultMultiLanguageToWidgetNode, shouldApplyDefaultMultiLanguageToWidgetProperty, triggerBrowserDownload, withDefaultMultiLanguageOnWidgetNodeTree, withDefaultMultiLanguageOnWidgetProperty };
 //# sourceMappingURL=acorex-platform-common.mjs.map