@acorex/connectivity 21.0.0-next.5 → 21.0.0-next.7

package/fesm2022/acorex-connectivity-mock.mjs

@@ -14,11 +14,10 @@ import { AXMSubscriptionManagementSubscriptionEntityService, AXMSubscriptionMana
 import { AXPSystemStatusType, AXPFileStorageStatus, AXPFileStorageService, AXVChangeType as AXVChangeType$1, AXP_SEARCH_PROVIDER, AXPLockService, AXPVersioningService, AXPSystemStatuses, AXPAppVersionService } from '@acorex/platform/common';
 import { AXMTenantService, AXMTenantManagementTenantUserEntityService, AXMTenantManagementPermissionsKeys, RootConfig as RootConfig$q } from '@acorex/modules/tenant-management';
 import { RootConfig as RootConfig$1 } from '@acorex/modules/calendar-management';
+import { provideCommandSetups, AXPCommandService, provideQuerySetups, AXPQueryService, AXPRuntimeModule } from '@acorex/platform/runtime';
 import Dexie from 'dexie';
 import { AXFileService } from '@acorex/core/file';
-import { AXPWorkflowExecutionService } from '@acorex/platform/workflow';
-import { AXPCommandService, provideCommandSetups, provideQuerySetups, AXPQueryService, AXPRuntimeModule } from '@acorex/platform/runtime';
-import { AXMPermissionsKeys as AXMPermissionsKeys$3, AXMDistributionServiceImpl, AXMDocumentService, AXMDistributionInteractionService, RootConfig as RootConfig$6, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMReviewService, AXMReviewServiceImpl, AXMDistributionInteractionServiceImpl, AXMFolderService, AXMDistributionService } from '@acorex/modules/document-management';
+import { AXMPermissionsKeys as AXMPermissionsKeys$3, AXMDistributionInteractionServiceImpl, AXMDistributionServiceImpl, AXMDocumentService, AXMDistributionInteractionService, AXMFolderServiceImpl, AXMDocumentServiceImpl, AXMReviewService, AXMDocumentTypeServiceImpl, RootConfig as RootConfig$6, AXMReviewServiceImpl, AXMFolderService, AXMDistributionService, AXPDocumentManagementService } from '@acorex/modules/document-management';
 import { AXMPermissionsKeys as AXMPermissionsKeys$2, RootConfig as RootConfig$5, AXMMetaDataDefinitionService, META_DATA_SELECTOR_FIELD, AXMQueryServiceImpl, AXMQueryService, AXMDataManagementFeatureKeys } from '@acorex/modules/data-management';
 import { AXMPermissionsKeys as AXMPermissionsKeys$4, RootConfig as RootConfig$a, AXPHumanCapitalManagementFeatureKeys } from '@acorex/modules/human-capital-management';
 import { AXMSettingsManagementPermissionKeys } from '@acorex/modules/settings-management';
@@ -60,6 +59,7 @@ import { RootConfig as RootConfig$v, AXM_ORDER_NUMBER_IDENTIFIER_RULE } from '@a
 import { RootConfig as RootConfig$x } from '@acorex/modules/help-desk';
 import { AXCExternalAuthorizationService } from '@acorex/connectivity/utils';
 import { RootConfig as RootConfig$y } from '@acorex/modules/workflow-management';
+import { AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_PROVIDER } from '@acorex/platform/workflow';
 import { AXCalendarService } from '@acorex/core/date-time';
 
 //#region ----   Constants   ----
@@ -611,6 +611,9 @@ class MockFeatureChecker {
     check(keys, context, baseResult) {
         const user = context.user;
         //console.log('[Feature Checker]', keys, user?.name, baseResult);
+        // if (keys.includes("SecurityManagement")) {
+        //   return false;
+        // }
         // Root user always has all features enabled
         if (user?.name === 'super-root') {
             return true;
@@ -1609,6 +1612,219 @@ class EntitySearchProvider {
     }
 }
 
+//#endregion
+//#region ----   Update Status Command   ----
+/**
+ * Generic command to update entity status
+ * Supports both single entity (id) and bulk updates (ids)
+ *
+ * Options:
+ * - entity: string - Entity key (e.g., 'OrderManagement.GroupOrder')
+ * - id?: string - Single entity ID
+ * - ids?: string[] - Multiple entity IDs (for bulk updates)
+ * - status: string - Target status value
+ * - statusField?: string - Status field name (default: 'statusId')
+ */
+class AXCEntityUpdateStatusCommand {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async execute(input) {
+        try {
+            const { entity, id, ids, status, statusField = 'statusId' } = input;
+            // Validate input
+            if (!entity) {
+                throw new Error('Entity name is required');
+            }
+            if (!id && (!ids || ids.length === 0)) {
+                throw new Error('Either id or ids must be provided');
+            }
+            if (!status) {
+                throw new Error('Status value is required');
+            }
+            const dataAccessor = this.entityService.withEntity(entity).data();
+            const updateData = { [statusField]: status };
+            // Handle bulk update
+            if (ids && ids.length > 0) {
+                const results = [];
+                for (const entityId of ids) {
+                    const updated = await dataAccessor.update(entityId, updateData);
+                    results.push(updated);
+                }
+                return {
+                    success: true,
+                    data: results,
+                };
+            }
+            // Handle single update
+            if (id) {
+                const updated = await dataAccessor.update(id, updateData);
+                return {
+                    success: true,
+                    data: updated,
+                    message: {
+                        text: 'Entity status updated successfully',
+                    },
+                };
+            }
+            throw new Error('Invalid input: neither id nor ids provided');
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: {
+                    text: error instanceof Error ? error.message : 'Failed to update entity status',
+                },
+            };
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class FileStorageDatabase extends Dexie {
+    constructor() {
+        super('ACoreXFileStorage');
+        this.version(1).stores({
+            files: 'fileId,refId,refType,category,isPrimary,status',
+        });
+    }
+}
+const db = new FileStorageDatabase();
+class AXCFileStorageService {
+    async mapToFileStorageInfo(record) {
+        if (!record) {
+            throw new Error('Record not found');
+        }
+        const { binary, ...fileInfo } = record;
+        const url = await this.fileService.blobToBase64(binary);
+        return { ...record, url };
+    }
+    async save(request) {
+        const fileId = AXPDataGenerator.uuid();
+        const fileInfo = {
+            fileId,
+            refId: request.refId,
+            refType: request.refType,
+            category: request.category,
+            size: request.file.size,
+            mimeType: request.file.type,
+            uploadedAt: new Date(),
+            isPublic: request.metadata?.['isPublic'] || true,
+            isPrimary: request.isPrimary || false,
+            status: request.status ?? AXPFileStorageStatus.Temporary, // Use enum
+            name: request.name,
+            binary: request.file,
+        };
+        // Save the binary content along with metadata in Dexie
+        await db.files.add({ ...fileInfo, binary: request.file });
+        return fileInfo;
+    }
+    async commit(fileId) {
+        const file = await db.files.get(fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        file.status = AXPFileStorageStatus.Committed; // Use enum
+        await db.files.put(file);
+    }
+    async markForDeletion(fileId) {
+        const file = await db.files.get(fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        file.status = AXPFileStorageStatus.PendingDeletion; // Use enum
+        await db.files.put(file);
+    }
+    async update(request) {
+        const file = await db.files.get(request.fileId);
+        if (!file) {
+            throw new Error('File not found');
+        }
+        const updatedFileInfo = {
+            ...file,
+            ...request.metadata,
+            name: request.name !== undefined ? request.name : file.name,
+            isPrimary: request.isPrimary !== undefined ? request.isPrimary : file.isPrimary,
+        };
+        await db.files.put(updatedFileInfo);
+        return this.mapToFileStorageInfo(updatedFileInfo);
+    }
+    async find(request) {
+        const files = await db.files.toArray();
+        const filteredFiles = files.filter((file) => {
+            return ((!request.refId || file.refId === request.refId) &&
+                (!request.refType || file.refType === request.refType) &&
+                (!request.category || file.category === request.category) &&
+                (!request.isPrimary || file.isPrimary === request.isPrimary) &&
+                (!request.isPublic || file.isPublic === request.isPublic) &&
+                (!request.mimeType || file.mimeType === request.mimeType) &&
+                (!request.uploadedAtRange ||
+                    (file.uploadedAt >= request.uploadedAtRange.from && file.uploadedAt <= request.uploadedAtRange.to)) &&
+                file.status === AXPFileStorageStatus.Committed // Use enum
+            );
+        });
+        // Map all filtered files to `AXPFileStorageInfo`
+        return Promise.all(filteredFiles.map((file) => this.mapToFileStorageInfo(file)));
+    }
+    async getInfo(fileId) {
+        // Simulate a delay of 2 seconds (2000 milliseconds)
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const file = await db.files.get(fileId);
+        return this.mapToFileStorageInfo(file);
+    }
+    async remove(fileId) {
+        await db.files.delete(fileId);
+    }
+    async cleanupTemporaryFiles() {
+        const files = await db.files.toArray();
+        const temporaryFiles = files.filter((file) => file.status === AXPFileStorageStatus.Temporary);
+        for (const file of temporaryFiles) {
+            await db.files.delete(file.fileId);
+        }
+    }
+    async cleanupMarkedFiles(gracePeriod) {
+        const now = new Date();
+        const files = await db.files.toArray();
+        for (const file of files) {
+            if (file.status === AXPFileStorageStatus.PendingDeletion &&
+                now.getTime() - file.uploadedAt.getTime() > gracePeriod) {
+                await db.files.delete(file.fileId);
+            }
+        }
+    }
+    // Semi-background cleanup job
+    constructor() {
+        this.fileService = inject(AXFileService);
+        setInterval(() => {
+            this.cleanupMarkedFiles(5 * 60 * 1000) // Grace period: 5 minutes in milliseconds
+                .catch((error) => console.error('Error during cleanup:', error));
+            this.cleanupTemporaryFiles() // Ensure temporary files are cleaned
+                .catch((error) => console.error('Error during cleanup:', error));
+        }, 5 * 60 * 1000); // Runs every 5 minutes
+    }
+    async findMany(ids) {
+        const files = await db.files.where('fileId').anyOf(ids).toArray();
+        return files.map((file) => ({
+            id: file.fileId,
+            fileId: file.fileId,
+            refId: file.refId,
+            refType: file.refType,
+            size: file.size,
+            name: file.name,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 class AXCLockService {
     constructor() {
         // Local Dexie database for storing lock information independent of AXPEntityStorageService
@@ -1760,145 +1976,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
-class FileStorageDatabase extends Dexie {
-    constructor() {
-        super('ACoreXFileStorage');
-        this.version(1).stores({
-            files: 'fileId,refId,refType,category,isPrimary,status',
-        });
-    }
-}
-const db = new FileStorageDatabase();
-class AXCFileStorageService {
-    async mapToFileStorageInfo(record) {
-        if (!record) {
-            throw new Error('Record not found');
-        }
-        const { binary, ...fileInfo } = record;
-        const url = await this.fileService.blobToBase64(binary);
-        return { ...record, url };
-    }
-    async save(request) {
-        const fileId = AXPDataGenerator.uuid();
-        const fileInfo = {
-            fileId,
-            refId: request.refId,
-            refType: request.refType,
-            category: request.category,
-            size: request.file.size,
-            mimeType: request.file.type,
-            uploadedAt: new Date(),
-            isPublic: request.metadata?.['isPublic'] || true,
-            isPrimary: request.isPrimary || false,
-            status: request.status ?? AXPFileStorageStatus.Temporary, // Use enum
-            name: request.name,
-            binary: request.file,
-        };
-        // Save the binary content along with metadata in Dexie
-        await db.files.add({ ...fileInfo, binary: request.file });
-        return fileInfo;
-    }
-    async commit(fileId) {
-        const file = await db.files.get(fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        file.status = AXPFileStorageStatus.Committed; // Use enum
-        await db.files.put(file);
-    }
-    async markForDeletion(fileId) {
-        const file = await db.files.get(fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        file.status = AXPFileStorageStatus.PendingDeletion; // Use enum
-        await db.files.put(file);
-    }
-    async update(request) {
-        const file = await db.files.get(request.fileId);
-        if (!file) {
-            throw new Error('File not found');
-        }
-        const updatedFileInfo = {
-            ...file,
-            ...request.metadata,
-            name: request.name !== undefined ? request.name : file.name,
-            isPrimary: request.isPrimary !== undefined ? request.isPrimary : file.isPrimary,
-        };
-        await db.files.put(updatedFileInfo);
-        return this.mapToFileStorageInfo(updatedFileInfo);
-    }
-    async find(request) {
-        const files = await db.files.toArray();
-        const filteredFiles = files.filter((file) => {
-            return ((!request.refId || file.refId === request.refId) &&
-                (!request.refType || file.refType === request.refType) &&
-                (!request.category || file.category === request.category) &&
-                (!request.isPrimary || file.isPrimary === request.isPrimary) &&
-                (!request.isPublic || file.isPublic === request.isPublic) &&
-                (!request.mimeType || file.mimeType === request.mimeType) &&
-                (!request.uploadedAtRange ||
-                    (file.uploadedAt >= request.uploadedAtRange.from && file.uploadedAt <= request.uploadedAtRange.to)) &&
-                file.status === AXPFileStorageStatus.Committed // Use enum
-            );
-        });
-        // Map all filtered files to `AXPFileStorageInfo`
-        return Promise.all(filteredFiles.map((file) => this.mapToFileStorageInfo(file)));
-    }
-    async getInfo(fileId) {
-        // Simulate a delay of 2 seconds (2000 milliseconds)
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-        const file = await db.files.get(fileId);
-        return this.mapToFileStorageInfo(file);
-    }
-    async remove(fileId) {
-        await db.files.delete(fileId);
-    }
-    async cleanupTemporaryFiles() {
-        const files = await db.files.toArray();
-        const temporaryFiles = files.filter((file) => file.status === AXPFileStorageStatus.Temporary);
-        for (const file of temporaryFiles) {
-            await db.files.delete(file.fileId);
-        }
-    }
-    async cleanupMarkedFiles(gracePeriod) {
-        const now = new Date();
-        const files = await db.files.toArray();
-        for (const file of files) {
-            if (file.status === AXPFileStorageStatus.PendingDeletion &&
-                now.getTime() - file.uploadedAt.getTime() > gracePeriod) {
-                await db.files.delete(file.fileId);
-            }
-        }
-    }
-    // Semi-background cleanup job
-    constructor() {
-        this.fileService = inject(AXFileService);
-        setInterval(() => {
-            this.cleanupMarkedFiles(5 * 60 * 1000) // Grace period: 5 minutes in milliseconds
-                .catch((error) => console.error('Error during cleanup:', error));
-            this.cleanupTemporaryFiles() // Ensure temporary files are cleaned
-                .catch((error) => console.error('Error during cleanup:', error));
-        }, 5 * 60 * 1000); // Runs every 5 minutes
-    }
-    async findMany(ids) {
-        const files = await db.files.where('fileId').anyOf(ids).toArray();
-        return files.map((file) => ({
-            id: file.fileId,
-            fileId: file.fileId,
-            refId: file.refId,
-            refType: file.refType,
-            size: file.size,
-            name: file.name,
-        }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFileStorageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
 //#region ----   Imports   ----
 var AXVChangeType;
 (function (AXVChangeType) {
@@ -2322,1004 +2399,6 @@ function buildSummaryFromChanges(changes, changeType) {
     return result;
 }
 
-//#region ----   Dexie DB   ----
-/**
- * Dexie database for workflow instances.
- */
-class AXCWorkflowExecutionDB extends Dexie {
-    constructor() {
-        super('ACoreXWorkflowExecutions');
-        this.version(2).stores({
-            instances: 'id, definitionId, status, subStatus, createdAt, updatedAt',
-        });
-        // Migration from v1 to v2: clear old executions table
-        this.version(1).stores({
-            executions: 'executionId, workflowId, status, currentStepId, lastUpdated',
-        });
-    }
-}
-/**
- * Singleton instance of workflow execution database.
- */
-const axWorkflowExecutionDB = new AXCWorkflowExecutionDB();
-//#endregion
-
-/**
- * Mock implementation of AXPWorkflowExecutionService.
- *
- * Uses IndexedDB (via Dexie) to store workflow execution states.
- *
- * @example
- * ```typescript
- * // In module providers
- * {
- *   provide: AXPWorkflowExecutionService,
- *   useClass: AXCWorkflowExecutionService,
- * }
- * ```
- */
-class AXCWorkflowExecutionService {
-    constructor() {
-        this.db = axWorkflowExecutionDB;
-        this.commandService = inject(AXPCommandService);
-        this.entityStorageService = inject(AXPEntityStorageService);
-    }
-    /**
-     * Start a new workflow execution.
-     * Creates a workflow instance and stores it in IndexedDB.
-     */
-    async startExecution(request) {
-        const instanceId = AXPDataGenerator.uuid();
-        const now = new Date().toISOString();
-        // Get workflow definition to find first step
-        const workflowResponse = await this.getWorkflowDefinition({
-            workflowId: request.workflowId
-        });
-        if (!workflowResponse.workflow) {
-            throw new Error(`Workflow definition not found: ${request.workflowId}`);
-        }
-        const workflow = workflowResponse.workflow;
-        // Find first step from Flowchart (activity with no incoming connections)
-        const flowchart = workflow.root;
-        const activities = flowchart.activities || [];
-        const connections = flowchart.connections || [];
-        // Build connection map: target -> source[]
-        const incomingConnections = new Map();
-        connections.forEach((conn) => {
-            const targetId = conn.target.activity;
-            if (!incomingConnections.has(targetId)) {
-                incomingConnections.set(targetId, []);
-            }
-            incomingConnections.get(targetId).push(conn.source.activity);
-        });
-        // Find root activity (activity with no incoming connections, or first activity)
-        let firstActivity = null;
-        for (const activity of activities) {
-            if (!incomingConnections.has(activity.id)) {
-                firstActivity = activity;
-                break;
-            }
-        }
-        // If no root found, use first activity
-        if (!firstActivity && activities.length > 0) {
-            firstActivity = activities[0];
-        }
-        const firstStepId = firstActivity?.id || 'root';
-        // Create workflow state
-        const workflowState = {
-            id: `state-${instanceId}`,
-            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
-            //definitionVersion: workflow.version,
-            definitionVersion: 1,
-            correlationId: null,
-            status: 'Running',
-            subStatus: 'Executing',
-            bookmarks: [],
-            incidents: [],
-            fault: null,
-            completionCallbacks: [],
-            activityExecutionContexts: firstActivity ? [{
-                    id: `ctx-${firstStepId}`,
-                    parentContextId: null,
-                    scheduledActivityNodeId: firstStepId,
-                    ownerActivityNodeId: null,
-                    properties: {},
-                    activityState: null,
-                    dynamicVariables: [],
-                    status: 'Running',
-                    isExecuting: false,
-                    faultCount: 0,
-                    startedAt: now,
-                    completedAt: null,
-                    tag: null
-                }] : [],
-            input: request.input || {},
-            output: {},
-            properties: {},
-            createdAt: now,
-            updatedAt: now,
-            finishedAt: null
-        };
-        // Create workflow instance
-        const instance = {
-            $schema: 'https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json',
-            id: instanceId,
-            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
-            //definitionVersionId: workflow.id,
-            //version: workflow.version,
-            version: 1,
-            definitionVersionId: '1',
-            parentWorkflowInstanceId: null,
-            workflowState,
-            status: 'Running',
-            subStatus: 'Executing',
-            correlationId: null,
-            name: workflow.name || null,
-            incidentCount: 0,
-            createdAt: now,
-            updatedAt: now,
-            finishedAt: null
-        };
-        // Store instance in IndexedDB
-        await this.db.instances.add(instance, instance.id);
-        // 🎯 Also store in entity service for entity-based access
-        await this.saveInstanceToEntityService(instance);
-        // Convert to execution state for response
-        let state = this.instanceToExecutionState(instance);
-        // 🎯 KEY LOGIC: Execute all backend activities until we reach a frontend activity
-        let currentActivity = firstActivity;
-        let executionCount = 0;
-        const maxExecutions = 100; // Prevent infinite loops
-        while (currentActivity && executionCount < maxExecutions) {
-            executionCount++;
-            // Map activity type to ACoreX format
-            let activityType = currentActivity.type;
-            if (activityType.startsWith('Elsa.')) {
-                let type = activityType.replace(/^Elsa\./, '');
-                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
-                activityType = `workflow-activity:${type}`;
-            }
-            // Determine execution mode
-            const executionMode = this.determineExecutionMode(activityType, currentActivity);
-            // If frontend activity → stop and return as pendingTask
-            if (executionMode === 'frontend') {
-                const pendingTask = this.createTaskFromActivity(currentActivity, state);
-                // Update state to suspended (waiting for frontend)
-                state = {
-                    ...state,
-                    status: 'suspended',
-                    currentStepId: currentActivity.id,
-                };
-                await this.updateInstanceFromExecutionState(instanceId, state);
-                return {
-                    executionId: instanceId,
-                    state,
-                    pendingTask
-                };
-            }
-            // Backend activity → execute it
-            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
-            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
-            // Update variables with output
-            state = {
-                ...state,
-                variables: {
-                    ...state.variables,
-                    ...executionResult.output
-                },
-                currentStepId: currentActivity.id,
-                lastUpdated: new Date()
-            };
-            // Find next activity based on outcome
-            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
-            const nextConnection = connections.find((conn) => conn.source.activity === currentActivity.id &&
-                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
-            if (!nextConnection) {
-                // No next activity → workflow completed
-                state = {
-                    ...state,
-                    status: 'completed',
-                    currentStepId: undefined,
-                    output: state.variables
-                };
-                await this.updateInstanceFromExecutionState(instanceId, state);
-                return {
-                    executionId: instanceId,
-                    state,
-                    pendingTask: null
-                };
-            }
-            // Find next activity
-            currentActivity = this.findActivityInFlowchart(flowchart, nextConnection.target.activity);
-        }
-        // If we exit loop without frontend activity, workflow is complete
-        state = {
-            ...state,
-            status: 'completed',
-            currentStepId: undefined,
-            output: state.variables
-        };
-        await this.updateInstanceFromExecutionState(instanceId, state);
-        return {
-            executionId: instanceId,
-            state,
-            pendingTask: null
-        };
-    }
-    /**
-     * Find activity in Flowchart by ID.
-     */
-    findActivityInFlowchart(flowchart, activityId) {
-        const activities = flowchart.activities || [];
-        return activities.find(a => a.id === activityId) || null;
-    }
-    /**
-     * Resume a suspended workflow execution.
-     *
-     * After frontend completes its task:
-     * 1. Validates taskToken
-     * 2. Finds next activity based on outcome
-     * 3. Executes ALL backend activities in sequence
-     * 4. Stops at first frontend activity and returns it as pendingTask
-     */
-    async resumeExecution(request) {
-        // Get current state
-        let state = await this.getExecutionState({
-            executionId: request.executionId,
-        });
-        if (!state) {
-            throw new Error(`Workflow execution not found: ${request.executionId}`);
-        }
-        if (state.status !== 'suspended') {
-            throw new Error(`Cannot resume workflow with status: ${state.status}. Expected: suspended`);
-        }
-        // TODO: Validate taskToken here for security
-        // For now, just verify stepId matches
-        if (state.currentStepId !== request.stepId) {
-            throw new Error(`Step mismatch: expected '${state.currentStepId}', got '${request.stepId}'`);
-        }
-        // Get workflow definition
-        const workflowResponse = await this.getWorkflowDefinition({
-            workflowId: state.workflowId
-        });
-        const workflow = workflowResponse.workflow;
-        const connections = workflow.root.connections || [];
-        // Update state with frontend activity outcome and user input
-        state = {
-            ...state,
-            variables: {
-                ...state.variables,
-                [`${request.stepId}_outcome`]: request.outcome,
-                [`${request.stepId}_userInput`]: request.userInput || {},
-            },
-            lastUpdated: new Date()
-        };
-        // Find next activity based on outcome from frontend
-        const nextConnection = connections.find((conn) => conn.source.activity === request.stepId &&
-            (conn.source.port === request.outcome || (!conn.source.port && request.outcome === 'Done')));
-        console.log('[AXCWorkflowExecutionService] 🔍 Looking for next connection', {
-            stepId: request.stepId,
-            outcome: request.outcome,
-            connectionsCount: connections.length,
-            foundConnection: !!nextConnection
-        });
-        if (!nextConnection) {
-            // No next activity → workflow completed
-            console.log('[AXCWorkflowExecutionService] ✅ No next activity found - workflow completed');
-            state = {
-                ...state,
-                status: 'completed',
-                currentStepId: undefined,
-                output: state.variables
-            };
-            console.log('[AXCWorkflowExecutionService] 📝 Updating instance to completed state');
-            await this.updateInstanceFromExecutionState(request.executionId, state);
-            return {
-                output: { outcome: request.outcome, userInput: request.userInput },
-                outcomes: { [request.outcome]: true },
-                nextTask: null,
-                state
-            };
-        }
-        // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
-        let currentActivity = this.findActivityInFlowchart(workflow.root, nextConnection.target.activity);
-        let executionCount = 0;
-        const maxExecutions = 100;
-        while (currentActivity && executionCount < maxExecutions) {
-            executionCount++;
-            // Map activity type
-            let activityType = currentActivity.type;
-            if (activityType.startsWith('Elsa.')) {
-                let type = activityType.replace(/^Elsa\./, '');
-                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
-                activityType = `workflow-activity:${type}`;
-            }
-            // Determine execution mode
-            const executionMode = this.determineExecutionMode(activityType, currentActivity);
-            // If frontend activity → stop and return as pendingTask
-            if (executionMode === 'frontend') {
-                const pendingTask = this.createTaskFromActivity(currentActivity, state);
-                state = {
-                    ...state,
-                    status: 'suspended',
-                    currentStepId: currentActivity.id,
-                };
-                await this.updateInstanceFromExecutionState(request.executionId, state);
-                return {
-                    output: { outcome: request.outcome, userInput: request.userInput },
-                    outcomes: { [request.outcome]: true },
-                    nextTask: pendingTask,
-                    state
-                };
-            }
-            // Backend activity → execute it
-            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
-            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
-            // Update variables with output
-            state = {
-                ...state,
-                variables: {
-                    ...state.variables,
-                    ...executionResult.output
-                },
-                currentStepId: currentActivity.id,
-                lastUpdated: new Date()
-            };
-            // Find next activity based on outcome
-            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
-            const nextConn = connections.find((conn) => conn.source.activity === currentActivity.id &&
-                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
-            if (!nextConn) {
-                // No next activity → workflow completed
-                state = {
-                    ...state,
-                    status: 'completed',
-                    currentStepId: undefined,
-                    output: state.variables
-                };
-                await this.updateInstanceFromExecutionState(request.executionId, state);
-                return {
-                    output: state.variables,
-                    outcomes: { Done: true },
-                    nextTask: null,
-                    state
-                };
-            }
-            // Find next activity
-            currentActivity = this.findActivityInFlowchart(workflow.root, nextConn.target.activity);
-        }
-        // If we exit loop, workflow is complete
-        state = {
-            ...state,
-            status: 'completed',
-            currentStepId: undefined,
-            output: state.variables
-        };
-        await this.updateInstanceFromExecutionState(request.executionId, state);
-        return {
-            output: state.variables,
-            outcomes: { Done: true },
-            nextTask: null,
-            state
-        };
-    }
-    /**
-     * Get current workflow execution state.
-     */
-    async getExecutionState(request) {
-        // Get instance from IndexedDB
-        const instance = await this.getInstance(request.executionId);
-        if (!instance) {
-            throw new Error(`Workflow execution not found: ${request.executionId}`);
-        }
-        // Convert instance to execution state
-        return this.instanceToExecutionState(instance);
-    }
-    /**
-     * Get workflow definition by ID.
-     *
-     * In mock implementation, this retrieves workflow definition from localStorage.
-     * In production, this would make an HTTP call to backend API.
-     *
-     * @param request - Get workflow definition request
-     * @returns Workflow definition
-     */
-    async getWorkflowDefinition(request) {
-        // In mock, try to get from localStorage first (for workflow-studio testing)
-        const storedWorkflow = localStorage.getItem(`workflow:${request.workflowId}`);
-        if (storedWorkflow) {
-            try {
-                const workflowDefinition = JSON.parse(storedWorkflow);
-                console.log('[AXCWorkflowExecutionService] 📄 Parsed workflow definition', {
-                    hasRoot: !!workflowDefinition.root,
-                    rootType: workflowDefinition.root?.type
-                });
-                // Validate format - if root is already a Flowchart
-                if (workflowDefinition.root && workflowDefinition.root.type === 'workflow-activity:flowchart') {
-                    return { workflow: workflowDefinition };
-                }
-                // If stored in materializerContext.stringData, parse it
-                if (workflowDefinition.materializerContext?.stringData) {
-                    try {
-                        const rootFlowchart = JSON.parse(workflowDefinition.materializerContext.stringData);
-                        if (rootFlowchart.type === 'workflow-activity:flowchart') {
-                            return {
-                                workflow: {
-                                    ...workflowDefinition,
-                                    root: rootFlowchart
-                                }
-                            };
-                        }
-                    }
-                    catch (error) {
-                        console.warn('[AXCWorkflowExecutionService] ⚠️ Failed to parse stringData from materializerContext:', error);
-                    }
-                }
-                // 🎯 NEW: If root is a single activity (not Flowchart), convert it to Flowchart
-                if (workflowDefinition.root && workflowDefinition.root.type !== 'workflow-activity:flowchart') {
-                    console.log('[AXCWorkflowExecutionService] 🔄 Converting single activity to Flowchart', workflowDefinition.root);
-                    const singleActivity = workflowDefinition.root;
-                    // Create a Flowchart with this single activity
-                    const flowchart = {
-                        id: 'root-flowchart',
-                        nodeId: 'root-flowchart',
-                        type: 'workflow-activity:flowchart',
-                        version: 1,
-                        activities: [singleActivity],
-                        connections: [],
-                        variables: []
-                    };
-                    console.log('[AXCWorkflowExecutionService] ✅ Created Flowchart from single activity', {
-                        activitiesCount: flowchart.activities.length,
-                        activityType: singleActivity.type
-                    });
-                    return {
-                        workflow: {
-                            ...workflowDefinition,
-                            root: flowchart
-                        }
-                    };
-                }
-            }
-            catch (error) {
-                console.warn(`[AXCWorkflowExecutionService] ⚠️ Failed to parse stored workflow ${request.workflowId}:`, error);
-            }
-        }
-        // If not found in localStorage, return a default mock workflow
-        // In production, this would be an HTTP call to backend
-        const now = new Date().toISOString();
-        const defaultWorkflow = {
-            name: request.workflowId, // workflowId is the name (unique key)
-            title: `Workflow ${request.workflowId}`, // Display title
-            description: 'Default mock workflow',
-            variables: [],
-            inputs: [],
-            outputs: [],
-            outcomes: ['Done'],
-            customProperties: {},
-            options: {
-                usableAsActivity: false,
-                autoUpdateConsumingWorkflows: false
-            },
-            root: {
-                id: 'root-flowchart',
-                nodeId: 'root-flowchart',
-                type: 'workflow-activity:flowchart',
-                version: 1,
-                activities: [],
-                connections: [],
-                variables: []
-            }
-        };
-        return { workflow: defaultWorkflow };
-    }
-    //#region ----   Task-Based Helper Methods   ----
-    /**
-     * Generate unique task token for task-based execution.
-     * Inspired by Temporal's task tokens for secure task completion.
-     */
-    generateTaskToken(executionId, activityId) {
-        return `${executionId}:${activityId}:${Date.now()}`;
-    }
-    /**
-     * Determine execution mode for an activity.
-     *
-     * Priority (highest to lowest):
-     * 1. Activity instance's executionMode (from AXPActivity in workflow definition)
-     * 2. ActivityDescriptor's executionMode (from ActivityProviderService)
-     * 3. Default: 'frontend'
-     *
-     * @param activityType - Activity type (e.g., 'workflow-activity:write-line')
-     * @param activity - Activity from workflow definition (AXPActivity)
-     * @returns Execution mode: 'frontend', 'backend', or 'both'
-     */
-    determineExecutionMode(activityType, activity) {
-        // 1. Check if executionMode is explicitly set in activity instance (highest priority)
-        if (activity?.executionMode) {
-            return activity.executionMode;
-        }
-        // 2. Check ActivityDescriptor from ActivityProviderService
-        // const descriptor = this.activityProviderService.getMetadata(activityType);
-        // if (descriptor?.executionMode) {
-        //   return descriptor.executionMode;
-        // }
-        // 3. Default to frontend (UI activities are more common)
-        return 'frontend';
-    }
-    /**
-     * Create a task from a workflow activity.
-     * Inspired by Temporal's Activity Task and Elsa's Bookmark pattern.
-     */
-    createTaskFromActivity(activity, state) {
-        // Extract properties from activity
-        // Activities have properties as AXPInputValue objects or primitives
-        const properties = {};
-        // Iterate through all properties of the activity
-        Object.keys(activity).forEach(key => {
-            // Skip standard Elsa fields
-            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata', 'executionMode'].includes(key)) {
-                return;
-            }
-            const value = activity[key];
-            // 🎯 SPECIAL HANDLING: If key is 'properties' and it's an object, flatten it
-            // This handles workflow-studio format where properties are nested
-            if (key === 'properties' && value && typeof value === 'object' && !('typeName' in value) && !('expression' in value)) {
-                // Flatten properties object
-                Object.keys(value).forEach(propKey => {
-                    const propValue = value[propKey];
-                    // Handle AXPInputValue format within properties
-                    if (propValue && typeof propValue === 'object' && 'typeName' in propValue && 'expression' in propValue) {
-                        if (propValue.expression && propValue.expression.value !== undefined) {
-                            properties[propKey] = propValue.expression.value;
-                        }
-                        else {
-                            properties[propKey] = null;
-                        }
-                    }
-                    else {
-                        // Direct value
-                        properties[propKey] = propValue;
-                    }
-                });
-                return;
-            }
-            // Handle AXPInputValue format
-            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
-                // It's an AXPInputValue - extract the expression value
-                if (value.expression && value.expression.value !== undefined) {
-                    properties[key] = value.expression.value;
-                }
-                else {
-                    properties[key] = null;
-                }
-            }
-            else {
-                // Direct value
-                properties[key] = value;
-            }
-        });
-        console.log('[AXCWorkflowExecutionService] 📦 Extracted properties for task', properties);
-        // Map activity type to ACoreX activity type
-        // Example: "Elsa.WriteLine" -> "workflow-activity:write-line"
-        let activityType = activity.type;
-        if (activityType.startsWith('Elsa.')) {
-            let type = activityType.replace(/^Elsa\./, '');
-            // Convert PascalCase to kebab-case
-            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
-            activityType = `workflow-activity:${type}`;
-        }
-        // Get executionMode from activity descriptor
-        const executionMode = this.determineExecutionMode(activityType, activity);
-        return {
-            taskToken: this.generateTaskToken(state.executionId, activity.id),
-            activityId: activity.id,
-            activityType,
-            activityName: activity.name || undefined,
-            executionMode,
-            input: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined,
-            config: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined
-        };
-    }
-    /**
-     * Save workflow instance to entity service for entity-based access.
-     */
-    async saveInstanceToEntityService(instance) {
-        try {
-            const entityModel = {
-                id: instance.id,
-                definitionId: instance.definitionId,
-                definitionVersionId: instance.definitionVersionId,
-                version: instance.version,
-                status: instance.status,
-                subStatus: instance.subStatus,
-                correlationId: instance.correlationId || undefined,
-                name: instance.name || undefined,
-                incidentCount: instance.incidentCount,
-                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
-                createdAt: instance.createdAt,
-                updatedAt: instance.updatedAt,
-                finishedAt: instance.finishedAt || undefined,
-                workflowInstance: instance
-            };
-            const entityName = 'WorkflowManagement.WorkflowInstance';
-            // Check if instance already exists
-            try {
-                const existing = await this.entityStorageService.getOne(entityName, entityModel.id);
-                if (existing) {
-                    // Already exists - don't insert again, will be updated later
-                    console.log('[AXCWorkflowExecutionService] ℹ️ Instance already exists in entity service, will be updated later', {
-                        instanceId: instance.id
-                    });
-                    return;
-                }
-            }
-            catch (getError) {
-                // Instance doesn't exist - proceed with insert
-            }
-            // Insert new instance
-            await this.entityStorageService.insertOne(entityName, entityModel);
-            console.log('[AXCWorkflowExecutionService] ✅ Inserted new instance in entity service', {
-                instanceId: instance.id,
-                status: instance.status,
-                subStatus: instance.subStatus
-            });
-        }
-        catch (error) {
-            console.warn('[AXCWorkflowExecutionService] Failed to save instance to entity service:', error);
-            // Don't throw - IndexedDB is primary storage
-        }
-    }
-    /**
-     * Update workflow instance in entity service.
-     * Uses upsert pattern: try update first, if fails then insert.
-     */
-    async updateInstanceInEntityService(instance) {
-        try {
-            const entityModel = {
-                id: instance.id,
-                definitionId: instance.definitionId,
-                definitionVersionId: instance.definitionVersionId,
-                version: instance.version,
-                status: instance.status,
-                subStatus: instance.subStatus,
-                correlationId: instance.correlationId || undefined,
-                name: instance.name || undefined,
-                incidentCount: instance.incidentCount,
-                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
-                createdAt: instance.createdAt,
-                updatedAt: instance.updatedAt,
-                finishedAt: instance.finishedAt || undefined,
-                workflowInstance: instance
-            };
-            const entityName = 'WorkflowManagement.WorkflowInstance';
-            // Try update first (upsert pattern)
-            try {
-                await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
-                console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service', {
-                    instanceId: instance.id,
-                    status: instance.status,
-                    subStatus: instance.subStatus
-                });
-                return; // Successfully updated, exit
-            }
-            catch (updateError) {
-                // Update failed - instance doesn't exist, try insert
-                console.log('[AXCWorkflowExecutionService] ℹ️ Update failed, trying insert', {
-                    instanceId: instance.id,
-                    error: updateError.message
-                });
-            }
-            // Try insert
-            try {
-                await this.entityStorageService.insertOne(entityName, entityModel);
-                console.log('[AXCWorkflowExecutionService] ✅ Inserted instance in entity service', {
-                    instanceId: instance.id,
-                    status: instance.status,
-                    subStatus: instance.subStatus
-                });
-            }
-            catch (insertError) {
-                // Insert might fail if instance was created between update and insert
-                // Try update again as fallback
-                try {
-                    await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
-                    console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service (after insert failed)', {
-                        instanceId: instance.id,
-                        status: instance.status,
-                        subStatus: instance.subStatus
-                    });
-                }
-                catch (finalError) {
-                    console.warn('[AXCWorkflowExecutionService] Failed to upsert instance in entity service:', finalError);
-                }
-            }
-        }
-        catch (error) {
-            console.warn('[AXCWorkflowExecutionService] Failed to update instance in entity service:', error);
-            // Don't throw - IndexedDB is primary storage
-        }
-    }
-    //#endregion
-    //#region ----   Backend Activity Executors   ----
-    /**
-     * Execute backend activities locally using CommandBus.
-     *
-     * Backend activities are registered as Commands and executed via CommandService.
-     * This provides a unified execution channel for all activities.
-     */
-    async executeBackendActivityLocally(activity, input, state) {
-        console.log('[AXCWorkflowExecutionService] 🔧 executeBackendActivityLocally', {
-            activityId: activity.id,
-            activityType: activity.type,
-            input
-        });
-        // Extract properties from activity
-        const properties = {};
-        Object.keys(activity).forEach(key => {
-            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata', 'executionMode'].includes(key)) {
-                return;
-            }
-            const value = activity[key];
-            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
-                if (value.expression && value.expression.value !== undefined) {
-                    properties[key] = value.expression.value;
-                }
-                else {
-                    properties[key] = null;
-                }
-            }
-            else {
-                properties[key] = value;
-            }
-        });
-        console.log('[AXCWorkflowExecutionService] 📦 Extracted properties', properties);
-        // Map activity type to ACoreX activity type
-        let activityType = activity.type;
-        if (activityType.startsWith('Elsa.')) {
-            let type = activityType.replace(/^Elsa\./, '');
-            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
-            activityType = `workflow-activity:${type}`;
-        }
-        console.log('[AXCWorkflowExecutionService] 🔀 Activity type mapped', {
-            original: activity.type,
-            mapped: activityType
-        });
-        // Check if activity is registered as a Command
-        const commandExists = this.commandService.exists(activityType);
-        console.log('[AXCWorkflowExecutionService] 🔍 Command exists?', commandExists, activityType);
-        if (commandExists) {
-            console.log(`[AXCWorkflowExecutionService] ⚡ Executing '${activityType}' via CommandBus`);
-            try {
-                // Execute via CommandBus
-                const result = await this.commandService.execute(activityType, properties);
-                const finalResult = {
-                    output: result?.data?.output || result,
-                    outcomes: result?.data?.outcomes || { Done: true }
-                };
-                console.log('[AXCWorkflowExecutionService] ✅ Final result', finalResult);
-                return finalResult;
-            }
-            catch (error) {
-                console.error(`[AXCWorkflowExecutionService] ❌ Backend activity '${activityType}' failed:`, error);
-                return {
-                    output: { error: error.message || 'Unknown error' },
-                    outcomes: { Failed: true }
-                };
-            }
-        }
-        // Fallback: Handle built-in activities that aren't Commands yet
-        console.warn(`[WorkflowExecutionService] Activity '${activityType}' not registered as Command, using fallback`);
-        switch (activityType) {
-            case 'workflow-activity:set-variable':
-                return this.executeSetVariable({ type: activityType, properties }, input);
-            case 'workflow-activity:http-request':
-                return this.executeHttpRequest({ type: activityType, properties }, input);
-            default:
-                return { output: null, outcomes: { Done: true } };
-        }
-    }
-    /**
-     * Set variable activity - stores value in workflow state.
-     */
-    async executeSetVariable(activity, input) {
-        const variableName = activity.properties?.variableName;
-        const value = activity.properties?.value;
-        return {
-            output: { [variableName]: value },
-            outcomes: { Done: true }
-        };
-    }
-    /**
-     * Execute HTTP request - makes real HTTP call.
-     * Supports different HTTP methods and handles timeouts.
-     */
-    async executeHttpRequest(activity, input) {
-        const url = activity.properties?.url;
-        const method = activity.properties?.method || 'GET';
-        const timeout = activity.properties?.timeout || 30000;
-        const headers = activity.properties?.headers || {};
-        const body = activity.properties?.body;
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), timeout);
-            const fetchOptions = {
-                method,
-                signal: controller.signal,
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...headers
-                }
-            };
-            if (body && method !== 'GET' && method !== 'HEAD') {
-                fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
-            }
-            const response = await fetch(url, fetchOptions);
-            clearTimeout(timeoutId);
-            const statusCode = response.status.toString();
-            let data;
-            try {
-                data = await response.json();
-            }
-            catch {
-                data = await response.text();
-            }
-            // Convert headers to object
-            const responseHeaders = {};
-            response.headers.forEach((value, key) => {
-                responseHeaders[key] = value;
-            });
-            return {
-                output: {
-                    statusCode,
-                    data,
-                    status: response.status,
-                    headers: responseHeaders
-                },
-                outcomes: {
-                    [statusCode]: true,
-                    Done: true
-                }
-            };
-        }
-        catch (error) {
-            if (error.name === 'AbortError') {
-                return {
-                    output: { error: 'Request timeout' },
-                    outcomes: { Timeout: true }
-                };
-            }
-            return {
-                output: { error: error.message },
-                outcomes: { Failed: true }
-            };
-        }
-    }
-    //#endregion
-    //#region ----   Instance Management   ----
-    /**
-     * Convert workflow instance to execution state (for backward compatibility).
-     */
-    instanceToExecutionState(instance) {
-        const state = instance.workflowState;
-        // Find current activity from execution contexts
-        const currentContext = state.activityExecutionContexts.find(ctx => ctx.status === 'Running' && !ctx.completedAt);
-        // Map status
-        let status = 'running';
-        if (instance.status === 'Finished') {
-            if (instance.subStatus === 'Faulted') {
-                status = 'error';
-            }
-            else {
-                status = 'completed';
-            }
-        }
-        else if (instance.subStatus === 'Suspended') {
-            status = 'suspended';
-        }
-        return {
-            executionId: instance.id,
-            workflowId: instance.definitionId,
-            status,
-            currentStepId: currentContext?.scheduledActivityNodeId,
-            variables: state.properties || {},
-            input: state.input || {},
-            output: state.output || {},
-            lastUpdated: new Date(instance.updatedAt)
-        };
-    }
-    /**
-     * Update execution state in instance and save to IndexedDB.
-     */
-    async updateInstanceFromExecutionState(executionId, executionState) {
-        const instance = await this.getInstance(executionId);
-        if (!instance) {
-            throw new Error(`Workflow instance not found: ${executionId}`);
-        }
-        // Update instance from execution state
-        const now = new Date().toISOString();
-        // Map execution state status to instance status
-        let status = 'Running';
-        let subStatus = 'Executing';
-        console.log('[AXCWorkflowExecutionService] 🔄 updateInstanceFromExecutionState', {
-            executionStateStatus: executionState.status,
-            instanceId: instance.id,
-            currentInstanceStatus: instance.status
-        });
-        if (executionState.status === 'completed') {
-            console.log('[AXCWorkflowExecutionService] ✅ Marking workflow as Finished');
-            status = 'Finished';
-            subStatus = 'Finished';
-            instance.finishedAt = now;
-        }
-        else if (executionState.status === 'error') {
-            status = 'Finished';
-            subStatus = 'Faulted';
-            instance.finishedAt = now;
-        }
-        else if (executionState.status === 'suspended') {
-            subStatus = 'Suspended';
-        }
-        instance.status = status;
-        instance.subStatus = subStatus;
-        instance.updatedAt = now;
-        // Update workflow state
-        instance.workflowState.status = status;
-        instance.workflowState.subStatus = subStatus;
-        instance.workflowState.input = executionState.input || {};
-        instance.workflowState.output = executionState.output || {};
-        instance.workflowState.properties = executionState.variables || {};
-        instance.workflowState.updatedAt = now;
-        if (executionState.status === 'completed' || executionState.status === 'error') {
-            instance.workflowState.finishedAt = now;
-        }
-        // Update activity execution context if currentStepId changed
-        if (executionState.currentStepId) {
-            const existingContext = instance.workflowState.activityExecutionContexts.find(ctx => ctx.scheduledActivityNodeId === executionState.currentStepId);
-            if (!existingContext) {
-                // Add new context
-                instance.workflowState.activityExecutionContexts.push({
-                    id: `ctx-${executionState.currentStepId}`,
-                    parentContextId: null,
-                    scheduledActivityNodeId: executionState.currentStepId,
-                    ownerActivityNodeId: null,
-                    properties: {},
-                    activityState: null,
-                    dynamicVariables: [],
-                    status: 'Running',
-                    isExecuting: false,
-                    faultCount: 0,
-                    startedAt: now,
-                    completedAt: null,
-                    tag: null
-                });
-            }
-        }
-        // Save to IndexedDB
-        await this.updateInstance(instance);
-        // 🎯 Also update in entity service
-        await this.updateInstanceInEntityService(instance);
-        return instance;
-    }
-    /**
-     * Get workflow instance from IndexedDB.
-     */
-    async getInstance(executionId) {
-        return await this.db.instances.get(executionId) || null;
-    }
-    /**
-     * Update workflow instance in IndexedDB.
-     */
-    async updateInstance(instance) {
-        instance.updatedAt = new Date().toISOString();
-        await this.db.instances.update(instance.id, instance);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowExecutionService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowExecutionService, decorators: [{
-            type: Injectable
-        }] });
-
 /**
  * Mock workflow definitions for testing and demonstration.
  */
@@ -3812,259 +2891,1084 @@ const workflowDefinitionMock = [
     },
 ];
 /**
- * Export definitionId list for easy access
+ * Export definitionId list for easy access
+ */
+const workflowDefinitionIds = {
+    createUser: 'create-user-workflow',
+    welcome: 'welcome-workflow',
+    dataProcessing: 'data-processing-workflow',
+};
+
+/**
+ * Seeds workflow definitions into localStorage for mock/demo purposes.
+ *
+ * Workflow definitions are stored in localStorage with key pattern:
+ * `workflow:{definitionId}`
+ *
+ * This allows the mock workflow execution service to retrieve definitions
+ * without making HTTP calls.
+ */
+let AXCWorkflowDefinitionDataSeeder$1 = class AXCWorkflowDefinitionDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        // Store each workflow definition in localStorage
+        // for (const workflow of workflowDefinitionMock) {
+        // localStorage.setItem(`workflow:${workflow.definitionId}`, JSON.stringify(workflow));
+        // console.log(`[WorkflowDefinitionSeeder] Seeded workflow: ${workflow.name} (${workflow.definitionId})`);
+        // }
+        // Also store in entity storage for entity-based access
+        await this.storageService.initial('Workflow.WorkflowDefinition', workflowDefinitionMock);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder }); }
+};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder$1, decorators: [{
+            type: Injectable
+        }] });
+
+class AXCCommonMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, providers: [
+            {
+                provide: AXP_ACTIVITY_LOG_PROVIDER,
+                useClass: AXCPActivityLogService,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: EntitySearchProvider,
+                multi: true,
+            },
+            {
+                provide: AXPLockService,
+                useClass: AXCLockService,
+            },
+            {
+                provide: AXPFileStorageService,
+                useClass: AXCFileStorageService,
+            },
+            {
+                provide: AXPVersioningService,
+                useClass: AXCVersioningService,
+            },
+            // {
+            //     provide: AXP_ACTIVITY_PROVIDER,
+            //     useClass: AXCActivityProvider,
+            //     multi: true,
+            // },
+            //TODO ADD after testing workflow local engine
+            // {
+            //     provide: AXP_WORKFLOW_ENGINE,
+            //     useClass: AXCWorkflowRuntimeService,
+            // },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXCWorkflowDefinitionDataSeeder$1,
+                multi: true,
+            },
+            // Register generic Entity:UpdateStatus command
+            provideCommandSetups([{ key: 'Entity:UpdateStatus', command: () => AXCEntityUpdateStatusCommand }]),
+            AXCEntityUpdateStatusCommand,
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_ACTIVITY_LOG_PROVIDER,
+                            useClass: AXCPActivityLogService,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: EntitySearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXPLockService,
+                            useClass: AXCLockService,
+                        },
+                        {
+                            provide: AXPFileStorageService,
+                            useClass: AXCFileStorageService,
+                        },
+                        {
+                            provide: AXPVersioningService,
+                            useClass: AXCVersioningService,
+                        },
+                        // {
+                        //     provide: AXP_ACTIVITY_PROVIDER,
+                        //     useClass: AXCActivityProvider,
+                        //     multi: true,
+                        // },
+                        //TODO ADD after testing workflow local engine
+                        // {
+                        //     provide: AXP_WORKFLOW_ENGINE,
+                        //     useClass: AXCWorkflowRuntimeService,
+                        // },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXCWorkflowDefinitionDataSeeder$1,
+                            multi: true,
+                        },
+                        // Register generic Entity:UpdateStatus command
+                        provideCommandSetups([{ key: 'Entity:UpdateStatus', command: () => AXCEntityUpdateStatusCommand }]),
+                        AXCEntityUpdateStatusCommand,
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+function toUiRows(changes) {
+    return changes.map((c) => ({
+        badge: toBadge(c.op),
+        path: c.path,
+        summary: toSummary(c),
+        oldValue: c.oldValue,
+        newValue: c.newValue,
+    }));
+}
+function toBadge(op) {
+    switch (op) {
+        case 'add':
+            return 'Added';
+        case 'remove':
+            return 'Removed';
+        case 'replace':
+            return 'Replaced';
+        case 'rename':
+            return 'Renamed';
+        case 'metadata':
+            return 'Metadata';
+        default:
+            return 'Updated';
+    }
+}
+function toSummary(c) {
+    switch (c.op) {
+        case 'add':
+            return 'Added';
+        case 'remove':
+            return 'Removed';
+        case 'replace':
+            return 'File replaced';
+        case 'rename':
+            return 'File renamed';
+        case 'metadata':
+            return 'File metadata updated';
+        default:
+            return 'Updated';
+    }
+}
+//#endregion
+
+//#region ----   Dexie DB   ----
+/**
+ * Dexie database for workflow instances.
  */
-const workflowDefinitionIds = {
-    createUser: 'create-user-workflow',
-    welcome: 'welcome-workflow',
-    dataProcessing: 'data-processing-workflow',
-};
+class AXCWorkflowExecutionDB extends Dexie {
+    constructor() {
+        super('ACoreXWorkflowExecutions');
+        this.version(2).stores({
+            instances: 'id, definitionId, status, subStatus, createdAt, updatedAt',
+        });
+        // Migration from v1 to v2: clear old executions table
+        this.version(1).stores({
+            executions: 'executionId, workflowId, status, currentStepId, lastUpdated',
+        });
+    }
+}
+/**
+ * Singleton instance of workflow execution database.
+ */
+const axWorkflowExecutionDB = new AXCWorkflowExecutionDB();
+//#endregion
 
 /**
- * Seeds workflow definitions into localStorage for mock/demo purposes.
+ * Mock implementation of AXPWorkflowEngine.
  *
- * Workflow definitions are stored in localStorage with key pattern:
- * `workflow:{definitionId}`
+ * Uses IndexedDB (via Dexie) to store workflow instance states.
  *
- * This allows the mock workflow execution service to retrieve definitions
- * without making HTTP calls.
+ * @example
+ * ```typescript
+ * // In module providers
+ * {
+ *   provide: AXP_WORKFLOW_ENGINE,
+ *   useClass: AXCWorkflowRuntimeService,
+ * }
+ * ```
  */
-let AXCWorkflowDefinitionDataSeeder$1 = class AXCWorkflowDefinitionDataSeeder {
+class AXCWorkflowRuntimeService {
     constructor() {
-        this.storageService = inject(AXPEntityStorageService);
+        this.db = axWorkflowExecutionDB;
+        this.commandService = inject(AXPCommandService);
+        this.entityStorageService = inject(AXPEntityStorageService);
     }
-    async seed() {
-        // Store each workflow definition in localStorage
-        // for (const workflow of workflowDefinitionMock) {
-        // localStorage.setItem(`workflow:${workflow.definitionId}`, JSON.stringify(workflow));
-        // console.log(`[WorkflowDefinitionSeeder] Seeded workflow: ${workflow.name} (${workflow.definitionId})`);
+    /**
+     * Start a new workflow instance.
+     * Creates a workflow instance and stores it in IndexedDB.
+     */
+    async start(request) {
+        const instanceId = AXPDataGenerator.uuid();
+        const now = new Date().toISOString();
+        // Get workflow definition from entity storage service
+        const workflowEntity = await this.entityStorageService.getOne('WorkflowManagement.WorkflowDefinition', request.workflowId);
+        if (!workflowEntity) {
+            throw new Error(`Workflow definition not found: ${request.workflowId}`);
+        }
+        // Convert entity model to workflow definition
+        const workflow = workflowEntity;
+        // Find first step from Flowchart (activity with no incoming connections)
+        const flowchart = workflow.root;
+        const activities = flowchart.activities || [];
+        const connections = flowchart.connections || [];
+        // Build connection map: target -> source[]
+        const incomingConnections = new Map();
+        connections.forEach((conn) => {
+            const targetId = conn.target.activity;
+            if (!incomingConnections.has(targetId)) {
+                incomingConnections.set(targetId, []);
+            }
+            incomingConnections.get(targetId).push(conn.source.activity);
+        });
+        // Find root activity (activity with no incoming connections, or first activity)
+        let firstActivity = null;
+        for (const activity of activities) {
+            if (!incomingConnections.has(activity.id)) {
+                firstActivity = activity;
+                break;
+            }
+        }
+        // If no root found, use first activity
+        if (!firstActivity && activities.length > 0) {
+            firstActivity = activities[0];
+        }
+        const firstStepId = firstActivity?.id || 'root';
+        // Create workflow state
+        const workflowState = {
+            id: `state-${instanceId}`,
+            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
+            //definitionVersion: workflow.version,
+            definitionVersion: 1,
+            correlationId: null,
+            status: 'Running',
+            subStatus: 'Executing',
+            bookmarks: [],
+            incidents: [],
+            fault: null,
+            completionCallbacks: [],
+            activityExecutionContexts: firstActivity ? [{
+                    id: `ctx-${firstStepId}`,
+                    parentContextId: null,
+                    scheduledActivityNodeId: firstStepId,
+                    ownerActivityNodeId: null,
+                    properties: {},
+                    activityState: null,
+                    dynamicVariables: [],
+                    status: 'Running',
+                    isExecuting: false,
+                    faultCount: 0,
+                    startedAt: now,
+                    completedAt: null,
+                    tag: null
+                }] : [],
+            input: request.input || {},
+            output: {},
+            properties: {},
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null
+        };
+        // Create workflow instance
+        const instance = {
+            $schema: 'https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json',
+            id: instanceId,
+            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
+            //definitionVersionId: workflow.id,
+            //version: workflow.version,
+            version: 1,
+            definitionVersionId: '1',
+            parentWorkflowInstanceId: null,
+            workflowState,
+            status: 'Running',
+            subStatus: 'Executing',
+            correlationId: null,
+            name: workflow.name || null,
+            incidentCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null
+        };
+        // Store instance in IndexedDB
+        await this.db.instances.add(instance, instance.id);
+        // 🎯 Also store in entity service for entity-based access
+        await this.saveInstanceToEntityService(instance);
+        // Convert to instance state for response
+        let state = this.instanceToInstanceState(instance);
+        // 🎯 KEY LOGIC: Execute all backend activities until we reach a frontend activity
+        let currentActivity = firstActivity;
+        let executionCount = 0;
+        const maxExecutions = 100; // Prevent infinite loops
+        while (currentActivity && executionCount < maxExecutions) {
+            executionCount++;
+            // Map activity type to ACoreX format
+            let activityType = currentActivity.type;
+            if (activityType.startsWith('Elsa.')) {
+                let type = activityType.replace(/^Elsa\./, '');
+                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+                activityType = `workflow-activity:${type}`;
+            }
+            // Determine execution mode
+            const executionMode = this.determineExecutionMode(activityType, currentActivity);
+            // If frontend activity → stop and return as pendingTask
+            if (executionMode === 'frontend') {
+                const pendingTask = this.createTaskFromActivity(currentActivity, state);
+                // Update state to suspended (waiting for frontend)
+                state = {
+                    ...state,
+                    status: 'suspended',
+                    currentStepId: currentActivity.id,
+                };
+                await this.updateInstanceFromState(instanceId, state);
+                return {
+                    instanceId: instanceId,
+                    state,
+                    pendingTask
+                };
+            }
+            // Backend activity → execute it
+            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
+            // Update variables with output
+            state = {
+                ...state,
+                variables: {
+                    ...state.variables,
+                    ...executionResult.output
+                },
+                currentStepId: currentActivity.id,
+                lastUpdated: new Date()
+            };
+            // Find next activity based on outcome
+            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+            const nextConnection = connections.find((conn) => conn.source.activity === currentActivity.id &&
+                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
+            if (!nextConnection) {
+                // No next activity → workflow completed
+                state = {
+                    ...state,
+                    status: 'completed',
+                    currentStepId: undefined,
+                    output: state.variables
+                };
+                await this.updateInstanceFromState(instanceId, state);
+                return {
+                    instanceId: instanceId,
+                    state,
+                    pendingTask: null
+                };
+            }
+            // Find next activity
+            currentActivity = this.findActivityInFlowchart(flowchart, nextConnection.target.activity);
+        }
+        // If we exit loop without frontend activity, workflow is complete
+        state = {
+            ...state,
+            status: 'completed',
+            currentStepId: undefined,
+            output: state.variables
+        };
+        await this.updateInstanceFromState(instanceId, state);
+        return {
+            instanceId: instanceId,
+            state,
+            pendingTask: null
+        };
+    }
+    /**
+     * Find activity in Flowchart by ID.
+     */
+    findActivityInFlowchart(flowchart, activityId) {
+        const activities = flowchart.activities || [];
+        return activities.find(a => a.id === activityId) || null;
+    }
+    /**
+     * Resume a suspended workflow instance.
+     *
+     * After frontend completes its task:
+     * 1. Validates taskToken
+     * 2. Finds next activity based on outcome
+     * 3. Executes ALL backend activities in sequence
+     * 4. Stops at first frontend activity and returns it as pendingTask
+     */
+    async resume(request) {
+        // Get current state
+        let state = await this.getState({
+            instanceId: request.instanceId,
+        });
+        if (!state) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        if (state.status !== 'suspended') {
+            throw new Error(`Cannot resume workflow with status: ${state.status}. Expected: suspended`);
+        }
+        // TODO: Validate taskToken here for security
+        // For now, just verify stepId matches
+        if (state.currentStepId !== request.stepId) {
+            throw new Error(`Step mismatch: expected '${state.currentStepId}', got '${request.stepId}'`);
+        }
+        // Get workflow definition from entity storage service
+        const workflowEntity = await this.entityStorageService.getOne('WorkflowManagement.WorkflowDefinition', state.workflowId);
+        if (!workflowEntity) {
+            throw new Error(`Workflow definition not found: ${state.workflowId}`);
+        }
+        // Convert entity model to workflow definition
+        const workflow = workflowEntity;
+        const connections = workflow.root.connections || [];
+        // Update state with frontend activity outcome and user input
+        state = {
+            ...state,
+            variables: {
+                ...state.variables,
+                [`${request.stepId}_outcome`]: request.outcome,
+                [`${request.stepId}_userInput`]: request.userInput || {},
+            },
+            lastUpdated: new Date()
+        };
+        // Find next activity based on outcome from frontend
+        const nextConnection = connections.find((conn) => conn.source.activity === request.stepId &&
+            (conn.source.port === request.outcome || (!conn.source.port && request.outcome === 'Done')));
+        console.log('[AXCWorkflowExecutionService] 🔍 Looking for next connection', {
+            stepId: request.stepId,
+            outcome: request.outcome,
+            connectionsCount: connections.length,
+            foundConnection: !!nextConnection
+        });
+        if (!nextConnection) {
+            // No next activity → workflow completed
+            console.log('[AXCWorkflowExecutionService] ✅ No next activity found - workflow completed');
+            state = {
+                ...state,
+                status: 'completed',
+                currentStepId: undefined,
+                output: state.variables
+            };
+            console.log('[AXCWorkflowExecutionService] 📝 Updating instance to completed state');
+            await this.updateInstanceFromState(request.instanceId, state);
+            return {
+                output: { outcome: request.outcome, userInput: request.userInput },
+                outcomes: { [request.outcome]: true },
+                nextTask: null,
+                state
+            };
+        }
+        // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
+        let currentActivity = this.findActivityInFlowchart(workflow.root, nextConnection.target.activity);
+        let executionCount = 0;
+        const maxExecutions = 100;
+        while (currentActivity && executionCount < maxExecutions) {
+            executionCount++;
+            // Map activity type
+            let activityType = currentActivity.type;
+            if (activityType.startsWith('Elsa.')) {
+                let type = activityType.replace(/^Elsa\./, '');
+                type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+                activityType = `workflow-activity:${type}`;
+            }
+            // Determine execution mode
+            const executionMode = this.determineExecutionMode(activityType, currentActivity);
+            // If frontend activity → stop and return as pendingTask
+            if (executionMode === 'frontend') {
+                const pendingTask = this.createTaskFromActivity(currentActivity, state);
+                state = {
+                    ...state,
+                    status: 'suspended',
+                    currentStepId: currentActivity.id,
+                };
+                await this.updateInstanceFromState(request.instanceId, state);
+                return {
+                    output: { outcome: request.outcome, userInput: request.userInput },
+                    outcomes: { [request.outcome]: true },
+                    nextTask: pendingTask,
+                    state
+                };
+            }
+            // Backend activity → execute it
+            console.log(`[WorkflowExecutionService] Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, { ...state.variables, ...state.input }, state);
+            // Update variables with output
+            state = {
+                ...state,
+                variables: {
+                    ...state.variables,
+                    ...executionResult.output
+                },
+                currentStepId: currentActivity.id,
+                lastUpdated: new Date()
+            };
+            // Find next activity based on outcome
+            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+            const nextConn = connections.find((conn) => conn.source.activity === currentActivity.id &&
+                (conn.source.port === outcome || (!conn.source.port && outcome === 'Done')));
+            if (!nextConn) {
+                // No next activity → workflow completed
+                state = {
+                    ...state,
+                    status: 'completed',
+                    currentStepId: undefined,
+                    output: state.variables
+                };
+                await this.updateInstanceFromState(request.instanceId, state);
+                return {
+                    output: state.variables,
+                    outcomes: { Done: true },
+                    nextTask: null,
+                    state
+                };
+            }
+            // Find next activity
+            currentActivity = this.findActivityInFlowchart(workflow.root, nextConn.target.activity);
+        }
+        // If we exit loop, workflow is complete
+        state = {
+            ...state,
+            status: 'completed',
+            currentStepId: undefined,
+            output: state.variables
+        };
+        await this.updateInstanceFromState(request.instanceId, state);
+        return {
+            output: state.variables,
+            outcomes: { Done: true },
+            nextTask: null,
+            state
+        };
+    }
+    /**
+     * Get current workflow execution state.
+     */
+    async getState(request) {
+        // Get instance from IndexedDB
+        const instance = await this.getInstance(request.instanceId);
+        if (!instance) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Convert instance to state
+        return this.instanceToInstanceState(instance);
+    }
+    //#region ----   Task-Based Helper Methods   ----
+    /**
+     * Generate unique task token for task-based execution.
+     * Inspired by Temporal's task tokens for secure task completion.
+     */
+    generateTaskToken(instanceId, activityId) {
+        return `${instanceId}:${activityId}:${Date.now()}`;
+    }
+    /**
+     * Determine execution mode for an activity.
+     *
+     * Priority (highest to lowest):
+     * 1. Activity instance's executionMode (from AXPActivity in workflow definition)
+     * 2. ActivityDescriptor's executionMode (from ActivityProviderService)
+     * 3. Default: 'frontend'
+     *
+     * @param activityType - Activity type (e.g., 'workflow-activity:write-line')
+     * @param activity - Activity from workflow definition (AXPActivity)
+     * @returns Execution mode: 'frontend', 'backend', or 'both'
+     */
+    determineExecutionMode(activityType, activity) {
+        // 1. Check if executionMode is explicitly set in activity instance (highest priority)
+        if (activity?.executionMode) {
+            return activity.executionMode;
+        }
+        // 2. Check ActivityDescriptor from ActivityProviderService
+        // const descriptor = this.activityProviderService.getMetadata(activityType);
+        // if (descriptor?.executionMode) {
+        //   return descriptor.executionMode;
         // }
-        // Also store in entity storage for entity-based access
-        await this.storageService.initial('Workflow.WorkflowDefinition', workflowDefinitionMock);
+        // 3. Default to frontend (UI activities are more common)
+        return 'frontend';
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder }); }
-};
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionDataSeeder$1, decorators: [{
-            type: Injectable
-        }] });
-
-//#endregion
-//#region ----   Update Status Command   ----
-/**
- * Generic command to update entity status
- * Supports both single entity (id) and bulk updates (ids)
- *
- * Options:
- * - entity: string - Entity key (e.g., 'OrderManagement.GroupOrder')
- * - id?: string - Single entity ID
- * - ids?: string[] - Multiple entity IDs (for bulk updates)
- * - status: string - Target status value
- * - statusField?: string - Status field name (default: 'statusId')
- */
-class AXCEntityUpdateStatusCommand {
-    constructor() {
-        this.entityService = inject(AXPEntityService);
+    /**
+     * Create a task from a workflow activity.
+     * Inspired by Temporal's Activity Task and Elsa's Bookmark pattern.
+     */
+    createTaskFromActivity(activity, state) {
+        // Extract properties from activity
+        // Activities have properties as AXPInputValue objects or primitives
+        const properties = {};
+        // Iterate through all properties of the activity
+        Object.keys(activity).forEach(key => {
+            // Skip standard Elsa fields
+            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata', 'executionMode'].includes(key)) {
+                return;
+            }
+            const value = activity[key];
+            // 🎯 SPECIAL HANDLING: If key is 'properties' and it's an object, flatten it
+            // This handles workflow-studio format where properties are nested
+            if (key === 'properties' && value && typeof value === 'object' && !('typeName' in value) && !('expression' in value)) {
+                // Flatten properties object
+                Object.keys(value).forEach(propKey => {
+                    const propValue = value[propKey];
+                    // Handle AXPInputValue format within properties
+                    if (propValue && typeof propValue === 'object' && 'typeName' in propValue && 'expression' in propValue) {
+                        if (propValue.expression && propValue.expression.value !== undefined) {
+                            properties[propKey] = propValue.expression.value;
+                        }
+                        else {
+                            properties[propKey] = null;
+                        }
+                    }
+                    else {
+                        // Direct value
+                        properties[propKey] = propValue;
+                    }
+                });
+                return;
+            }
+            // Handle AXPInputValue format
+            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
+                // It's an AXPInputValue - extract the expression value
+                if (value.expression && value.expression.value !== undefined) {
+                    properties[key] = value.expression.value;
+                }
+                else {
+                    properties[key] = null;
+                }
+            }
+            else {
+                // Direct value
+                properties[key] = value;
+            }
+        });
+        console.log('[AXCWorkflowExecutionService] 📦 Extracted properties for task', properties);
+        // Map activity type to ACoreX activity type
+        // Example: "Elsa.WriteLine" -> "workflow-activity:write-line"
+        let activityType = activity.type;
+        if (activityType.startsWith('Elsa.')) {
+            let type = activityType.replace(/^Elsa\./, '');
+            // Convert PascalCase to kebab-case
+            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+            activityType = `workflow-activity:${type}`;
+        }
+        // Get executionMode from activity descriptor
+        const executionMode = this.determineExecutionMode(activityType, activity);
+        return {
+            taskToken: this.generateTaskToken(state.instanceId, activity.id),
+            activityId: activity.id,
+            activityType,
+            activityName: activity.name || undefined,
+            executionMode,
+            input: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined,
+            config: (executionMode === 'frontend' || executionMode === 'both') ? properties : undefined
+        };
+    }
+    /**
+     * Save workflow instance to entity service for entity-based access.
+     */
+    async saveInstanceToEntityService(instance) {
+        try {
+            const entityModel = {
+                id: instance.id,
+                definitionId: instance.definitionId,
+                definitionVersionId: instance.definitionVersionId,
+                version: instance.version,
+                status: instance.status,
+                subStatus: instance.subStatus,
+                correlationId: instance.correlationId || undefined,
+                name: instance.name || undefined,
+                incidentCount: instance.incidentCount,
+                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
+                createdAt: instance.createdAt,
+                updatedAt: instance.updatedAt,
+                finishedAt: instance.finishedAt || undefined,
+                workflowInstance: instance
+            };
+            const entityName = 'WorkflowManagement.WorkflowInstance';
+            // Check if instance already exists
+            try {
+                const existing = await this.entityStorageService.getOne(entityName, entityModel.id);
+                if (existing) {
+                    // Already exists - don't insert again, will be updated later
+                    console.log('[AXCWorkflowExecutionService] ℹ️ Instance already exists in entity service, will be updated later', {
+                        instanceId: instance.id
+                    });
+                    return;
+                }
+            }
+            catch (getError) {
+                // Instance doesn't exist - proceed with insert
+            }
+            // Insert new instance
+            await this.entityStorageService.insertOne(entityName, entityModel);
+            console.log('[AXCWorkflowExecutionService] ✅ Inserted new instance in entity service', {
+                instanceId: instance.id,
+                status: instance.status,
+                subStatus: instance.subStatus
+            });
+        }
+        catch (error) {
+            console.warn('[AXCWorkflowExecutionService] Failed to save instance to entity service:', error);
+            // Don't throw - IndexedDB is primary storage
+        }
     }
-    async execute(input) {
+    /**
+     * Update workflow instance in entity service.
+     * Uses upsert pattern: try update first, if fails then insert.
+     */
+    async updateInstanceInEntityService(instance) {
         try {
-            const { entity, id, ids, status, statusField = 'statusId' } = input;
-            // Validate input
-            if (!entity) {
-                throw new Error('Entity name is required');
+            const entityModel = {
+                id: instance.id,
+                definitionId: instance.definitionId,
+                definitionVersionId: instance.definitionVersionId,
+                version: instance.version,
+                status: instance.status,
+                subStatus: instance.subStatus,
+                correlationId: instance.correlationId || undefined,
+                name: instance.name || undefined,
+                incidentCount: instance.incidentCount,
+                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
+                createdAt: instance.createdAt,
+                updatedAt: instance.updatedAt,
+                finishedAt: instance.finishedAt || undefined,
+                workflowInstance: instance
+            };
+            const entityName = 'WorkflowManagement.WorkflowInstance';
+            // Try update first (upsert pattern)
+            try {
+                await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
+                console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service', {
+                    instanceId: instance.id,
+                    status: instance.status,
+                    subStatus: instance.subStatus
+                });
+                return; // Successfully updated, exit
             }
-            if (!id && (!ids || ids.length === 0)) {
-                throw new Error('Either id or ids must be provided');
+            catch (updateError) {
+                // Update failed - instance doesn't exist, try insert
+                console.log('[AXCWorkflowExecutionService] ℹ️ Update failed, trying insert', {
+                    instanceId: instance.id,
+                    error: updateError.message
+                });
             }
-            if (!status) {
-                throw new Error('Status value is required');
+            // Try insert
+            try {
+                await this.entityStorageService.insertOne(entityName, entityModel);
+                console.log('[AXCWorkflowExecutionService] ✅ Inserted instance in entity service', {
+                    instanceId: instance.id,
+                    status: instance.status,
+                    subStatus: instance.subStatus
+                });
             }
-            const dataAccessor = this.entityService.withEntity(entity).data();
-            const updateData = { [statusField]: status };
-            // Handle bulk update
-            if (ids && ids.length > 0) {
-                const results = [];
-                for (const entityId of ids) {
-                    const updated = await dataAccessor.update(entityId, updateData);
-                    results.push(updated);
+            catch (insertError) {
+                // Insert might fail if instance was created between update and insert
+                // Try update again as fallback
+                try {
+                    await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
+                    console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service (after insert failed)', {
+                        instanceId: instance.id,
+                        status: instance.status,
+                        subStatus: instance.subStatus
+                    });
                 }
-                return {
-                    success: true,
-                    data: results,
+                catch (finalError) {
+                    console.warn('[AXCWorkflowExecutionService] Failed to upsert instance in entity service:', finalError);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('[AXCWorkflowExecutionService] Failed to update instance in entity service:', error);
+            // Don't throw - IndexedDB is primary storage
+        }
+    }
+    //#endregion
+    //#region ----   Backend Activity Executors   ----
+    /**
+     * Execute backend activities locally using CommandBus.
+     *
+     * Backend activities are registered as Commands and executed via CommandService.
+     * This provides a unified execution channel for all activities.
+     */
+    async executeBackendActivityLocally(activity, input, state) {
+        console.log('[AXCWorkflowExecutionService] 🔧 executeBackendActivityLocally', {
+            activityId: activity.id,
+            activityType: activity.type,
+            input
+        });
+        // Extract properties from activity
+        const properties = {};
+        Object.keys(activity).forEach(key => {
+            if (['id', 'nodeId', 'name', 'type', 'version', 'customProperties', 'metadata', 'executionMode'].includes(key)) {
+                return;
+            }
+            const value = activity[key];
+            if (value && typeof value === 'object' && 'typeName' in value && 'expression' in value) {
+                if (value.expression && value.expression.value !== undefined) {
+                    properties[key] = value.expression.value;
+                }
+                else {
+                    properties[key] = null;
+                }
+            }
+            else {
+                properties[key] = value;
+            }
+        });
+        console.log('[AXCWorkflowExecutionService] 📦 Extracted properties', properties);
+        // Map activity type to ACoreX activity type
+        let activityType = activity.type;
+        if (activityType.startsWith('Elsa.')) {
+            let type = activityType.replace(/^Elsa\./, '');
+            type = type.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '');
+            activityType = `workflow-activity:${type}`;
+        }
+        console.log('[AXCWorkflowExecutionService] 🔀 Activity type mapped', {
+            original: activity.type,
+            mapped: activityType
+        });
+        // Check if activity is registered as a Command
+        const commandExists = this.commandService.exists(activityType);
+        console.log('[AXCWorkflowExecutionService] 🔍 Command exists?', commandExists, activityType);
+        if (commandExists) {
+            console.log(`[AXCWorkflowExecutionService] ⚡ Executing '${activityType}' via CommandBus`);
+            try {
+                // Execute via CommandBus
+                const result = await this.commandService.execute(activityType, properties);
+                const finalResult = {
+                    output: result?.data?.output || result,
+                    outcomes: result?.data?.outcomes || { Done: true }
                 };
+                console.log('[AXCWorkflowExecutionService] ✅ Final result', finalResult);
+                return finalResult;
             }
-            // Handle single update
-            if (id) {
-                const updated = await dataAccessor.update(id, updateData);
+            catch (error) {
+                console.error(`[AXCWorkflowExecutionService] ❌ Backend activity '${activityType}' failed:`, error);
                 return {
-                    success: true,
-                    data: updated,
-                    message: {
-                        text: 'Entity status updated successfully',
-                    },
+                    output: { error: error.message || 'Unknown error' },
+                    outcomes: { Failed: true }
                 };
             }
-            throw new Error('Invalid input: neither id nor ids provided');
         }
-        catch (error) {
+        // Fallback: Handle built-in activities that aren't Commands yet
+        console.warn(`[WorkflowExecutionService] Activity '${activityType}' not registered as Command, using fallback`);
+        switch (activityType) {
+            case 'workflow-activity:set-variable':
+                return this.executeSetVariable({ type: activityType, properties }, input);
+            case 'workflow-activity:http-request':
+                return this.executeHttpRequest({ type: activityType, properties }, input);
+            default:
+                return { output: null, outcomes: { Done: true } };
+        }
+    }
+    /**
+     * Set variable activity - stores value in workflow state.
+     */
+    async executeSetVariable(activity, input) {
+        const variableName = activity.properties?.variableName;
+        const value = activity.properties?.value;
+        return {
+            output: { [variableName]: value },
+            outcomes: { Done: true }
+        };
+    }
+    /**
+     * Execute HTTP request - makes real HTTP call.
+     * Supports different HTTP methods and handles timeouts.
+     */
+    async executeHttpRequest(activity, input) {
+        const url = activity.properties?.url;
+        const method = activity.properties?.method || 'GET';
+        const timeout = activity.properties?.timeout || 30000;
+        const headers = activity.properties?.headers || {};
+        const body = activity.properties?.body;
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const fetchOptions = {
+                method,
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                }
+            };
+            if (body && method !== 'GET' && method !== 'HEAD') {
+                fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+            }
+            const response = await fetch(url, fetchOptions);
+            clearTimeout(timeoutId);
+            const statusCode = response.status.toString();
+            let data;
+            try {
+                data = await response.json();
+            }
+            catch {
+                data = await response.text();
+            }
+            // Convert headers to object
+            const responseHeaders = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
             return {
-                success: false,
-                message: {
-                    text: error instanceof Error ? error.message : 'Failed to update entity status',
+                output: {
+                    statusCode,
+                    data,
+                    status: response.status,
+                    headers: responseHeaders
                 },
+                outcomes: {
+                    [statusCode]: true,
+                    Done: true
+                }
+            };
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                return {
+                    output: { error: 'Request timeout' },
+                    outcomes: { Timeout: true }
+                };
+            }
+            return {
+                output: { error: error.message },
+                outcomes: { Failed: true }
             };
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCEntityUpdateStatusCommand, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class AXCCommonMockModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, providers: [
-            {
-                provide: AXP_ACTIVITY_LOG_PROVIDER,
-                useClass: AXCPActivityLogService,
-                multi: true,
-            },
-            {
-                provide: AXP_SEARCH_PROVIDER,
-                useClass: EntitySearchProvider,
-                multi: true,
-            },
-            {
-                provide: AXPLockService,
-                useClass: AXCLockService,
-            },
-            {
-                provide: AXPFileStorageService,
-                useClass: AXCFileStorageService,
-            },
-            {
-                provide: AXPVersioningService,
-                useClass: AXCVersioningService,
-            },
-            // {
-            //     provide: AXP_ACTIVITY_PROVIDER,
-            //     useClass: AXCActivityProvider,
-            //     multi: true,
-            // },
-            {
-                provide: AXPWorkflowExecutionService,
-                useClass: AXCWorkflowExecutionService,
-            },
-            {
-                provide: AXP_DATA_SEEDER_TOKEN,
-                useClass: AXCWorkflowDefinitionDataSeeder$1,
-                multi: true,
-            },
-            // Register generic Entity:UpdateStatus command
-            provideCommandSetups([
-                { key: 'Entity:UpdateStatus', command: () => AXCEntityUpdateStatusCommand },
-            ]),
-            AXCEntityUpdateStatusCommand,
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCCommonMockModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        {
-                            provide: AXP_ACTIVITY_LOG_PROVIDER,
-                            useClass: AXCPActivityLogService,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_SEARCH_PROVIDER,
-                            useClass: EntitySearchProvider,
-                            multi: true,
-                        },
-                        {
-                            provide: AXPLockService,
-                            useClass: AXCLockService,
-                        },
-                        {
-                            provide: AXPFileStorageService,
-                            useClass: AXCFileStorageService,
-                        },
-                        {
-                            provide: AXPVersioningService,
-                            useClass: AXCVersioningService,
-                        },
-                        // {
-                        //     provide: AXP_ACTIVITY_PROVIDER,
-                        //     useClass: AXCActivityProvider,
-                        //     multi: true,
-                        // },
-                        {
-                            provide: AXPWorkflowExecutionService,
-                            useClass: AXCWorkflowExecutionService,
-                        },
-                        {
-                            provide: AXP_DATA_SEEDER_TOKEN,
-                            useClass: AXCWorkflowDefinitionDataSeeder$1,
-                            multi: true,
-                        },
-                        // Register generic Entity:UpdateStatus command
-                        provideCommandSetups([
-                            { key: 'Entity:UpdateStatus', command: () => AXCEntityUpdateStatusCommand },
-                        ]),
-                        AXCEntityUpdateStatusCommand,
-                    ],
-                }]
-        }] });
-
-//#region ----   Imports   ----
-function toUiRows(changes) {
-    return changes.map((c) => ({
-        badge: toBadge(c.op),
-        path: c.path,
-        summary: toSummary(c),
-        oldValue: c.oldValue,
-        newValue: c.newValue,
-    }));
-}
-function toBadge(op) {
-    switch (op) {
-        case 'add':
-            return 'Added';
-        case 'remove':
-            return 'Removed';
-        case 'replace':
-            return 'Replaced';
-        case 'rename':
-            return 'Renamed';
-        case 'metadata':
-            return 'Metadata';
-        default:
-            return 'Updated';
+    //#endregion
+    //#region ----   Instance Management   ----
+    /**
+     * Convert workflow instance to instance state.
+     */
+    instanceToInstanceState(instance) {
+        const state = instance.workflowState;
+        // Find current activity from execution contexts
+        const currentContext = state.activityExecutionContexts.find(ctx => ctx.status === 'Running' && !ctx.completedAt);
+        // Map status
+        let status = 'running';
+        if (instance.status === 'Finished') {
+            if (instance.subStatus === 'Faulted') {
+                status = 'error';
+            }
+            else {
+                status = 'completed';
+            }
+        }
+        else if (instance.subStatus === 'Suspended') {
+            status = 'suspended';
+        }
+        return {
+            instanceId: instance.id,
+            workflowId: instance.definitionId,
+            status,
+            currentStepId: currentContext?.scheduledActivityNodeId,
+            variables: state.properties || {},
+            input: state.input || {},
+            output: state.output || {},
+            lastUpdated: new Date(instance.updatedAt)
+        };
     }
-}
-function toSummary(c) {
-    switch (c.op) {
-        case 'add':
-            return 'Added';
-        case 'remove':
-            return 'Removed';
-        case 'replace':
-            return 'File replaced';
-        case 'rename':
-            return 'File renamed';
-        case 'metadata':
-            return 'File metadata updated';
-        default:
-            return 'Updated';
+    /**
+     * Update instance state in instance and save to IndexedDB.
+     */
+    async updateInstanceFromState(instanceId, instanceState) {
+        const instance = await this.getInstance(instanceId);
+        if (!instance) {
+            throw new Error(`Workflow instance not found: ${instanceId}`);
+        }
+        // Update instance from state
+        const now = new Date().toISOString();
+        // Map state status to instance status
+        let status = 'Running';
+        let subStatus = 'Executing';
+        console.log('[AXCWorkflowRuntimeService] 🔄 updateInstanceFromState', {
+            instanceStateStatus: instanceState.status,
+            instanceId: instance.id,
+            currentInstanceStatus: instance.status
+        });
+        if (instanceState.status === 'completed') {
+            console.log('[AXCWorkflowRuntimeService] ✅ Marking workflow as Finished');
+            status = 'Finished';
+            subStatus = 'Finished';
+            instance.finishedAt = now;
+        }
+        else if (instanceState.status === 'error') {
+            status = 'Finished';
+            subStatus = 'Faulted';
+            instance.finishedAt = now;
+        }
+        else if (instanceState.status === 'suspended') {
+            subStatus = 'Suspended';
+        }
+        instance.status = status;
+        instance.subStatus = subStatus;
+        instance.updatedAt = now;
+        // Update workflow state
+        instance.workflowState.status = status;
+        instance.workflowState.subStatus = subStatus;
+        instance.workflowState.input = instanceState.input || {};
+        instance.workflowState.output = instanceState.output || {};
+        instance.workflowState.properties = instanceState.variables || {};
+        instance.workflowState.updatedAt = now;
+        if (instanceState.status === 'completed' || instanceState.status === 'error') {
+            instance.workflowState.finishedAt = now;
+        }
+        // Update activity execution context if currentStepId changed
+        if (instanceState.currentStepId) {
+            const existingContext = instance.workflowState.activityExecutionContexts.find(ctx => ctx.scheduledActivityNodeId === instanceState.currentStepId);
+            if (!existingContext) {
+                // Add new context
+                instance.workflowState.activityExecutionContexts.push({
+                    id: `ctx-${instanceState.currentStepId}`,
+                    parentContextId: null,
+                    scheduledActivityNodeId: instanceState.currentStepId,
+                    ownerActivityNodeId: null,
+                    properties: {},
+                    activityState: null,
+                    dynamicVariables: [],
+                    status: 'Running',
+                    isExecuting: false,
+                    faultCount: 0,
+                    startedAt: now,
+                    completedAt: null,
+                    tag: null
+                });
+            }
+        }
+        // Save to IndexedDB
+        await this.updateInstance(instance);
+        // 🎯 Also update in entity service
+        await this.updateInstanceInEntityService(instance);
+        return instance;
+    }
+    /**
+     * Get workflow instance from IndexedDB.
+     */
+    async getInstance(instanceId) {
+        return await this.db.instances.get(instanceId) || null;
+    }
+    /**
+     * Update workflow instance in IndexedDB.
+     */
+    async updateInstance(instance) {
+        instance.updatedAt = new Date().toISOString();
+        await this.db.instances.update(instance.id, instance);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowRuntimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowRuntimeService }); }
 }
-//#endregion
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowRuntimeService, decorators: [{
+            type: Injectable
+        }] });
 
 //#region ----   Imports   ----
 //#endregion
@@ -10219,6 +10123,198 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+class AXCDistributionInteractionMockService extends AXMDistributionInteractionServiceImpl {
+    constructor() {
+        super(...arguments);
+        //#region ----   Services & Dependencies   ----
+        this.usersService = inject(AXMUsersEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    //#endregion
+    async query(request) {
+        // Raw mode: return ungrouped interaction items (used for bulk aggregation)
+        if (request?.params?.raw === true) {
+            const rawRes = await super.query({
+                filter: request.filter,
+                sort: request.sort,
+                params: request.params,
+                take: 100000,
+                skip: 0,
+            });
+            const total = rawRes.items.length;
+            const skip = request?.skip ?? 0;
+            const take = request?.take ?? total;
+            const pagedItems = rawRes.items.slice(skip, skip + take);
+            return {
+                items: pagedItems,
+                total,
+            };
+        }
+        const items = (await super.query({
+            filter: request.filter,
+            sort: request.sort,
+            params: request.params,
+            take: 100000,
+            skip: 0,
+        })).items;
+        // Extract documentDistributionId from request filter
+        let documentDistributionId;
+        if (request.filter && typeof request.filter === 'object') {
+            if (request.filter.filters && request.filter.filters.length > 0 && request.filter.filters[0].field === 'documentDistributionId') {
+                documentDistributionId = request.filter.filters[0].value;
+            }
+        }
+        // Get the distribution record to access assignedTo property using storage service to avoid circular calls
+        if (documentDistributionId) {
+            try {
+                // Use storage service directly to get distribution record
+                const distribution = await this.storageService.getOne('DocumentManagement.Distribution', documentDistributionId);
+                if (distribution && distribution.assignedTo && Array.isArray(distribution.assignedTo)) {
+                    // Get all assigned user IDs
+                    const assignedUserIds = distribution.assignedTo.map((user) => user.id || user);
+                    // Get existing interaction user IDs (from created.user.id)
+                    const existingUserIds = new Set(items
+                        .map((item) => item?.created?.user?.id)
+                        .filter((id) => !!id));
+                    // Find users who are assigned but don't have interaction records
+                    const missingUserIds = assignedUserIds.filter((userId) => !existingUserIds.has(userId));
+                    // Create missing interaction records
+                    for (const userId of missingUserIds) {
+                        let fullName = 'Unknown';
+                        try {
+                            const userRes = await this.usersService.query({
+                                skip: 0,
+                                take: 1,
+                                filter: { field: 'id', operator: { type: 'equal' }, value: userId },
+                            });
+                            const u = userRes.items?.[0];
+                            if (u) {
+                                const candidate = `${u.firstName ?? ''} ${u.lastName ?? ''}`.trim();
+                                fullName = candidate || u.username || u.title || u.name || fullName;
+                            }
+                        }
+                        catch { }
+                        const missingRecord = {
+                            id: `missing-${documentDistributionId}-${userId}`,
+                            documentDistributionId: documentDistributionId,
+                            auditInfo: {
+                                created: { at: new Date(), by: { id: userId, type: 'user', fullName } },
+                                updated: { at: new Date(), by: { id: userId, type: 'user', fullName } },
+                            },
+                            action: 'Fake', // Default action, but with false flags
+                        };
+                        // Add the missing record to the items array
+                        items.push(missingRecord);
+                    }
+                }
+            }
+            catch (error) {
+            }
+        }
+        // Group items by creator user id
+        const groupedItems = this.groupItemsByCreatedBy(items);
+        // Collect distinct user IDs from grouped items
+        const userIds = Array.from(new Set(groupedItems.map((g) => g.createdBy).filter((id) => !!id)));
+        // Fetch users by IDs (in operator)
+        let usersMap = new Map();
+        if (userIds.length > 0) {
+            try {
+                const usersRes = await this.usersService.query({
+                    skip: 0,
+                    take: userIds.length,
+                    filter: {
+                        field: 'id',
+                        operator: { type: 'in' },
+                        value: userIds,
+                    },
+                });
+                usersMap = new Map(usersRes.items.map((u) => [
+                    u.id,
+                    {
+                        id: u.id,
+                        name: u.username,
+                        title: `${u.firstName} ${u.lastName}`,
+                    },
+                ]));
+            }
+            catch {
+                // If fetching users fails, continue without enrichment
+                usersMap = new Map();
+            }
+        }
+        // Convert grouped items back to the expected format with user enrichment
+        const enrichedItems = groupedItems.map((summary) => ({
+            id: summary.id,
+            createdBy: summary.createdBy,
+            hasViewed: summary.hasViewed,
+            lastViewDate: summary.lastViewDate,
+            hasSigned: summary.hasSigned,
+            lastSignDate: summary.lastSignDate,
+            totalInteractions: summary.totalInteractions,
+            user: usersMap.get(summary.createdBy) ?? {
+                id: this.sessionService?.user?.id ?? '',
+                name: this.sessionService?.user?.name ?? '',
+                title: this.sessionService?.user?.title ?? '',
+            },
+        }));
+        // Apply pagination using request.skip and request.take
+        const total = enrichedItems.length;
+        const skip = request?.skip ?? 0;
+        const take = request?.take ?? total;
+        const pagedItems = enrichedItems.slice(skip, skip + take);
+        return {
+            items: pagedItems,
+            total,
+        };
+    }
+    /**
+     * Groups distribution interaction items by createdBy and creates a summary
+     */
+    groupItemsByCreatedBy(items) {
+        console.log(items);
+        const groupedMap = new Map();
+        for (const item of items) {
+            const createdBy = item?.created?.user?.id || 'unknown';
+            if (!groupedMap.has(createdBy)) {
+                // Initialize summary for new createdBy
+                groupedMap.set(createdBy, {
+                    id: createdBy, // Use createdBy as the ID for the summary
+                    createdBy: createdBy,
+                    hasViewed: false,
+                    lastViewDate: undefined,
+                    hasSigned: false,
+                    lastSignDate: undefined,
+                    totalInteractions: 0,
+                });
+            }
+            const summary = groupedMap.get(createdBy);
+            summary.totalInteractions++;
+            // Check for view actions
+            if (item.action === 'Viewed') {
+                summary.hasViewed = true;
+                // Update last view date if this is more recent
+                if (!summary.lastViewDate || item.actionTime && item.actionTime > summary.lastViewDate) {
+                    summary.lastViewDate = item.actionTime;
+                }
+            }
+            // Check for sign actions
+            if (item.action === 'Signed') {
+                summary.hasSigned = true;
+                // Update last sign date if this is more recent
+                if (!summary.lastSignDate || item.actionTime && item.actionTime > summary.lastSignDate) {
+                    summary.lastSignDate = item.actionTime;
+                }
+            }
+        }
+        return Array.from(groupedMap.values());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService, decorators: [{
+            type: Injectable
+        }] });
+
 class AXCDistributionMockService extends AXMDistributionServiceImpl {
     constructor() {
         super(...arguments);
@@ -10328,153 +10424,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             type: Injectable
         }] });
 
-const DOCUMENT_TYPES = [
-    {
-        id: AXPDataGenerator.uuid(),
-        name: 'risk-assessment-report',
-        title: 'Risk Assessment Report',
-        maxSize: 5000,
-        isEncrypted: false,
-        enableVersioning: true,
-        enableExpiration: false,
-        requiresReview: true,
-        requiresDistribution: false,
-        metaDataList: [
-            {
-                id: AXPDataGenerator.uuid(),
-                text: 'Description',
-                //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
-                hasCheckbox: true,
-                isSelected: true,
-                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
-                name: 'description',
-                title: 'Description',
-                isRequired: true,
-                placeholder: '',
-                status: 'active',
-            },
-        ],
-        type: {
-            selectedItems: [
-                {
-                    name: 'image.jpg',
-                    title: 'Image/JPEG',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-                {
-                    name: 'image.png',
-                    title: 'Image/PNG',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-                {
-                    name: 'image.gif',
-                    title: 'Image/GIF',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-            ],
-            context: {
-                image: {
-                    width: '22',
-                    height: '33',
-                },
-                gift: {
-                    duration: '11',
-                },
-            },
-        },
-    },
-    {
-        id: AXPDataGenerator.uuid(),
-        name: 'any',
-        title: 'Upload File',
-        maxSize: 50000,
-        isEncrypted: false,
-        enableVersioning: false,
-        enableExpiration: false,
-        requiresReview: false,
-        requiresDistribution: false,
-        control: { isSystem: true },
-        metaDataList: [],
-        type: {
-            selectedItems: [],
-            context: {
-                audio: {
-                    bitrate: '320',
-                    duration: '180',
-                },
-            },
-        },
-    },
-    {
-        id: AXPDataGenerator.uuid(),
-        name: 'file-meeting',
-        title: 'File Meeting',
-        maxSize: 50000,
-        isEncrypted: false,
-        enableVersioning: true,
-        enableExpiration: true,
-        requiresReview: true,
-        requiresDistribution: true,
-        metaDataList: [
-            {
-                id: AXPDataGenerator.uuid(),
-                text: 'Description',
-                //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
-                hasCheckbox: true,
-                isSelected: true,
-                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
-                name: 'description',
-                title: 'Description',
-                isRequired: true,
-                placeholder: '',
-                status: 'active',
-            },
-        ],
-        type: {
-            selectedItems: [
-                {
-                    name: 'image.jpg',
-                    title: 'Image/JPEG',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-                {
-                    name: 'image.png',
-                    title: 'Image/PNG',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-                {
-                    name: 'image.gif',
-                    title: 'Image/GIF',
-                    icon: 'fa-light fa-image ax-text-purple-500',
-                },
-            ],
-            context: {
-                image: {
-                    width: '22',
-                    height: '33',
-                },
-                gift: {
-                    duration: '11',
-                },
-            },
-        },
-    },
-];
-
-class AXCDocumentTypeDataSeeder {
-    constructor() {
-        this.storageService = inject(AXPEntityStorageService);
-    }
-    async seed() {
-        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.documentType.name}`, DOCUMENT_TYPES);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder, decorators: [{
-            type: Injectable
-        }] });
-
 class AXCFolderMockService extends AXMFolderServiceImpl {
     async updateParentFolders(folder) {
         if (folder.parentId) {
@@ -10535,24 +10484,6 @@ class AXCFolderMockService extends AXMFolderServiceImpl {
             await super.deleteOne(id);
         }
     }
-    async getPath(folderId, stopFolderId) {
-        const path = [];
-        let currentId = folderId;
-        while (currentId) {
-            const folder = await super.getOne(currentId);
-            if (!folder) {
-                // Folder not found in persisted storage
-                break;
-            }
-            path.push(folder);
-            if (currentId == stopFolderId) {
-                // Stop if we reach the specified stop folder ID
-                break;
-            }
-            currentId = folder.parentId ?? null;
-        }
-        return path.reverse();
-    }
     /**
      * Finds the first non-inheriting folder in the hierarchy
      * @param folderId ID of the starting folder
@@ -10645,46 +10576,6 @@ class AXCFolderMockService extends AXMFolderServiceImpl {
         }
         return folder;
     }
-    /**
-     * Search folders with specified name using recursive method
-     * @param searchTerm search term
-     * @param rootFolderId ID of the root folder to start the search
-     */
-    async searchFolders(searchTerm, rootFolderId) {
-        const result = [];
-        await this.searchFoldersRecursive(searchTerm, rootFolderId, result);
-        return result;
-    }
-    /**
-     * Recursive folder search
-     * @param searchTerm search term
-     * @param folderId current folder ID
-     * @param result results array
-     */
-    async searchFoldersRecursive(searchTerm, folderId, result) {
-        try {
-            // Get current folder
-            const currentFolder = await this.getOne(folderId);
-            if (!currentFolder) {
-                return;
-            }
-            // Check subfolders
-            const subFolders = currentFolder.folders || [];
-            // Add folders that match the search term
-            for (const folder of subFolders) {
-                if (folder.name.toLowerCase().includes(searchTerm.toLowerCase())) {
-                    result.push(folder);
-                }
-                // Recursive search in subfolders
-                if (folder.id) {
-                    await this.searchFoldersRecursive(searchTerm, folder.id, result);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Error searching folders:', error);
-        }
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFolderMockService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCFolderMockService }); }
 }
@@ -10751,12 +10642,78 @@ class AXMFileMockService extends AXMDocumentServiceImpl {
             await super.deleteOne(id);
         }
     }
-    async getPath(documentId, stop) {
-        const file = await this.getOne(documentId);
+    async query(request) {
+        const result = await super.query(request);
+        // Use lazy injection to avoid circular dependency
+        const reviewService = this.injector.get(AXMReviewService, null);
+        if (reviewService) {
+            // Process items sequentially to avoid performance issues
+            for (const item of result.items) {
+                try {
+                    if (item.documentType?.requiresReview) {
+                        const reviewResult = await reviewService.query({
+                            skip: 0,
+                            take: 1,
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'documentId',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: item.id,
+                                    },
+                                    {
+                                        field: 'version',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: item.version,
+                                    },
+                                ],
+                            },
+                        });
+                        item.documentReview = reviewResult.items[0];
+                    }
+                }
+                catch (error) {
+                    // Continue processing other items if one fails
+                }
+            }
+        }
+        // Map result items to fileData structure
+        const mappedResult = {
+            ...result,
+            items: result.items.map((item) => ({
+                ...item,
+                // fileId: 'file:' + item.fileId,
+            })),
+        };
+        return mappedResult;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXCDocumentManagementService {
+    constructor() {
+        // Create instances directly to avoid circular dependency
+        // These services all use the same Dexie database, so they share data
+        this.folderService = new AXCFolderMockService();
+        this.documentService = new AXMFileMockService();
+        this.documentTypeService = new AXMDocumentTypeServiceImpl();
+    }
+    //#region ----   Document Methods   ----
+    async getDocumentPath(documentId, stopFolderId) {
+        const file = await this.documentService.getOne(documentId);
         if (!file) {
             throw new Error('File not found');
         }
-        return await this.folderService.getPath(file.parentId, stop);
+        return await this.getFolderPath(file.parentId, stopFolderId);
     }
     async searchFiles(searchTerm, rootFolderId) {
         const result = [];
@@ -10764,10 +10721,10 @@ class AXMFileMockService extends AXMDocumentServiceImpl {
         return result;
     }
     /**
-     * جستجوی بازگشتی فایل‌ها
-     * @param searchTerm عبارت جستجو
-     * @param folderId شناسه فولدر فعلی
-     * @param result آرایه نتایج
+     * Recursive file search
+     * @param searchTerm search term
+     * @param folderId current folder ID
+     * @param result results array
      */
     async searchFilesRecursive(searchTerm, folderId, result) {
         try {
@@ -10792,63 +10749,247 @@ class AXMFileMockService extends AXMDocumentServiceImpl {
             console.error('Error searching files:', error);
         }
     }
-    async query(request) {
-        const result = await super.query(request);
-        // Use lazy injection to avoid circular dependency
-        const reviewService = this.injector.get(AXMReviewService, null);
-        if (reviewService) {
-            // Process items sequentially to avoid performance issues
-            for (const item of result.items) {
-                try {
-                    if (item.documentType?.requiresReview) {
-                        const reviewResult = await reviewService.query({
-                            skip: 0,
-                            take: 1,
-                            filter: {
-                                logic: 'and',
-                                filters: [
-                                    {
-                                        field: 'documentId',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: item.id,
-                                    },
-                                    {
-                                        field: 'version',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: item.version,
-                                    },
-                                ],
-                            },
-                        });
-                        item.documentReview = reviewResult.items[0];
-                    }
+    async findManyDocuments(ids) {
+        const resp = await this.documentService.query({
+            skip: 0,
+            take: ids.length || 1000,
+            filter: {
+                field: 'id',
+                operator: { type: 'in' },
+                value: ids,
+            },
+        });
+        return (resp?.items ?? []);
+    }
+    //#endregion
+    //#region ----   Folder Methods   ----
+    async getFolderPath(folderId, stopFolderId) {
+        const path = [];
+        let currentId = folderId;
+        while (currentId) {
+            const folder = await this.folderService.getOne(currentId);
+            if (!folder) {
+                // Folder not found in persisted storage
+                break;
+            }
+            path.push(folder);
+            if (currentId == stopFolderId) {
+                // Stop if we reach the specified stop folder ID
+                break;
+            }
+            currentId = folder.parentId ?? null;
+        }
+        return path.reverse();
+    }
+    async searchFolders(searchTerm, rootFolderId) {
+        const result = [];
+        await this.searchFoldersRecursive(searchTerm, rootFolderId, result);
+        return result;
+    }
+    /**
+     * Recursive folder search
+     * @param searchTerm search term
+     * @param folderId current folder ID
+     * @param result results array
+     */
+    async searchFoldersRecursive(searchTerm, folderId, result) {
+        try {
+            // Get current folder
+            const currentFolder = await this.folderService.getOne(folderId);
+            if (!currentFolder) {
+                return;
+            }
+            // Check subfolders
+            const subFolders = currentFolder.folders || [];
+            // Add folders that match the search term
+            for (const folder of subFolders) {
+                if (folder.name.toLowerCase().includes(searchTerm.toLowerCase())) {
+                    result.push(folder);
                 }
-                catch (error) {
-                    // Continue processing other items if one fails
+                // Recursive search in subfolders
+                if (folder.id) {
+                    await this.searchFoldersRecursive(searchTerm, folder.id, result);
                 }
             }
         }
-        // Map result items to fileData structure
-        const mappedResult = {
-            ...result,
-            items: result.items.map((item) => ({
-                ...item,
-                // fileId: 'file:' + item.fileId,
-            })),
-        };
-        return mappedResult;
+        catch (error) {
+            console.error('Error searching folders:', error);
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService }); }
+    //#endregion
+    //#region ----   DocumentType Methods   ----
+    async getDocumentTypeByName(name) {
+        return (await this.documentTypeService.query({
+            skip: 0,
+            take: 1,
+            filter: {
+                logic: 'and',
+                filters: [
+                    {
+                        field: 'name',
+                        operator: {
+                            type: 'equal',
+                        },
+                        value: name,
+                    },
+                ],
+            },
+        })).items[0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentManagementService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXMFileMockService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentManagementService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
+const DOCUMENT_TYPES = [
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'risk-assessment-report',
+        title: 'Risk Assessment Report',
+        maxSize: 5000,
+        isEncrypted: false,
+        enableVersioning: true,
+        enableExpiration: false,
+        requiresReview: true,
+        requiresDistribution: false,
+        metaDataList: [
+            {
+                id: AXPDataGenerator.uuid(),
+                text: 'Description',
+                //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
+                hasCheckbox: true,
+                isSelected: true,
+                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
+                name: 'description',
+                title: 'Description',
+                isRequired: true,
+                placeholder: '',
+                status: 'active',
+            },
+        ],
+        type: {
+            selectedItems: [
+                {
+                    name: 'image.jpg',
+                    title: 'Image/JPEG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.png',
+                    title: 'Image/PNG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.gif',
+                    title: 'Image/GIF',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+            ],
+            context: {
+                image: {
+                    width: '22',
+                    height: '33',
+                },
+                gift: {
+                    duration: '11',
+                },
+            },
+        },
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'any',
+        title: 'Upload File',
+        maxSize: 50000,
+        isEncrypted: false,
+        enableVersioning: false,
+        enableExpiration: false,
+        requiresReview: false,
+        requiresDistribution: false,
+        control: { isSystem: true },
+        metaDataList: [],
+        type: {
+            selectedItems: [],
+            context: {
+                audio: {
+                    bitrate: '320',
+                    duration: '180',
+                },
+            },
+        },
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'file-meeting',
+        title: 'File Meeting',
+        maxSize: 50000,
+        isEncrypted: false,
+        enableVersioning: true,
+        enableExpiration: true,
+        requiresReview: true,
+        requiresDistribution: true,
+        metaDataList: [
+            {
+                id: AXPDataGenerator.uuid(),
+                text: 'Description',
+                //  "parentId": "9e3c7586-4722-4170-bc55-e612ca2ab4b5",
+                hasCheckbox: true,
+                isSelected: true,
+                interface: '{"type":"text-editor","name":"description-editor1","meta":{"header":true},"options":{"multiple":false,"disabled":false,"hasClearButton":false},"defaultValue":"","path":"description"}',
+                name: 'description',
+                title: 'Description',
+                isRequired: true,
+                placeholder: '',
+                status: 'active',
+            },
+        ],
+        type: {
+            selectedItems: [
+                {
+                    name: 'image.jpg',
+                    title: 'Image/JPEG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.png',
+                    title: 'Image/PNG',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+                {
+                    name: 'image.gif',
+                    title: 'Image/GIF',
+                    icon: 'fa-light fa-image ax-text-purple-500',
+                },
+            ],
+            context: {
+                image: {
+                    width: '22',
+                    height: '33',
+                },
+                gift: {
+                    duration: '11',
+                },
+            },
+        },
+    },
+];
+
+class AXCDocumentTypeDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(`${RootConfig$6.module.name}.${RootConfig$6.entities.documentType.name}`, DOCUMENT_TYPES);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentTypeDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
 // Section: Constants and Initial Setup
 const checkbox = '{"type":"document-layout","children":[{"type":"page-layout","children":[{"type":"checkbox-editor","name":"checkbox-editor1","options":{"label":"i accept","readonly":false,"disabled":false},"defaultValue":false,"path":"accept-check-box"}],"name":"page-layout1"}],"name":"document"}';
 const allTypes = DOCUMENT_TYPES;
@@ -11438,198 +11579,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             type: Injectable
         }] });
 
-class AXCDistributionInteractionMockService extends AXMDistributionInteractionServiceImpl {
-    constructor() {
-        super(...arguments);
-        //#region ----   Services & Dependencies   ----
-        this.usersService = inject(AXMUsersEntityService);
-        this.sessionService = inject(AXPSessionService);
-    }
-    //#endregion
-    async query(request) {
-        // Raw mode: return ungrouped interaction items (used for bulk aggregation)
-        if (request?.params?.raw === true) {
-            const rawRes = await super.query({
-                filter: request.filter,
-                sort: request.sort,
-                params: request.params,
-                take: 100000,
-                skip: 0,
-            });
-            const total = rawRes.items.length;
-            const skip = request?.skip ?? 0;
-            const take = request?.take ?? total;
-            const pagedItems = rawRes.items.slice(skip, skip + take);
-            return {
-                items: pagedItems,
-                total,
-            };
-        }
-        const items = (await super.query({
-            filter: request.filter,
-            sort: request.sort,
-            params: request.params,
-            take: 100000,
-            skip: 0,
-        })).items;
-        // Extract documentDistributionId from request filter
-        let documentDistributionId;
-        if (request.filter && typeof request.filter === 'object') {
-            if (request.filter.filters && request.filter.filters.length > 0 && request.filter.filters[0].field === 'documentDistributionId') {
-                documentDistributionId = request.filter.filters[0].value;
-            }
-        }
-        // Get the distribution record to access assignedTo property using storage service to avoid circular calls
-        if (documentDistributionId) {
-            try {
-                // Use storage service directly to get distribution record
-                const distribution = await this.storageService.getOne('DocumentManagement.Distribution', documentDistributionId);
-                if (distribution && distribution.assignedTo && Array.isArray(distribution.assignedTo)) {
-                    // Get all assigned user IDs
-                    const assignedUserIds = distribution.assignedTo.map((user) => user.id || user);
-                    // Get existing interaction user IDs (from created.user.id)
-                    const existingUserIds = new Set(items
-                        .map((item) => item?.created?.user?.id)
-                        .filter((id) => !!id));
-                    // Find users who are assigned but don't have interaction records
-                    const missingUserIds = assignedUserIds.filter((userId) => !existingUserIds.has(userId));
-                    // Create missing interaction records
-                    for (const userId of missingUserIds) {
-                        let fullName = 'Unknown';
-                        try {
-                            const userRes = await this.usersService.query({
-                                skip: 0,
-                                take: 1,
-                                filter: { field: 'id', operator: { type: 'equal' }, value: userId },
-                            });
-                            const u = userRes.items?.[0];
-                            if (u) {
-                                const candidate = `${u.firstName ?? ''} ${u.lastName ?? ''}`.trim();
-                                fullName = candidate || u.username || u.title || u.name || fullName;
-                            }
-                        }
-                        catch { }
-                        const missingRecord = {
-                            id: `missing-${documentDistributionId}-${userId}`,
-                            documentDistributionId: documentDistributionId,
-                            auditInfo: {
-                                created: { at: new Date(), by: { id: userId, type: 'user', fullName } },
-                                updated: { at: new Date(), by: { id: userId, type: 'user', fullName } },
-                            },
-                            action: 'Fake', // Default action, but with false flags
-                        };
-                        // Add the missing record to the items array
-                        items.push(missingRecord);
-                    }
-                }
-            }
-            catch (error) {
-            }
-        }
-        // Group items by creator user id
-        const groupedItems = this.groupItemsByCreatedBy(items);
-        // Collect distinct user IDs from grouped items
-        const userIds = Array.from(new Set(groupedItems.map((g) => g.createdBy).filter((id) => !!id)));
-        // Fetch users by IDs (in operator)
-        let usersMap = new Map();
-        if (userIds.length > 0) {
-            try {
-                const usersRes = await this.usersService.query({
-                    skip: 0,
-                    take: userIds.length,
-                    filter: {
-                        field: 'id',
-                        operator: { type: 'in' },
-                        value: userIds,
-                    },
-                });
-                usersMap = new Map(usersRes.items.map((u) => [
-                    u.id,
-                    {
-                        id: u.id,
-                        name: u.username,
-                        title: `${u.firstName} ${u.lastName}`,
-                    },
-                ]));
-            }
-            catch {
-                // If fetching users fails, continue without enrichment
-                usersMap = new Map();
-            }
-        }
-        // Convert grouped items back to the expected format with user enrichment
-        const enrichedItems = groupedItems.map((summary) => ({
-            id: summary.id,
-            createdBy: summary.createdBy,
-            hasViewed: summary.hasViewed,
-            lastViewDate: summary.lastViewDate,
-            hasSigned: summary.hasSigned,
-            lastSignDate: summary.lastSignDate,
-            totalInteractions: summary.totalInteractions,
-            user: usersMap.get(summary.createdBy) ?? {
-                id: this.sessionService?.user?.id ?? '',
-                name: this.sessionService?.user?.name ?? '',
-                title: this.sessionService?.user?.title ?? '',
-            },
-        }));
-        // Apply pagination using request.skip and request.take
-        const total = enrichedItems.length;
-        const skip = request?.skip ?? 0;
-        const take = request?.take ?? total;
-        const pagedItems = enrichedItems.slice(skip, skip + take);
-        return {
-            items: pagedItems,
-            total,
-        };
-    }
-    /**
-     * Groups distribution interaction items by createdBy and creates a summary
-     */
-    groupItemsByCreatedBy(items) {
-        console.log(items);
-        const groupedMap = new Map();
-        for (const item of items) {
-            const createdBy = item?.created?.user?.id || 'unknown';
-            if (!groupedMap.has(createdBy)) {
-                // Initialize summary for new createdBy
-                groupedMap.set(createdBy, {
-                    id: createdBy, // Use createdBy as the ID for the summary
-                    createdBy: createdBy,
-                    hasViewed: false,
-                    lastViewDate: undefined,
-                    hasSigned: false,
-                    lastSignDate: undefined,
-                    totalInteractions: 0,
-                });
-            }
-            const summary = groupedMap.get(createdBy);
-            summary.totalInteractions++;
-            // Check for view actions
-            if (item.action === 'Viewed') {
-                summary.hasViewed = true;
-                // Update last view date if this is more recent
-                if (!summary.lastViewDate || item.actionTime && item.actionTime > summary.lastViewDate) {
-                    summary.lastViewDate = item.actionTime;
-                }
-            }
-            // Check for sign actions
-            if (item.action === 'Signed') {
-                summary.hasSigned = true;
-                // Update last sign date if this is more recent
-                if (!summary.lastSignDate || item.actionTime && item.actionTime > summary.lastSignDate) {
-                    summary.lastSignDate = item.actionTime;
-                }
-            }
-        }
-        return Array.from(groupedMap.values());
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDistributionInteractionMockService, decorators: [{
-            type: Injectable
-        }] });
-
 class AXCDocumentManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXCDocumentManagementMockModule }); }
@@ -11640,6 +11589,10 @@ class AXCDocumentManagementMockModule {
             { provide: AXMDocumentService, useClass: AXMFileMockService },
             { provide: AXMDistributionService, useClass: AXCDistributionMockService },
             { provide: AXMReviewService, useClass: AXCReviewMockService },
+            {
+                provide: AXPDocumentManagementService,
+                useClass: AXCDocumentManagementService,
+            },
             { provide: AXMDistributionInteractionService, useClass: AXCDistributionInteractionMockService },
         ] }); }
 }
@@ -11656,6 +11609,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                         { provide: AXMDocumentService, useClass: AXMFileMockService },
                         { provide: AXMDistributionService, useClass: AXCDistributionMockService },
                         { provide: AXMReviewService, useClass: AXCReviewMockService },
+                        {
+                            provide: AXPDocumentManagementService,
+                            useClass: AXCDocumentManagementService,
+                        },
                         { provide: AXMDistributionInteractionService, useClass: AXCDistributionInteractionMockService },
                     ],
                 }]
@@ -12521,7 +12478,7 @@ class AXMFormDataSourcesProvider {
     }
 }
 
-function generateCategories$3() {
+function generateCategories$4() {
     const categories = [];
     const ids = new Map();
     // Root categories - reduced to 5 main areas
@@ -12667,7 +12624,7 @@ function generateCategories$3() {
     });
     return categories;
 }
-const TEMPLATE_CATEGORIES = generateCategories$3();
+const TEMPLATE_CATEGORIES = generateCategories$4();
 
 class AXMFormTemplateCategoryDataSeeder {
     constructor() {
@@ -39109,7 +39066,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * - itemsCount: Direct reports in this category
  * - No need for boolean flags (hasChild, hasReport)
  */
-function generateCategories$2() {
+function generateCategories$3() {
     const categories = [];
     // Root categories with child count metadata
     const rootCategories = [
@@ -39162,7 +39119,7 @@ function generateCategories$2() {
     });
     return categories;
 }
-const PRODUCT_REPORT_CATEGORIES = generateCategories$2();
+const PRODUCT_REPORT_CATEGORIES = generateCategories$3();
 //#endregion
 //#region ----   Mock Parameter Groups   ----
 const productCatalogParameterGroups = [
@@ -39852,6 +39809,8 @@ const APPLICATION_TREE = [
                     'DocumentManagement',
                     'AssessmentManagement',
                     'SecurityManagement',
+                    'CalendarManagement',
+                    'TaskManagement',
                     AXPCommonFeatureKeys.GlobalSearch,
                     AXPHumanCapitalManagementFeatureKeys.EmployeeManagement,
                     AXPHumanCapitalManagementFeatureKeys.LeaveManagement,
@@ -41117,7 +41076,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * - itemsCount: Direct reports in this category
  * - No need for boolean flags (hasChild, hasReport)
  */
-function generateCategories$1() {
+function generateCategories$2() {
     const categories = [];
     // Root category: Platform Analytics
     const rootCategories = [
@@ -41141,7 +41100,7 @@ function generateCategories$1() {
     });
     return categories;
 }
-const PLATFORM_ANALYTICS_REPORT_CATEGORIES = generateCategories$1();
+const PLATFORM_ANALYTICS_REPORT_CATEGORIES = generateCategories$2();
 //#endregion
 //#region ----   Mock Parameter Groups   ----
 const platformAnalyticsParameterGroups = [
@@ -46333,6 +46292,14 @@ const createFileCastMiddleware = {
                 return undefined;
             }
         })();
+        const documentManagementService = (() => {
+            try {
+                return inject(AXPDocumentManagementService);
+            }
+            catch {
+                return undefined;
+            }
+        })();
         const folderService = (() => {
             try {
                 return inject(AXMFolderService);
@@ -46431,14 +46398,17 @@ const createFileCastMiddleware = {
                     try {
                         await fileStorageService.remove(fileId);
                     }
-                    catch (error) {
-                    }
+                    catch (error) { }
                 }
                 // Return null to indicate this file should be removed from the list
                 return null;
             }
             // Case 2: Reference-based file (handle document updates)
-            if (file.source?.kind === 'reference' && file.source.value && typeof file.source.value === 'object' && 'id' in file.source.value && 'type' in file.source.value) {
+            if (file.source?.kind === 'reference' &&
+                file.source.value &&
+                typeof file.source.value === 'object' &&
+                'id' in file.source.value &&
+                'type' in file.source.value) {
                 const reference = file.source.value;
                 // Only handle document references
                 if (reference.type === 'document' && documentService) {
@@ -46504,8 +46474,7 @@ const createFileCastMiddleware = {
                             });
                             return { id: docId, kind: 'document' };
                         }
-                        catch (error) {
-                        }
+                        catch (error) { }
                     }
                     else {
                     }
@@ -46553,8 +46522,7 @@ const createFileCastMiddleware = {
                             });
                             return { id: docId, kind: 'document' };
                         }
-                        catch (error) {
-                        }
+                        catch (error) { }
                     }
                     else {
                     }
@@ -46614,8 +46582,11 @@ const createFileCastMiddleware = {
             const values = Object.values(candidate.meta);
             if (!Array.isArray(values) || values.length === 0)
                 return false;
-            return values.every((m) => m && typeof m === 'object' &&
-                typeof m.name === 'string' && typeof m.title === 'string' && typeof m.value === 'string');
+            return values.every((m) => m &&
+                typeof m === 'object' &&
+                typeof m.name === 'string' &&
+                typeof m.title === 'string' &&
+                typeof m.value === 'string');
         };
         const ensureDocumentRecord = async (svc, payload) => {
             // Resolve or create folder hierarchy: <Entity>/<Record Title|Name>
@@ -46623,9 +46594,7 @@ const createFileCastMiddleware = {
             try {
                 if (folderService) {
                     const findFolderByName = async (name, parent) => {
-                        const filters = [
-                            { field: 'name', operator: { type: 'equal' }, value: name },
-                        ];
+                        const filters = [{ field: 'name', operator: { type: 'equal' }, value: name }];
                         if (parent) {
                             filters.push({ field: 'parentId', operator: { type: 'equal' }, value: parent });
                         }
@@ -46663,7 +46632,10 @@ const createFileCastMiddleware = {
                     if (root?.id) {
                         const entityFullName = ctx.entityName || 'Entity';
                         const entityNameOnly = entityFullName.split('.').pop() || entityFullName;
-                        const recordFolderName = (ctx?.data?.title || ctx?.data?.name || payload.name || 'Record').toString();
+                        const recordFolderName = (ctx?.data?.title ||
+                            ctx?.data?.name ||
+                            payload.name ||
+                            'Record').toString();
                         const entityFolderId = await ensureFolder(entityNameOnly, root.id);
                         parentId = await ensureFolder(recordFolderName, entityFolderId);
                     }
@@ -46824,8 +46796,8 @@ const createFileCastMiddleware = {
                                 const allDocIds = [...documentIdList, ...referenceDocIds];
                                 const [manyInfos, documents] = await Promise.all([
                                     fileIdList.length ? fileStorageService.findMany(fileIdList) : Promise.resolve([]),
-                                    allDocIds.length && documentService
-                                        ? documentService.findMany(allDocIds)
+                                    allDocIds.length && documentManagementService
+                                        ? documentManagementService.findManyDocuments(allDocIds)
                                         : Promise.resolve([]),
                                 ]);
                                 const infoMap = new Map(manyInfos.map((i) => [i.fileId, i]));
@@ -46934,8 +46906,8 @@ const createFileCastMiddleware = {
                             else if (isDocumentId(value)) {
                                 const actualDocId = removeDocumentPrefix(value);
                                 try {
-                                    if (documentService) {
-                                        const docs = await documentService.findMany([actualDocId]);
+                                    if (documentManagementService) {
+                                        const docs = await documentManagementService.findManyDocuments([actualDocId]);
                                         const doc = docs?.[0];
                                         if (doc) {
                                             const listItem = {
@@ -46970,7 +46942,11 @@ const createFileCastMiddleware = {
                                     }
                                 }
                                 catch (error) {
-                                    console.error('[file-cast] ❌ Failed to get document info', { keyPath, documentId: actualDocId, error });
+                                    console.error('[file-cast] ❌ Failed to get document info', {
+                                        keyPath,
+                                        documentId: actualDocId,
+                                        error,
+                                    });
                                     setValueByPath(resultData, keyPath, {
                                         id: actualDocId,
                                         name: 'Unknown Document',
@@ -46981,9 +46957,9 @@ const createFileCastMiddleware = {
                             }
                             else if (isReference(value)) {
                                 const reference = parseReference(value);
-                                if (reference && reference.type === 'document' && documentService) {
+                                if (reference && reference.type === 'document' && documentManagementService) {
                                     try {
-                                        const docs = await documentService.findMany([reference.id]);
+                                        const docs = await documentManagementService.findManyDocuments([reference.id]);
                                         const doc = docs?.[0];
                                         if (doc) {
                                             const listItem = {
@@ -47009,7 +46985,11 @@ const createFileCastMiddleware = {
                                         }
                                     }
                                     catch (error) {
-                                        console.error('[file-cast] ❌ Failed to get reference document info', { keyPath, reference, error });
+                                        console.error('[file-cast] ❌ Failed to get reference document info', {
+                                            keyPath,
+                                            reference,
+                                            error,
+                                        });
                                         setValueByPath(resultData, keyPath, {
                                             id: reference.id,
                                             name: 'Unknown Document',
@@ -48839,7 +48819,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * - childrenCount: Direct child categories (for lazy loading)
  * - itemsCount: Direct activities in this category
  */
-function generateCategories() {
+function generateCategories$1() {
     const categories = [];
     // Root categories
     const rootCategories = [
@@ -48941,7 +48921,7 @@ function generateCategories() {
     });
     return categories;
 }
-const ACTIVITY_CATEGORIES = generateCategories();
+const ACTIVITY_CATEGORIES = generateCategories$1();
 //#endregion
 
 class AXCActivityCategorySeeder {
@@ -48972,6 +48952,7 @@ function generateActivityDefinitions() {
     const queryCategory = ACTIVITY_CATEGORIES.find(c => c.title === 'Query');
     // Command category activities
     if (commandCategory) {
+        // Check Permission Activity
         definitions.push({
             name: 'check-permission',
             type: 'workflow-activity:check-permission',
@@ -48979,8 +48960,73 @@ function generateActivityDefinitions() {
             description: 'Checks if a user has a specific permission',
             category: commandCategory.id,
             executionMode: 'backend',
+            icon: 'fa-shield-alt',
             outcomes: ['HasPermission', 'NoPermission'],
+            inputs: [
+                {
+                    name: 'permission',
+                    title: 'Permission Key',
+                    description: 'Permission key to check (e.g., "Users.Create")',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter permission key (e.g., Users.Create)',
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'userId',
+                    title: 'User ID',
+                    description: 'User ID to check (optional, defaults to current user)',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter user ID (leave empty for current user)',
+                            },
+                        },
+                    },
+                },
+            ],
+            outputs: [
+                {
+                    name: 'hasPermission',
+                    title: 'Has Permission',
+                    description: 'Whether user has the permission',
+                    schema: {
+                        dataType: 'boolean',
+                    },
+                },
+                {
+                    name: 'userId',
+                    title: 'User ID',
+                    description: 'User ID that was checked',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+                {
+                    name: 'permission',
+                    title: 'Permission',
+                    description: 'Permission that was checked',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+            ],
         });
+        // Execute Command Activity
         definitions.push({
             name: 'execute-command',
             type: 'workflow-activity:execute-command',
@@ -48988,8 +49034,82 @@ function generateActivityDefinitions() {
             description: 'Executes a command operation',
             category: commandCategory.id,
             executionMode: 'backend',
+            icon: 'fa-terminal',
             outcomes: ['Done', 'Failed'],
+            inputs: [
+                {
+                    name: 'commandKey',
+                    title: 'Command Key',
+                    description: 'Command key to execute (e.g., "User:Create")',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter command key (e.g., User:Create)',
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'input',
+                    title: 'Command Input',
+                    description: 'Command input data as JSON object',
+                    schema: {
+                        dataType: 'object',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Advanced.CodeEditor,
+                            options: {
+                                language: 'json',
+                                placeholder: 'Enter JSON object for command input',
+                            },
+                        },
+                    },
+                },
+            ],
+            outputs: [
+                {
+                    name: 'result',
+                    title: 'Result',
+                    description: 'Command result data',
+                    schema: {
+                        dataType: 'object',
+                    },
+                },
+                {
+                    name: 'success',
+                    title: 'Success',
+                    description: 'Whether command executed successfully',
+                    schema: {
+                        dataType: 'boolean',
+                    },
+                },
+                {
+                    name: 'error',
+                    title: 'Error',
+                    description: 'Error message if command failed',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+                {
+                    name: 'entityId',
+                    title: 'Entity ID',
+                    description: 'Created/Updated entity ID (if applicable)',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+            ],
         });
+        // Show Confirm Popup Activity
         definitions.push({
             name: 'show-confirm-popup',
             type: 'workflow-activity:show-confirm-popup',
@@ -48997,11 +49117,272 @@ function generateActivityDefinitions() {
             description: 'Shows a confirmation popup dialog with OK and Cancel buttons',
             category: commandCategory.id,
             executionMode: 'frontend',
+            icon: 'fa-question-circle',
             outcomes: ['ok', 'cancel'],
+            inputs: [
+                {
+                    name: 'title',
+                    title: 'Title',
+                    description: 'Title of the confirmation dialog',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter dialog title',
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'message',
+                    title: 'Message',
+                    description: 'Message/content of the confirmation dialog',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.LargeTextBox,
+                            options: {
+                                placeholder: 'Enter confirmation message',
+                                rows: 4,
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'type',
+                    title: 'Dialog Type',
+                    description: 'Dialog type/color (e.g., warning, danger, info, success)',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        defaultValue: 'warning',
+                        interface: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                valueField: 'value',
+                                textField: 'text',
+                                dataSource: [
+                                    { value: 'warning', text: 'Warning' },
+                                    { value: 'danger', text: 'Danger' },
+                                    { value: 'info', text: 'Info' },
+                                    { value: 'success', text: 'Success' },
+                                ],
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'direction',
+                    title: 'Button Direction',
+                    description: 'Button layout direction',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        defaultValue: 'horizontal',
+                        interface: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                valueField: 'value',
+                                textField: 'text',
+                                dataSource: [
+                                    { value: 'horizontal', text: 'Horizontal' },
+                                    { value: 'vertical', text: 'Vertical' },
+                                ],
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'closable',
+                    title: 'Closable',
+                    description: 'Whether dialog is closable',
+                    schema: {
+                        dataType: 'boolean',
+                        nullable: true,
+                        defaultValue: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.ToggleSwitch,
+                        },
+                    },
+                },
+                {
+                    name: 'defaultAction',
+                    title: 'Default Action',
+                    description: 'Default action button',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        defaultValue: 'cancel',
+                        interface: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                valueField: 'value',
+                                textField: 'text',
+                                dataSource: [
+                                    { value: 'confirm', text: 'Confirm' },
+                                    { value: 'cancel', text: 'Cancel' },
+                                ],
+                            },
+                        },
+                    },
+                },
+            ],
+            outputs: [],
+        });
+        // Show Layout Popup Activity
+        definitions.push({
+            name: 'show-layout-popup',
+            type: 'workflow-activity:show-layout-popup',
+            title: 'Show Layout Popup',
+            description: 'Shows a popup dialog with a custom layout built using layout builder. Actions are defined dynamically and each action creates a corresponding outcome.',
+            category: commandCategory.id,
+            executionMode: 'frontend',
+            icon: 'fa-window-maximize',
+            // Outcomes are dynamic based on actions - default outcomes shown for reference
+            outcomes: ['submit', 'cancel'],
+            inputs: [
+                {
+                    name: 'layout',
+                    title: 'Layout Definition',
+                    description: 'Layout definition as JSON string or AXPWidgetNode object',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Advanced.CodeEditor,
+                            options: {
+                                language: 'json',
+                                placeholder: 'Enter layout definition as JSON',
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'title',
+                    title: 'Dialog Title',
+                    description: 'Title of the dialog',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter dialog title',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'size',
+                    title: 'Dialog Size',
+                    description: 'Size of the dialog',
+                    schema: {
+                        dataType: 'string',
+                        nullable: true,
+                        defaultValue: 'md',
+                        interface: {
+                            type: AXPWidgetsList.Editors.SelectBox,
+                            options: {
+                                valueField: 'value',
+                                textField: 'text',
+                                dataSource: [
+                                    { value: 'sm', text: 'Small' },
+                                    { value: 'md', text: 'Medium' },
+                                    { value: 'lg', text: 'Large' },
+                                    { value: 'xl', text: 'Extra Large' },
+                                    { value: 'xxl', text: 'Extra Extra Large' },
+                                ],
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'closeButton',
+                    title: 'Show Close Button',
+                    description: 'Whether to show close button',
+                    schema: {
+                        dataType: 'boolean',
+                        nullable: true,
+                        defaultValue: true,
+                        interface: {
+                            type: AXPWidgetsList.Editors.ToggleSwitch,
+                        },
+                    },
+                },
+                {
+                    name: 'context',
+                    title: 'Initial Context',
+                    description: 'Initial context data for the form as JSON object',
+                    schema: {
+                        dataType: 'object',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Advanced.CodeEditor,
+                            options: {
+                                language: 'json',
+                                placeholder: 'Enter initial context as JSON object',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'actions',
+                    title: 'Dialog Actions',
+                    description: 'Dialog actions (buttons) to display in footer. Each action will create a corresponding outcome. Format: { prefix?: Array<Action>, suffix?: Array<Action> }',
+                    schema: {
+                        dataType: 'object',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Advanced.CodeEditor,
+                            options: {
+                                language: 'json',
+                                placeholder: 'Enter actions as JSON object with prefix and/or suffix arrays',
+                            },
+                        },
+                    },
+                },
+            ],
+            outputs: [
+                {
+                    name: 'result',
+                    title: 'Result',
+                    description: 'Result data from the dialog (form values)',
+                    schema: {
+                        dataType: 'object',
+                    },
+                },
+                {
+                    name: 'action',
+                    title: 'Action',
+                    description: 'Action that was clicked (e.g., submit, cancel, or custom action name)',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+            ],
         });
     }
     // Query category activities
     if (queryCategory) {
+        // Execute Query Activity
         definitions.push({
             name: 'execute-query',
             type: 'workflow-activity:execute-query',
@@ -49009,7 +49390,72 @@ function generateActivityDefinitions() {
             description: 'Executes a query operation',
             category: queryCategory.id,
             executionMode: 'backend',
+            icon: 'fa-search',
             outcomes: ['Done', 'Valid', 'Exists', 'NotFound', 'Failed'],
+            inputs: [
+                {
+                    name: 'queryKey',
+                    title: 'Query Key',
+                    description: 'Query key to execute (e.g., "User:CheckEmailExists")',
+                    schema: {
+                        dataType: 'string',
+                        nullable: false,
+                        interface: {
+                            type: AXPWidgetsList.Editors.TextBox,
+                            options: {
+                                placeholder: 'Enter query key (e.g., User:CheckEmailExists)',
+                            },
+                        },
+                    },
+                    validations: [
+                        {
+                            rule: 'required',
+                        },
+                    ],
+                },
+                {
+                    name: 'parameters',
+                    title: 'Query Parameters',
+                    description: 'Query parameters as JSON object',
+                    schema: {
+                        dataType: 'object',
+                        nullable: true,
+                        interface: {
+                            type: AXPWidgetsList.Advanced.CodeEditor,
+                            options: {
+                                language: 'json',
+                                placeholder: 'Enter query parameters as JSON object',
+                            },
+                        },
+                    },
+                },
+            ],
+            outputs: [
+                {
+                    name: 'data',
+                    title: 'Data',
+                    description: 'Query result data',
+                    schema: {
+                        dataType: 'object',
+                    },
+                },
+                {
+                    name: 'success',
+                    title: 'Success',
+                    description: 'Whether query executed successfully',
+                    schema: {
+                        dataType: 'boolean',
+                    },
+                },
+                {
+                    name: 'error',
+                    title: 'Error',
+                    description: 'Error message if query failed',
+                    schema: {
+                        dataType: 'string',
+                    },
+                },
+            ],
         });
     }
     return definitions;
@@ -49034,6 +49480,156 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             type: Injectable
         }] });
 
+//#region ----   Mock Categories   ----
+/**
+ * Generate workflow categories with optimized count metadata
+ *
+ * Uses childrenCount & itemsCount for performance:
+ * - childrenCount: Direct child categories (for lazy loading)
+ * - itemsCount: Direct workflows in this category
+ */
+function generateCategories() {
+    const categories = [];
+    // Root categories
+    const rootCategories = [
+        {
+            title: 'Business Process',
+            description: 'Business process workflows',
+            childrenCount: 0,
+            itemsCount: 2,
+        },
+        {
+            title: 'Approval',
+            description: 'Approval and review workflows',
+            childrenCount: 0,
+            itemsCount: 1,
+        },
+        {
+            title: 'Data Processing',
+            description: 'Data processing and transformation workflows',
+            childrenCount: 0,
+            itemsCount: 1,
+        },
+        {
+            title: 'Integration',
+            description: 'Integration and API workflows',
+            childrenCount: 0,
+            itemsCount: 0,
+        },
+        {
+            title: 'Notification',
+            description: 'Notification and communication workflows',
+            childrenCount: 0,
+            itemsCount: 0,
+        },
+        {
+            title: 'General',
+            description: 'General purpose workflows',
+            childrenCount: 0,
+            itemsCount: 0,
+        },
+    ];
+    rootCategories.forEach(({ title, description, childrenCount, itemsCount }) => {
+        const categoryId = AXPDataGenerator.uuid();
+        categories.push({
+            id: categoryId,
+            title,
+            description,
+            parentId: undefined,
+            childrenCount,
+            itemsCount,
+        });
+    });
+    return categories;
+}
+const WORKFLOW_CATEGORIES = generateCategories();
+//#endregion
+
+/**
+ * Mock Workflow Category Provider
+ *
+ * Provides workflow categories from mock data.
+ */
+class AXCWorkflowCategoryProvider {
+    async getList(parentId) {
+        if (parentId === undefined) {
+            // Return root categories
+            return WORKFLOW_CATEGORIES.filter(cat => cat.parentId === undefined);
+        }
+        // Return child categories
+        return WORKFLOW_CATEGORIES.filter(cat => cat.parentId === parentId);
+    }
+    async getById(id) {
+        return WORKFLOW_CATEGORIES.find(cat => cat.id === id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowCategoryProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowCategoryProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowCategoryProvider, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Mock Workflow Definition Provider
+ *
+ * Provides workflow definition metadata from mock data.
+ * Converts workflow definitions to metadata format.
+ */
+class AXCWorkflowDefinitionMetadataProvider {
+    constructor() {
+        this.metadataCache = null;
+    }
+    getMetadataCache() {
+        if (this.metadataCache) {
+            return this.metadataCache;
+        }
+        this.metadataCache = new Map();
+        // Find Business Process category (first category with itemsCount > 0)
+        const businessProcessCategory = WORKFLOW_CATEGORIES.find(cat => cat.title === 'Business Process');
+        const approvalCategory = WORKFLOW_CATEGORIES.find(cat => cat.title === 'Approval');
+        const dataProcessingCategory = WORKFLOW_CATEGORIES.find(cat => cat.title === 'Data Processing');
+        // Convert workflow definitions to metadata
+        workflowDefinitionMock.forEach(def => {
+            let categoryId;
+            // Map workflow to category based on name/type
+            if (def.name?.includes('approval') || def.name?.includes('review')) {
+                categoryId = approvalCategory?.id;
+            }
+            else if (def.name?.includes('process') || def.name?.includes('data')) {
+                categoryId = dataProcessingCategory?.id;
+            }
+            else {
+                categoryId = businessProcessCategory?.id;
+            }
+            const metadata = {
+                name: def.name || '',
+                title: def.title || def.name || '',
+                description: def.description || undefined,
+                category: categoryId,
+                icon: 'fa-light fa-diagram-project',
+                version: 1,
+                isPublished: true,
+                isBrowsable: true,
+            };
+            this.metadataCache.set(metadata.name, metadata);
+        });
+        return this.metadataCache;
+    }
+    async getList(categoryId) {
+        const cache = this.getMetadataCache();
+        return Array.from(cache.values()).filter(meta => meta.category === categoryId);
+    }
+    async getById(name) {
+        const cache = this.getMetadataCache();
+        return cache.get(name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionMetadataProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionMetadataProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowDefinitionMetadataProvider, decorators: [{
+            type: Injectable
+        }] });
+
 class AXCWorkflowManagementMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowManagementMockModule }); }
@@ -49059,6 +49655,18 @@ class AXCWorkflowManagementMockModule {
                 useClass: AXCActivityDefinitionSeeder,
                 multi: true,
             },
+            // Workflow Category Provider
+            {
+                provide: AXP_WORKFLOW_CATEGORY_PROVIDER,
+                useClass: AXCWorkflowCategoryProvider,
+                multi: true,
+            },
+            // Workflow Definition Metadata Provider
+            {
+                provide: AXP_WORKFLOW_PROVIDER,
+                useClass: AXCWorkflowDefinitionMetadataProvider,
+                multi: true,
+            },
         ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXCWorkflowManagementMockModule, decorators: [{
@@ -49089,6 +49697,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                             useClass: AXCActivityDefinitionSeeder,
                             multi: true,
                         },
+                        // Workflow Category Provider
+                        {
+                            provide: AXP_WORKFLOW_CATEGORY_PROVIDER,
+                            useClass: AXCWorkflowCategoryProvider,
+                            multi: true,
+                        },
+                        // Workflow Definition Metadata Provider
+                        {
+                            provide: AXP_WORKFLOW_PROVIDER,
+                            useClass: AXCWorkflowDefinitionMetadataProvider,
+                            multi: true,
+                        },
                     ],
                 }]
         }] });
@@ -49585,5 +50205,5 @@ const AXCMockEntityLogListener = {
  * Generated bundle index. Do not edit.
  */
 
-export { ACTIVITY_CATEGORIES, ACTIVITY_DEFINITIONS, APPLICATIONS, AXCActivityCategorySeeder, AXCActivityDefinitionSeeder, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationDataSeeder, AXCApplicationManagementMockModule, AXCAssessmentManagementMockModule, AXCAssetManagementMockModule, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCEditionDataSeeder, AXCFileStorageService, AXCFinancialCoreMockModule, AXCFormTemplateManagementMockModule, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLearningManagementMockModule, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCMeasurementCoreMockModule, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMetadataCategorySeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCNotificationManagementMockModule, AXCOrderManagementMockModule, AXCOrganizationManagementMockModule, AXCPersonManagementMockModule, AXCPlatformManagementMockModule, AXCProcurementManagementMockModule, AXCProductCatalogMockModule, AXCProjectManagementMockModule, AXCQueryCategoryMetadataInheritanceQuery, AXCReportManagementMockModule, AXCSecurityManagementMockModule, AXCSubscriptionManagementMockModule, AXCSupplierManagementMockModule, AXCTaskManagementMockModule, AXCTenantManagementMockModule, AXCTenantSeeder, AXCTokensDataSeeder, AXCUserPassStrategyMock, AXCVersionDB, AXCVersioningService, AXCWorkflowDefinitionDataSeeder, AXCWorkflowExecutionDB, AXCWorkflowExecutionService, AXCWorkflowManagementMockModule, AXMAiResponderService, AXMAssessmentCaseDataSeeder, AXMAssessmentSessionDataSeeder, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMEmployeeDataSeeder, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMJobDefinitionDataSeeder, AXMJobLevelDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMQuestionBankItemCategoryDataSeeder, AXMQuestionBankItemDataSeeder, AXMQuestionnaireCategoryDataSeeder, AXMQuestionnaireDataSeeder, AXMReportExecuteCommand, AXMResponsibilityDataSeeder, AXMTagDataSeeder, AXMTeamDataSeeder, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXVChangeType, BUSINESS_UNITS_MOCK, COSTMANAGER_ENTERPRISE, COSTMANAGER_PROFESSIONAL, COSTMANAGER_STANDARD, CRM_ENTERPRISE, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYMENT_TYPES_MOCK, FINANCE_BASIC, FINANCE_ENTERPRISE, FINANCE_PRO, HR_ENTERPRISE, JOB_DEFINITIONS_CATEGORY_MOCK, JOB_DEFINITIONS_MOCK, JOB_LEVELS_MOCK, LASER_PLUMBING_TENANT_ID, LEAVE_REQUESTS_MOCK, ORDERING_BASIC, ORDERING_ENTERPRISE, ORDERING_STANDARD, OWNERSHIP_FILTER_BYPASS, PLATFORM_CONSOLE, PLATFORM_TENANT_ID, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, QUESTIONNAIRE_CATEGORY_MOCK, QUESTION_BANK_ITEM_CATEGORY_MOCK, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, SAFETYMINDER_BASIC, SAFETYMINDER_ENTERPRISE, SAFETYMINDER_PROFESSIONAL, SHOP_BASIC, SHOP_ENTERPRISE, SHOP_PRO, TAGS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, TIMEPLICITY_TENANT_ID, TOKENS, VISIBILITY_FILTER_BYPASS, assessmentCaseMock, assessmentSessionMock, auditLoggerMiddleware, avatarInterface, axVersionDB, axWorkflowExecutionDB, bypassAllFilters, bypassOwnershipFilter, bypassVisibilityFilter, calendarEventMock, calendarEventTypeMockData, calendarMock, checkboxInterface, childCountMiddleware, colorInterface, computeDiff, contactInterface, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, dateInterface, dateTimeInterface, descriptionInterface, emailInterface, fileUploaderInterface, findContactMethod, findEmployeeById, findPersonById, generateUserDashboard, groupOrderItemCalculatorMiddleware, historyLoggerMiddleware, identifierCommitMiddleware, imageInterface, lockGuardMiddleware, longTextAnswerInterface, lookupInterface, lookupResolverMiddleware, mapInterface, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, metadataCategoryMocks, mockRoleDefinitions, mockUsers, multipleChoiceInterface, multipleSelectInterface, normalizeAnyFileArrayForView, normalizeSnapshotFileFieldsForView, numberInterface, participantIds, passwordInterface, phoneInterface, primaryMiddleware, qrcodeInterface, questionBankItemMock, questionnaireMock, ratingInterface, richTextInterface, scaleInterface, selectInterface, selectionListInterface, signatureInterface, signatureLoaderMiddleware, tagInterface, tenantMocks, textAreaInterface, textInterface, timeDurationInterface, titleInterface, toUiRows, toggleInterface, urlInterface, versionInterface, visibilityFilterMiddleware, workflowDefinitionEntityMock, workflowDefinitionIds, workflowDefinitionMock, yesNoInterface };
+export { ACTIVITY_CATEGORIES, ACTIVITY_DEFINITIONS, APPLICATIONS, AXCActivityCategorySeeder, AXCActivityDefinitionSeeder, AXCAppTermDataSeeder, AXCAppVersionDataSeeder, AXCApplicationDataSeeder, AXCApplicationManagementMockModule, AXCAssessmentManagementMockModule, AXCAssetManagementMockModule, AXCAuthMockModule, AXCCalendarDataSeeder, AXCCalendarEventDataSeeder, AXCCalendarManagementMockModule, AXCCommonMockModule, AXCContactManagementMockModule, AXCContentManagementMockModule, AXCConversationMockModule, AXCCustomerManagementMockModule, AXCDashboardManagementMockModule, AXCDataManagementMockModule, AXCDexieEntityStorageService, AXCDocumentManagementMockModule, AXCEditionDataSeeder, AXCFileStorageService, AXCFinancialCoreMockModule, AXCFormTemplateManagementMockModule, AXCGoogleStrategyMock, AXCHelpDeskMockModule, AXCHumanCapitalManagementMockModule, AXCIdentifierManagementMockModule, AXCJsaSeeder, AXCLearningManagementMockModule, AXCLocaleManagementMockModule, AXCLocationManagementMockModule, AXCLockService, AXCMeasurementCoreMockModule, AXCMeetingManagementMockModule, AXCMetaDataDefinitionDataSeeder, AXCMetadataCategorySeeder, AXCMiddlewaresModule, AXCMockEntityLogListener, AXCMockModule, AXCNotificationManagementMockModule, AXCOrderManagementMockModule, AXCOrganizationManagementMockModule, AXCPersonManagementMockModule, AXCPlatformManagementMockModule, AXCProcurementManagementMockModule, AXCProductCatalogMockModule, AXCProjectManagementMockModule, AXCQueryCategoryMetadataInheritanceQuery, AXCReportManagementMockModule, AXCSecurityManagementMockModule, AXCSubscriptionManagementMockModule, AXCSupplierManagementMockModule, AXCTaskManagementMockModule, AXCTenantManagementMockModule, AXCTenantSeeder, AXCTokensDataSeeder, AXCUserPassStrategyMock, AXCVersionDB, AXCVersioningService, AXCWorkflowCategoryProvider, AXCWorkflowDefinitionDataSeeder, AXCWorkflowDefinitionMetadataProvider, AXCWorkflowExecutionDB, AXCWorkflowManagementMockModule, AXCWorkflowRuntimeService, AXMAiResponderService, AXMAssessmentCaseDataSeeder, AXMAssessmentSessionDataSeeder, AXMBusinessUnitDataSeeder, AXMCalendarEventTypeSeeder, AXMEmployeeDataSeeder, AXMEmploymentTypeDataSeeder, AXMFormDataSourcesProvider, AXMJobDefinitionDataSeeder, AXMJobLevelDataSeeder, AXMLeaveRequestDataSeeder, AXMMeetingDataSeeder, AXMMeetingFilesDataSeeder, AXMMeetingParticipantDataSeeder, AXMMeetingRoleTypeDataSeeder, AXMMeetingSessionDataSeeder, AXMMeetingTypeDataSeeder, AXMMeetingTypeFileTemplateDataSeeder, AXMPositionAssignmentDataSeeder, AXMPositionDataSeeder, AXMQuestionBankItemCategoryDataSeeder, AXMQuestionBankItemDataSeeder, AXMQuestionnaireCategoryDataSeeder, AXMQuestionnaireDataSeeder, AXMReportExecuteCommand, AXMResponsibilityDataSeeder, AXMTagDataSeeder, AXMTeamDataSeeder, AXPDashboardDataSeeder, AXPIdentifierDB, AXPMessageDataSeeder, AXPMockChecksumProvider, AXPMockClockProvider, AXPMockIdentifierService, AXPMockLookupProvider, AXPMockPolicyProvider, AXPMockSequenceProvider, AXPRoomDataSeeder, AXPSecurityManagementRoleDataSeeder, AXPSecurityManagementUserDataSeeder, AXPTaskBoardPlatformManagementTaskProvider, AXPTaskBoardProjectManagementTaskProvider, AXVChangeType, BUSINESS_UNITS_MOCK, COSTMANAGER_ENTERPRISE, COSTMANAGER_PROFESSIONAL, COSTMANAGER_STANDARD, CRM_ENTERPRISE, DASHBOARDS, EDITIONS, EMPLOYEES_MOCK, EMPLOYMENT_TYPES_MOCK, FINANCE_BASIC, FINANCE_ENTERPRISE, FINANCE_PRO, HR_ENTERPRISE, JOB_DEFINITIONS_CATEGORY_MOCK, JOB_DEFINITIONS_MOCK, JOB_LEVELS_MOCK, LASER_PLUMBING_TENANT_ID, LEAVE_REQUESTS_MOCK, ORDERING_BASIC, ORDERING_ENTERPRISE, ORDERING_STANDARD, OWNERSHIP_FILTER_BYPASS, PLATFORM_CONSOLE, PLATFORM_TENANT_ID, POSITIONS_CATEGORY_MOCK, POSITIONS_MOCK, POSITION_ASSIGNMENTS_MOCK, QUESTIONNAIRE_CATEGORY_MOCK, QUESTION_BANK_ITEM_CATEGORY_MOCK, RESPONSIBILITIES_CATEGORY_MOCK, RESPONSIBILITIES_MOCK, SAFETYMINDER_BASIC, SAFETYMINDER_ENTERPRISE, SAFETYMINDER_PROFESSIONAL, SHOP_BASIC, SHOP_ENTERPRISE, SHOP_PRO, TAGS_MOCK, TASKS, TASK_STATUSES, TASK_TEMPLATES, TASK_TYPES, TEAMS_MOCK, TIMEPLICITY_TENANT_ID, TOKENS, VISIBILITY_FILTER_BYPASS, WORKFLOW_CATEGORIES, assessmentCaseMock, assessmentSessionMock, auditLoggerMiddleware, avatarInterface, axVersionDB, axWorkflowExecutionDB, bypassAllFilters, bypassOwnershipFilter, bypassVisibilityFilter, calendarEventMock, calendarEventTypeMockData, calendarMock, checkboxInterface, childCountMiddleware, colorInterface, computeDiff, contactInterface, createAndSaveDashboardForUser, createDashboardForUser, createFileCastMiddleware, dateInterface, dateTimeInterface, descriptionInterface, emailInterface, fileUploaderInterface, findContactMethod, findEmployeeById, findPersonById, generateUserDashboard, groupOrderItemCalculatorMiddleware, historyLoggerMiddleware, identifierCommitMiddleware, imageInterface, lockGuardMiddleware, longTextAnswerInterface, lookupInterface, lookupResolverMiddleware, mapInterface, meetingFilesMock, meetingIds, meetingMock, meetingParticipantMock, meetingRoleTypeMock, meetingSessionMock, meetingTimeSlotMock, meetingTypeFileTemplateMock, meetingTypeMock, mergeDetailRelationMiddleware, metadataCategoryMocks, mockRoleDefinitions, mockUsers, multipleChoiceInterface, multipleSelectInterface, normalizeAnyFileArrayForView, normalizeSnapshotFileFieldsForView, numberInterface, participantIds, passwordInterface, phoneInterface, primaryMiddleware, qrcodeInterface, questionBankItemMock, questionnaireMock, ratingInterface, richTextInterface, scaleInterface, selectInterface, selectionListInterface, signatureInterface, signatureLoaderMiddleware, tagInterface, tenantMocks, textAreaInterface, textInterface, timeDurationInterface, titleInterface, toUiRows, toggleInterface, urlInterface, versionInterface, visibilityFilterMiddleware, workflowDefinitionEntityMock, workflowDefinitionIds, workflowDefinitionMock, yesNoInterface };
 //# sourceMappingURL=acorex-connectivity-mock.mjs.map