@acorex/platform 21.0.0-next.8 → 21.0.0-next.83

package/fesm2022/acorex-platform-core.mjs

@@ -1,11 +1,29 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, computed, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, signal, output, DestroyRef, Renderer2, untracked, Injector, runInInjectionContext, provideAppInitializer, NgModule, Pipe } from '@angular/core';
+import { InjectionToken, inject, Injectable, Directive, computed, Injector, ChangeDetectionStrategy, Component, input, ElementRef, ViewContainerRef, signal, effect, runInInjectionContext, Optional, Inject, NgModule, EventEmitter, HostListener, Output, provideAppInitializer, Pipe } from '@angular/core';
+import { AXTranslationService, resolveMultiLanguageString } from '@acorex/core/translation';
+import { AXDataSource } from '@acorex/cdk/common';
+import { isPlainObject, get, set, isNil, isEmpty, isArray, merge, isObjectLike, transform, isEqual, differenceWith, union, cloneDeep, has, sortBy, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
-import { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, isEqual, differenceWith, union, cloneDeep, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
+import * as i1 from '@acorex/components/skeleton';
+import { AXSkeletonModule } from '@acorex/components/skeleton';
 import { Subject, interval, fromEvent } from 'rxjs';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { DOCUMENT } from '@angular/common';
+import { AXLocaleService } from '@acorex/core/locale';
 import { AXCalendarService } from '@acorex/core/date-time';
 import { startWith, map, debounceTime } from 'rxjs/operators';
 
+//#region ---- Datasource keys ----
+/** Platform core datasource registry names. */
+const AXPPlatformCoreDataSourceKeys = {
+    ModuleManifests: 'platform-module-manifests',
+    CatalogScopes: 'platform-catalog-scopes',
+};
+//#endregion
+
+//#region ---- Contracts barrel ----
+//#endregion
+
 const AXP_ACTIVITY_LOG_PROVIDER = new InjectionToken('AXP_ACTIVITY_LOGS_PROVIDER');
 class AXPActivityLogService {
     constructor() {
@@ -17,10 +35,10 @@ class AXPActivityLogService {
     async getHistoryByIds(refId, refType, ids) {
         return (await Promise.all(this.providers?.map((p) => p.getHistoryByIds(refId, refType, ids)) ?? [])).flat();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityLogService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityLogService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -28,6 +46,180 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 class AXPActivityLogProvider {
 }
 
+//#region ---- Catalog scope definition ----
+//#endregion
+
+//#region ---- Provider contract ----
+const AXP_CATALOG_SCOPE_DEFINITION_PROVIDER = new InjectionToken('AXP_CATALOG_SCOPE_DEFINITION_PROVIDER');
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Aggregator service ----
+/**
+ * Collects {@link AXPCatalogScopeDefinition} entries from all registered providers.
+ */
+class AXPCatalogScopeDefinitionProviderService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.providers = inject(AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, { optional: true });
+        this.translation = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        const merged = [];
+        const seen = new Set();
+        if (!Array.isArray(this.providers)) {
+            return merged;
+        }
+        for (const raw of this.providers) {
+            const provider = await Promise.resolve(raw);
+            if (!provider || typeof provider.items !== 'function') {
+                continue;
+            }
+            for (const item of await provider.items()) {
+                const name = item.name?.trim();
+                if (!name) {
+                    continue;
+                }
+                if (seen.has(name)) {
+                    throw new Error(`Duplicate catalog scope definition: "${name}"`);
+                }
+                seen.add(name);
+                merged.push(item);
+            }
+        }
+        return merged.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+    async get(name) {
+        const key = name?.trim();
+        if (!key) {
+            return undefined;
+        }
+        return (await this.items()).find((d) => d.name === key);
+    }
+    /**
+     * Scopes applicable to the given entity ref (`Module.Entity`).
+     */
+    async byTarget(entityRef) {
+        const target = entityRef?.trim();
+        if (!target) {
+            return [];
+        }
+        return (await this.items()).filter((d) => d.targets?.some((t) => t === target));
+    }
+    /**
+     * Resolves display title for a scope key (active locale).
+     */
+    resolveTitle(definition) {
+        const locale = this.translation.getActiveLang() ?? 'en-US';
+        if (typeof definition.title === 'string') {
+            const title = definition.title.trim();
+            if (title.startsWith('@')) {
+                return this.translation.translateSync(title) || title;
+            }
+            return title;
+        }
+        return resolveMultiLanguageString(definition.title, locale) || definition.name;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Data source definition ----
+/**
+ * Registered catalog scopes for select / selection-list widgets via {@link AXPPlatformCoreDataSourceKeys.CatalogScopes}.
+ */
+class AXPCatalogScopeDefinitionsDataSourceDefinition {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.catalogScopeRegistry = inject(AXPCatalogScopeDefinitionProviderService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        return [
+            {
+                name: AXPPlatformCoreDataSourceKeys.CatalogScopes,
+                title: 'Catalog scopes',
+                source: () => new AXDataSource({
+                    key: 'name',
+                    pageSize: 500,
+                    load: async (e) => {
+                        const all = await this.catalogScopeRegistry.items();
+                        const localeFilter = this.readTargetFilter(e?.filter);
+                        const items = all
+                            .filter((scope) => !localeFilter || scope.targets?.includes(localeFilter))
+                            .map((scope) => ({
+                            name: scope.name,
+                            title: this.catalogScopeRegistry.resolveTitle(scope),
+                            description: scope.description,
+                            targets: scope.targets,
+                            icon: scope.icon,
+                            cssClass: scope.cssClass,
+                        }));
+                        return { items, total: items.length };
+                    },
+                    byKey: async (key) => {
+                        const name = String(key ?? '').trim();
+                        if (!name) {
+                            return undefined;
+                        }
+                        const scope = await this.catalogScopeRegistry.get(name);
+                        if (!scope) {
+                            return undefined;
+                        }
+                        return {
+                            name: scope.name,
+                            title: this.catalogScopeRegistry.resolveTitle(scope),
+                            description: scope.description,
+                            targets: scope.targets,
+                            icon: scope.icon,
+                            cssClass: scope.cssClass,
+                        };
+                    },
+                }),
+                columns: [
+                    { name: 'name', title: 'Name', datatype: 'string', type: 'text-editor' },
+                    { name: 'title', title: 'Title', datatype: 'string', type: 'text-editor' },
+                ],
+                filters: [
+                    {
+                        field: 'targets',
+                        title: 'Target entity',
+                        operator: { type: 'contains' },
+                        widget: { type: 'text-editor' },
+                        filterType: { advance: false, inline: false },
+                    },
+                ],
+                textField: { name: 'title', title: 'Title' },
+                valueField: { name: 'name', title: 'Name' },
+            },
+        ];
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    readTargetFilter(filter) {
+        if (!filter || typeof filter !== 'object') {
+            return undefined;
+        }
+        const f = filter;
+        if (f.field === 'targets' && typeof f.value === 'string' && f.value.trim()) {
+            return f.value.trim();
+        }
+        return undefined;
+    }
+}
+//#endregion
+
 //#region ----   Color Palette Provider   ----
 /**
  * Abstract class for color palette providers
@@ -170,10 +362,10 @@ class AXPColorPaletteService {
         const uniquePalettes = allPalettes.filter((palette, index, self) => index === self.findIndex((p) => p.name === palette.name));
         this.cache = uniquePalettes;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPColorPaletteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPColorPaletteService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPColorPaletteService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -288,13 +480,277 @@ class AXPDefaultColorPalettesProvider extends AXPColorPaletteProvider {
             },
         ];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDefaultColorPalettesProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDefaultColorPalettesProvider }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDefaultColorPalettesProvider, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider, decorators: [{
             type: Injectable
         }] });
 
+//#region ----   Column Width Provider   ----
+/**
+ * Injection token for column width providers
+ * Use this to register multiple column width providers with multi: true
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: AXP_COLUMN_WIDTH_PROVIDER,
+ *     useValue: {
+ *       matchers: [
+ *         { name: 'title', width: '300px', priority: 10 },
+ *         { widgetType: /text-box/i, width: '200px' }
+ *       ],
+ *       priority: 150
+ *     },
+ *     multi: true
+ *   }
+ * ]
+ * ```
+ */
+const AXP_COLUMN_WIDTH_PROVIDER = new InjectionToken('AXP_COLUMN_WIDTH_PROVIDER');
+//#endregion
+
+//#region ----   Column Width Service   ----
+/**
+ * Service for resolving column widths based on registered providers
+ * Supports matching by column name (priority) and widget type (fallback)
+ * Uses multi-provider pattern for extensibility
+ */
+class AXPColumnWidthService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.providers = inject(AXP_COLUMN_WIDTH_PROVIDER, {
+            optional: true,
+        }) ?? [];
+    }
+    //#region ----   Public Methods   ----
+    /**
+     * Resolve width for a column based on registered providers
+     * Only returns a width if column doesn't already have one set
+     *
+     * @param column Column to resolve width for
+     * @returns Resolved width string (normalized) or undefined if no match or column already has width
+     */
+    resolveWidth(column) {
+        // If column already has a width set, don't override
+        const existingWidth = column.width || column.options?.width;
+        if (existingWidth) {
+            return undefined;
+        }
+        // Get widget type from column (support both widget.type and showAs.type)
+        const widgetType = column.widget?.type || column.showAs?.type;
+        // Collect all matchers from all providers
+        const allMatchers = this.collectMatchers();
+        // Try name-based matches first (higher priority)
+        const nameMatch = this.findNameMatch(column.name, allMatchers);
+        if (nameMatch) {
+            return this.normalizeWidth(nameMatch.width);
+        }
+        // Fallback to widget-type matches (case-insensitive)
+        if (widgetType) {
+            const widgetMatch = this.findWidgetTypeMatch(widgetType, allMatchers);
+            if (widgetMatch) {
+                return this.normalizeWidth(widgetMatch.width);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Apply resolved width to a column (mutates the column)
+     * Only applies if column doesn't already have a width
+     *
+     * @param column Column to apply width to
+     * @returns true if width was applied, false if column already had width or no match found
+     */
+    applyWidth(column) {
+        const width = this.resolveWidth(column);
+        if (!width) {
+            return false;
+        }
+        // Apply to the appropriate property
+        if (column.options) {
+            column.options.width = width;
+        }
+        else {
+            column.width = width;
+        }
+        return true;
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Collect all matchers from all providers, sorted by provider priority and matcher priority
+     */
+    collectMatchers() {
+        const allMatchers = [];
+        for (const provider of this.providers) {
+            const providerPriority = provider.priority ?? 100;
+            for (const matcher of provider.matchers) {
+                allMatchers.push({
+                    matcher,
+                    providerPriority,
+                });
+            }
+        }
+        // Sort by provider priority (descending), then by matcher priority (descending)
+        allMatchers.sort((a, b) => {
+            if (a.providerPriority !== b.providerPriority) {
+                return b.providerPriority - a.providerPriority; // Higher priority first
+            }
+            const priorityA = a.matcher.priority ?? 0;
+            const priorityB = b.matcher.priority ?? 0;
+            return priorityB - priorityA; // Higher priority first
+        });
+        return allMatchers;
+    }
+    /**
+     * Find first matching matcher by column name
+     * Name matches take precedence over widget type matches
+     */
+    findNameMatch(columnName, allMatchers) {
+        for (const { matcher } of allMatchers) {
+            if (!matcher.name) {
+                continue; // Skip if no name matcher
+            }
+            if (typeof matcher.name === 'string') {
+                // Exact string match (case-sensitive for names)
+                if (matcher.name === columnName) {
+                    return matcher;
+                }
+            }
+            else if (matcher.name instanceof RegExp) {
+                // RegExp match
+                if (matcher.name.test(columnName)) {
+                    return matcher;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find first matching matcher by widget type (case-insensitive)
+     */
+    findWidgetTypeMatch(widgetType, allMatchers) {
+        const widgetTypeLower = widgetType.toLowerCase();
+        for (const { matcher } of allMatchers) {
+            if (!matcher.widgetType) {
+                continue; // Skip if no widget type matcher
+            }
+            if (typeof matcher.widgetType === 'string') {
+                // Case-insensitive string match
+                if (matcher.widgetType.toLowerCase() === widgetTypeLower) {
+                    return matcher;
+                }
+            }
+            else if (matcher.widgetType instanceof RegExp) {
+                // RegExp match (should already be case-insensitive if needed, but we'll test case-insensitively)
+                // Create a new regex with case-insensitive flag if not already present
+                let regex = matcher.widgetType;
+                if (!regex.flags.includes('i')) {
+                    regex = new RegExp(regex.source, regex.flags + 'i');
+                }
+                if (regex.test(widgetType)) {
+                    return matcher;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Normalize width value to string format
+     * Numbers are converted to pixels (e.g., 150 -> '150px')
+     * Strings are preserved as-is (supports any CSS unit)
+     */
+    normalizeWidth(width) {
+        if (typeof width === 'number') {
+            return `${width}px`;
+        }
+        return width;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----   Column Width Types   ----
+//#endregion
+
+//#region ----   Default Column Width Provider   ----
+/**
+ * Default column width configuration
+ * Migrated from DEFAULT_COLUMN_WIDTHS in column-width.middleware.ts
+ * Provides sensible defaults for common column names
+ */
+const defaultColumnWidthProvider = {
+    priority: 100,
+    matchers: [
+        // Priority: name-based matches (higher priority = more specific)
+        { name: 'code', width: '150px', priority: 10 },
+        { name: 'name', width: '250px', priority: 10 },
+        { name: 'title', width: '250px', priority: 10 },
+        { name: 'description', width: '350px', priority: 10 },
+        { name: 'note', width: '350px', priority: 10 },
+        { name: 'notes', width: '350px', priority: 10 },
+        { name: 'content', width: '500px', priority: 10 },
+        { name: 'level', width: '100px', priority: 10 },
+        { name: 'order', width: '100px', priority: 10 },
+        { name: 'phones', width: '300px', priority: 10 },
+        { name: 'emails', width: '300px', priority: 10 },
+    ],
+};
+//#endregion
+
+class AXPComponentSlot {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlot, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPComponentSlot, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlot, decorators: [{
+            type: Directive
+        }] });
+
+//#region ---- Locale map shape ----
+/** Per-locale string map (`{ 'en-US': '...', 'fa-IR': '...' }`). */
+function isLocaleStringMap(value) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    const entries = Object.values(value);
+    if (entries.length === 0) {
+        return false;
+    }
+    return entries.every((entry) => entry === null || entry === undefined || typeof entry === 'string');
+}
+/**
+ * Use locale-map read/write when the option is on or live/saved data is already a map.
+ * Auto-enables when API data is a map but the editor option was left off.
+ */
+function shouldUseLocaleMapShape(localeMapOptionEnabled, current, saved) {
+    return localeMapOptionEnabled || isLocaleStringMap(current) || isLocaleStringMap(saved);
+}
+/** Updates one locale entry; preserves sibling locales from current or saved map. */
+function buildLocaleTextMapValue(current, saved, lang, input) {
+    const seed = isLocaleStringMap(current)
+        ? { ...current }
+        : isLocaleStringMap(saved)
+            ? { ...saved }
+            : {};
+    seed[lang] = input ?? '';
+    for (const key of Object.keys(seed)) {
+        if ((seed[key] ?? '').trim() === '') {
+            delete seed[key];
+        }
+    }
+    return Object.keys(seed).length === 0 ? null : seed;
+}
+//#endregion
+
 function extractNestedFieldsWildcard(obj, basePath, fields) {
     const result = {};
     if (fields.length === 1 && fields[0] === '*') {
@@ -313,7 +769,41 @@ function setSmart(obj, smartPath, value) {
     const lastPart = pathParts[pathParts.length - 1];
     const fieldMatch = lastPart.match(/^\{(.+)\}$/);
     if (!fieldMatch) {
+        // Fix: If value is undefined and we're setting a nested property,
+        // check if the parent object exists and if setting this would result in
+        // all properties being undefined. If so, set the parent to null instead.
+        if (isNil(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = get(obj, parentPath);
+            // If parent is already null/undefined, don't recreate the object structure
+            if (isNil(parentObj)) {
+                return obj;
+            }
+            // Check if parent is a plain object (not array, not null)
+            if (isPlainObject(parentObj)) {
+                const existingKeys = Object.keys(parentObj);
+                // Check if all existing properties are null/undefined using lodash
+                const allNil = isEmpty(existingKeys) || existingKeys.every((key) => isNil(parentObj[key]));
+                if (allNil) {
+                    // Set parent to null instead of creating/keeping an object with all undefined properties
+                    set(obj, parentPath, null);
+                    return obj;
+                }
+            }
+        }
         set(obj, smartPath, value);
+        // After setting, check again if parent should be null using lodash
+        if (isNil(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = get(obj, parentPath);
+            if (isPlainObject(parentObj)) {
+                // Use lodash to check if all properties are null/undefined
+                const allNil = Object.keys(parentObj).every((key) => isNil(parentObj[key]));
+                if (allNil) {
+                    set(obj, parentPath, null);
+                }
+            }
+        }
         return obj;
     }
     const fields = fieldMatch[1].split(',').map((f) => f.trim());
@@ -522,152 +1012,972 @@ function getDetailedChanges(obj1, obj2) {
 function getEnumValues(enumType) {
     return Object.entries(enumType).map(([key, value]) => ({ id: value, title: key }));
 }
-
-class AXPContextChangeEvent {
+//#region ---- Form value equality (dirty / baseline) ----
+/** Whether a value uses the multi-language text widget shape (string or locale map). */
+function isMultiLanguageFormShape(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return true;
+    }
+    return isLocaleStringMap(value);
 }
-const AXPContextStore = signalStore({
-    providedIn: 'root',
-}, 
-// Initial State
-withState(() => ({
-    data: {}, // Shared context data
-    state: 'initiated', // Current state
-    initialSnapshot: {}, // Snapshot of the first initialized state
-    previousSnapshot: {}, // Snapshot of the previous state
-    lastChange: {
-        state: 'initiated',
-    }, // Last change event
-})), 
-// Computed Signals
-withComputed(({ data, state, lastChange, initialSnapshot, previousSnapshot }) => ({
-    isChanged: computed(() => state() === 'changed'),
-    isReset: computed(() => state() === 'restored'),
-    isInitiated: computed(() => state() === 'initiated'),
-    isEmpty: computed(() => Object.keys(data()).length === 0),
-    isDirty: computed(() => !isEqual(data(), previousSnapshot())),
-    snapshot: computed(() => cloneDeep(data())), // Current data snapshot
-    initial: computed(() => cloneDeep(initialSnapshot())), // Initial snapshot
-    previous: computed(() => cloneDeep(previousSnapshot())), // Previous snapshot
-    changeEvent: computed(() => lastChange()), // Reactive last change event
-})), 
-// Methods for State Management
-withMethods((store) => ({
-    // Update a specific value
-    update(path, value) {
-        const currentData = cloneDeep(store.data());
-        const oldValue = getSmart(currentData, path);
-        // Skip if the value hasn't changed
-        if (isEqual(oldValue, value)) {
-            return;
+/** Drops empty/whitespace locale entries from a multi-language map. */
+function normalizeLocaleStringMap(value) {
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string') {
+            continue;
         }
-        // Update the value and prepare the change event
-        const updatedData = setSmart(currentData, path, value);
-        const changeEvent = {
-            oldValue,
-            newValue: value,
-            path,
-            state: 'changed',
-            data: updatedData,
-        };
-        // Patch the state
-        patchState(store, {
-            previousSnapshot: store.snapshot(), // Save the previous state
-            data: updatedData,
-            state: 'changed',
-            lastChange: changeEvent,
-        });
-    },
-    patch(context) {
-        const currentData = cloneDeep(store.data());
-        // Update the value and prepare the change event
-        const updatedData = { ...currentData, ...context };
-        const changeEvent = {
-            state: 'patch',
-            data: updatedData,
-        };
-        // Patch the state
-        patchState(store, {
-            previousSnapshot: store.snapshot(), // Save the previous state
-            data: updatedData,
-            state: 'changed',
-            lastChange: changeEvent,
-        });
-    },
-    // Reset to the initial state
-    reset() {
-        const initialData = store.initial();
-        const changeEvent = {
-            oldValue: cloneDeep(store.data()), // Current data becomes old value
-            newValue: cloneDeep(initialData), // Reset to the initial state
-            path: '',
-            state: 'restored',
-            data: initialData,
-        };
-        patchState(store, {
-            previousSnapshot: store.snapshot(), // Save the previous state
-            data: initialData,
-            state: 'restored',
-            lastChange: changeEvent,
-        });
-    },
-    // Initialize the state
-    set(initialData) {
-        const currentData = store.data();
-        if (isEqual(currentData, initialData)) {
-            return; // Skip if the current state matches the initial state
+        const trimmed = entry.trim();
+        if (trimmed !== '') {
+            normalized[key] = trimmed;
         }
-        const changeEvent = {
-            oldValue: null,
-            newValue: cloneDeep(initialData),
-            path: '',
-            state: 'initiated',
-            data: initialData,
-        };
-        patchState(store, {
-            initialSnapshot: cloneDeep(initialData), // Save the initial state
-            previousSnapshot: store.snapshot(), // Save the current state as the previous
-            data: initialData,
-            state: 'initiated',
-            lastChange: changeEvent,
-        });
-    },
-    // Get a specific value
-    getValue(path) {
-        return getSmart(store.data(), path);
-    },
-})));
-
-class AXPDataGenerator {
-    static uuid() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
-            const random = (Math.random() * 16) | 0;
-            const value = char === 'x' ? random : (random & 0x3) | 0x8;
-            return value.toString(16);
-        });
     }
-    static number(...args) {
-        let min = 0;
-        let max = 100;
-        if (args.length == 1)
-            max = args[0];
-        if (args.length == 2) {
-            min = args[0];
-            max = args[1];
-        }
-        return Math.floor(Math.random() * (max - min + 1)) + min;
+    return Object.keys(normalized).length === 0 ? null : normalized;
+}
+/**
+ * Compares multi-language field values (plain string vs locale map) for dirty/baseline checks.
+ * Returns `null` when either side is not a multi-language shape (caller uses generic normalization).
+ */
+function compareMultiLanguageFormValues(a, b) {
+    if (!isMultiLanguageFormShape(a) || !isMultiLanguageFormShape(b)) {
+        return null;
     }
-    static date(...args) {
-        let start = new Date(2000, 0, 1);
-        let end = new Date();
-        if (args.length === 1) {
-            start = args[0];
+    const normalizeScalar = (value) => {
+        if (value === null || value === undefined) {
+            return null;
         }
-        else if (args.length === 2) {
-            start = args[0];
-            end = args[1];
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed === '' ? null : trimmed;
         }
-        const startTime = start.getTime();
-        const endTime = end.getTime();
+        if (isLocaleStringMap(value)) {
+            return normalizeLocaleStringMap(value);
+        }
+        return null;
+    };
+    const left = normalizeScalar(a);
+    const right = normalizeScalar(b);
+    if (left === null && right === null) {
+        return true;
+    }
+    if (left === null || right === null) {
+        return false;
+    }
+    if (typeof left === 'string' && typeof right === 'string') {
+        return left === right;
+    }
+    if (typeof left === 'string' && typeof right === 'object') {
+        const values = Object.values(right);
+        return values.length > 0 && values.every((text) => text === left);
+    }
+    if (typeof right === 'string' && typeof left === 'object') {
+        const values = Object.values(left);
+        return values.length > 0 && values.every((text) => text === right);
+    }
+    if (typeof left !== 'object' || typeof right !== 'object') {
+        return false;
+    }
+    const leftMap = left;
+    const rightMap = right;
+    const leftKeys = Object.keys(leftMap).sort();
+    const rightKeys = Object.keys(rightMap).sort();
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => leftMap[key] === rightMap[key]);
+}
+/** Lookup/select filter-mode payload: `{ value, displayText?, operation }`. */
+function isFilterFormShape(value) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    const record = value;
+    return 'value' in record && 'operation' in record;
+}
+/**
+ * Compares filter-mode widget values by selection identity; ignores derived `displayText`.
+ */
+function compareFilterFormValues(a, b) {
+    if (!isFilterFormShape(a) || !isFilterFormShape(b)) {
+        return null;
+    }
+    const left = a;
+    const right = b;
+    if (!isFormValueEqual(left['value'], right['value'])) {
+        return false;
+    }
+    const opLeft = get(left, 'operation.type');
+    const opRight = get(right, 'operation.type');
+    if (opLeft !== undefined || opRight !== undefined) {
+        return opLeft === opRight;
+    }
+    return true;
+}
+function isReferenceScalar(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+/** Scalar id or `{ id }` identity used by lookup/select widgets. */
+function getReferenceId(value) {
+    if (isNil(value)) {
+        return undefined;
+    }
+    if (isReferenceScalar(value)) {
+        return value;
+    }
+    if (isPlainObject(value)) {
+        const id = get(value, 'id');
+        if (!isNil(id)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+/**
+ * Compares scalar selection ids to full lookup/select items (`5` vs `{ id: 5, ... }`).
+ * Does not apply when both sides are objects — those use structural compare so field edits stay dirty.
+ */
+function compareReferenceFormValues(a, b) {
+    const refA = getReferenceId(a);
+    const refB = getReferenceId(b);
+    if (refA === undefined || refB === undefined) {
+        return null;
+    }
+    const aIsScalar = isReferenceScalar(a);
+    const bIsScalar = isReferenceScalar(b);
+    if (!aIsScalar && !bIsScalar) {
+        return null;
+    }
+    return isEqual(normalizeFormValue(refA), normalizeFormValue(refB));
+}
+/**
+ * Semantic equality for lookup/select values when restoring saved baseline shape.
+ * Compares by selection identity (id), including two full items with the same id.
+ */
+function isSelectionValueEqual(a, b) {
+    const filterEqual = compareFilterFormValues(a, b);
+    if (filterEqual !== null) {
+        return filterEqual;
+    }
+    const refA = getReferenceId(a);
+    const refB = getReferenceId(b);
+    if (refA !== undefined && refB !== undefined) {
+        return isEqual(normalizeFormValue(refA), normalizeFormValue(refB));
+    }
+    return isFormValueEqual(a, b);
+}
+/**
+ * Stable sort key for order-insensitive array comparison (after normalization).
+ */
+function formValueSortKey(value) {
+    if (value === null) {
+        return '\0';
+    }
+    if (typeof value === 'number') {
+        return `n:${value}`;
+    }
+    if (typeof value === 'boolean') {
+        return `b:${value}`;
+    }
+    if (typeof value === 'string') {
+        return `s:${value}`;
+    }
+    try {
+        return `j:${JSON.stringify(value)}`;
+    }
+    catch {
+        return `u:${String(value)}`;
+    }
+}
+/**
+ * Sorts normalized array items so order does not affect dirty checks.
+ */
+function sortNormalizedArrayItems(items) {
+    return [...items].sort((a, b) => formValueSortKey(a).localeCompare(formValueSortKey(b)));
+}
+/**
+ * Normalizes a form/context value for semantic baseline comparison.
+ *
+ * Rules:
+ * - `null`, `undefined`, whitespace-only strings, and empty arrays → `null` (empty)
+ * - Numeric strings → numbers (`"5"` and `5` match)
+ * - Arrays → elements normalized; empty/all-empty → `null`; otherwise sorted (order ignored)
+ * - Plain objects → keys sorted; `null`/empty nested values omitted
+ * - `Date` → epoch milliseconds
+ */
+function normalizeFormValue(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return null;
+        }
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            const num = Number(trimmed);
+            if (!Number.isNaN(num)) {
+                return num;
+            }
+        }
+        return trimmed;
+    }
+    if (typeof value === 'number') {
+        return Number.isNaN(value) ? null : value;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (isArray(value)) {
+        const normalizedItems = value
+            .map((item) => normalizeFormValue(item))
+            .filter((item) => item !== null);
+        if (normalizedItems.length === 0) {
+            return null;
+        }
+        return sortNormalizedArrayItems(normalizedItems);
+    }
+    if (isPlainObject(value)) {
+        const record = value;
+        if (isLocaleStringMap(record)) {
+            return normalizeLocaleStringMap(record);
+        }
+        const normalized = {};
+        for (const key of Object.keys(record).sort()) {
+            const next = normalizeFormValue(record[key]);
+            if (next !== null) {
+                normalized[key] = next;
+            }
+        }
+        return normalized;
+    }
+    return value;
+}
+/**
+ * Semantic equality for dirty-state and baseline checks.
+ * Prefer over lodash `isEqual` when comparing user-edited form/context data to a saved baseline.
+ *
+ * Arrays: `[]`, `null`, and all-empty lists are equivalent; non-empty arrays compare as multisets (order ignored).
+ */
+function isFormValueEqual(a, b) {
+    const multiLanguageEqual = compareMultiLanguageFormValues(a, b);
+    if (multiLanguageEqual !== null) {
+        return multiLanguageEqual;
+    }
+    const filterEqual = compareFilterFormValues(a, b);
+    if (filterEqual !== null) {
+        return filterEqual;
+    }
+    const referenceEqual = compareReferenceFormValues(a, b);
+    if (referenceEqual !== null) {
+        return referenceEqual;
+    }
+    if (isArray(a) && isArray(b)) {
+        // Empty repeater rows normalize away; raw length must differ before multiset compare.
+        if (a.length !== b.length) {
+            return false;
+        }
+        return isEqual(normalizeFormValue(a), normalizeFormValue(b));
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const left = a;
+        const right = b;
+        const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+        for (const key of keys) {
+            if (!isFormValueEqual(left[key], right[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return isEqual(normalizeFormValue(a), normalizeFormValue(b));
+}
+/**
+ * Returns whether `current` differs from the saved/clean `baseline` snapshot.
+ */
+function isFormContextDirty(current, baseline) {
+    return !isFormValueEqual(current, baseline);
+}
+/**
+ * Clones a context object for use as a dirty-tracking baseline.
+ */
+function captureFormContextBaseline(context) {
+    return cloneDeep(context);
+}
+//#endregion
+
+class AXPContextChangeEvent {
+}
+//#endregion
+//#region ---- Context signal store ----
+const AXPContextStore = signalStore(withState(() => ({
+    data: {},
+    state: 'initiated',
+    /** Last committed / saved baseline — discard reverts to this snapshot. */
+    savedSnapshot: {},
+    previousSnapshot: {},
+    lastChange: {
+        state: 'initiated',
+    },
+})), withComputed(({ data, state, lastChange, savedSnapshot, previousSnapshot }) => ({
+    isChanged: computed(() => state() === 'changed'),
+    isReset: computed(() => state() === 'restored'),
+    isInitiated: computed(() => state() === 'initiated'),
+    isEmpty: computed(() => Object.keys(data()).length === 0),
+    isSavedCommitted: computed(() => !isEmpty(savedSnapshot())),
+    isDirty: computed(() => {
+        const saved = savedSnapshot();
+        if (isEmpty(saved)) {
+            return false;
+        }
+        return isFormContextDirty(data(), saved);
+    }),
+    snapshot: computed(() => cloneDeep(data())),
+    saved: computed(() => cloneDeep(savedSnapshot())),
+    /** @deprecated Use {@link saved} — only saved baseline is tracked. */
+    initial: computed(() => cloneDeep(savedSnapshot())),
+    previous: computed(() => cloneDeep(previousSnapshot())),
+    changeEvent: computed(() => lastChange()),
+})), withMethods((store) => {
+    const updateValue = (path, value, options) => {
+        const currentData = cloneDeep(store.data());
+        const oldValue = getSmart(currentData, path);
+        const hasSaved = !isEmpty(store.savedSnapshot());
+        const savedAtPath = hasSaved ? getSmart(store.savedSnapshot(), path) : undefined;
+        if (hasSaved && isSelectionValueEqual(value, savedAtPath) && !isEqual(value, savedAtPath)) {
+            value = cloneDeep(savedAtPath);
+        }
+        const isArrayLengthChange = Array.isArray(value) && (!Array.isArray(oldValue) || value.length !== oldValue.length);
+        if (!isArrayLengthChange && isEqual(oldValue, value)) {
+            return;
+        }
+        const shouldNormalizeSavedShape = hasSaved && isSelectionValueEqual(value, savedAtPath) && !isEqual(oldValue, value);
+        if (!isArrayLengthChange && isFormValueEqual(oldValue, value) && !shouldNormalizeSavedShape) {
+            return;
+        }
+        const origin = options?.origin ?? 'system';
+        const updatedData = setSmart(currentData, path, value);
+        const changeEvent = {
+            oldValue,
+            newValue: value,
+            path,
+            state: 'changed',
+            data: updatedData,
+            origin,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(),
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+        });
+    };
+    const applyObjectPaths = (obj, options, prefix = '') => {
+        for (const [key, value] of Object.entries(obj ?? {})) {
+            const path = prefix ? `${prefix}.${key}` : key;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                applyObjectPaths(value, options, path);
+            }
+            else {
+                updateValue(path, value, options);
+            }
+        }
+    };
+    const revertToSaved = () => {
+        const savedData = store.saved();
+        const changeEvent = {
+            oldValue: cloneDeep(store.data()),
+            newValue: cloneDeep(savedData),
+            path: '',
+            state: 'restored',
+            data: savedData,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(),
+            data: savedData,
+            state: 'restored',
+            lastChange: changeEvent,
+        });
+    };
+    return {
+        update(path, value, options) {
+            updateValue(path, value, options);
+        },
+        applyObjectPaths,
+        patch(context, options) {
+            const currentData = cloneDeep(store.data());
+            const updatedData = { ...currentData, ...context };
+            const changeEvent = {
+                state: 'patch',
+                data: updatedData,
+            };
+            const syncedSnapshot = cloneDeep(updatedData);
+            patchState(store, {
+                ...(options?.updateSaved
+                    ? { savedSnapshot: syncedSnapshot, previousSnapshot: syncedSnapshot }
+                    : { previousSnapshot: store.snapshot() }),
+                data: updatedData,
+                state: 'changed',
+                lastChange: changeEvent,
+            });
+        },
+        /** Reverts live data to the last saved snapshot. */
+        revertToSaved,
+        reset() {
+            revertToSaved();
+        },
+        /** Loads live data; saved baseline is committed separately via {@link commitSaved}. */
+        set(initialData) {
+            const currentData = store.data();
+            if (isFormValueEqual(currentData, initialData)) {
+                return;
+            }
+            const changeEvent = {
+                oldValue: null,
+                newValue: cloneDeep(initialData),
+                path: '',
+                state: 'initiated',
+                data: initialData,
+            };
+            patchState(store, {
+                previousSnapshot: store.snapshot(),
+                data: initialData,
+                state: 'initiated',
+                lastChange: changeEvent,
+            });
+        },
+        getValue(path) {
+            return getSmart(store.data(), path);
+        },
+        getSavedValue(path) {
+            return getSmart(store.savedSnapshot(), path);
+        },
+        hasValue(path) {
+            return has(store.data(), path);
+        },
+        /** Marks the current data as the saved baseline. */
+        commitSaved() {
+            const snapshot = cloneDeep(store.data());
+            patchState(store, {
+                savedSnapshot: snapshot,
+                previousSnapshot: snapshot,
+                state: 'initiated',
+                lastChange: {
+                    state: 'initiated',
+                    data: snapshot,
+                },
+            });
+        },
+        /** Merges parent-bound entity fields without resetting the saved baseline. */
+        applyParentBind(merged) {
+            if (isFormValueEqual(store.data(), merged)) {
+                return;
+            }
+            patchState(store, {
+                data: merged,
+            });
+        },
+    };
+}));
+//#endregion
+
+class AXPExpressionEvaluatorScopeProviderContext {
+    constructor() {
+        this.scopes = {};
+    }
+    addScope(namespace, functions) {
+        this.scopes[namespace] = { ...this.scopes[namespace], ...functions };
+    }
+    getScopes() {
+        return this.scopes;
+    }
+}
+const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER = new InjectionToken('AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER');
+class AXPExpressionEvaluatorScopeProviderService {
+    constructor() {
+        this.injector = inject(Injector);
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache)
+            return;
+        const raw = this.injector.get(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, [], { optional: true });
+        const providers = Array.isArray(raw)
+            ? raw
+            : typeof raw === 'function'
+                ? raw()
+                : [];
+        const context = new AXPExpressionEvaluatorScopeProviderContext();
+        for (const provider of providers) {
+            // Resolve lazy-loaded providers (provideLazyProvider useFactory returns Promise<Provider>)
+            const resolved = await Promise.resolve(provider);
+            if (!resolved || typeof resolved.provide !== 'function') {
+                continue;
+            }
+            await resolved.provide(context);
+        }
+        this.cache = context.getScopes();
+    }
+    async getScopesAsync() {
+        await this.load();
+        return this.cache || {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPExpressionEvaluatorService {
+    constructor() {
+        // Memoization cache for compiled expressions
+        this.expressionCache = new Map();
+        this.providerService = inject(AXPExpressionEvaluatorScopeProviderService);
+    }
+    getOrCompileFunction(expression) {
+        if (!this.expressionCache.has(expression)) {
+            // Check if expression contains multiple statements (has semicolons or newlines)
+            const hasMultipleStatements = expression.includes(';') || expression.includes('\n');
+            let fn;
+            if (hasMultipleStatements) {
+                // For multiple statements, execute them in sequence and return the last expression
+                fn = new Function('scope', `with (scope) { return (async function() { ${expression} })(); }`);
+            }
+            else {
+                // For single expressions, use return
+                fn = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
+            }
+            this.expressionCache.set(expression, fn);
+        }
+        return this.expressionCache.get(expression);
+    }
+    async getMergedScope(userScope) {
+        const pluginScopes = await this.providerService.getScopesAsync();
+        // Merge pluginScopes and userScope (userScope takes precedence)
+        return { ...pluginScopes, ...userScope };
+    }
+    async evaluate(source, scope = {}) {
+        try {
+            const mergedScope = await this.getMergedScope(scope);
+            if (typeof source === 'string' && source.includes('{{')) {
+                return await this.evaluateStringExpression(source, mergedScope);
+            }
+            else if (Array.isArray(source)) {
+                const evaluatedArray = [];
+                for (const item of source) {
+                    evaluatedArray.push(await this.evaluate(item, mergedScope));
+                }
+                return evaluatedArray;
+            }
+            else if (typeof source === 'object' && source !== null) {
+                const evaluatedObject = {};
+                for (const key in source) {
+                    if (source.hasOwnProperty(key)) {
+                        evaluatedObject[key] = await this.evaluate(source[key], mergedScope);
+                    }
+                }
+                return evaluatedObject;
+            }
+            else {
+                return source;
+            }
+        }
+        catch (error) {
+            console.error('Expression evaluator - Error evaluating expression:', source, error);
+            return false;
+        }
+    }
+    async evaluateStringExpression(templateExpression, scope) {
+        // Check if the input is exactly a single {{ ... }} expression (handle multiline)
+        const exactMatch = templateExpression.match(/^\s*\{\{\s*([\s\S]*?)\s*\}\}\s*$/);
+        if (exactMatch) {
+            const expression = exactMatch[1];
+            const sandbox = this.getOrCompileFunction(expression);
+            const result = await sandbox(scope);
+            return result;
+        }
+        // Otherwise, interpolate all {{ ... }} expressions in the string
+        const regex = /\{\{\s*([\s\S]*?)\s*\}\}/g;
+        // Collect all matches and their positions
+        const matches = [];
+        let match;
+        while ((match = regex.exec(templateExpression)) !== null) {
+            matches.push({
+                expression: match[1],
+                start: match.index,
+                end: regex.lastIndex,
+                raw: match[0],
+            });
+        }
+        // Evaluate all expressions in parallel
+        const values = await Promise.all(matches.map((m) => {
+            const sandbox = this.getOrCompileFunction(m.expression);
+            return sandbox(scope);
+        }));
+        // Reconstruct the string with evaluated values
+        let result = '';
+        let lastIndex = 0;
+        matches.forEach((m, i) => {
+            result += templateExpression.slice(lastIndex, m.start);
+            const value = values[i];
+            result += value !== undefined && value !== null ? value : '';
+            lastIndex = m.end;
+        });
+        result += templateExpression.slice(lastIndex);
+        return result;
+    }
+    isExpression(expression) {
+        if (typeof expression === 'string') {
+            return expression.trim().startsWith('{{') && expression.trim().endsWith('}}');
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPComponentSlotPlaceholderComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotPlaceholderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.9", type: AXPComponentSlotPlaceholderComponent, isStandalone: true, selector: "axp-component-slot-placeholder", ngImport: i0, template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXSkeletonModule }, { kind: "component", type: i1.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-component-slot-placeholder',
+                    template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXSkeletonModule],
+                    standalone: true,
+                }]
+        }] });
+
+class AXPComponentSlotRegistryService {
+    constructor() {
+        this.registry = new Map();
+    }
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
+        }
+    }
+    get(slotName) {
+        return this.registry.get(slotName) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AXPComponentSlotDirective {
+    constructor() {
+        this.name = input.required(...(ngDevMode ? [{ debugName: "name" }] : /* istanbul ignore next */ []));
+        this.host = input(...(ngDevMode ? [undefined, { debugName: "host" }] : /* istanbul ignore next */ []));
+        this.context = input(...(ngDevMode ? [undefined, { debugName: "context" }] : /* istanbul ignore next */ []));
+        this.elementRef = inject(ElementRef);
+        this.registryService = inject(AXPComponentSlotRegistryService);
+        this.injector = inject(Injector);
+        this.evaluator = inject(AXPExpressionEvaluatorService);
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.contextStore = inject(AXPContextStore);
+        this.isEmpty = computed(() => this._viewCount() === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : /* istanbul ignore next */ []));
+        // Create a signal to store the count of children
+        this._viewCount = signal(0, ...(ngDevMode ? [{ debugName: "_viewCount" }] : /* istanbul ignore next */ []));
+        // Track component references for updates
+        this.componentRefs = [];
+        // Track placeholder references for replacement
+        this.placeholderRefs = new Map();
+        // Watch for context changes and update component instances
+        effect(() => {
+            const currentContext = this.context();
+            const currentHost = this.host();
+            // Update all component references with new context and host
+            this.componentRefs.forEach((componentRef) => {
+                if (componentRef.instance) {
+                    Object.assign(componentRef.instance, {
+                        host: currentHost,
+                        context: currentContext,
+                    });
+                }
+            });
+        });
+    }
+    async ngOnInit() {
+        await this.loadComponents();
+        // Update the signal after loading
+        this._viewCount.set(this.viewContainerRef.length);
+    }
+    async loadComponents() {
+        this.viewContainerRef.clear();
+        // Clear previous component references
+        this.componentRefs = [];
+        this.placeholderRefs.clear();
+        const configs = sortBy(this.registryService.get(this.name()), (c) => c.priority ?? 0);
+        if (!configs) {
+            console.error(`No component found for slot ${this.name()}`);
+            return;
+        }
+        // Evaluate conditions and check features in parallel for performance
+        const results = await Promise.all(configs.map(async (c) => {
+            // Check condition if provided
+            const conditionPassed = c.condition ? await this.evaluateCondition(c.condition) : true;
+            // Check features if provided
+            // const featuresPassed =
+            //   c.features && c.features.length > 0 ? this.sessionService.isFeatureEnabled(...c.features) : true;
+            return {
+                config: c,
+                // visible: conditionPassed && featuresPassed,
+                visible: conditionPassed,
+            };
+        }));
+        // Filter visible components while preserving priority order
+        const slots = results.filter((r) => r.visible).map((r) => r.config);
+        // Create skeleton placeholders immediately in priority order
+        slots.forEach((config, index) => {
+            const placeholderRef = this.viewContainerRef.createComponent(AXPComponentSlotPlaceholderComponent);
+            this.placeholderRefs.set(index, placeholderRef);
+        });
+        // Load all components in parallel and replace placeholders as they become ready
+        const loadPromises = slots.map(async (config, index) => {
+            let component;
+            let options = {};
+            // load component
+            if (typeof config.loadComponent === 'function') {
+                await runInInjectionContext(this.injector, async () => {
+                    component = await config.loadComponent?.();
+                });
+            }
+            else if (config.component) {
+                component = config.component;
+            }
+            // load options
+            if (typeof config.options === 'function') {
+                await runInInjectionContext(this.injector, async () => {
+                    const fun = config.options;
+                    options = await fun();
+                });
+            }
+            else if (config.options) {
+                options = await this.evaluator.evaluate(config.options, {});
+            }
+            // Replace placeholder with actual component as soon as it's ready
+            if (!component) {
+                console.warn(`Component failed to load for slot ${this.name()} at index ${index}`);
+                // Remove placeholder if component failed to load
+                const placeholderRef = this.placeholderRefs.get(index);
+                if (placeholderRef) {
+                    placeholderRef.destroy();
+                    this.placeholderRefs.delete(index);
+                }
+                return;
+            }
+            // Get the placeholder reference at this index
+            const placeholderRef = this.placeholderRefs.get(index);
+            if (!placeholderRef) {
+                console.warn(`Placeholder not found for index ${index}`);
+                return;
+            }
+            // Get the index of the placeholder in the view container
+            const placeholderIndex = this.viewContainerRef.indexOf(placeholderRef.hostView);
+            // Remove the placeholder
+            placeholderRef.destroy();
+            this.placeholderRefs.delete(index);
+            // Create the actual component at the same position
+            const componentRef = this.viewContainerRef.createComponent(component, { index: placeholderIndex });
+            // Store the component reference for future updates
+            this.componentRefs.push(componentRef);
+            Object.assign(componentRef.instance, {
+                host: this.host(),
+                context: this.context(),
+                ...options,
+            });
+        });
+        // Wait for all components to finish loading (they render as they become ready)
+        await Promise.all(loadPromises);
+    }
+    async evaluateCondition(condition) {
+        if (typeof condition === 'string') {
+            const result = await this.evaluator.evaluate(condition, {});
+            return result;
+        }
+        return condition(this.contextStore.data());
+        //return condition(this.context());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: true, transformFunction: null }, host: { classPropertyName: "host", publicName: "host", isSignal: true, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["slot"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                    standalone: false,
+                    exportAs: 'slot',
+                }]
+        }], ctorParameters: () => [], propDecorators: { name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: true }] }], host: [{ type: i0.Input, args: [{ isSignal: true, alias: "host", required: false }] }], context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: false }] }] } });
+
+class AXPComponentSlotModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPComponentSlotModuleFactory']
+                }] }] });
+
+//#region ---- AI metadata ----
+//#endregion
+
+const AXP_CONTEXT_DEFINITION_PROVIDER = new InjectionToken('AXP_CONTEXT_DEFINITION_PROVIDER');
+//#endregion
+
+//#region ---- Aggregator service ----
+/**
+ * Collects {@link AXPContextDefinition} entries from all registered {@link AXPContextDefinitionProvider} instances.
+ */
+class AXPContextDefinitionProviderService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.providers = inject(AXP_CONTEXT_DEFINITION_PROVIDER, { optional: true });
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        const items = [];
+        if (!Array.isArray(this.providers)) {
+            return items;
+        }
+        for (const raw of this.providers) {
+            const provider = await Promise.resolve(raw);
+            if (provider && typeof provider.items === 'function') {
+                items.push(...(await provider.items()));
+            }
+        }
+        return items;
+    }
+    async get(name) {
+        return (await this.items()).find((d) => d.name === name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPDataGenerator {
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const random = (Math.random() * 16) | 0;
+            const value = char === 'x' ? random : (random & 0x3) | 0x8;
+            return value.toString(16);
+        });
+    }
+    static number(...args) {
+        let min = 0;
+        let max = 100;
+        if (args.length == 1)
+            max = args[0];
+        if (args.length == 2) {
+            min = args[0];
+            max = args[1];
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    static date(...args) {
+        let start = new Date(2000, 0, 1);
+        let end = new Date();
+        if (args.length === 1) {
+            start = args[0];
+        }
+        else if (args.length === 2) {
+            start = args[0];
+            end = args[1];
+        }
+        const startTime = start.getTime();
+        const endTime = end.getTime();
         return new Date(startTime + Math.random() * (endTime - startTime));
     }
     static array(length = 5, generator) {
@@ -829,11 +2139,14 @@ class AXPDataSourceDefinitionProviderService {
     }
     async items() {
         const items = [];
-        // Load from DI tokens
+        // Load from DI tokens; resolve lazy providers (provideLazyProvider uses useFactory that returns Promise<T>)
         if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                set(provider, '__parent__', this);
-                items.push(...(await provider.items()));
+            for (const raw of this.providers) {
+                const provider = await Promise.resolve(raw);
+                if (provider && typeof provider.items === 'function') {
+                    set(provider, '__parent__', this);
+                    items.push(...(await provider.items()));
+                }
             }
         }
         return items;
@@ -841,52 +2154,32 @@ class AXPDataSourceDefinitionProviderService {
     async get(name) {
         return (await this.items()).find((c) => c.name == name);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDataSourceDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDataSourceDefinitionProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDataSourceDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-class AXPElementDataDirective {
-    constructor(elementRef) {
-        this.elementRef = elementRef;
-        this.data = input(null, ...(ngDevMode ? [{ debugName: "data", alias: 'axp-data' }] : [{ alias: 'axp-data' }]));
-        this.path = input('__data__', ...(ngDevMode ? [{ debugName: "path", alias: 'axp-data-path' }] : [{ alias: 'axp-data-path' }]));
-        // Effect to update element data when inputs change
-        this.updateEffect = effect(() => {
-            const currentData = this.data();
-            const currentPath = this.path();
-            set(this.elementRef.nativeElement, currentPath, currentData);
-        }, ...(ngDevMode ? [{ debugName: "updateEffect" }] : []));
-    }
-    ngOnInit() {
-        // Initial data setup
-        set(this.elementRef.nativeElement, this.path(), this.data());
-    }
-    /**
-     * Get data from the element
-     */
-    getData() {
-        return get(this.elementRef.nativeElement, this.path());
-    }
-    /**
-     * Update data at runtime
-     */
-    setData(data) {
-        set(this.elementRef.nativeElement, this.path(), data);
+// src/app/directives/grid-layout.directive.ts
+class AXPContentCheckerDirective {
+    constructor() {
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.elementRef = inject((ElementRef));
+        this.isEmpty = computed(() => this.viewContainerRef.length === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : /* istanbul ignore next */ []));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPElementDataDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AXPElementDataDirective, isStandalone: true, selector: "[axp-data]", inputs: { data: { classPropertyName: "data", publicName: "axp-data", isSignal: true, isRequired: false, transformFunction: null }, path: { classPropertyName: "path", publicName: "axp-data-path", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContentCheckerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPContentCheckerDirective, isStandalone: true, selector: "[axp-content-checker]", exportAs: ["checker"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPElementDataDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContentCheckerDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[axp-data]',
-                    standalone: true
+                    selector: '[axp-content-checker]',
+                    standalone: true,
+                    exportAs: 'checker'
                 }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { data: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data", required: false }] }], path: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data-path", required: false }] }] } });
+        }] });
 
 class AXPDblClickDirective {
     constructor() {
@@ -909,10 +2202,10 @@ class AXPDblClickDirective {
         }
         this.lastTap = currentTime;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDblClickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: AXPDblClickDirective, isStandalone: true, selector: "[onDblClick]", outputs: { onDblClick: "onDblClick" }, host: { listeners: { "dblclick": "handleOnDblClick($event)", "touchend": "onTouchEnd($event)" } }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDblClickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPDblClickDirective, isStandalone: true, selector: "[onDblClick]", outputs: { onDblClick: "onDblClick" }, host: { listeners: { "dblclick": "handleOnDblClick($event)", "touchend": "onTouchEnd($event)" } }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDblClickDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDblClickDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[onDblClick]'
@@ -927,12 +2220,51 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 args: ['touchend', ['$event']]
             }] } });
 
+class AXPElementDataDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.data = input(null, { ...(ngDevMode ? { debugName: "data" } : /* istanbul ignore next */ {}), alias: 'axp-data' });
+        this.path = input('__data__', { ...(ngDevMode ? { debugName: "path" } : /* istanbul ignore next */ {}), alias: 'axp-data-path' });
+        // Effect to update element data when inputs change
+        this.updateEffect = effect(() => {
+            const currentData = this.data();
+            const currentPath = this.path();
+            set(this.elementRef.nativeElement, currentPath, currentData);
+        }, ...(ngDevMode ? [{ debugName: "updateEffect" }] : /* istanbul ignore next */ []));
+    }
+    ngOnInit() {
+        // Initial data setup
+        set(this.elementRef.nativeElement, this.path(), this.data());
+    }
+    /**
+     * Get data from the element
+     */
+    getData() {
+        return get(this.elementRef.nativeElement, this.path());
+    }
+    /**
+     * Update data at runtime
+     */
+    setData(data) {
+        set(this.elementRef.nativeElement, this.path(), data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPElementDataDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPElementDataDirective, isStandalone: true, selector: "[axp-data]", inputs: { data: { classPropertyName: "data", publicName: "axp-data", isSignal: true, isRequired: false, transformFunction: null }, path: { classPropertyName: "path", publicName: "axp-data-path", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPElementDataDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-data]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { data: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data", required: false }] }], path: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data-path", required: false }] }] } });
+
 // src/app/directives/grid-layout.directive.ts
 class AXPGridLayoutDirective {
     constructor(el, renderer) {
         this.el = el;
         this.renderer = renderer;
-        this.options = input.required(...(ngDevMode ? [{ debugName: "options", alias: 'axp-grid-layout' }] : [{ alias: 'axp-grid-layout' }]));
+        this.options = input.required({ ...(ngDevMode ? { debugName: "options" } : /* istanbul ignore next */ {}), alias: 'axp-grid-layout' });
     }
     ngOnChanges(changes) {
         if (changes['options']) {
@@ -968,240 +2300,24 @@ class AXPGridLayoutDirective {
             }
         });
     }
