@acorex/platform 21.0.0-beta.7 → 21.0.0-beta.9

package/fesm2022/acorex-platform-layout-entity.mjs

@@ -357,65 +357,78 @@ class AXPEntityMiddleware {
         this.providedModifiers = inject(AXP_ENTITY_MODIFIER, { optional: true }) || [];
         this.providedActionPlugins = inject(AXP_ENTITY_ACTION_PLUGIN, { optional: true }) || [];
         this.injector = inject(Injector);
-        for (const { entityName, modifier } of this.providedModifiers) {
-            this.register(entityName, modifier);
+        for (const { entityName, modifier, order } of this.providedModifiers) {
+            this.register(entityName, modifier, order);
         }
     }
     //#endregion
     //#region ----   Registration Methods   ----
-    register(entityName, modifier) {
+    register(entityName, modifier, order) {
+        const resolvedOrder = order ?? 0;
         if (entityName instanceof RegExp) {
-            this.patternModifiers.push({ pattern: this.normalizeRegExp(entityName), modifier });
+            this.patternModifiers.push({ pattern: this.normalizeRegExp(entityName), modifier, order: resolvedOrder });
             return;
         }
         if (entityName.includes('*')) {
             const pattern = this.wildcardToRegExp(entityName);
-            this.patternModifiers.push({ pattern, modifier });
+            this.patternModifiers.push({ pattern, modifier, order: resolvedOrder });
             return;
         }
-        this.exactModifiers.set(entityName, modifier);
+        this.exactModifiers.set(entityName, { modifier, order: resolvedOrder });
     }
     //#endregion
     //#region ----   Processing   ----
     async process(entity) {
-        // First, expand action plugins if entity.plugins exists
         const context = createModifierContext(entity);
-        const plugins = entity.plugins;
-        if (plugins && plugins.length) {
-            const sorted = [...this.providedActionPlugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-            for (const p of plugins) {
-                const contrib = sorted.find((x) => x.name === p.name);
-                if (contrib) {
-                    try {
-                        await runInInjectionContext(this.injector, () => contrib.apply(context, p.options));
-                    }
-                    catch (err) {
-                        console.error('[AXPEntityMiddleware] action plugin failed:', p.name, err);
-                    }
-                }
-            }
-        }
-        // Then apply entity-specific modifiers
-        // Collect all matching modifiers
-        const modifiers = [];
-        // Exact match first
+        const steps = [];
         const exact = this.exactModifiers.get(entity.name);
         if (exact) {
-            modifiers.push(exact);
+            steps.push(this.createModifierStep(exact, context));
         }
-        // Then all pattern matches
-        for (const { pattern, modifier } of this.patternModifiers) {
-            if (pattern.test(entity.name)) {
-                modifiers.push(modifier);
+        for (const entry of this.patternModifiers) {
+            if (entry.pattern.test(entity.name)) {
+                steps.push(this.createModifierStep(entry, context));
             }
         }
-        // Apply all matching modifiers in order
-        for (const modifier of modifiers) {
-            runInInjectionContext(this.injector, () => modifier(context));
+        const entityPlugins = entity.plugins ?? [];
+        for (const pluginRef of entityPlugins) {
+            const contrib = this.providedActionPlugins.find((x) => x.name === pluginRef.name);
+            if (contrib) {
+                steps.push(this.createPluginStep(contrib, pluginRef.name, context));
+            }
+        }
+        const sorted = steps.sort((a, b) => a.order - b.order);
+        for (const step of sorted) {
+            try {
+                await runInInjectionContext(this.injector, step.run);
+            }
+            catch (err) {
+                console.error('[AXPEntityMiddleware] entity processing step failed:', err);
+            }
         }
         return context.toEntity();
     }
     //#endregion
+    //#region ----   Step Factories   ----
+    createModifierStep(entry, context) {
+        return {
+            order: entry.order,
+            run: () => entry.modifier(context),
+        };
+    }
+    createPluginStep(contrib, pluginName, context) {
+        return {
+            order: contrib.order ?? 0,
+            run: async () => {
+                const pluginRef = context.plugins.find(pluginName).get();
+                if (!pluginRef) {
+                    return;
+                }
+                await contrib.apply(context, pluginRef.options);
+            },
+        };
+    }
+    //#endregion
     //#region ----   Helpers   ----
     wildcardToRegExp(pattern) {
         const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, '\\$&');
@@ -3215,6 +3228,24 @@ class AXPEntityDataProviderImpl {
     insertOne(entity) {
         return this.storageService.insertOne(this.entityName, entity);
     }
+    count(request) {
+        return this.storageService.count(this.entityName, request);
+    }
+    queryAll(request, options) {
+        return this.storageService.queryAll(this.entityName, request, options);
+    }
+    getMany(ids) {
+        return this.storageService.getMany(this.entityName, ids);
+    }
+    exists(id) {
+        return this.storageService.exists(this.entityName, id);
+    }
+    upsertOne(entity, options) {
+        return this.storageService.upsertOne(this.entityName, entity, options);
+    }
+    aggregate(request, options) {
+        return this.storageService.aggregate(this.entityName, request, options);
+    }
 }
 class AXMEntityCrudService {
 }
@@ -3316,6 +3347,24 @@ class AXMEntityCrudServiceImpl {
     get storageService() {
         return this._storageService;
     }
+    async count(request) {
+        return this._entityDataProvider.count(request);
+    }
+    async queryAll(request, options) {
+        return this._entityDataProvider.queryAll(request, options);
+    }
+    async getMany(ids) {
+        return this._entityDataProvider.getMany(ids);
+    }
+    async exists(id) {
+        return this._entityDataProvider.exists(id);
+    }
+    async upsertOne(entity, options) {
+        return this._entityDataProvider.upsertOne(entity, options);
+    }
+    async aggregate(request, options) {
+        return this._entityDataProvider.aggregate(request, options);
+    }
     async custom(request) { }
 }
 
@@ -3943,6 +3992,11 @@ class AXPEntityDetailListViewModel {
         this.filterOperatorMiddleware = this.injector.get(AXPFilterOperatorMiddlewareService);
         this.expressionEvaluator = this.injector.get(AXPExpressionEvaluatorService);
         this.queryExecutor = this.injector.get(AXPQueryExecutor);
+        this.settingsService = this.injector.get(AXPSettingsService);
+        this.destroyed = new Subject();
+        this.showRowIndexColumnEnabled = signal(false, ...(ngDevMode ? [{ debugName: "showRowIndexColumnEnabled" }] : /* istanbul ignore next */ []));
+        /** Whether the row index column is shown (user setting). */
+        this.showIndexColumn = computed(() => this.showRowIndexColumnEnabled(), ...(ngDevMode ? [{ debugName: "showIndexColumn" }] : /* istanbul ignore next */ []));
         this.dataSource = new AXDataSource({
             byKey: async (key) => {
                 const execute = this.detailEntity()?.queries?.byKey?.execute;
@@ -4082,8 +4136,28 @@ class AXPEntityDetailListViewModel {
             };
             return await this.expressionEvaluator.evaluate(actionData, scope);
         };
+        void this.syncShowRowIndexColumnSetting();
+        this.settingsService.onLoaded.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+        this.settingsService.onChanged.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
         this.initialize();
     }
+    async syncShowRowIndexColumnSetting() {
+        try {
+            const value = await this.settingsService.get(AXPCommonSettings.ShowRowIndexColumn);
+            this.showRowIndexColumnEnabled.set(value ?? false);
+        }
+        catch {
+            this.showRowIndexColumnEnabled.set(false);
+        }
+    }
+    destroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
     async initialize() {
         const entityResolver = this.injector.get(AXPEntityDefinitionRegistryService);
         const [moduleName, entityName] = this.detailEntityConfig.entity.split('.');
@@ -4223,6 +4297,118 @@ const AXPEntityEventsKeys = {
     REFRESH_DATA: 'entity:refresh-data',
 };
 
+/**
+ * Resolves a stable row id from entity list row data.
+ */
+function getEntityListRowId(data, key = 'id') {
+    const value = data[key];
+    if (value != null && value !== '') {
+        return String(value);
+    }
+    return '';
+}
+/**
+ * Finds row data in a hierarchical grid tree (root rows and nested children).
+ */
+function findEntityListRowDataInTree(items, id, key) {
+    for (const item of items) {
+        if (item && typeof item === 'object' && String(item[key]) === id) {
+            return item;
+        }
+        const rec = item;
+        const metaChildren = rec?.['__meta__']?.['children'];
+        const directChildren = rec?.['children'];
+        const childArr = Array.isArray(metaChildren)
+            ? metaChildren
+            : Array.isArray(directChildren)
+                ? directChildren
+                : null;
+        if (childArr?.length) {
+            const found = findEntityListRowDataInTree(childArr, id, key);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Restores expanded rows after data load (parents before children).
+ */
+async function restoreEntityListExpandedRows(options) {
+    const pending = [...new Set(options.expandedRowIds.filter(Boolean))];
+    if (!pending.length) {
+        return;
+    }
+    let safety = 0;
+    const maxPasses = Math.max(pending.length * 3, 10);
+    while (pending.length > 0 && safety++ < maxPasses) {
+        const rows = options.getDisplayedRows();
+        let progressed = false;
+        for (let i = pending.length - 1; i >= 0; i--) {
+            const id = pending[i];
+            const item = findEntityListRowDataInTree(rows, id, options.rowKey);
+            if (!item) {
+                continue;
+            }
+            const meta = item['__meta__'];
+            if (meta?.['expanded'] !== true) {
+                await options.expandRow({ data: item });
+            }
+            pending.splice(i, 1);
+            progressed = true;
+        }
+        if (!progressed) {
+            break;
+        }
+    }
+}
+
+/**
+ * Applies take/skip to the data source without triggering {@link AXDataSource.load}.
+ */
+function applyDataSourcePagingWithoutLoad(dataSource, paging) {
+    const take = Math.max(1, paging.take);
+    const skip = Math.max(0, paging.skip);
+    const page = Math.floor(skip / take);
+    const ds = dataSource;
+    dataSource.config.pageSize = take;
+    if (ds._query) {
+        ds._query.take = take;
+        ds._query.skip = skip;
+    }
+    ds._page = page;
+}
+function getDataSourcePageIndex(dataSource) {
+    const ds = dataSource;
+    return ds._page ?? 0;
+}
+function normalizeListPaging(paging, defaultTake) {
+    const take = typeof paging?.take === 'number' && paging.take > 0 ? paging.take : defaultTake;
+    const skip = typeof paging?.skip === 'number' && paging.skip >= 0 ? paging.skip : 0;
+    return { take, skip };
+}
+
+const AXPEntityListPersistenceModeDefault = 'persistent';
+function normalizeEntityListPersistenceMode(value) {
+    if (value === 'none' || value === 'persistent' || value === 'route') {
+        return value;
+    }
+    return AXPEntityListPersistenceModeDefault;
+}
+function canPersistEntityListState(mode) {
+    return mode !== 'none';
+}
+/** `none` never reads list state from user settings. */
+function shouldLoadEntityListStateFromStorage(mode) {
+    return mode !== 'none';
+}
+/** `route` clears stored list state when the route entity (module + name) changes. */
+function shouldResetEntityListStateOnRouteEntry(mode) {
+    return mode === 'route';
+}
+const ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY = 'axp-entity-list-route-context';
+
 /**
  * Entity Event Dispatcher - A wrapper for entity-specific events
  * Handles pattern-based dispatching for entity operations with wildcard support
@@ -4556,14 +4742,17 @@ class AXPEntityMasterListViewModel {
         return `${resolvedCommand}${suffix}`;
     }
     async setView(viewName = null) {
-        const entitySetting = await this.settings.get(this.settingEntityKey);
-        const selectedViewName = entitySetting?.list?.currentView;
+        let selectedViewName;
+        if (await this.shouldLoadPersistedListState()) {
+            const entitySetting = await this.settings.get(this.settingEntityKey);
+            selectedViewName = entitySetting?.list?.currentView;
+        }
         if (viewName != this.view().name) {
             this.view.set(this.views().find((c) => c.name == (viewName || selectedViewName)) ?? this.views()[0]);
             this.applyViewSorts();
             this.applyViewColumns();
             this.applyViewFilters();
-            // this.applyFilterAndSort();
+            this.resolvedListPaging.set(null);
             await this.applySettings();
         }
     }
@@ -4587,6 +4776,15 @@ class AXPEntityMasterListViewModel {
         this.lastAppliedSortKey = null;
         this.lastAppliedFilterKey = null;
         this.hasQueryParamsFilters = false; // Flag to prevent overriding queryParams filters
+        /** Persisted expanded row ids for hierarchical lists (per view). */
+        this.expandedRowIds = signal([], ...(ngDevMode ? [{ debugName: "expandedRowIds" }] : /* istanbul ignore next */ []));
+        /** When true, row expand/collapse is not written to user settings (restore in progress). */
+        this.skipExpandedRowPersistence = false;
+        /** Resolved take/skip for the current view (null until loaded from settings). */
+        this.resolvedListPaging = signal(null, ...(ngDevMode ? [{ debugName: "resolvedListPaging" }] : /* istanbul ignore next */ []));
+        /** When true, pager changes are not persisted (programmatic UI sync). */
+        this.skipListPagingPersistence = false;
+        this.listPersistenceMode = null;
         this.events$ = new Subject();
         //****************** Views ******************//
         this.views = computed(() => {
@@ -4596,6 +4794,18 @@ class AXPEntityMasterListViewModel {
             });
         }, ...(ngDevMode ? [{ debugName: "views" }] : /* istanbul ignore next */ []));
         this.view = signal(this.views()[0], ...(ngDevMode ? [{ debugName: "view" }] : /* istanbul ignore next */ []));
+        this.showRowIndexColumnEnabled = signal(false, ...(ngDevMode ? [{ debugName: "showRowIndexColumnEnabled" }] : /* istanbul ignore next */ []));
+        /**
+         * Row index column: if the list view defines `indexCol` (true/false), that overrides the user setting;
+         * if `indexCol` is omitted, visibility follows {@link AXPCommonSettings.ShowRowIndexColumn}.
+         */
+        this.showIndexColumn = computed(() => {
+            const indexCol = this.view().indexCol;
+            if (indexCol !== undefined) {
+                return indexCol;
+            }
+            return this.showRowIndexColumnEnabled();
+        }, ...(ngDevMode ? [{ debugName: "showIndexColumn" }] : /* istanbul ignore next */ []));
         this.dataSource = new AXDataSource({
             byKey: async (key) => {
                 const execute = this.entityDef.queries?.byKey?.execute;
@@ -4766,13 +4976,88 @@ class AXPEntityMasterListViewModel {
             }
         });
         this.sortedFields.set(this.sortableFields());
+        void this.syncShowRowIndexColumnSetting();
+        this.settings.onLoaded.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+        this.settings.onChanged.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            void this.syncShowRowIndexColumnSetting();
+        });
+    }
+    async syncShowRowIndexColumnSetting() {
+        try {
+            const value = await this.settings.get(AXPCommonSettings.ShowRowIndexColumn);
+            this.showRowIndexColumnEnabled.set(value ?? false);
+        }
+        catch {
+            console.log('catch');
+            this.showRowIndexColumnEnabled.set(false);
+        }
+    }
+    /**
+     * Applies {@link AXPCommonSettings.EntityListPersistenceMode} for this list instance.
+     * Call once when the list view model is created (before loading list UI state).
+     */
+    async initializeListPersistence() {
+        const mode = await this.getListPersistenceMode();
+        debugger;
+        if (!shouldResetEntityListStateOnRouteEntry(mode)) {
+            return;
+        }
+        const routeKey = this.settingEntityKey;
+        let previousRouteKey = null;
+        try {
+            previousRouteKey = sessionStorage.getItem(ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY);
+        }
+        catch {
+            previousRouteKey = null;
+        }
+        if (previousRouteKey !== routeKey) {
+            await this.clearEntityListSettings();
+            try {
+                sessionStorage.setItem(ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY, routeKey);
+            }
+            catch {
+                // sessionStorage may be unavailable
+            }
+        }
+    }
+    async getListPersistenceMode() {
+        if (this.listPersistenceMode != null) {
+            return this.listPersistenceMode;
+        }
+        const value = await this.settings.get(AXPCommonSettings.EntityListPersistenceMode);
+        this.listPersistenceMode = normalizeEntityListPersistenceMode(value);
+        return this.listPersistenceMode;
+    }
+    async shouldLoadPersistedListState() {
+        return shouldLoadEntityListStateFromStorage(await this.getListPersistenceMode());
+    }
+    async shouldPersistListState() {
+        return canPersistEntityListState(await this.getListPersistenceMode());
+    }
+    async clearEntityListSettings() {
+        await this.settings.scope(AXPPlatformScope.User).update(this.settingEntityKey, (prev) => {
+            if (!prev || typeof prev !== 'object') {
+                return {};
+            }
+            const next = { ...prev };
+            delete next['list'];
+            return next;
+        });
     }
     async applySettings() {
-        this.saveSettings('view');
+        if (await this.shouldPersistListState()) {
+            this.saveSettings('view');
+        }
+        if (!(await this.shouldLoadPersistedListState())) {
+            this.loadListPagingFromViewSettings(null);
+            this.expandedRowIds.set([]);
+            return;
+        }
         const listViewSetting = await this.settings.get(this.settingEntityKey);
         if (listViewSetting) {
             const columns = listViewSetting.list?.views?.[this.view().name]?.columns;
-            const pageSize = listViewSetting.list?.views?.[this.view().name]?.pageSize;
             const sorts = listViewSetting.list?.views?.[this.view().name]?.sorts;
             const filters = listViewSetting.list?.views?.[this.view().name]?.filters;
             let columnVisibilityMap;
@@ -4781,7 +5066,7 @@ class AXPEntityMasterListViewModel {
                 columnVisibilityMap = new Map(columns.map((col) => [col.name, col.visible]));
                 columnWidthsMap = new Map(columns.map((col) => [col.name, col.width]));
             }
-            // Do not set pageSize here to avoid triggering an extra load
+            this.loadListPagingFromViewSettings(listViewSetting);
             if (columns && columnVisibilityMap && columnWidthsMap) {
                 this.columns.update((prev) => prev
                     .map((c) => {
@@ -4803,16 +5088,102 @@ class AXPEntityMasterListViewModel {
             if (Array.isArray(filters) && !this.hasQueryParamsFilters) {
                 this.filterQueries.set(filters);
             }
+            const expandedRowIds = listViewSetting.list?.views?.[this.view().name]?.expandedRowIds;
+            if (Array.isArray(expandedRowIds)) {
+                this.expandedRowIds.set(expandedRowIds.map((id) => String(id)).filter(Boolean));
+            }
+            else {
+                this.expandedRowIds.set([]);
+            }
+        }
+        else {
+            this.loadListPagingFromViewSettings(null);
+        }
+    }
+    async ensureListPagingResolved() {
+        if (this.resolvedListPaging() != null) {
+            return;
+        }
+        if (!(await this.shouldLoadPersistedListState())) {
+            this.loadListPagingFromViewSettings(null);
+            return;
+        }
+        const entitySetting = await this.settings.get(this.settingEntityKey);
+        this.loadListPagingFromViewSettings(entitySetting);
+    }
+    getResolvedListPaging() {
+        return (this.resolvedListPaging() ??
+            normalizeListPaging(undefined, this.view().pageSize || this.dataSource.config.pageSize || 10));
+    }
+    applyPagingToDataSourceWithoutLoad() {
+        applyDataSourcePagingWithoutLoad(this.dataSource, this.getResolvedListPaging());
+    }
+    saveListPaging(take, skip) {
+        const paging = normalizeListPaging({ take, skip }, this.view().pageSize || 10);
+        this.resolvedListPaging.set(paging);
+        this.saveSettings('listPaging', paging);
+    }
+    resetListPagingSkip() {
+        const paging = normalizeListPaging({ take: this.getResolvedListPaging().take, skip: 0 }, this.view().pageSize || 10);
+        this.resolvedListPaging.set(paging);
+        this.saveSettings('listPaging', paging);
+    }
+    loadListPagingFromViewSettings(entitySetting) {
+        const viewSettings = entitySetting?.list?.views?.[this.view().name];
+        const defaultTake = this.view().pageSize || 10;
+        let paging = viewSettings?.paging;
+        if (!paging && typeof viewSettings?.pageSize === 'number') {
+            paging = { take: viewSettings.pageSize, skip: 0 };
+        }
+        this.resolvedListPaging.set(normalizeListPaging(paging, defaultTake));
+    }
+    getExpandedRowIds() {
+        return this.expandedRowIds();
+    }
+    /**
+     * Updates persisted expanded row ids when the user expands or collapses a tree row.
+     */
+    updateExpandedRowId(rowId, expanded) {
+        if (!rowId || !this.parentKey()) {
+            return;
+        }
+        const next = new Set(this.expandedRowIds());
+        if (expanded) {
+            next.add(rowId);
+        }
+        else {
+            next.delete(rowId);
+        }
+        const ids = Array.from(next);
+        this.expandedRowIds.set(ids);
+        this.saveSettings('expandedRows', ids);
+    }
+    handleRowExpandChange(rowData) {
+        if (this.skipExpandedRowPersistence || !this.parentKey()) {
+            return;
+        }
+        const key = this.dataSource.config?.key ?? 'id';
+        const rowId = getEntityListRowId(rowData, key);
+        if (!rowId) {
+            return;
         }
+        // onItemExpanded fires before the grid toggles __meta__.expanded on expandedItem.
+        const meta = rowData['__meta__'];
+        const wasExpanded = meta?.['expanded'] === true;
+        this.updateExpandedRowId(rowId, !wasExpanded);
     }
     async saveSettings(changesType, data) {
+        if (!(await this.shouldPersistListState())) {
+            return;
+        }
         const updateSettings = (updateFn) => {
             this.settings.scope(AXPPlatformScope.User).update(this.settingEntityKey, updateFn);
         };
         switch (changesType) {
-            case 'columnSizes':
+            case 'columnSizes': {
+                const columnSizeData = data;
                 updateSettings((prev) => {
-                    const field = data.dataField.split('-')[1];
+                    const field = columnSizeData.dataField.split('-')[1];
                     const newSettings = { ...prev };
                     const existingColumns = prev?.list?.views?.[this.view().name]?.columns;
                     const baseColumns = Array.isArray(existingColumns) && existingColumns.length
@@ -4824,7 +5195,7 @@ class AXPEntityMasterListViewModel {
                         }));
                     const updatedColumns = baseColumns.map((c) => ({
                         ...c,
-                        width: c.name === field ? data.width : c.width,
+                        width: c.name === field ? columnSizeData.width : c.width,
                     }));
                     const x = this.allAvailableColumns().map((c) => ({
                         name: c.column?.options?.dataPath ?? c.name,
@@ -4835,10 +5206,12 @@ class AXPEntityMasterListViewModel {
                     return newSettings;
                 });
                 break;
-            case 'columnOrders':
+            }
+            case 'columnOrders': {
+                const orderedColumns = data;
                 updateSettings((prev) => {
                     const newSettings = { ...prev };
-                    set(newSettings, `list.views.${this.view().name}.columns`, data.map((c) => ({
+                    set(newSettings, `list.views.${this.view().name}.columns`, orderedColumns.map((c) => ({
                         name: c.column?.options?.dataPath ?? c.name,
                         visible: c.visible,
                         width: c.width,
@@ -4846,6 +5219,7 @@ class AXPEntityMasterListViewModel {
                     return newSettings;
                 });
                 break;
+            }
             case 'view':
                 updateSettings((prev) => ({
                     ...prev,
@@ -4865,6 +5239,26 @@ class AXPEntityMasterListViewModel {
                             [this.view().name]: {
                                 ...prev?.list?.views?.[this.view().name],
                                 pageSize: data,
+                                paging: normalizeListPaging({
+                                    take: data,
+                                    skip: prev?.list?.views?.[this.view().name]?.paging?.skip,
+                                }, this.view().pageSize || 10),
+                            },
+                        },
+                    },
+                }));
+                break;
+            case 'listPaging':
+                updateSettings((prev) => ({
+                    ...prev,
+                    list: {
+                        ...prev?.list,
+                        views: {
+                            ...prev?.list?.views,
+                            [this.view().name]: {
+                                ...prev?.list?.views?.[this.view().name],
+                                paging: data,
+                                pageSize: data.take,
                             },
                         },
                     },
@@ -4900,6 +5294,21 @@ class AXPEntityMasterListViewModel {
                     },
                 }));
                 break;
+            case 'expandedRows':
+                updateSettings((prev) => ({
+                    ...prev,
+                    list: {
+                        ...prev?.list,
+                        views: {
+                            ...prev?.list?.views,
+                            [this.view().name]: {
+                                ...prev?.list?.views?.[this.view().name],
+                                expandedRowIds: data,
+                            },
+                        },
+                    },
+                }));
+                break;
             default:
                 break;
         }
@@ -5139,6 +5548,7 @@ class AXPEntityMasterListViewModel {
         this.applyViewFilters();
     }
     async applyFilterAndSort() {
+        await this.ensureListPagingResolved();
         const sorts = this.sortedFields()
             .filter((sf) => sf.dir)
             .map((s) => ({ name: s.name, dir: s.dir }));
@@ -5148,10 +5558,12 @@ class AXPEntityMasterListViewModel {
         if (sortKey === this.lastAppliedSortKey && filterKey === this.lastAppliedFilterKey) {
             return; // No effective change; avoid redundant refresh
         }
-        // Determine if filters changed (for pagination reset)
-        const filtersChanged = filterKey !== this.lastAppliedFilterKey;
+        const filtersChanged = this.lastAppliedFilterKey != null && filterKey !== this.lastAppliedFilterKey;
         this.lastAppliedSortKey = sortKey;
         this.lastAppliedFilterKey = filterKey;
+        if (filtersChanged) {
+            this.resetListPagingSkip();
+        }
         this.dataSource.clearFilter();
         this.dataSource.sort(...sorts.map((s) => ({ dir: s.dir, field: s.name })));
         this.dataSource.filter(this.filterOperatorMiddleware.transformFilter({
@@ -5358,7 +5770,9 @@ class AXPEntityListViewModelFactory {
         this.layout.setNavigationLoading(true);
         const config = await this.entityService.resolve(moduleName, entityName);
         this.layout.setNavigationLoading(false);
-        return new AXPEntityMasterListViewModel(this.injector, config);
+        const vm = new AXPEntityMasterListViewModel(this.injector, config);
+        await vm.initializeListPersistence();
+        return vm;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPEntityListViewModelFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPEntityListViewModelFactory, providedIn: 'root' }); }
@@ -6343,6 +6757,225 @@ const AXPEntityPreloadFiltersViewModelResolver = async (route, state) => {
 };
 //#endregion
 
+//#region ---- Path / numeric helpers ----
+function getPath(obj, path) {
+    if (obj == null || path.length === 0) {
+        return undefined;
+    }
+    const parts = path.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object') {
+            return undefined;
+        }
+        cur = cur[p];
+    }
+    return cur;
+}
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function defaultAlias(measure, index) {
+    if (measure.alias?.trim()) {
+        return measure.alias.trim();
+    }
+    if (measure.reducer === 'count') {
+        return index === 0 ? 'count' : `count_${index}`;
+    }
+    const field = measure.field ?? 'value';
+    const safeField = field.replace(/\./g, '_');
+    return `${measure.reducer}_${safeField}`;
+}
+/**
+ * Pure aggregation over already-filtered plain rows (e.g. outputs of {@link filterSortEntityRows}).
+ */
+function computeEntityAggregates(rows, request) {
+    const groupBy = request.groupBy ?? [];
+    const measures = request.measures ?? [];
+    if (measures.length === 0) {
+        return [];
+    }
+    const groups = new Map();
+    const stableGroupKey = (row) => {
+        const parts = groupBy.map((path) => getPath(row, path));
+        return JSON.stringify(parts);
+    };
+    for (const row of rows) {
+        const k = stableGroupKey(row);
+        let bucket = groups.get(k);
+        if (!bucket) {
+            bucket = {
+                keyParts: groupBy.map((path) => getPath(row, path)),
+                rows: [],
+            };
+            groups.set(k, bucket);
+        }
+        bucket.rows.push(row);
+    }
+    const result = [];
+    for (const bucket of groups.values()) {
+        const out = {};
+        groupBy.forEach((field, i) => {
+            out[field] = bucket.keyParts[i];
+        });
+        measures.forEach((measure, index) => {
+            const alias = defaultAlias(measure, index);
+            const gRows = bucket.rows;
+            if (measure.reducer === 'count') {
+                out[alias] = gRows.length;
+                return;
+            }
+            const fieldPath = measure.field;
+            if (!fieldPath) {
+                out[alias] = null;
+                return;
+            }
+            const nums = gRows.map((r) => toNumber(getPath(r, fieldPath))).filter((n) => n !== null);
+            switch (measure.reducer) {
+                case 'sum':
+                    out[alias] = nums.reduce((a, b) => a + b, 0);
+                    break;
+                case 'min':
+                    out[alias] = nums.length ? Math.min(...nums) : null;
+                    break;
+                case 'max':
+                    out[alias] = nums.length ? Math.max(...nums) : null;
+                    break;
+                case 'avg':
+                    out[alias] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                    break;
+                default:
+                    out[alias] = null;
+            }
+        });
+        result.push(out);
+    }
+    return result;
+}
+//#endregion
+
+//#endregion
+//#region ---- Pure helpers ----
+/**
+ * Fields where `contains` means hierarchical category membership (expand to descendants).
+ * Excludes e.g. `roleIds`, which uses array membership only and must use normal filter logic.
+ */
+function isCategoryContainsFieldName(field) {
+    if (field === 'categoryIds') {
+        return true;
+    }
+    if (typeof field === 'string' && field.endsWith('Ids') && field !== 'roleIds') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if the entity is a category entity (ends with 'Category').
+ */
+function isCategoryEntity(entityName) {
+    return entityName.endsWith('Category');
+}
+/**
+ * Check if the filter is a category filter (contains operator on categoryIds field).
+ * Handles both simple filters and compound filters.
+ */
+function isCategoryFilter(filter) {
+    if (filter?.operator?.type === 'contains' && isCategoryContainsFieldName(filter.field)) {
+        return true;
+    }
+    if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+        return filter.filters.some((nestedFilter) => nestedFilter?.operator?.type === 'contains' && isCategoryContainsFieldName(nestedFilter.field));
+    }
+    return false;
+}
+//#endregion
+//#region ---- Query execution ----
+/**
+ * Apply recursive category filtering: entities that belong to the category or any of its children.
+ */
+async function applyRecursiveCategoryFilter(result, filter, entityName, getAllChildCategoryIds) {
+    let categoryFilter = filter;
+    let otherFilters = [];
+    if (filter?.logic && filter?.filters && Array.isArray(filter.filters)) {
+        const categoryFilterIndex = filter.filters.findIndex((f) => f?.operator?.type === 'contains' && isCategoryContainsFieldName(f.field));
+        if (categoryFilterIndex !== -1) {
+            categoryFilter = filter.filters[categoryFilterIndex];
+            otherFilters = filter.filters.filter((_, index) => index !== categoryFilterIndex);
+        }
+    }
+    if (!categoryFilter) {
+        return applyFilterArray(result, [filter]);
+    }
+    const categoryId = categoryFilter.value;
+    const categoryField = categoryFilter.field;
+    const allCategoryIds = await getAllChildCategoryIds(categoryId, entityName);
+    let filteredResult = result.filter((item) => {
+        const categoryIds = item[categoryField];
+        if (!categoryIds)
+            return false;
+        const itemCategoryIds = Array.isArray(categoryIds) ? categoryIds : [categoryIds];
+        return itemCategoryIds.some((itemCategoryId) => allCategoryIds.includes(itemCategoryId));
+    });
+    if (otherFilters.length > 0) {
+        filteredResult = applyFilterArray(filteredResult, otherFilters);
+    }
+    return filteredResult;
+}
+/**
+ * Calculate childrenCount for each category entity when missing.
+ */
+async function calculateChildrenCounts(items, entityName, getDirectChildCount) {
+    return Promise.all(items.map(async (item) => {
+        if (typeof item.childrenCount === 'number') {
+            return { ...item };
+        }
+        const childrenCount = await getDirectChildCount(item.id, entityName);
+        return { ...item, childrenCount };
+    }));
+}
+/**
+ * Loads raw rows for an entity and applies the same sorting and filtering as {@link runEntityQuery},
+ * without pagination.
+ */
+async function filterSortEntityRows(entityName, request, adapters) {
+    let result = await adapters.getRawAll(entityName);
+    if (request.sort && request.sort.length) {
+        result = applySortArray(result, request.sort);
+    }
+    if (request.filter && isCategoryFilter(request.filter)) {
+        result = await applyRecursiveCategoryFilter(result, request.filter, entityName, adapters.getAllChildCategoryIds);
+    }
+    else {
+        result = applyFilterArray(result, request.filter ? [request.filter] : []);
+    }
+    if (isCategoryEntity(entityName)) {
+        result = await calculateChildrenCounts(result, entityName, adapters.getDirectChildCount);
+    }
+    return result;
+}
+/**
+ * Shared entity query logic: sort, filter (including recursive category filter), childrenCount, pagination.
+ */
+async function runEntityQuery(entityName, request, adapters) {
+    const rows = await filterSortEntityRows(entityName, request, adapters);
+    const skip = request.skip ?? 0;
+    const take = request.take ?? 0;
+    return {
+        total: rows.length,
+        items: rows.slice(skip, skip + take),
+    };
+}
+//#endregion
+
+//#endregion
+
 //#region ---- Imports ----
 //#endregion
 //#region ---- Constants ----
@@ -7082,7 +7715,7 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             // Use setTimeout to ensure DOM is updated after tree reload
             setTimeout(() => {
                 if (this.searchValue().trim()) {
-                    this.highlightService.highlight('ax-tree-view .ax-truncate', this.searchValue().trim());
+                    this.highlightService.highlight('ax-tree-view .truncate', this.searchValue().trim());
                 }
             }, 100);
         }
@@ -10581,6 +11214,7 @@ class AXPEntityListTableService {
         this.workflow = inject(AXPWorkflowService);
         this.commandService = inject(AXPCommandService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.settings = inject(AXPSettingsService);
         this.evaluateExpressions = async (options, data) => {
             if (!options) {
                 return {};
@@ -10601,6 +11235,20 @@ class AXPEntityListTableService {
      * Convert Entity to List Widget Options
      */
     async convertEntityToListOptions(entity, options, allActions) {
+        const viewIndexCol = entity.interfaces?.master?.list?.views?.[0]?.indexCol;
+        let showIndex = false;
+        if (viewIndexCol !== undefined) {
+            showIndex = viewIndexCol;
+        }
+        else {
+            try {
+                const fromSetting = await this.settings.get(AXPCommonSettings.ShowRowIndexColumn);
+                showIndex = fromSetting ?? false;
+            }
+            catch {
+                showIndex = false;
+            }
+        }
         const listOptions = {
             // 📊 Data Source
             dataSource: this.createDataSource(entity),
@@ -10610,7 +11258,7 @@ class AXPEntityListTableService {
             primaryCommands: this.createRowCommands(allActions, 'primary'),
             secondaryCommands: this.createRowCommands(allActions, 'secondary'),
             // ⚙️ Table Features
-            showIndex: entity.interfaces?.master?.list?.views?.[0]?.indexCol ?? false,
+            showIndex,
             allowSelection: this.hasSelectedScopeActions(entity),
             paging: true,
             showHeader: true,
@@ -10627,7 +11275,6 @@ class AXPEntityListTableService {
             // 🎪 Events
             ...this.createDefaultEvents(entity, allActions, options?.excludeProperties),
         };
-        console.log('listOptions', listOptions);
         return listOptions;
     }
     //#endregion
@@ -11015,6 +11662,7 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         this.commandService = inject(AXPCommandService);
         this.eventService = inject(AXPBroadcastEventService);
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.route = inject(ActivatedRoute);
         this.isMounted = signal(false, ...(ngDevMode ? [{ debugName: "isMounted" }] : /* istanbul ignore next */ []));
         this.entity = signal(null, ...(ngDevMode ? [{ debugName: "entity" }] : /* istanbul ignore next */ []));
         this.listNode = signal(null, ...(ngDevMode ? [{ debugName: "listNode" }] : /* istanbul ignore next */ []));
@@ -11188,13 +11836,7 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
     //   console.log(this.listWidget()?.instance.output('selectedRows'));
     // }
     async execute(commandName, _data) {
-        const action = this.allActions().find((c) => {
-            return (c.name == commandName &&
-                ((this.selectedItems().length
-                    ? c.scope == AXPEntityCommandScope.Selected
-                    : c.scope == AXPEntityCommandScope.Individual) ||
-                    c.scope == AXPEntityCommandScope.TypeLevel));
-        });
+        const action = this.findToolbarAction(commandName);
         const command = commandName.split('&')[0];
         const commandData = action?.scope == AXPEntityCommandScope.Selected
             ? this.selectedItems()
@@ -11260,6 +11902,29 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
             });
         }
     }
+    /**
+     * Resolves toolbar commands including nested dropdown (`items`) actions.
+     */
+    findToolbarAction(commandName) {
+        const scopeMatches = (c) => (this.selectedItems().length
+            ? c.scope === AXPEntityCommandScope.Selected
+            : c.scope === AXPEntityCommandScope.Individual) || c.scope === AXPEntityCommandScope.TypeLevel;
+        const visit = (nodes) => {
+            for (const node of nodes) {
+                if (node.name === commandName && scopeMatches(node)) {
+                    return node;
+                }
+                if (node.items?.length) {
+                    const nested = visit(node.items);
+                    if (nested) {
+                        return nested;
+                    }
+                }
+            }
+            return undefined;
+        };
+        return visit(this.allActions());
+    }
     async evaluateToolbarExpressions(opts, expressionData) {
         if (!opts) {
             return {};
@@ -11272,6 +11937,92 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         };
         return (await this.expressionEvaluator.evaluate(opts, scope));
     }
+    /**
+     * Parses the `filters` query param (same shape as standalone entity list routes).
+     */
+    parseFiltersFromRoute() {
+        const filtersJson = this.route.snapshot.queryParamMap.get('filters');
+        if (!filtersJson) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(filtersJson);
+            const rows = [];
+            if (Array.isArray(parsed)) {
+                for (const item of parsed) {
+                    if (item && typeof item === 'object' && typeof item.field === 'string') {
+                        rows.push(item);
+                    }
+                }
+            }
+            else if (parsed !== null && typeof parsed === 'object') {
+                for (const [field, value] of Object.entries(parsed)) {
+                    rows.push({ field, value, operator: { type: 'equal' } });
+                }
+            }
+            return rows
+                .filter((row) => row.field && row.value !== undefined && row.value !== null && row.value !== '')
+                .map((row) => ({
+                field: row.field,
+                operator: row.operator && typeof row.operator === 'object' && 'type' in row.operator
+                    ? row.operator
+                    : { type: 'equal' },
+                value: row.value,
+                hidden: true,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Route `filters` apply only when the active details `page` matches this list's entity
+     * (e.g. WorkOrder filters must not affect FailureRegister on the same asset layout).
+     */
+    shouldApplyRouteFilters() {
+        const pageId = this.route.snapshot.queryParamMap.get('page');
+        if (!pageId) {
+            return false;
+        }
+        const entitySource = this.entitySource();
+        if (!entitySource) {
+            return false;
+        }
+        const [, entityName] = entitySource.split('.');
+        return !!entityName && pageId === entityName;
+    }
+    /**
+     * Merges route filters into related-entity toolbar filters (route wins per field).
+     */
+    mergeToolbarFilters(baseFilters, routeFilters) {
+        const byField = new Map(baseFilters.map((filter) => [filter.field, filter]));
+        for (const filter of routeFilters) {
+            byField.set(filter.field, filter);
+        }
+        return [...byField.values()];
+    }
+    getMergedToolbarFilters() {
+        const base = (this.getValue()?.toolbar?.filters ?? []);
+        if (!this.shouldApplyRouteFilters()) {
+            return base;
+        }
+        const routeFilters = this.parseFiltersFromRoute();
+        return routeFilters.length ? this.mergeToolbarFilters(base, routeFilters) : base;
+    }
+    /**
+     * Applies merged route + parent-scope filters to the widget value and data source.
+     */
+    applyMergedRouteFiltersToList() {
+        const merged = this.getMergedToolbarFilters();
+        const current = this.getValue();
+        if (!isEqual$1(current?.toolbar?.filters, merged)) {
+            this.setValue({
+                ...current,
+                toolbar: { ...(current?.toolbar ?? {}), filters: merged },
+            });
+        }
+        this.pushToolbarFiltersToDataSource();
+    }
     /**
      * Re-evaluates related-entity list filters from the live dialog form context (e.g. after create saves the main row id).
      */
@@ -11461,23 +12212,27 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
                 mode: 'view',
                 defaultValue: this.getValue()?.table,
             });
+            const mergedToolbarFilters = this.getMergedToolbarFilters();
             this.toolbarNode.set({
                 type: AXPWidgetsCatalog.listToolbar,
                 path: `toolbar`,
                 options: toolbarOptions,
                 mode: 'view',
                 defaultValue: {
-                    filters: this.getValue()?.toolbar?.filters,
+                    filters: mergedToolbarFilters,
                     sorts: this.getValue()?.toolbar?.sorts,
                     columns: this.getValue()?.toolbar?.columns,
                 },
             });
             queueMicrotask(() => {
-                void this.pushToolbarFiltersToDataSource();
+                this.applyMergedRouteFiltersToList();
             });
         }, 100);
     }
     async ngAfterViewInit() {
+        this.route.queryParamMap.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            this.applyMergedRouteFiltersToList();
+        });
         this.workflow.events$
             .pipe(ofType(AXPRefreshEvent))
             .pipe(takeUntil(this.destroyed))
@@ -13269,6 +14024,14 @@ class AXPLookupWidgetEditComponent extends AXPValueWidgetComponent {
             }
         });
     }
+    outputs() {
+        return [
+            {
+                name: 'selectedItems',
+                value: this.selectedItems(),
+            },
+        ];
+    }
     singleOrMultiple(values) {
         return this.multiple() ? values : values[0];
     }
@@ -17430,9 +18193,16 @@ class AXPPageListConverter extends AXPBaseRelatedEntityConverter {
                         return result;
                     };
                     const flatActions = flattenActions(mergedActions);
-                    const action = flatActions.find((a) => {
-                        return a.name === command.name || a.name === commandName || a.name.split('&')[0] === commandName;
-                    });
+                    /**
+                     * Toolbar keys are `commandKey&action.name`. Several dropdown items can share the same `commandKey`
+                     * (e.g. multiple `WorkflowManagement.WorkflowDefinition:Execute` lifecycle templates). Matching only by
+                     * prefix makes `.find` return the first sibling — wrong template (e.g. offboarding runs onboarding).
+                     */
+                    const action = command.name.includes('&')
+                        ? flatActions.find((a) => a.name === command.name)
+                        : flatActions.find((a) => {
+                            return a.name === command.name || a.name === commandName || a.name.split('&')[0] === commandName;
+                        });
                     if (!action) {
                         console.warn(`Action ${commandName} not found in entity definition`);
                         return {
@@ -19388,6 +20158,9 @@ function getDedupKey(op, entityName, init) {
     if (op === 'getOne' && init?.id !== undefined) {
         return `getOne:${entityName}:${String(init.id)}`;
     }
+    if (op === 'exists' && init?.id !== undefined) {
+        return `exists:${entityName}:${String(init.id)}`;
+    }
     if (op === 'getAll') {
         return `getAll:${entityName}`;
     }
@@ -19395,6 +20168,20 @@ function getDedupKey(op, entityName, init) {
         const r = init.request;
         return `query:${entityName}:${r.skip ?? 0}:${r.take ?? 0}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}:${JSON.stringify(r.params ?? null)}`;
     }
+    if (op === 'count' && init?.request) {
+        const r = init.request;
+        return `count:${entityName}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}`;
+    }
+    if (op === 'queryAll' && init?.request) {
+        const r = init.request;
+        return `queryAll:${entityName}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}:${JSON.stringify(init.queryAllOptions ?? null)}`;
+    }
+    if (op === 'getMany' && init?.ids) {
+        return `getMany:${entityName}:${init.ids.map(String).join(',')}`;
+    }
+    if (op === 'aggregate' && init?.aggregateRequest) {
+        return `aggregate:${entityName}:${JSON.stringify(init.aggregateRequest)}:${JSON.stringify(init.aggregateOptions ?? null)}`;
+    }
     return '';
 }
 class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
@@ -19454,6 +20241,13 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
                 insertOne: (name, e) => this.backend.insertOne(name, e),
                 query: (name, request) => this.backend.query(name, request),
                 updateOne: (name, id, data) => this.backend.updateOne(name, id, data),
+                deleteOne: (name, id) => this.backend.deleteOne(name, id),
+                count: (name, request) => this.backend.count(name, request),
+                queryAll: (name, request, options) => this.backend.queryAll(name, request, options),
+                getMany: (name, ids) => this.backend.getMany(name, ids),
+                exists: (name, id) => this.backend.exists(name, id),
+                upsertOne: (name, entity, options) => this.backend.upsertOne(name, entity, options),
+                aggregate: (name, request, options) => this.backend.aggregate(name, request, options),
             },
             ...init,
         };
@@ -19525,6 +20319,100 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
         const ctx = this.createCtx('query', entityName, { request });
         return this.run(ctx, () => this.backend.query(ctx.entityName, request));
     }
+    async count(entityName, request) {
+        const filterSortRequest = { ...request, skip: 0, take: 0 };
+        const key = getDedupKey('count', entityName, { request: filterSortRequest });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('count', entityName, { request: filterSortRequest });
+                return this.run(ctx, () => this.backend.count(ctx.entityName, request));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('count', entityName, { request: filterSortRequest });
+        return this.run(ctx, () => this.backend.count(ctx.entityName, request));
+    }
+    async queryAll(entityName, request, options) {
+        const filterSortRequest = { ...request, skip: 0, take: 0 };
+        const key = getDedupKey('queryAll', entityName, { request: filterSortRequest, queryAllOptions: options });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('queryAll', entityName, { request: filterSortRequest });
+                return this.run(ctx, () => this.backend.queryAll(ctx.entityName, request, options));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('queryAll', entityName, { request: filterSortRequest });
+        return this.run(ctx, () => this.backend.queryAll(ctx.entityName, request, options));
+    }
+    async getMany(entityName, ids) {
+        const key = getDedupKey('getMany', entityName, { ids: ids });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('getMany', entityName);
+                return this.run(ctx, () => this.backend.getMany(ctx.entityName, ids));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('getMany', entityName);
+        return this.run(ctx, () => this.backend.getMany(ctx.entityName, ids));
+    }
+    async exists(entityName, id) {
+        const key = getDedupKey('exists', entityName, { id });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('exists', entityName, { id });
+                return this.run(ctx, () => this.backend.exists(ctx.entityName, id));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('exists', entityName, { id });
+        return this.run(ctx, () => this.backend.exists(ctx.entityName, id));
+    }
+    async upsertOne(entityName, entity, options) {
+        const ctx = this.createCtx('upsertOne', entityName, { data: entity });
+        ctx.locals.set('upsertOptions', options);
+        return this.run(ctx, () => this.backend.upsertOne(ctx.entityName, entity, options));
+    }
+    async aggregate(entityName, request, options) {
+        const key = getDedupKey('aggregate', entityName, { aggregateRequest: request, aggregateOptions: options });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('aggregate', entityName);
+                ctx.locals.set('aggregateRequest', request);
+                ctx.locals.set('aggregateOptions', options);
+                return this.run(ctx, () => this.backend.aggregate(ctx.entityName, request, options));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
+        const ctx = this.createCtx('aggregate', entityName);
+        return this.run(ctx, () => this.backend.aggregate(ctx.entityName, request, options));
+    }
     async runWithDedup(key, fn) {
         try {
             return await fn();
@@ -20485,5 +21373,5 @@ var getEntityDetails_query = /*#__PURE__*/Object.freeze({
  * Generated bundle index. Do not edit.
  */
 
-export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCategoryTreeService, AXPCreateEntityCommand, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntitiesListDataSourceDefinition, AXPEntityApplyUpdatesAction, AXPEntityCategoryTreeSelectorComponent, AXPEntityCategoryWidget, AXPEntityCategoryWidgetColumnComponent, AXPEntityCategoryWidgetEditComponent, AXPEntityCategoryWidgetViewComponent, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDataSelectorService, AXPEntityDefinitionProviderWidget, AXPEntityDefinitionProviderWidgetEditComponent, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailPopoverComponent, AXPEntityDetailPopoverService, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityEventsKeys, AXPEntityFormBuilderService, AXPEntityListTableService, AXPEntityListToolbarService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityListWidget, AXPEntityListWidgetViewComponent, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityPreloadFiltersContainerComponent, AXPEntityPreloadFiltersViewModel, AXPEntityPreloadFiltersViewModelResolver, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPEntityUpdateViewSectionViewModel, AXPGetEntityDetailsQuery, AXPLayoutOrderingConfigService, AXPLookupWidget, AXPLookupWidgetColumnComponent, AXPLookupWidgetEditComponent, AXPLookupWidgetViewComponent, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPMultiSourceDefinitionProviderContext, AXPMultiSourceDefinitionProviderService, AXPMultiSourceFederatedSearchService, AXPMultiSourceSelectorComponent, AXPMultiSourceSelectorService, AXPMultiSourceSelectorWidget, AXPMultiSourceSelectorWidgetColumnComponent, AXPMultiSourceSelectorWidgetEditComponent, AXPMultiSourceSelectorWidgetViewComponent, AXPMultiSourceType, AXPOpenEntityDetailsCommand, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPRelatedColumnEnrichmentService, AXPRelatedColumnMetadataResolver, AXPSelectorStructureWidget, AXPSelectorStructureWidgetColumnComponent, AXPSelectorStructureWidgetEditComponent, AXPSelectorStructureWidgetViewComponent, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXPTruncatedBreadcrumbComponent, AXPUpdateEntityCommand, AXPViewEntityDetailsCommand, AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_MODIFIER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_MULTI_SOURCE_DEFINITION_PROVIDER, DEFAULT_COLUMN_ORDER, DEFAULT_PAIR_SPAN_RULES, DEFAULT_PROPERTY_ORDER, DEFAULT_SECTION_ORDER, EntityBuilder, EntityDataAccessor, actionExists, axpCreateEntityAiToolInputDefaults, axpCreateEntityCommandDefinition, cloneLayoutArrays, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectQuickSearchPathsFromSingleEntityDefinition, columnOrderingMiddleware, columnOrderingMiddlewareProvider, columnWidthMiddleware, columnWidthMiddlewareProvider, createColumnOrderingMiddlewareProvider, createLayoutOrderingMiddlewareProvider, createModifierContext, defaultMultiLanguageMiddleware, defaultMultiLanguageMiddlewareProvider, detectEntityChanges, ensureLayoutPropertyView, ensureLayoutSection, ensureListActions, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware, getMasterInterfacePropertySortKey, isAXPMiddlewareAbortError, layoutOrderingMiddlewareFactory, layoutOrderingMiddlewareProvider, mergeForeignKeyFieldIntoCreateActions, provideEntity, resolveEntityPluginDetailPageOrder, searchResultDescriptionMiddleware, searchResultDescriptionMiddlewareProvider };
+export { AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCategoryTreeService, AXPCreateEntityCommand, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEntitiesListDataSourceDefinition, AXPEntityApplyUpdatesAction, AXPEntityCategoryTreeSelectorComponent, AXPEntityCategoryWidget, AXPEntityCategoryWidgetColumnComponent, AXPEntityCategoryWidgetEditComponent, AXPEntityCategoryWidgetViewComponent, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDataSelectorService, AXPEntityDefinitionProviderWidget, AXPEntityDefinitionProviderWidgetEditComponent, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailPopoverComponent, AXPEntityDetailPopoverService, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityEventsKeys, AXPEntityFormBuilderService, AXPEntityListPersistenceModeDefault, AXPEntityListTableService, AXPEntityListToolbarService, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityListWidget, AXPEntityListWidgetViewComponent, AXPEntityMasterCreateViewModel, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityPreloadFiltersContainerComponent, AXPEntityPreloadFiltersViewModel, AXPEntityPreloadFiltersViewModelResolver, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPEntityUpdateViewSectionViewModel, AXPGetEntityDetailsQuery, AXPLayoutOrderingConfigService, AXPLookupWidget, AXPLookupWidgetColumnComponent, AXPLookupWidgetEditComponent, AXPLookupWidgetViewComponent, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPMultiSourceDefinitionProviderContext, AXPMultiSourceDefinitionProviderService, AXPMultiSourceFederatedSearchService, AXPMultiSourceSelectorComponent, AXPMultiSourceSelectorService, AXPMultiSourceSelectorWidget, AXPMultiSourceSelectorWidgetColumnComponent, AXPMultiSourceSelectorWidgetEditComponent, AXPMultiSourceSelectorWidgetViewComponent, AXPMultiSourceType, AXPOpenEntityDetailsCommand, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPRelatedColumnEnrichmentService, AXPRelatedColumnMetadataResolver, AXPSelectorStructureWidget, AXPSelectorStructureWidgetColumnComponent, AXPSelectorStructureWidgetEditComponent, AXPSelectorStructureWidgetViewComponent, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXPTruncatedBreadcrumbComponent, AXPUpdateEntityCommand, AXPViewEntityDetailsCommand, AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_MODIFIER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_MULTI_SOURCE_DEFINITION_PROVIDER, DEFAULT_COLUMN_ORDER, DEFAULT_PAIR_SPAN_RULES, DEFAULT_PROPERTY_ORDER, DEFAULT_SECTION_ORDER, ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY, EntityBuilder, EntityDataAccessor, actionExists, applyDataSourcePagingWithoutLoad, axpCreateEntityAiToolInputDefaults, axpCreateEntityCommandDefinition, canPersistEntityListState, cloneLayoutArrays, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectQuickSearchPathsFromSingleEntityDefinition, columnOrderingMiddleware, columnOrderingMiddlewareProvider, columnWidthMiddleware, columnWidthMiddlewareProvider, computeEntityAggregates, createColumnOrderingMiddlewareProvider, createLayoutOrderingMiddlewareProvider, createModifierContext, defaultMultiLanguageMiddleware, defaultMultiLanguageMiddlewareProvider, detectEntityChanges, ensureLayoutPropertyView, ensureLayoutSection, ensureListActions, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware, filterSortEntityRows, findEntityListRowDataInTree, getDataSourcePageIndex, getEntityListRowId, getMasterInterfacePropertySortKey, isAXPMiddlewareAbortError, isCategoryEntity, isCategoryFilter, layoutOrderingMiddlewareFactory, layoutOrderingMiddlewareProvider, mergeForeignKeyFieldIntoCreateActions, normalizeEntityListPersistenceMode, normalizeListPaging, provideEntity, resolveEntityPluginDetailPageOrder, restoreEntityListExpandedRows, runEntityQuery, searchResultDescriptionMiddleware, searchResultDescriptionMiddlewareProvider, shouldLoadEntityListStateFromStorage, shouldResetEntityListStateOnRouteEntry };
 //# sourceMappingURL=acorex-platform-layout-entity.mjs.map