-    clearClasses() {
-        const currentClasses = this.el.nativeElement.className.split(' ');
-        currentClasses.forEach((className) => {
-            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
-                this.renderer.removeClass(this.el.nativeElement, className);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.12", type: AXPGridLayoutDirective, isStandalone: true, selector: "[axp-grid-layout]", inputs: { options: { classPropertyName: "options", publicName: "axp-grid-layout", isSignal: true, isRequired: true, transformFunction: null } }, usesOnChanges: true, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[axp-grid-layout]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-grid-layout", required: true }] }] } });
-
-// src/app/directives/grid-layout.directive.ts
-class AXPContentCheckerDirective {
-    constructor() {
-        this.viewContainerRef = inject(ViewContainerRef);
-        this.elementRef = inject((ElementRef));
-        this.isEmpty = computed(() => this.viewContainerRef.length === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : []));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPContentCheckerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: AXPContentCheckerDirective, isStandalone: true, selector: "[axp-content-checker]", exportAs: ["checker"], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPContentCheckerDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[axp-content-checker]',
-                    standalone: true,
-                    exportAs: 'checker'
-                }]
-        }] });
-
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Directive   ----
-/**
- * Fullscreen directive that provides CSS-based fullscreen functionality
- * Usage: <element axFullscreen #fullscreen="axFullscreen"></element>
- * Then: fullscreen.toggle() or fullscreen.enter() or fullscreen.exit()
- */
-class AXFullscreenDirective {
-    constructor(elementRef) {
-        this.elementRef = elementRef;
-        //#region ----   Properties   ----
-        /**
-         * Current fullscreen state
-         */
-        this.isFullscreenState = signal(false, ...(ngDevMode ? [{ debugName: "isFullscreenState" }] : []));
-        /**
-         * Original element styles to restore
-         */
-        this.originalStyles = {};
-        /**
-         * Original parent element reference
-         */
-        this.originalParent = null;
-        /**
-         * Fullscreen container element
-         */
-        this.fullscreenContainer = null;
-        /**
-         * Fullscreen change event
-         */
-        this.fullscreenChange = output();
-        //#endregion
-        //#region ----   Constructor   ----
-        this.destroyRef = inject(DestroyRef);
-        this.renderer = inject(Renderer2);
-        // Sync state changes to output
-        effect(() => {
-            const isFullscreen = this.isFullscreenState();
-            untracked(() => {
-                this.fullscreenChange.emit(isFullscreen);
-            });
-        });
-    }
-    //#endregion
-    //#region ----   Public API   ----
-    /**
-     * Toggle fullscreen state
-     */
-    async toggle() {
-        if (this.isFullscreenState()) {
-            await this.exit();
-        }
-        else {
-            await this.enter();
-        }
-    }
-    /**
-     * Enter fullscreen mode using CSS
-     */
-    async enter() {
-        if (this.isFullscreenState()) {
-            return;
-        }
-        const element = this.elementRef.nativeElement;
-        try {
-            // Store original styles and parent
-            this.storeOriginalStyles(element);
-            this.originalParent = element.parentElement;
-            // Create fullscreen container
-            this.fullscreenContainer = this.renderer.createElement('div');
-            this.renderer.setStyle(this.fullscreenContainer, 'position', 'fixed');
-            this.renderer.setStyle(this.fullscreenContainer, 'top', '0');
-            this.renderer.setStyle(this.fullscreenContainer, 'left', '0');
-            this.renderer.setStyle(this.fullscreenContainer, 'width', '100vw');
-            this.renderer.setStyle(this.fullscreenContainer, 'height', '100vh');
-            this.renderer.setStyle(this.fullscreenContainer, 'z-index', '9999');
-            this.renderer.setStyle(this.fullscreenContainer, 'background-color', '#ffffff');
-            this.renderer.setStyle(this.fullscreenContainer, 'overflow', 'auto');
-            // Move element to container
-            this.renderer.appendChild(this.fullscreenContainer, element);
-            // Apply fullscreen styles to element
-            this.renderer.setStyle(element, 'position', 'relative');
-            this.renderer.setStyle(element, 'width', '100%');
-            this.renderer.setStyle(element, 'height', '100%');
-            this.renderer.setStyle(element, 'margin', '0');
-            this.renderer.setStyle(element, 'padding', '0');
-            // Append container to body
-            this.renderer.appendChild(document.body, this.fullscreenContainer);
-            // Prevent body scroll
-            this.renderer.setStyle(document.body, 'overflow', 'hidden');
-            this.isFullscreenState.set(true);
-        }
-        catch (error) {
-            console.error('Error entering fullscreen:', error);
-            this.restoreOriginalStyles(element);
-        }
-    }
-    /**
-     * Exit fullscreen mode
-     */
-    async exit() {
-        if (!this.isFullscreenState()) {
-            return;
-        }
-        const element = this.elementRef.nativeElement;
-        try {
-            // Restore body scroll
-            this.renderer.removeStyle(document.body, 'overflow');
-            // Move element back to original parent
-            if (this.fullscreenContainer && this.originalParent) {
-                this.renderer.removeChild(this.fullscreenContainer, element);
-                this.renderer.appendChild(this.originalParent, element);
-                // Remove container
-                this.renderer.removeChild(document.body, this.fullscreenContainer);
-                this.fullscreenContainer = null;
-            }
-            // Restore original styles
-            this.restoreOriginalStyles(element);
-            this.isFullscreenState.set(false);
-        }
-        catch (error) {
-            console.error('Error exiting fullscreen:', error);
-        }
-    }
-    /**
-     * Check if currently in fullscreen mode
-     */
-    isFullscreen() {
-        return this.isFullscreenState();
-    }
-    //#endregion
-    //#region ----   Private Methods   ----
-    /**
-     * Store original element styles
-     */
-    storeOriginalStyles(element) {
-        const computedStyle = window.getComputedStyle(element);
-        this.originalStyles = {
-            position: computedStyle.position,
-            top: computedStyle.top,
-            left: computedStyle.left,
-            width: computedStyle.width,
-            height: computedStyle.height,
-            zIndex: computedStyle.zIndex,
-            backgroundColor: computedStyle.backgroundColor,
-            margin: computedStyle.margin,
-            padding: computedStyle.padding,
-        };
-    }
-    /**
-     * Restore original element styles
-     */
-    restoreOriginalStyles(element) {
-        if (!this.originalStyles) {
-            return;
-        }
-        // Restore each style property
-        Object.entries(this.originalStyles).forEach(([key, value]) => {
-            const styleKey = this.camelToKebabCase(key);
-            if (value) {
-                this.renderer.setStyle(element, styleKey, value);
-            }
-            else {
-                this.renderer.removeStyle(element, styleKey);
-            }
-        });
-        this.originalStyles = {};
-    }
-    /**
-     * Convert camelCase to kebab-case for CSS properties
-     */
-    camelToKebabCase(str) {
-        return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2').toLowerCase();
-    }
-    //#endregion
-    //#region ----   Lifecycle   ----
-    ngOnDestroy() {
-        // Exit fullscreen if still active
-        if (this.isFullscreenState()) {
-            this.exit().catch(() => {
-                // Ignore errors during cleanup
-            });
-        }
+    clearClasses() {
+        const currentClasses = this.el.nativeElement.className.split(' ');
+        currentClasses.forEach((className) => {
+            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXFullscreenDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: AXFullscreenDirective, isStandalone: true, selector: "[axFullscreen]", outputs: { fullscreenChange: "fullscreenChange" }, exportAs: ["axFullscreen"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPGridLayoutDirective, isStandalone: true, selector: "[axp-grid-layout]", inputs: { options: { classPropertyName: "options", publicName: "axp-grid-layout", isSignal: true, isRequired: true, transformFunction: null } }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXFullscreenDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[axFullscreen]',
+                    selector: '[axp-grid-layout]',
                     standalone: true,
-                    exportAs: 'axFullscreen',
                 }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { fullscreenChange: [{ type: i0.Output, args: ["fullscreenChange"] }] } });
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-grid-layout", required: true }] }] } });
 
 const AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER = new InjectionToken('AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER');
 
@@ -1339,10 +2455,10 @@ class AXPDistributedEventListenerService {
         this.listenersByKey.clear();
         this.providersLoaded = false;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDistributedEventListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDistributedEventListenerService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDistributedEventListenerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1466,220 +2582,777 @@ class AXPBroadcastEventService {
         // Cleanup multi-tab event history
         this.multiTabEventHistory.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPBroadcastEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPBroadcastEventService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPBroadcastEventService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
 
-class AXPExpressionEvaluatorScopeProviderContext {
+class AXPHookService {
     constructor() {
-        this.scopes = {};
-    }
-    addScope(namespace, functions) {
-        this.scopes[namespace] = { ...this.scopes[namespace], ...functions };
+        this.listenerProviders = inject(AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, { optional: true }) || [];
+        this.injector = inject(Injector);
     }
-    getScopes() {
-        return this.scopes;
+    /**
+     * Resolve all providers (handle both direct providers and Promise<provider>)
+     */
+    async resolveProviders() {
+        return Promise.all(this.listenerProviders.map(p => p instanceof Promise ? p : Promise.resolve(p)));
     }
-}
-const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER = new InjectionToken('AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER');
-class AXPExpressionEvaluatorScopeProviderService {
-    constructor() {
-        this.providers = inject(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, { optional: true });
-        this.cache = null;
+    /**
+     * Fire sync hooks (fire-and-forget).
+     * All providers with the given key will be executed.
+     * Execution is not awaited.
+     */
+    fire(key, data) {
+        this.resolveProviders().then(providers => {
+            providers
+                .filter(p => p.key === key)
+                .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0))
+                .forEach(p => {
+                try {
+                    runInInjectionContext(this.injector, () => p.execute(data));
+                }
+                catch (err) {
+                    console.error(`[AXPHookService] Hook '${key}' failed`, err);
+                }
+            });
+        });
     }
-    async load() {
-        if (this.cache)
-            return;
-        const context = new AXPExpressionEvaluatorScopeProviderContext();
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                await provider.provide(context);
-            }
+    /**
+     * Run async hooks sequentially (waterfall).
+     * The output of each hook is passed as input to the next hook.
+     * Returns the final merged data after all hooks are executed.
+     */
+    async runAsync(key, initialData) {
+        const providers = (await this.resolveProviders())
+            .filter(p => p.key === key)
+            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        let data = initialData;
+        for (const p of providers) {
+            data = await Promise.resolve(runInInjectionContext(this.injector, () => p.execute(data)));
         }
-        this.cache = context.getScopes();
-    }
-    async getScopesAsync() {
-        await this.load();
-        return this.cache || {};
+        return data;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-class AXPExpressionEvaluatorService {
-    constructor() {
-        // Memoization cache for compiled expressions
-        this.expressionCache = new Map();
-        this.providerService = inject(AXPExpressionEvaluatorScopeProviderService);
+//#region ---- Types ----
+/** Priority tier — higher values win when multiple bindings match. */
+var AXPKeyboardShortcutPriority;
+(function (AXPKeyboardShortcutPriority) {
+    AXPKeyboardShortcutPriority[AXPKeyboardShortcutPriority["Global"] = 0] = "Global";
+    AXPKeyboardShortcutPriority[AXPKeyboardShortcutPriority["Page"] = 10] = "Page";
+    AXPKeyboardShortcutPriority[AXPKeyboardShortcutPriority["Panel"] = 20] = "Panel";
+    AXPKeyboardShortcutPriority[AXPKeyboardShortcutPriority["Modal"] = 100] = "Modal";
+})(AXPKeyboardShortcutPriority || (AXPKeyboardShortcutPriority = {}));
+//#endregion
+
+//#region ---- Overlay Layer DOM Utilities ----
+/** Acorex overlay root (modal shell, popup, dialog). */
+const AX_OVERLAY_CONTAINER_SELECTOR = '.ax-overlay-container';
+/** Anchored widget panel inside an overlay (select, date picker, dropdown). */
+const AX_OVERLAY_PANE_SELECTOR = '.ax-overlay-pane';
+/**
+ * True when a visible overlay layer is foreground (modal, popup, widget popover/picker).
+ */
+function hasForegroundOverlayLayer(document) {
+    if (getVisibleAnchoredOverlayPanes(document).length > 0) {
+        return true;
     }
-    getOrCompileFunction(expression) {
-        if (!this.expressionCache.has(expression)) {
-            // Check if expression contains multiple statements (has semicolons or newlines)
-            const hasMultipleStatements = expression.includes(';') || expression.includes('\n');
-            let fn;
-            if (hasMultipleStatements) {
-                // For multiple statements, execute them in sequence and return the last expression
-                fn = new Function('scope', `with (scope) { return (async function() { ${expression} })(); }`);
-            }
-            else {
-                // For single expressions, use return
-                fn = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
-            }
-            this.expressionCache.set(expression, fn);
+    return getVisibleOverlayContainers(document).length > 0;
+}
+/**
+ * Returns visible anchored overlay panes (widget popovers/pickers).
+ */
+function getVisibleAnchoredOverlayPanes(document) {
+    return Array.from(document.querySelectorAll(AX_OVERLAY_PANE_SELECTOR)).filter(isVisibleOverlayElement);
+}
+/**
+ * Visible anchored panes that are not contained by `excludeContainer` (e.g. dialog shell).
+ */
+function getNestedVisibleOverlayPanes(document, excludeContainer) {
+    return getVisibleAnchoredOverlayPanes(document).filter((pane) => !excludeContainer?.contains(pane));
+}
+/**
+ * Collects visible overlay containers in stacking order (later / higher z-index wins).
+ */
+function getVisibleOverlayContainers(document) {
+    return Array.from(document.querySelectorAll(AX_OVERLAY_CONTAINER_SELECTOR))
+        .filter(isVisibleOverlayElement)
+        .sort(compareOverlayStackOrder);
+}
+/** Topmost visible overlay container, if any. */
+function getTopVisibleOverlayContainer(document) {
+    const containers = getVisibleOverlayContainers(document);
+    return containers.length ? containers[containers.length - 1] : null;
+}
+/** Nearest overlay container ancestor of `element`. */
+function findOverlayContainerAncestor(element) {
+    return element.closest(AX_OVERLAY_CONTAINER_SELECTOR);
+}
+/**
+ * Returns true when the overlay element is rendered and visible in the viewport.
+ */
+function isVisibleOverlayElement(element) {
+    if (!(element instanceof HTMLElement)) {
+        return false;
+    }
+    const style = getComputedStyle(element);
+    if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) {
+        return false;
+    }
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+}
+function compareOverlayStackOrder(a, b) {
+    const za = Number(getComputedStyle(a).zIndex) || 0;
+    const zb = Number(getComputedStyle(b).zIndex) || 0;
+    if (za !== zb) {
+        return za - zb;
+    }
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+        return -1;
+    }
+    if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+        return 1;
+    }
+    return 0;
+}
+//#endregion
+
+//#region ---- Imports ----
+const HORIZONTAL_DIRECTIONAL_KEY_MIRRORS = {
+    arrowleft: 'arrowright',
+    arrowright: 'arrowleft',
+    left: 'right',
+    right: 'left',
+    '[': ']',
+    ']': '[',
+};
+/** Maps a horizontal direction key to its RTL semantic counterpart. */
+function mirrorHorizontalDirectionalKey(key) {
+    const normalized = normalizeShortcutToken(key);
+    return HORIZONTAL_DIRECTIONAL_KEY_MIRRORS[normalized] ?? normalized;
+}
+/** True when the chord's primary key is a horizontal direction key (`←`/`→`, `[`/`]`). */
+function isHorizontalDirectionalShortcutKey(key) {
+    return normalizeShortcutToken(key) in HORIZONTAL_DIRECTIONAL_KEY_MIRRORS;
+}
+/**
+ * Resolves direction behavior for a chord.
+ * Horizontal direction keys default to `semantic`; others default to `physical`.
+ * An explicit binding value always wins.
+ */
+function resolveEffectiveDirectionBehavior(chord, explicit) {
+    if (explicit === 'physical' || explicit === 'semantic') {
+        return explicit;
+    }
+    const { key } = parseKeyboardShortcutChord(chord);
+    return isHorizontalDirectionalShortcutKey(key) ? 'semantic' : 'physical';
+}
+/** Resolves the key the user presses for a semantically registered chord in RTL. */
+function resolveSemanticDirectionalKey(storedKey, rtl) {
+    const normalized = normalizeShortcutToken(storedKey);
+    if (!rtl) {
+        return normalized;
+    }
+    return mirrorHorizontalDirectionalKey(normalized);
+}
+/** Chord string with directional key mirrored for RTL display/matching when semantic. */
+function resolveDisplayShortcutChord(chord, isRtl, explicitDirectionBehavior) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, explicitDirectionBehavior);
+    const parts = chord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return chord;
+    }
+    const keyPart = parts.pop() ?? '';
+    const rtl = directionBehavior === 'semantic' && isRtl;
+    const resolvedKey = resolveSemanticDirectionalKey(keyPart, rtl);
+    return [...parts, resolvedKey].join('+');
+}
+const MODIFIER_ALIASES = {
+    ctrl: 'ctrl',
+    control: 'ctrl',
+    shift: 'shift',
+    alt: 'alt',
+    option: 'alt',
+    meta: 'meta',
+    cmd: 'meta',
+    command: 'meta',
+    win: 'meta',
+};
+const KEY_DISPLAY_MAC = {
+    ctrl: '⌃',
+    control: '⌃',
+    shift: '⇧',
+    alt: '⌥',
+    option: '⌥',
+    meta: '⌘',
+    cmd: '⌘',
+    command: '⌘',
+    win: '⌘',
+    enter: '↵',
+    escape: 'Esc',
+    esc: 'Esc',
+    home: 'Home',
+    arrowleft: '←',
+    arrowright: '→',
+    arrowup: '↑',
+    arrowdown: '↓',
+    pageup: 'PgUp',
+    pagedown: 'PgDn',
+    backspace: '⌫',
+    delete: '⌦',
+    space: 'Space',
+};
+/**
+ * Parses a shortcut chord such as `Enter`, `Escape`, or `ctrl+shift+s`.
+ */
+function parseKeyboardShortcutChord(chord) {
+    const parts = chord
+        .trim()
+        .toLowerCase()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const key = normalizeShortcutToken(parts.pop() ?? '');
+    const parsed = {
+        ctrl: false,
+        shift: false,
+        alt: false,
+        meta: false,
+        key,
+    };
+    for (const part of parts) {
+        const alias = MODIFIER_ALIASES[part];
+        if (alias) {
+            parsed[alias] = true;
         }
-        return this.expressionCache.get(expression);
     }
-    async getMergedScope(userScope) {
-        const pluginScopes = await this.providerService.getScopesAsync();
-        // Merge pluginScopes and userScope (userScope takes precedence)
-        return { ...pluginScopes, ...userScope };
+    return parsed;
+}
+/**
+ * Returns true when the keyboard event matches the given chord.
+ * On macOS, `ctrl+*` chords also match `meta+*` for common platform shortcuts.
+ */
+function matchesKeyboardShortcutChord(event, chord, options) {
+    const parsed = parseKeyboardShortcutChord(chord);
+    const mac = isMacPlatform();
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    if (!matchesShortcutModifiers(parsed, event, mac)) {
+        return false;
     }
-    async evaluate(source, scope = {}) {
-        try {
-            const mergedScope = await this.getMergedScope(scope);
-            if (typeof source === 'string' && source.includes('{{')) {
-                return await this.evaluateStringExpression(source, mergedScope);
-            }
-            else if (Array.isArray(source)) {
-                const evaluatedArray = [];
-                for (const item of source) {
-                    evaluatedArray.push(await this.evaluate(item, mergedScope));
-                }
-                return evaluatedArray;
-            }
-            else if (typeof source === 'object' && source !== null) {
-                const evaluatedObject = {};
-                for (const key in source) {
-                    if (source.hasOwnProperty(key)) {
-                        evaluatedObject[key] = await this.evaluate(source[key], mergedScope);
-                    }
-                }
-                return evaluatedObject;
-            }
-            else {
-                return source;
-            }
+    const actualKey = normalizeShortcutEventKey(event);
+    const expectedKey = normalizeShortcutToken(parsed.key);
+    const rtlSemantic = directionBehavior === 'semantic' &&
+        options?.isRtl === true &&
+        isHorizontalDirectionalShortcutKey(expectedKey);
+    if (rtlSemantic) {
+        return actualKey === mirrorHorizontalDirectionalKey(expectedKey);
+    }
+    return actualKey === expectedKey;
+}
+/**
+ * Matches modifier keys for a parsed chord.
+ * `ctrl+alt` chords also accept AltGraph (Windows) so layout-produced characters still match physical keys.
+ */
+function matchesShortcutModifiers(parsed, event, mac) {
+    if (parsed.shift !== event.shiftKey) {
+        return false;
+    }
+    const altGraph = hasAltGraphModifier(event);
+    if (parsed.ctrl && parsed.alt) {
+        if (altGraph) {
+            return true;
         }
-        catch (error) {
-            console.error('Expression evaluator - Error evaluating expression:', source, error);
+        return event.ctrlKey && event.altKey;
+    }
+    if (parsed.alt !== event.altKey) {
+        return false;
+    }
+    if (parsed.meta) {
+        if (!event.metaKey) {
+            return false;
+        }
+        return true;
+    }
+    if (parsed.ctrl) {
+        if (mac) {
+            return event.metaKey || event.ctrlKey;
+        }
+        return event.ctrlKey;
+    }
+    if (event.ctrlKey || event.metaKey) {
+        return false;
+    }
+    return true;
+}
+function hasAltGraphModifier(event) {
+    return typeof event.getModifierState === 'function' && event.getModifierState('AltGraph');
+}
+/**
+ * Formats one chord for UI display (OS-aware modifier symbols).
+ */
+function formatKeyboardShortcutChord(chord, options) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    const resolvedChord = options?.skipDirectionResolve
+        ? chord
+        : resolveDisplayShortcutChord(chord, options?.isRtl === true, directionBehavior);
+    const mac = isMacPlatform();
+    const parts = resolvedChord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return '';
+    }
+    const keyPart = normalizeShortcutToken(parts.pop() ?? '');
+    const modifierParts = parts.map((part) => formatShortcutPart(part.toLowerCase(), mac));
+    const keyDisplay = formatShortcutPart(keyPart, mac);
+    if (mac) {
+        return [...modifierParts, keyDisplay].join('');
+    }
+    return [...modifierParts, keyDisplay].join('+');
+}
+/**
+ * Formats multiple chords as a single display string (e.g. `← / PgUp`).
+ */
+function formatKeyboardShortcutChords(chords, options) {
+    return chords.map((chord) => formatKeyboardShortcutChord(chord, options)).join(' / ');
+}
+/** Maps a chord to `ax-kbd-item` key parts (modifiers + display symbols). */
+function chordToKbdItemKeys(chord, options) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    const resolvedChord = options?.skipDirectionResolve
+        ? chord
+        : resolveDisplayShortcutChord(chord, options?.isRtl === true, directionBehavior);
+    const mac = isMacPlatform();
+    const symbolKeys = {
+        arrowleft: '←',
+        arrowright: '→',
+        arrowup: '↑',
+        arrowdown: '↓',
+        pageup: 'PgUp',
+        pagedown: 'PgDn',
+        enter: '↵',
+        escape: 'Esc',
+        esc: 'Esc',
+        space: 'Space',
+        '[': '[',
+        ']': ']',
+    };
+    return resolvedChord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const normalized = part.toLowerCase();
+        if (mac && (normalized === 'ctrl' || normalized === 'control')) {
+            return '⌘';
+        }
+        return symbolKeys[normalized] ?? part;
+    });
+}
+/**
+ * When focus is in a native edit control, avoid stealing plain key shortcuts.
+ */
+function isKeyboardTargetInsideEditableField(target) {
+    if (!(target instanceof HTMLElement)) {
+        return false;
+    }
+    if (target.isContentEditable) {
+        return true;
+    }
+    const field = target.closest('input, textarea, select');
+    if (!field || field.disabled) {
+        return false;
+    }
+    if (field instanceof HTMLInputElement) {
+        const type = field.type;
+        if (type === 'hidden' ||
+            type === 'checkbox' ||
+            type === 'radio' ||
+            type === 'button' ||
+            type === 'submit' ||
+            type === 'reset' ||
+            type === 'file' ||
+            field.readOnly) {
             return false;
         }
+        return true;
+    }
+    if (field instanceof HTMLTextAreaElement) {
+        return !field.readOnly;
+    }
+    return true;
+}
+/**
+ * Returns true when Esc should close an open widget overlay first (select, date picker, popover, modal).
+ * Used by the global shortcut registry so page-level Esc bindings do not swallow overlay dismiss.
+ */
+function shouldDeferEscapeToOpenOverlay(document) {
+    return hasForegroundOverlayLayer(document);
+}
+function isMacPlatform() {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+    return /Mac|iPhone|iPad|iPod/i.test(navigator.userAgent);
+}
+function normalizeShortcutToken(key) {
+    const normalized = key.trim().toLowerCase();
+    if (normalized === 'esc') {
+        return 'escape';
+    }
+    if (normalized === 'left') {
+        return 'arrowleft';
+    }
+    if (normalized === 'right') {
+        return 'arrowright';
+    }
+    if (normalized === 'up') {
+        return 'arrowup';
+    }
+    if (normalized === 'down') {
+        return 'arrowdown';
+    }
+    if (normalized === '[' || normalized === 'bracketleft') {
+        return '[';
+    }
+    if (normalized === ']' || normalized === 'bracketright') {
+        return ']';
+    }
+    return normalized;
+}
+function normalizeShortcutEventKey(event) {
+    if (event.key === 'Enter') {
+        return 'enter';
+    }
+    if (event.key === 'Escape') {
+        return 'escape';
+    }
+    if (event.key === 'Home') {
+        return 'home';
+    }
+    if (event.key === ' ') {
+        return 'space';
+    }
+    if (event.key === '[' || event.code === 'BracketLeft') {
+        return '[';
+    }
+    if (event.key === ']' || event.code === 'BracketRight') {
+        return ']';
+    }
+    const codeMatch = event.code.match(/^Key([A-Z])$/);
+    if (codeMatch) {
+        return codeMatch[1].toLowerCase();
+    }
+    const digitMatch = event.code.match(/^Digit([0-9])$/);
+    if (digitMatch) {
+        return digitMatch[1];
+    }
+    if (event.key.length === 1) {
+        return event.key.toLowerCase();
+    }
+    const fnMatch = event.code.match(/^F(\d+)$/);
+    if (fnMatch) {
+        return `f${fnMatch[1]}`;
+    }
+    return event.key.toLowerCase();
+}
+function formatShortcutPart(part, mac) {
+    const normalized = normalizeShortcutToken(part);
+    if (mac && KEY_DISPLAY_MAC[normalized]) {
+        return KEY_DISPLAY_MAC[normalized];
+    }
+    if (!mac && MODIFIER_ALIASES[normalized]) {
+        return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    }
+    if (KEY_DISPLAY_MAC[normalized]) {
+        return KEY_DISPLAY_MAC[normalized];
+    }
+    if (normalized.length === 1) {
+        return normalized.toUpperCase();
+    }
+    return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+//#endregion
+
+//#region ---- Keyboard Shortcut Declaration Utilities ----
+/**
+ * Normalizes a declarative shortcut (`'ctrl+s'` or `{ keys: 'home', allowInEditableFields: false }`).
+ */
+function normalizeKeyboardShortcut(shortcut) {
+    if (typeof shortcut === 'string') {
+        const chord = shortcut.trim();
+        if (!chord) {
+            return undefined;
+        }
+        return { keys: [chord] };
     }
-    async evaluateStringExpression(templateExpression, scope) {
-        // Check if the input is exactly a single {{ ... }} expression (handle multiline)
-        const exactMatch = templateExpression.match(/^\s*\{\{\s*([\s\S]*?)\s*\}\}\s*$/);
-        if (exactMatch) {
-            const expression = exactMatch[1];
-            const sandbox = this.getOrCompileFunction(expression);
-            const result = await sandbox(scope);
-            return result;
-        }
-        // Otherwise, interpolate all {{ ... }} expressions in the string
-        const regex = /\{\{\s*([\s\S]*?)\s*\}\}/g;
-        // Collect all matches and their positions
-        const matches = [];
-        let match;
-        while ((match = regex.exec(templateExpression)) !== null) {
-            matches.push({
-                expression: match[1],
-                start: match.index,
-                end: regex.lastIndex,
-                raw: match[0],
-            });
-        }
-        // Evaluate all expressions in parallel
-        const values = await Promise.all(matches.map((m) => {
-            const sandbox = this.getOrCompileFunction(m.expression);
-            return sandbox(scope);
-        }));
-        // Reconstruct the string with evaluated values
-        let result = '';
-        let lastIndex = 0;
-        matches.forEach((m, i) => {
-            result += templateExpression.slice(lastIndex, m.start);
-            const value = values[i];
-            result += value !== undefined && value !== null ? value : '';
-            lastIndex = m.end;
-        });
-        result += templateExpression.slice(lastIndex);
-        return result;
+    return normalizeKeyboardShortcutConfig(shortcut);
+}
+/**
+ * Normalizes an array of declarative shortcuts. Empty or invalid entries are skipped.
+ */
+function normalizeKeyboardShortcuts(shortcuts) {
+    if (!shortcuts?.length) {
+        return [];
     }
-    isExpression(expression) {
-        if (typeof expression === 'string') {
-            return expression.includes('{{');
+    const result = [];
+    for (const shortcut of shortcuts) {
+        const normalized = normalizeKeyboardShortcut(shortcut);
+        if (normalized) {
+            result.push(normalized);
         }
-        return false;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorService, providedIn: 'root' }); }
+    return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPExpressionEvaluatorService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
+/** Returns the first chord from declarative shortcuts (for UI hints such as `ax-kbd`). */
+function getPrimaryKeyboardShortcutChord(shortcuts) {
+    return normalizeKeyboardShortcuts(shortcuts)[0]?.keys[0];
+}
+function normalizeKeyboardShortcutConfig(shortcut) {
+    const keys = Array.isArray(shortcut.keys) ? shortcut.keys : [shortcut.keys];
+    const normalizedKeys = keys.map((chord) => chord.trim()).filter(Boolean);
+    if (normalizedKeys.length === 0) {
+        return undefined;
+    }
+    return {
+        keys: normalizedKeys,
+        allowInEditableFields: shortcut.allowInEditableFields,
+        when: shortcut.when,
+        directionBehavior: shortcut.directionBehavior,
+    };
+}
+//#endregion
 
-class AXPHookService {
+//#region ---- Imports ----
+//#endregion
+class AXPKeyboardShortcutRegistry {
     constructor() {
-        this.listenerProviders = inject(AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, { optional: true }) || [];
-        this.injector = inject(Injector);
+        //#region ---- Services & Dependencies ----
+        this.document = inject(DOCUMENT);
+        this.localeService = inject(AXLocaleService);
+        this.activeProfile = toSignal(this.localeService.profileChanged$, {
+            initialValue: this.localeService.activeProfile(),
+        });
+        this.registrations = signal([], ...(ngDevMode ? [{ debugName: "registrations" }] : /* istanbul ignore next */ []));
+        this.helpDialogHandler = null;
+        this.listenerAttached = false;
+        //#endregion
+        //#region ---- Computed Properties ----
+        /** Active shortcut entries for the help dialog. */
+        this.helpEntries = computed(() => {
+            this.activeProfile();
+            return this.buildHelpEntries();
+        }, ...(ngDevMode ? [{ debugName: "helpEntries" }] : /* istanbul ignore next */ []));
+        this.onDocumentKeyDown = (event) => {
+            if (event.key === 'Escape' && shouldDeferEscapeToOpenOverlay(this.document)) {
+                return;
+            }
+            if (event.key === 'F1') {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                if (hasForegroundOverlayLayer(this.document)) {
+                    return;
+                }
+            }
+            const candidates = this.resolveActiveCandidates(event);
+            if (candidates.length === 0) {
+                return;
+            }
+            const match = candidates[0];
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            void match.binding.handler(event);
+        };
     }
+    //#endregion
+    //#region ---- Public Methods ----
     /**
-     * Resolve all providers (handle both direct providers and Promise<provider>)
+     * Registers a scope of shortcuts. Unregisters automatically when `owner` is destroyed.
      */
-    async resolveProviders() {
-        return Promise.all(this.listenerProviders.map(p => p instanceof Promise ? p : Promise.resolve(p)));
+    register(options) {
+        const { owner, ...registrationOptions } = options;
+        const registrationId = `${options.id}-${this.createRegistrationId()}`;
+        const entry = {
+            ...registrationOptions,
+            registrationId,
+            priority: options.priority ?? 0,
+        };
+        this.registrations.update((items) => [
+            ...items.filter((item) => item.id !== options.id),
+            entry,
+        ]);
+        this.ensureListener();
+        try {
+            owner.onDestroy(() => {
+                this.unregister(registrationId);
+            });
+        }
+        catch {
+            // Owner view was already destroyed (e.g. async registration after navigation).
+            this.unregister(registrationId);
+        }
     }
     /**
-     * Fire sync hooks (fire-and-forget).
-     * All providers with the given key will be executed.
-     * Execution is not awaited.
+     * Wires the F1 help dialog opener (provided by platform/common).
      */
-    fire(key, data) {
-        this.resolveProviders().then(providers => {
-            providers
-                .filter(p => p.key === key)
-                .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0))
-                .forEach(p => {
-                try {
-                    runInInjectionContext(this.injector, () => p.execute(data));
+    setHelpDialogHandler(handler) {
+        this.helpDialogHandler = handler;
+        this.ensureHelpShortcutRegistered();
+    }
+    /** OS-aware display string for UI hints. */
+    formatDisplayKeys(chords) {
+        return formatKeyboardShortcutChords(chords, { isRtl: this.isRtlProfile() });
+    }
+    //#endregion
+    //#region ---- Private Methods ----
+    ensureHelpShortcutRegistered() {
+        const alreadyRegistered = this.registrations().some((entry) => entry.id === 'system:keyboard-shortcuts-help');
+        if (alreadyRegistered || !this.helpDialogHandler) {
+            return;
+        }
+        const handler = this.helpDialogHandler;
+        const entry = {
+            registrationId: 'system:keyboard-shortcuts-help',
+            id: 'system:keyboard-shortcuts-help',
+            priority: -1,
+            scope: '@general:keyboard-shortcuts.groups.system',
+            shortcuts: [
+                {
+                    keys: ['f1'],
+                    title: '@general:keyboard-shortcuts.help-action',
+                    allowInEditableFields: true,
+                    handler: () => {
+                        void handler();
+                    },
+                },
+            ],
+        };
+        this.registrations.update((items) => [...items, entry]);
+        this.ensureListener();
+    }
+    createRegistrationId() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    }
+    unregister(registrationId) {
+        this.registrations.update((items) => items.filter((item) => item.registrationId !== registrationId));
+    }
+    ensureListener() {
+        if (this.listenerAttached || typeof this.document === 'undefined') {
+            return;
+        }
+        this.document.addEventListener('keydown', this.onDocumentKeyDown, true);
+        this.listenerAttached = true;
+    }
+    resolveActiveCandidates(event) {
+        const editable = isKeyboardTargetInsideEditableField(event.target);
+        const candidates = [];
+        for (const registration of this.registrations()) {
+            if (!this.isRegistrationActive(registration)) {
+                continue;
+            }
+            const priority = registration.priority ?? 0;
+            for (const binding of registration.shortcuts) {
+                if (binding.when && !binding.when()) {
+                    continue;
                 }
-                catch (err) {
-                    console.error(`[AXPHookService] Hook '${key}' failed`, err);
+                if (editable && !binding.allowInEditableFields) {
+                    continue;
                 }
-            });
-        });
+                for (const chord of binding.keys) {
+                    const directionBehavior = resolveEffectiveDirectionBehavior(chord, binding.directionBehavior);
+                    if (!matchesKeyboardShortcutChord(event, chord, {
+                        directionBehavior,
+                        isRtl: this.isRtlProfile(),
+                    })) {
+                        continue;
+                    }
+                    candidates.push({
+                        priority,
+                        registration,
+                        binding,
+                        chord,
+                    });
+                    break;
+                }
+            }
+        }
+        return candidates.sort((a, b) => b.priority - a.priority);
     }
-    /**
-     * Run async hooks sequentially (waterfall).
-     * The output of each hook is passed as input to the next hook.
-     * Returns the final merged data after all hooks are executed.
-     */
-    async runAsync(key, initialData) {
-        const providers = (await this.resolveProviders())
-            .filter(p => p.key === key)
-            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-        let data = initialData;
-        for (const p of providers) {
-            data = await Promise.resolve(runInInjectionContext(this.injector, () => p.execute(data)));
+    isRegistrationActive(registration) {
+        if (registration.when && !registration.when()) {
+            return false;
         }
-        return data;
+        const element = registration.elementRef?.nativeElement;
+        if (element && !this.document.contains(element)) {
+            return false;
+        }
+        return true;
+    }
+    isRtlProfile() {
+        return this.activeProfile()?.i18nMeta?.rtl === true;
+    }
+    buildHelpEntries() {
+        const entries = [];
+        const isRtl = this.isRtlProfile();
+        for (const registration of this.registrations()) {
+            if (!this.isRegistrationActive(registration)) {
+                continue;
+            }
+            if (registration.id === 'system:keyboard-shortcuts-help') {
+                continue;
+            }
+            const priority = registration.priority ?? 0;
+            for (const binding of registration.shortcuts) {
+                const displayChords = binding.keys.map((chord) => {
+                    const directionBehavior = resolveEffectiveDirectionBehavior(chord, binding.directionBehavior);
+                    return resolveDisplayShortcutChord(chord, isRtl, directionBehavior);
+                });
+                entries.push({
+                    registrationId: registration.registrationId,
+                    bindingTitle: binding.title,
+                    chords: [...binding.keys],
+                    displayChords,
+                    displayKeys: formatKeyboardShortcutChords(displayChords, { skipDirectionResolve: true }),
+                    scope: registration.scope,
+                    group: binding.group ?? registration.group,
+                    priority,
+                });
+            }
+        }
+        return entries.sort((a, b) => b.priority - a.priority || a.bindingTitle.localeCompare(b.bindingTitle));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHookService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHookService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPHookService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            args: [{
+                    providedIn: 'root',
+                }]
         }] });
 
 //#region ----   Imports   ----
@@ -1957,37 +3630,108 @@ class AXPModuleManifestRegistry {
         }
         return { missingModules, missingFeatures };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
+//#region ---- Imports ----
+//#endregion
+//#region ---- Module manifests data source ----
+/**
+ * Data source definition for module names/titles from {@link AXPModuleManifestRegistry}.
+ */
+class AXPModuleManifestsDataSourceDefinition {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.manifestRegistry = inject(AXPModuleManifestRegistry);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        return [
+            {
+                name: AXPPlatformCoreDataSourceKeys.ModuleManifests,
+                title: 'Module manifests',
+                source: () => new AXDataSource({
+                    key: 'id',
+                    load: async () => {
+                        await this.manifestRegistry.initialize();
+                        const list = this.manifestRegistry.getAll().map((m) => ({
+                            id: m.name,
+                            title: m.title || m.name,
+                        }));
+                        return { items: list, total: list.length };
+                    },
+                    byKey: async (key) => {
+                        await this.manifestRegistry.initialize();
+                        const m = this.manifestRegistry.getAll().find((x) => x.name === key);
+                        return m ? { id: m.name, title: m.title || m.name } : undefined;
+                    },
+                    pageSize: 1000,
+                }),
+                columns: [
+                    {
+                        name: 'id',
+                        title: 'ID',
+                        datatype: 'string',
+                        type: 'text-editor',
+                    },
+                    {
+                        name: 'title',
+                        title: 'Title',
+                        datatype: 'string',
+                        type: 'text-editor',
+                    },
+                ],
+                filters: [
+                    {
+                        field: 'title',
+                        title: 'Title',
+                        operator: { type: 'equal' },
+                        widget: { type: 'text-editor' },
+                        filterType: { advance: true, inline: true },
+                    },
+                ],
+                textField: { name: 'title', title: 'Title' },
+                valueField: { name: 'id', title: 'ID' },
+            },
+        ];
+    }
+}
+//#endregion
+
 class AXPAppStartUpService {
     constructor() {
+        this.translationService = inject(AXTranslationService);
         this.tasks = [];
     }
+    //#endregion
+    //#region ----   Public Methods   ----
     registerTask(task) {
         this.tasks.push(task);
     }
     async runAllTasks() {
         for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
-            this.updateStatus(task.statusText);
+            await this.updateStatus(task.statusText);
             await task.run();
         }
     }
-    updateStatus(status) {
+    async updateStatus(status) {
         const loadingText = document.querySelector('#loadingText');
         if (loadingText) {
-            loadingText.innerHTML = status;
+            const translatedStatus = this.translationService.resolve(status);
+            loadingText.innerHTML = await this.translationService.translateAsync(translatedStatus);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppStartUpService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -2018,24 +3762,57 @@ class AXPModuleManifestModule {
         // Register manifest initialization task
         appInitService.registerTask({
             name: 'ModuleManifests',
-            statusText: 'Loading module manifests...',
+            statusText: '@general:app-startup.loading-module-manifests',
             priority: 1, // Load early, before features/permissions
             run: async () => {
                 await manifestRegistry.initialize();
             },
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule, deps: [{ token: AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule, deps: [{ token: AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [],
                 }]
         }], ctorParameters: () => [{ type: AXPAppStartUpService }, { type: i0.Injector }] });
 
+//#region ---- Imports ----
+//#endregion
+//#region ---- Compare & sort ----
+const DEFAULT_COLLATOR_OPTIONS = { sensitivity: 'base' };
+/**
+ * Locale-aware comparison of {@link AXPMultiLanguageString} values (plain string, `@scope:key`, or locale map).
+ * Resolves each side with {@link resolveMultiLanguageString} for `locale`, then compares with `String#localeCompare`.
+ */
+function compareMultiLanguageStrings(a, b, locale, collatorOptions = DEFAULT_COLLATOR_OPTIONS) {
+    const sa = resolveMultiLanguageString(a ?? '', locale);
+    const sb = resolveMultiLanguageString(b ?? '', locale);
+    return sa.localeCompare(sb, locale, collatorOptions);
+}
+/**
+ * Stable sort copy: orders items by resolved string for `getValue(item)` using the active `locale`.
+ */
+function sortByMultiLanguageString(items, getValue, locale, collatorOptions) {
+    return [...items].sort((x, y) => compareMultiLanguageStrings(getValue(x), getValue(y), locale, collatorOptions));
+}
+/**
+ * True when the resolved value contains `query` (case-insensitive) for `locale`.
+ * Useful for search/filter flows over {@link AXPMultiLanguageString}.
+ */
+function searchInMultiLanguageString(value, query, locale) {
+    const q = query.trim().toLocaleLowerCase(locale);
+    if (!q) {
+        return true;
+    }
+    const text = resolveMultiLanguageString(value ?? '', locale).toLocaleLowerCase(locale);
+    return text.includes(q);
+}
+//#endregion
+
 //#region ----   Tag Types   ----
 //#endregion
 
@@ -2187,10 +3964,10 @@ class AXPTagService {
         const uniqueTags = allTags.filter((tag, index, self) => index === self.findIndex((t) => t.title.toLowerCase() === tag.title.toLowerCase()));
         this.cache = uniqueTags;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTagService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPTagService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3121,14 +4898,25 @@ function getNestedKeys(obj, prefix = '') {
     }
     return keys;
 }
+/** Normalizes definition categories to an array for iteration and serialization. */
+function normalizeDefinitionCategories(categories) {
+    if (categories == null) {
+        return [];
+    }
+    return Array.isArray(categories) ? categories : [categories];
+}
+
+//#region ----   Imports   ----
+//#endregion
 
 function applySystemActionDefault(action, type) {
     const systemAction = getSystemActions(type);
     return {
-        name: systemAction.key,
-        title: systemAction.title,
-        icon: systemAction.icon,
-        color: systemAction.color,
+        ...action,
+        name: action.name ?? systemAction.key,
+        title: action.title ?? systemAction.title,
+        icon: action.icon ?? systemAction.icon,
+        color: action.color ?? systemAction.color,
     };
 }
 
@@ -3153,8 +4941,6 @@ class AXPIconLogoConfig {
 
 var AXPPlatformScope;
 (function (AXPPlatformScope) {
-    AXPPlatformScope["Environment"] = "C";
-    AXPPlatformScope["Global"] = "G";
     AXPPlatformScope["Platform"] = "P";
     AXPPlatformScope["Tenant"] = "T";
     AXPPlatformScope["User"] = "U";
@@ -3162,8 +4948,6 @@ var AXPPlatformScope;
 ;
 function resolvePlatformScopeKey(name) {
     const scopeMap = {
-        environment: AXPPlatformScope.Environment,
-        global: AXPPlatformScope.Global,
         platform: AXPPlatformScope.Platform,
         tenant: AXPPlatformScope.Tenant,
         user: AXPPlatformScope.User,
@@ -3172,8 +4956,6 @@ function resolvePlatformScopeKey(name) {
 }
 function resolvePlatformScopeName(scope) {
     const scopeMap = {
-        C: 'environment',
-        G: 'global',
         P: 'platform',
         T: 'tenant',
         U: 'user',
@@ -3193,7 +4975,7 @@ var AXPExportTemplateToken;
 class AXPCountdownPipe {
     constructor() {
         this.calendarService = inject(AXCalendarService);
-        this.countdownSignal = signal(this.setupTimer(), ...(ngDevMode ? [{ debugName: "countdownSignal" }] : []));
+        this.countdownSignal = signal(this.setupTimer(), ...(ngDevMode ? [{ debugName: "countdownSignal" }] : /* istanbul ignore next */ []));
         this.targetDate = 0;
         this.prevValue = 0;
     }
@@ -3222,10 +5004,10 @@ class AXPCountdownPipe {
     updateTargetDate(value) {
         this.targetDate = new Date(value).getTime();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPCountdownPipe, isStandalone: true, name: "countdown", pure: false }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, isStandalone: true, name: "countdown", pure: false }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPCountdownPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'countdown',
@@ -3235,6 +5017,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
         }] });
 
 const loggingEnabled = false; // Set to true to enable logging, false to disable
+//#region ---- Multilingual string helpers ----
+/**
+ * Lowercased text for client-side filtering: plain string or all locale values joined.
+ */
+function toFilterSearchText(value) {
+    if (typeof value === 'string') {
+        return value.toLowerCase();
+    }
+    if (isLocaleStringMap(value)) {
+        return Object.values(value).join(' ').toLowerCase();
+    }
+    return undefined;
+}
+function filterValuesAreEqual(itemRaw, condRaw) {
+    if (typeof condRaw === 'string' && isLocaleStringMap(itemRaw)) {
+        return Object.values(itemRaw).some((v) => v.toLowerCase() === condRaw.toLowerCase());
+    }
+    if (typeof itemRaw === 'string' && isLocaleStringMap(condRaw)) {
+        return Object.values(condRaw).some((v) => v.toLowerCase() === itemRaw.toLowerCase());
+    }
+    const itemScalar = typeof itemRaw === 'string' ? itemRaw.toLowerCase() : itemRaw;
+    const condScalar = typeof condRaw === 'string' ? condRaw.toLowerCase() : condRaw;
+    return isEqual(itemScalar, condScalar);
+}
+//#endregion
 function applyCondition(item, condition) {
     const rawValue = condition.field ? get(item, condition.field) : null;
     const itemValue = typeof rawValue === 'string' ? rawValue.toLowerCase() : rawValue;
@@ -3255,7 +5062,12 @@ function applyCondition(item, condition) {
     switch (op) {
         case 'equal':
         case 'eq':
-            result = isEqual(valueToCompare, conditionValue);
+            if (!isNil(condition.field) && condition.field !== '') {
+                result = filterValuesAreEqual(rawValue, condition.value);
+            }
+            else {
+                result = isEqual(valueToCompare, conditionValue);
+            }
             if (loggingEnabled) {
                 console.log('Equal check result:', result);
             }
@@ -3263,7 +5075,12 @@ function applyCondition(item, condition) {
         case 'notEqual':
         case 'ne':
         case 'neq':
-            result = !isEqual(valueToCompare, conditionValue);
+            if (!isNil(condition.field) && condition.field !== '') {
+                result = !filterValuesAreEqual(rawValue, condition.value);
+            }
+            else {
+                result = !isEqual(valueToCompare, conditionValue);
+            }
             if (loggingEnabled) {
                 console.log('Not equal check result:', result);
             }
@@ -3296,12 +5113,15 @@ function applyCondition(item, condition) {
                 console.log('Less than or equal check result:', result);
             }
             break;
-        case 'contains':
-            if (typeof valueToCompare === 'string') {
-                result = includes(valueToCompare, conditionValue);
+        case 'contains': {
+            const needle = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystack = toFilterSearchText(rawValue);
+            if (haystack !== undefined) {
+                result = includes(haystack, needle);
             }
-            else if (Array.isArray(valueToCompare)) {
-                result = includes(valueToCompare.map((val) => val.toString().toLowerCase()), conditionValue);
+            else if (Array.isArray(rawValue)) {
+                result = includes(rawValue.map((val) => toFilterSearchText(val) ?? val.toString().toLowerCase()), needle);
             }
             else {
                 result = false;
@@ -3310,13 +5130,18 @@ function applyCondition(item, condition) {
                 console.log('Contains check result:', result);
             }
             break;
+        }
         case 'in':
             if (Array.isArray(conditionValue)) {
                 if (typeof valueToCompare === 'string') {
-                    result = conditionValue.some(val => typeof val === 'string' ? val.toLowerCase() === valueToCompare : val === valueToCompare);
+                    result = conditionValue.some((val) => typeof val === 'string' ? val.toLowerCase() === valueToCompare : val === valueToCompare);
+                }
+                else if (isLocaleStringMap(rawValue)) {
+                    const localeValues = Object.values(rawValue).map((v) => v.toLowerCase());
+                    result = localeValues.some((localeVal) => conditionValue.some((val) => typeof val === 'string' ? val.toLowerCase() === localeVal : val === localeVal));
                 }
                 else if (Array.isArray(valueToCompare)) {
-                    result = valueToCompare.some(val => conditionValue.some(condVal => typeof val === 'string' && typeof condVal === 'string'
+                    result = valueToCompare.some((val) => conditionValue.some((condVal) => typeof val === 'string' && typeof condVal === 'string'
                         ? val.toLowerCase() === condVal.toLowerCase()
                         : val === condVal));
                 }
@@ -3331,12 +5156,15 @@ function applyCondition(item, condition) {
                 console.log('In check result:', result);
             }
             break;
-        case 'notContains':
-            if (typeof valueToCompare === 'string') {
-                result = !includes(valueToCompare, conditionValue);
+        case 'notContains': {
+            const needleNc = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackNc = toFilterSearchText(rawValue);
+            if (haystackNc !== undefined) {
+                result = !includes(haystackNc, needleNc);
             }
-            else if (Array.isArray(valueToCompare)) {
-                result = !includes(valueToCompare.map((val) => val.toString().toLowerCase()), conditionValue);
+            else if (Array.isArray(rawValue)) {
+                result = !includes(rawValue.map((val) => toFilterSearchText(val) ?? val.toString().toLowerCase()), needleNc);
             }
             else {
                 result = false;
@@ -3345,18 +5173,27 @@ function applyCondition(item, condition) {
                 console.log('Not contains check result:', result);
             }
             break;
-        case 'startsWith':
-            result = typeof valueToCompare === 'string' && startsWith(valueToCompare, conditionValue);
+        }
+        case 'startsWith': {
+            const prefix = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackSw = toFilterSearchText(rawValue);
+            result = haystackSw !== undefined && startsWith(haystackSw, prefix);
             if (loggingEnabled) {
                 console.log('Starts with check result:', result);
             }
             break;
-        case 'endsWith':
-            result = typeof valueToCompare === 'string' && endsWith(valueToCompare, conditionValue);
+        }
+        case 'endsWith': {
+            const suffix = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackEw = toFilterSearchText(rawValue);
+            result = haystackEw !== undefined && endsWith(haystackEw, suffix);
             if (loggingEnabled) {
                 console.log('Ends with check result:', result);
             }
             break;
+        }
         case 'isEmpty':
             result = isEmpty(valueToCompare);
             if (loggingEnabled) {
@@ -3508,45 +5345,45 @@ class AXPDeviceService {
         /**
          * Current screen size (Small, Medium, Large)
          */
-        this.screenSize = signal(getScreenSize(), ...(ngDevMode ? [{ debugName: "screenSize" }] : []));
+        this.screenSize = signal(getScreenSize(), ...(ngDevMode ? [{ debugName: "screenSize" }] : /* istanbul ignore next */ []));
         /**
          * Current device type (Mobile, Tablet, Desktop)
          */
-        this.deviceType = signal(getDeviceType(), ...(ngDevMode ? [{ debugName: "deviceType" }] : []));
+        this.deviceType = signal(getDeviceType(), ...(ngDevMode ? [{ debugName: "deviceType" }] : /* istanbul ignore next */ []));
         /**
          * Whether the device supports touch input
          */
-        this.isTouchDevice = signal(isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchDevice" }] : []));
+        this.isTouchDevice = signal(isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchDevice" }] : /* istanbul ignore next */ []));
         //#endregion
         //#region ----   Computed Signals   ----
         /**
          * Whether the screen size is Small
          */
-        this.isSmall = computed(() => this.screenSize() === AXPScreenSize.Small, ...(ngDevMode ? [{ debugName: "isSmall" }] : []));
+        this.isSmall = computed(() => this.screenSize() === AXPScreenSize.Small, ...(ngDevMode ? [{ debugName: "isSmall" }] : /* istanbul ignore next */ []));
         /**
          * Whether the screen size is Medium
          */
-        this.isMedium = computed(() => this.screenSize() === AXPScreenSize.Medium, ...(ngDevMode ? [{ debugName: "isMedium" }] : []));
+        this.isMedium = computed(() => this.screenSize() === AXPScreenSize.Medium, ...(ngDevMode ? [{ debugName: "isMedium" }] : /* istanbul ignore next */ []));
         /**
          * Whether the screen size is Large
          */
-        this.isLarge = computed(() => this.screenSize() === AXPScreenSize.Large, ...(ngDevMode ? [{ debugName: "isLarge" }] : []));
+        this.isLarge = computed(() => this.screenSize() === AXPScreenSize.Large, ...(ngDevMode ? [{ debugName: "isLarge" }] : /* istanbul ignore next */ []));
         /**
          * Whether the device is Mobile
          */
-        this.isMobileDevice = computed(() => this.deviceType() === AXPDeviceType.Mobile, ...(ngDevMode ? [{ debugName: "isMobileDevice" }] : []));
+        this.isMobileDevice = computed(() => this.deviceType() === AXPDeviceType.Mobile, ...(ngDevMode ? [{ debugName: "isMobileDevice" }] : /* istanbul ignore next */ []));
         /**
          * Whether the device is Tablet
          */
-        this.isTabletDevice = computed(() => this.deviceType() === AXPDeviceType.Tablet, ...(ngDevMode ? [{ debugName: "isTabletDevice" }] : []));
+        this.isTabletDevice = computed(() => this.deviceType() === AXPDeviceType.Tablet, ...(ngDevMode ? [{ debugName: "isTabletDevice" }] : /* istanbul ignore next */ []));
         /**
          * Whether the device is Desktop
          */
-        this.isDesktopDevice = computed(() => this.deviceType() === AXPDeviceType.Desktop, ...(ngDevMode ? [{ debugName: "isDesktopDevice" }] : []));
+        this.isDesktopDevice = computed(() => this.deviceType() === AXPDeviceType.Desktop, ...(ngDevMode ? [{ debugName: "isDesktopDevice" }] : /* istanbul ignore next */ []));
         /**
          * Whether the device supports touch (alias for isTouchDevice)
          */
-        this.isTouchScreen = computed(() => this.isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchScreen" }] : []));
+        this.isTouchScreen = computed(() => this.isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchScreen" }] : /* istanbul ignore next */ []));
         //#endregion
         //#region ----   Private Properties   ----
         this._resizeListener = null;
@@ -3612,10 +5449,10 @@ class AXPDeviceService {
     destroy() {
         this._removeResizeListener();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDeviceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDeviceService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDeviceService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3719,10 +5556,10 @@ class AXHighlightService {
         resultHTML += '</span>';
         return resultHTML;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXHighlightService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXHighlightService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXHighlightService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -3754,17 +5591,23 @@ async function createProviderWithInjectionContext(loader) {
  *
  * @param token - The injection token to provide
  * @param loader - Function that returns a promise resolving to the provider class
- * @param multi - Whether the provider is multi-provider (defaults to true)
+ * @param multi - Optional. Whether the provider is a multi-provider (array of values). Defaults to `true`. Pass `false` for a single provider.
  * @returns Provider configuration object
  *
  * @example
  * ```typescript
- * providers: [
- *   provideLazyProvider(
- *     AXP_SETTING_DEFINITION_PROVIDER,
- *     () => import('./settings.provider').then(m => m.AXMSettingProvider)
- *   )
- * ]
+ * // Multi-provider (default)
+ * provideLazyProvider(
+ *   AXP_DATASOURCE_DEFINITION_PROVIDER,
+ *   () => import('./datasource.provider').then(m => m.AXMDataSourceProvider)
+ * )
+ *
+ * // Single provider
+ * provideLazyProvider(
+ *   SOME_TOKEN,
+ *   () => import('./my.provider').then(m => m.MyProvider),
+ *   false
+ * )
  * ```
  */
 function provideLazyProvider(token, loader, multi = true) {
@@ -3775,11 +5618,113 @@ function provideLazyProvider(token, loader, multi = true) {
     };
 }
 
+//#region ---- Unwrapping ----
+/**
+ * If `raw` is a plain non-array object with a `value` property, returns `value`; otherwise returns `raw`.
+ */
+function unwrapValueProperty(raw) {
+    if (raw && typeof raw === 'object' && !Array.isArray(raw) && !(raw instanceof Date) && 'value' in raw) {
+        return raw.value;
+    }
+    return raw;
+}
+//#endregion
+//#region ---- Scalar coercion ----
+/**
+ * Coerces to a trimmed string. Plain objects may carry `{ value }` from setting widgets or `{ id }` from select payloads using `valueField: 'id'`.
+ */
+function coerceUnknownToTrimmedString(raw) {
+    if (typeof raw === 'string') {
+        return raw.trim();
+    }
+    if (raw && typeof raw === 'object' && !Array.isArray(raw) && !(raw instanceof Date)) {
+        const r = raw;
+        if ('value' in r && r['value'] != null) {
+            return String(r['value']).trim();
+        }
+        if ('id' in r && r['id'] != null) {
+            return String(r['id']).trim();
+        }
+    }
+    return '';
+}
+/**
+ * Coerces to boolean: direct booleans pass through; wrapped `{ value: true | 'true' }` is respected; otherwise false.
+ */
+function coerceUnknownToBoolean(raw) {
+    if (typeof raw === 'boolean') {
+        return raw;
+    }
+    if (raw && typeof raw === 'object' && 'value' in raw) {
+        const v = raw.value;
+        return v === true || v === 'true';
+    }
+    return false;
+}
+/** Parses a finite number after optional `{ value }` unwrap; non-finite or empty string yields NaN. */
+function coerceUnknownToFiniteNumber(raw) {
+    const v = unwrapValueProperty(raw);
+    if (v === null || v === undefined) {
+        return NaN;
+    }
+    if (typeof v === 'number') {
+        return Number.isFinite(v) ? v : NaN;
+    }
+    if (typeof v === 'boolean') {
+        return v ? 1 : 0;
+    }
+    if (typeof v === 'string') {
+        const t = v.trim();
+        if (t === '') {
+            return NaN;
+        }
+        const n = Number(t);
+        return Number.isFinite(n) ? n : NaN;
+    }
+    return NaN;
+}
+/** Parses a Date after optional `{ value }` unwrap; invalid input yields Invalid Date. */
+function coerceUnknownToDate(raw) {
+    const v = unwrapValueProperty(raw);
+    if (v === null || v === undefined) {
+        return new Date(NaN);
+    }
+    if (v instanceof Date) {
+        return new Date(v.getTime());
+    }
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        return new Date(v);
+    }
+    if (typeof v === 'string') {
+        const t = v.trim();
+        if (t === '') {
+            return new Date(NaN);
+        }
+        return new Date(t);
+    }
+    return new Date(NaN);
+}
+//#endregion
+
 function extractTextFromHtml(value) {
     const div = document.createElement('div');
     div.innerHTML = value;
     return div.textContent || div.innerText || '';
 }
+/**
+ * True when the string likely contains HTML markup (e.g. `<p>`, `<ul>`), as opposed to plain text.
+ * Used to choose innerHTML vs text interpolation for multilingual fields.
+ */
+function containsHtmlMarkup(value) {
+    if (value == null) {
+        return false;
+    }
+    const t = value.trim();
+    if (!t) {
+        return false;
+    }
+    return /<\/?[a-z][\s\S]*?>/i.test(t);
+}
 /**
  * Generate kebab-case group name from title
  */
@@ -3797,5 +5742,5 @@ function generateKebabCase(title) {
  * Generated bundle index. Do not edit.
  */
 
-export { AXFullscreenDirective, AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, createProviderWithInjectionContext, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, provideLazyProvider, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPCatalogScopeDefinitionProviderService, AXPCatalogScopeDefinitionsDataSourceDefinition, AXPColorPaletteProvider, AXPColorPaletteService, AXPColumnWidthService, AXPComponentLogoConfig, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextDefinitionProviderService, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPKeyboardShortcutPriority, AXPKeyboardShortcutRegistry, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPModuleManifestsDataSourceDefinition, AXPPlatformCoreDataSourceKeys, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_COLUMN_WIDTH_PROVIDER, AXP_CONTEXT_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, AX_OVERLAY_CONTAINER_SELECTOR, AX_OVERLAY_PANE_SELECTOR, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, buildLocaleTextMapValue, captureFormContextBaseline, chordToKbdItemKeys, cleanDeep, coerceUnknownToBoolean, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToTrimmedString, compareMultiLanguageStrings, containsHtmlMarkup, createProviderWithInjectionContext, defaultColumnWidthProvider, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, findOverlayContainerAncestor, formatKeyboardShortcutChord, formatKeyboardShortcutChords, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getNestedVisibleOverlayPanes, getPrimaryKeyboardShortcutChord, getSmart, getSystemActions, getTopVisibleOverlayContainer, getVisibleAnchoredOverlayPanes, getVisibleOverlayContainers, hasForegroundOverlayLayer, isFormContextDirty, isFormValueEqual, isHorizontalDirectionalShortcutKey, isKeyboardTargetInsideEditableField, isLocaleStringMap, isMacPlatform, isSelectionValueEqual, isVisibleOverlayElement, matchesKeyboardShortcutChord, mirrorHorizontalDirectionalKey, normalizeDefinitionCategories, normalizeKeyboardShortcut, normalizeKeyboardShortcuts, objectKeyValueTransforms, parseKeyboardShortcutChord, provideLazyProvider, resolveActionLook, resolveDisplayShortcutChord, resolveEffectiveDirectionBehavior, resolvePlatformScopeKey, resolvePlatformScopeName, resolveSemanticDirectionalKey, searchInMultiLanguageString, setSmart, shouldDeferEscapeToOpenOverlay, shouldUseLocaleMapShape, sortByMultiLanguageString, unwrapValueProperty };
 //# sourceMappingURL=acorex-platform-core.mjs.map