@acorex/platform 21.0.0-next.5 → 21.0.0-next.51

package/fesm2022/acorex-platform-workflow.mjs

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, Optional, Inject, NgModule, InjectionToken } from '@angular/core';
+import { Injectable, inject, InjectionToken, Optional, Inject, NgModule } from '@angular/core';
 import { Subject, filter } from 'rxjs';
 import { cloneDeep, get, set } from 'lodash-es';
-import { setSmart } from '@acorex/platform/core';
+import { setSmart, AXPExpressionEvaluatorService, AXPDataGenerator } from '@acorex/platform/core';
+import { AXTranslationService } from '@acorex/core/translation';
 import { AXPCommandService } from '@acorex/platform/runtime';
 
 class AXPWorkflowError extends Error {
@@ -23,10 +24,10 @@ class AXPWorkflowEventService {
     get events$() {
         return this.eventSubject.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -116,10 +117,10 @@ class AXPWorkflowRegistryService {
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -158,17 +159,17 @@ class AXPWorkflowAction {
     dispatch(event) {
         this.eventService.dispatch(event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowAction, decorators: [{
             type: Injectable
         }] });
 class AXPWorkflowFunction {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowFunction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
             type: Injectable
         }] });
 function createWorkFlowEvent(type) {
@@ -184,10 +185,10 @@ class AXPWorkflowDecideAction extends AXPWorkflowAction {
     async execute(context) {
         // its a fake action
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDecideAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDecideAction, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -373,10 +374,10 @@ class AXPWorkflowService {
         }
         return this.injector.get(functionType);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -401,268 +402,10 @@ class AXPStartWorkflowAction extends AXPWorkflowAction {
             throw e;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXPWorkflowModule {
-    static forRoot(config) {
-        return {
-            ngModule: AXPWorkflowModule,
-            providers: [
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? { AXPStartWorkflowAction }),
-                ...Object.values(config?.functions ?? {}),
-            ],
-        };
-    }
-    static forChild(config) {
-        return {
-            ngModule: AXPWorkflowModule,
-            providers: [
-                // Built-in activities are already registered in forRoot via @NgModule providers
-                // No need to register again in forChild
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? {}),
-                ...Object.values(config?.functions ?? {}),
-            ],
-        };
-    }
-    /**
-     * @ignore
-     */
-    constructor(instances) {
-        instances?.forEach((f) => {
-            f();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [],
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: ['AXPWorkflowModuleFactory']
-                }] }] });
-
-/**
- * Injection token for workflow definition loaders.
- * Multiple loaders can be provided (multi: true).
- */
-const AXP_WORKFLOW_DEFINITION_LOADER = new InjectionToken('AXP_WORKFLOW_DEFINITION_LOADER');
-/**
- * Resolver service for workflow definitions.
- * Aggregates all registered loaders and resolves workflow definitions.
- */
-class AXPWorkflowDefinitionResolver {
-    constructor() {
-        this.loaders = inject(AXP_WORKFLOW_DEFINITION_LOADER, { optional: true });
-    }
-    /**
-     * Get workflow definition by name (unique key).
-     * Tries all registered loaders until one returns a definition.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    async get(name) {
-        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
-        for (const loader of loaderArray) {
-            try {
-                const definition = await loader.get(name);
-                if (definition) {
-                    return definition;
-                }
-            }
-            catch (error) {
-                console.warn(`[AXPWorkflowDefinitionResolver] Loader failed for ${name}:`, error);
-            }
-        }
-        return null;
-    }
-    /**
-     * Get all available workflow names from all loaders.
-     * @returns Array of unique workflow names
-     */
-    async getAllNames() {
-        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
-        const allNames = new Set();
-        for (const loader of loaderArray) {
-            if (loader.getAllNames) {
-                try {
-                    const names = await loader.getAllNames();
-                    names.forEach((name) => allNames.add(name));
-                }
-                catch (error) {
-                    console.warn('[AXPWorkflowDefinitionResolver] Failed to get names from loader:', error);
-                }
-            }
-        }
-        return Array.from(allNames);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-/**
- * Registry service for workflow definitions.
- * Caches loaded definitions and provides change notifications.
- */
-class AXPWorkflowDefinitionRegistryService {
-    constructor() {
-        this.resolver = inject(AXPWorkflowDefinitionResolver);
-        this.cache = new Map();
-        this.onChanged = new Subject();
-    }
-    /**
-     * Observable for workflow definition changes.
-     */
-    get onChanged$() {
-        return this.onChanged.asObservable();
-    }
-    /**
-     * Get workflow definition by name (unique key).
-     * Uses cache if available, otherwise loads from resolver.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
-     */
-    async get(name) {
-        // Check cache first
-        if (this.cache.has(name)) {
-            return this.cache.get(name);
-        }
-        // Load from resolver
-        const definition = await this.resolver.get(name);
-        if (definition) {
-            this.cache.set(name, definition);
-            this.onChanged.next({ name, action: 'registered' });
-        }
-        return definition;
-    }
-    /**
-     * Register a workflow definition in the cache.
-     * @param definition - The workflow definition to register
-     */
-    register(definition) {
-        this.cache.set(definition.name, definition);
-        this.onChanged.next({ name: definition.name, action: 'registered' });
-    }
-    /**
-     * Update a workflow definition in the cache.
-     * @param definition - The updated workflow definition
-     */
-    update(definition) {
-        if (this.cache.has(definition.name)) {
-            this.cache.set(definition.name, definition);
-            this.onChanged.next({ name: definition.name, action: 'updated' });
-        }
-    }
-    /**
-     * Remove a workflow definition from the cache.
-     * @param name - The workflow name to remove
-     */
-    remove(name) {
-        if (this.cache.has(name)) {
-            this.cache.delete(name);
-            this.onChanged.next({ name, action: 'removed' });
-        }
-    }
-    /**
-     * Clear all cached workflow definitions.
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Check if a workflow definition is cached.
-     * @param definitionId - The workflow definition ID
-     * @returns True if cached, false otherwise
-     */
-    has(definitionId) {
-        return this.cache.has(definitionId);
-    }
-    /**
-     * Get all cached workflow definition IDs.
-     * @returns Array of definition IDs (only those that have been loaded)
-     */
-    getAllIds() {
-        return Array.from(this.cache.keys());
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -675,6 +418,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 // Compatible with Elsa backend while using ACoreX naming conventions
 // ============================================
 
+// Note:
+// Previous versions defined dedicated activity result/command types here
+// (AXPActivityResult / AXPActivity) that wrapped output and outcome.
+// Activities are now modeled directly as AXPCommand with outcome stored in
+// AXPExecuteCommandResult.metadata.outcome.
+
 const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER', {
     factory: () => [],
 });
@@ -850,6 +599,19 @@ class AXPActivityDefinitionService {
         this.pendingActivityRequests.set(name, requestPromise);
         return requestPromise;
     }
+    /**
+     * Get all activity definitions (flat list) by loading root categories and their activities.
+     * Used by activity selector UIs (e.g. automation command configurator).
+     */
+    async getAllActivities() {
+        const categories = await this.getCategories(undefined);
+        const all = [];
+        for (const cat of categories) {
+            const activities = await this.getActivitiesByCategoryId(cat.id);
+            all.push(...activities);
+        }
+        return all;
+    }
     /**
      * Get category ID containing a specific activity definition
      *
@@ -867,7 +629,7 @@ class AXPActivityDefinitionService {
         if (definition && definition.category) {
             // Try to find category by name/id
             const categories = await this.getCategories();
-            const found = categories.find(cat => cat.id === definition.category || cat.title === definition.category);
+            const found = categories.find((cat) => cat.id === definition.category);
             if (found) {
                 return found.id;
             }
@@ -1094,10 +856,10 @@ class AXPActivityDefinitionService {
         this.pendingActivitiesRequests.clear();
         this.pendingActivityRequests.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityDefinitionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityDefinitionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1105,359 +867,1777 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
         }] });
 
 /**
- * Abstract service for workflow execution operations.
+ * Injection token for workflow engine.
+ * Default implementation is AXPWorkflowLocalEngine.
+ */
+const AXP_WORKFLOW_ENGINE = new InjectionToken('AXP_WORKFLOW_ENGINE');
+
+//#region ----   Error Codes   ----
+/**
+ * Stable workflow engine error codes for UI branching (toasts, take-over flow, etc.).
+ */
+const AXP_WORKFLOW_ERROR_CODES = {
+    TASK_NOT_ASSIGNEE: 'WORKFLOW_TASK_NOT_ASSIGNEE',
+    CLAIM_REQUIRED: 'WORKFLOW_CLAIM_REQUIRED',
+    REASSIGN_NOT_ALLOWED: 'WORKFLOW_REASSIGN_NOT_ALLOWED',
+};
+//#endregion
+//#region ----   Engine Error   ----
+/**
+ * Business-rule failure from {@link AXPWorkflowEngine} (expected, user-facing).
+ */
+class AXPWorkflowEngineError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'AXPWorkflowEngineError';
+    }
+}
+/**
+ * Resolves a stable error code from an unknown thrown value.
+ */
+function getWorkflowEngineErrorCode(error) {
+    if (error instanceof AXPWorkflowEngineError) {
+        return error.code;
+    }
+    return undefined;
+}
+/**
+ * Resolves a user-facing message and optional code from an unknown thrown value.
+ */
+function getWorkflowEngineErrorInfo(error) {
+    if (error instanceof AXPWorkflowEngineError) {
+        return { message: error.message, code: error.code };
+    }
+    if (error instanceof Error) {
+        return { message: error.message };
+    }
+    return { message: 'An unexpected workflow error occurred' };
+}
+//#endregion
+
+/**
+ * Activity types that use the task board (suspend until user acts via inbox), not inline interactive execution.
+ */
+const AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES = [
+    'workflow-activity:human-task',
+    'workflow-activity:cartable',
+];
+function axpIsWorkflowTaskBoardActivityType(activityType) {
+    return !!activityType && AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES.includes(activityType);
+}
+
+//#endregion
+/**
+ * Workflow Expression Scope Service
+ *
+ * Shared service for building expression evaluation scope from workflow data.
+ * Used by both Local Engine and Mock Runtime to manage workflow data (inputs, variables, outputs).
  *
- * This service handles communication with backend for workflow execution.
+ * Responsibilities:
+ * - Build expression evaluation scope from workflow state
+ * - Provide context.eval() function for accessing workflow data
+ * - Manage workflow data structure (inputs, variables, outputs)
  *
- * Implementation should be provided in connectivity layer:
- * - Mock implementation: @acorex/connectivity/mock
- * - API implementation: @acorex/connectivity/api
+ * This service does NOT:
+ * - Execute activities
+ * - Evaluate expressions (delegates to AXPExpressionEvaluatorService)
+ * - Manage workflow state (handled by runtime)
  *
  * @example
  * ```typescript
- * // In connectivity/mock
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     // Mock implementation
- *   }
- * }
+ * const scopeService = inject(WorkflowExpressionScopeService);
  *
- * // In connectivity/api
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   constructor(private http: HttpClient) {}
+ * // Build scope from workflow state
+ * const scope = scopeService.buildScope({
+ *   inputs: state.input || {},
+ *   variables: state.variables || {},
+ *   outputs: activityOutputs
+ * });
  *
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     return firstValueFrom(
- *       this.http.post<AXPStartWorkflowExecutionResponse>(
- *         `${this.config.baseUrl}/api/workflows/${request.workflowId}/start`,
- *         { input: request.input }
- *       )
- *     );
- *   }
- * }
+ * // Or build from state directly
+ * const scope = scopeService.buildScopeFromState(state, activityOutputs);
  * ```
  */
-class AXPWorkflowExecutionService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService, decorators: [{
-            type: Injectable
-        }] });
-
-//#endregion
-/**
- * Production Workflow Coordinator.
- *
- * Separates frontend/backend execution:
- * - Frontend activities: Execute with AXPCommand in browser
- * - Backend activities: Execute via API calls to backend
- * - State caching: Caches workflow state in client for performance
- *
- */
-class WorkflowCoordinator {
-    constructor() {
-        //#region ----   Services & Dependencies   ----
-        this.workflowExecutionService = inject(AXPWorkflowExecutionService);
-        this.commandService = inject(AXPCommandService);
-        //#endregion
-        //#region ----   State Cache (Client-side for Performance)   ----
-        /**
-         * Cache workflow states in memory for quick access.
-         * Key: executionId
-         * Value: AXPWorkflowExecutionState
-         */
-        this.stateCache = new Map();
-    }
-    //#endregion
-    //#region ----   Public Methods   ----
+class WorkflowExpressionScopeService {
+    //#region ----   Private Helpers (dot-notation input normalization) ----
     /**
-     * Start workflow execution in backend.
-     *
-     * Backend decides what to do: returns pendingTask or indicates completion.
-     * Frontend only calls API - no business logic here.
-     *
-     * @param workflowId - Workflow ID
-     * @param input - Initial input data
-     * @returns Execution result with pendingTask (if any)
-     *
-     * @example
-     * ```typescript
-     * const result = await coordinator.startWorkflow('my-workflow', { userId: '123' });
-     *
-     * if (result.pendingTask) {
-     *   // Execute task if frontend, or wait for backend to complete
-     *   if (result.pendingTask.executionMode === 'frontend') {
-     *     await coordinator.executeTask(result.pendingTask);
-     *     await coordinator.completeTask(result.executionId, result.pendingTask, outcome, output);
-     *   }
-     * }
-     * ```
+     * Collect dot-notation key-value pairs from nested objects so that e.g.
+     * { metadata: { "metadata.questionnaire.id": "x" } } becomes { "metadata.questionnaire.id": "x" } at root.
+     * Top-level non-dot keys are kept as-is.
      */
-    async startWorkflow(workflowId, input = {}) {
-        try {
-            const execution = await this.startWorkflowExecution(workflowId, input);
-            const result = {
-                success: true,
-                output: execution.state.output,
-                nextTask: execution.pendingTask || null,
-                executionId: execution.executionId,
-                state: execution.state
-            };
-            return result;
-        }
-        catch (error) {
-            console.error('[WorkflowCoordinator] ❌ Error in startWorkflow', error);
-            return {
-                success: false,
-                error: error.message || 'Failed to start workflow',
-                nextTask: null
-            };
+    flattenDotKeysFromTree(obj) {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key.includes('.')) {
+                result[key] = value;
+            }
+            else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                for (const [k, v] of Object.entries(value)) {
+                    if (k.includes('.')) {
+                        result[k] = v;
+                    }
+                    else {
+                        result[key + '.' + k] = v;
+                    }
+                }
+            }
+            else {
+                result[key] = value;
+            }
         }
+        return result;
     }
     /**
-     * Execute a frontend task using AXPCommand.
-     *
-     * Only executes if task.executionMode is 'frontend' or 'both'.
-     * Backend tasks are handled automatically by backend.
-     *
-     * @param task - Task to execute
-     * @returns Execution result with output and outcome
+     * Expand flat keys with dots into nested objects.
+     * e.g. { "metadata.questionnaire.id": "x" } -> { metadata: { questionnaire: { id: "x" } } }.
      */
-    async executeTask(task) {
-        // Only execute frontend tasks
-        if (task.executionMode !== 'frontend' && task.executionMode !== 'both') {
-            throw new Error(`Task '${task.activityId}' is not a frontend task. Backend handles it automatically.`);
+    expandDotKeys(obj) {
+        if (obj === null || typeof obj !== 'object')
+            return obj;
+        const result = {};
+        const dotKeys = [];
+        const simpleKeys = [];
+        for (const [key, value] of Object.entries(obj)) {
+            if (key.includes('.')) {
+                dotKeys.push([key, value]);
+            }
+            else {
+                simpleKeys.push([key, value]);
+            }
+        }
+        for (const [key, value] of dotKeys) {
+            const parts = key.split('.');
+            let current = result;
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+            current[parts[parts.length - 1]] = value;
         }
-        return await this.executeFrontendActivity(task);
+        for (const [key, value] of simpleKeys) {
+            result[key] = value;
+        }
+        return result;
     }
     /**
-     * Complete a task and get next task from backend.
-     *
-     * Sends task result to backend API.
-     * Backend decides: next task, fail, or complete workflow.
+     * Normalize workflow input so that flat dot-notation keys (e.g. from form schema
+     * "metadata.questionnaire.id") become nested for expression access (inputs.metadata.questionnaire.id).
+     */
+    normalizeInputs(input) {
+        if (!input || typeof input !== 'object')
+            return {};
+        const flattened = this.flattenDotKeysFromTree(input);
+        return this.expandDotKeys(flattened);
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Build expression evaluation scope for workflow activities.
+     *
+     * Provides workflow-specific data (inputs, variables, outputs) and context.eval() function.
+     * Other data (session, current user, etc.) are provided by expression evaluator scope providers.
+     *
+     * Scope includes:
+     * - inputs: Workflow input values (accessible as inputs.propertyName)
+     * - variables: Workflow state variables (accessible as variables.propertyName or vars.propertyName)
+     * - outputs: Previous activity outputs (accessible as outputs.activityId)
+     * - context.eval(path): Function to access nested properties from workflow data
+     *
+     * Expressions can use:
+     * - {{inputs.userName}} - Direct access to workflow input
+     * - {{variables.someVar}} or {{vars.someVar}} - Direct access to workflow variable
+     * - {{outputs.activityId.property}} - Direct access to previous activity output
+     * - {{context.eval("inputs.userName")}} - Access via context.eval (supports nested paths)
+     * - {{context.eval("variables.someVar")}} - Access variables via context.eval
+     * - {{context.eval("outputs.activityId.property")}} - Access outputs via context.eval
+     * - {{session.currentUser().name}} - Access current user via expression evaluator scope providers
+     *
+     * The context.eval() function provides a unified way to access all workflow data,
+     * similar to how entity-detail-list uses context.eval() to access parent data.
+     *
+     * @param context - Workflow expression context containing inputs, variables, and outputs
+     * @returns Expression evaluator scope with workflow data and context.eval() function
+     */
+    buildScope(context) {
+        // Normalize inputs so flat dot-notation keys (e.g. metadata.questionnaire.id from forms) become nested for expressions
+        const inputs = this.normalizeInputs(context.inputs || {});
+        // Build merged workflow data object for context.eval()
+        // This allows expressions like: context.eval("inputs.userName") or context.eval("variables.count")
+        const workflowData = {
+            inputs,
+            variables: context.variables || {},
+            vars: context.variables || {}, // Alias for convenience
+            outputs: context.outputs || {},
+        };
+        // Build scope object with workflow-specific data and context.eval()
+        // Note: AXPExpressionEvaluatorScope type expects { [namespace]: { [name]: Function } }
+        // but evaluate() method actually accepts flat objects with values too
+        // We'll use 'any' to allow both values and functions
+        const scope = {
+            // Direct access to workflow data
+            inputs: workflowData.inputs,
+            variables: workflowData.variables,
+            vars: workflowData.vars,
+            outputs: workflowData.outputs,
+            // Context object with eval function (similar to entity-detail-list pattern)
+            context: {
+                eval: (path) => {
+                    // Use lodash get to access nested properties
+                    // Supports paths like: "inputs.userName", "variables.count", "outputs.activityId.property"
+                    return get(workflowData, path);
+                },
+            },
+        };
+        return scope;
+    }
+    /**
+     * Build expression evaluation scope from workflow instance state.
+     *
+     * Convenience method that extracts data from AXPWorkflowInstanceState.
+     *
+     * @param state - Workflow instance state
+     * @param activityOutputs - Map of activity outputs (activityId -> output)
+     * @returns Expression evaluator scope with workflow data and context.eval() function
+     */
+    buildScopeFromState(state, activityOutputs) {
+        // Convert activity outputs to record format
+        const outputs = {};
+        if (activityOutputs) {
+            if (activityOutputs instanceof Map) {
+                activityOutputs.forEach((output, activityId) => {
+                    outputs[activityId] = output;
+                });
+            }
+            else {
+                Object.assign(outputs, activityOutputs);
+            }
+        }
+        // Convenience alias for the last activity output (if available).
+        // This allows expressions like: {{outputs.last.someField}}
+        if (outputs['last'] === undefined && state.lastActivityOutput !== undefined) {
+            outputs['last'] = state.lastActivityOutput;
+        }
+        return this.buildScope({
+            inputs: this.normalizeInputs((state.input || {})),
+            variables: state.variables || {},
+            outputs: outputs,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: WorkflowExpressionScopeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: WorkflowExpressionScopeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: WorkflowExpressionScopeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+//#region ----   Constants   ----
+/**
+ * Activity types handled internally by the workflow engine (e.g. mock backend).
+ * When such an activity is not registered as Command on the client, we skip execution
+ * without warning — the engine will run it when executing the workflow.
+ */
+const ENGINE_BUILTIN_ACTIVITY_TYPES = new Set([
+    'workflow-activity:set-variable',
+    'workflow-activity:http-request',
+    'workflow-activity:resolve-employee-user-id',
+]);
+//#endregion
+/**
+ * Activity Executor Service
+ *
+ * Service for executing workflow activities via CommandBus.
+ * Automatically evaluates expressions in activity inputs before execution.
+ *
+ * @example
+ * ```typescript
+ * const executor = inject(ActivityExecutor);
+ *
+ * // Execute activity with task and workflow state (expressions will be evaluated)
+ * const result = await executor.execute(task, workflowState, activityOutputs);
+ * ```
+ */
+class ActivityExecutor {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.commandService = inject(AXPCommandService);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.expressionScopeService = inject(WorkflowExpressionScopeService);
+        this.translateService = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Execute a workflow activity with expression evaluation.
+     *
+     * Evaluates expressions in activity inputs using workflow state,
+     * then executes the activity via CommandBus.
      *
-     * @param executionId - Execution ID
-     * @param task - Completed task
-     * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
-     * @param output - Task output/result
-     * @returns Next task from backend (if any)
+     * @param task - Workflow task containing activity information
+     * @param workflowState - Current workflow instance state (for expression evaluation)
+     * @param activityOutputs - Map of previous activity outputs (for expression evaluation)
+     * @returns Execution result with output and outcome
      */
-    async completeTask(executionId, task, outcome, output) {
+    async execute(task, workflowState, activityOutputs) {
         try {
-            // Send result to backend - backend decides next step
-            const response = await this.workflowExecutionService.resumeExecution({
-                executionId,
-                stepId: task.activityId,
-                taskToken: task.taskToken,
-                outcome,
-                userInput: output
-            });
-            // Update cache
-            if (response.state) {
-                this.stateCache.set(executionId, response.state);
+            const activityName = task.activityType;
+            // Evaluate inputs if workflow state is provided
+            let evaluatedInputs = task.input || {};
+            if (workflowState) {
+                // Prefer explicit outputs, fallback to outputs stored in state
+                const outputsForScope = activityOutputs ??
+                    workflowState.activityOutputs ??
+                    undefined;
+                // Build expression scope from workflow state
+                const scope = this.expressionScopeService.buildScopeFromState(workflowState, outputsForScope);
+                // Evaluate all inputs recursively (handles nested objects and arrays)
+                evaluatedInputs = await this.expressionEvaluator.evaluate(task.input || {}, scope);
+            }
+            // Check if command exists
+            const commandExists = this.commandService.exists(activityName);
+            if (!commandExists) {
+                if (!ENGINE_BUILTIN_ACTIVITY_TYPES.has(activityName)) {
+                    console.warn(`[ActivityExecutor] ⚠️ Activity '${activityName}' is not registered as Command. ` +
+                        `Skipping execution.`);
+                }
+                return {
+                    output: null,
+                    outcome: 'Done'
+                };
             }
+            // Flatten properties if nested (designer-style nested payload)
+            let commandInput = evaluatedInputs;
+            if (commandInput['properties'] && typeof commandInput['properties'] === 'object') {
+                // Flatten: {properties: {text: "..."}} -> {text: "..."}
+                commandInput = { ...commandInput['properties'] };
+            }
+            // Execute activity via CommandBus
+            // Activities (AXPActivity) return {output, outcome}; legacy may return {output, outcomes}
+            const result = await this.commandService.execute(activityName, commandInput);
+            if (!result) {
+                return {
+                    output: null,
+                    outcome: 'Failed',
+                };
+            }
+            if (!result.success) {
+                return {
+                    output: {
+                        error: await this.resolveCommandMessageTextForError(result.message?.text),
+                    },
+                    outcome: 'Failed',
+                };
+            }
+            const commandResult = result.data;
+            // Prefer unified outcome in result.metadata; fall back to legacy data.outcome/outcomes.
+            const metadataOutcome = result?.metadata?.['outcome'];
+            let outcome = 'Done';
+            if (typeof metadataOutcome === 'string' && metadataOutcome.length > 0) {
+                outcome = metadataOutcome;
+            }
+            else if (typeof commandResult?.outcome === 'string' && commandResult.outcome.length > 0) {
+                outcome = commandResult.outcome;
+            }
+            else {
+                const outcomes = (commandResult?.outcomes ?? {});
+                if (outcomes && typeof outcomes === 'object' && Object.keys(outcomes).length > 0) {
+                    outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || 'Done';
+                }
+            }
+            // Prefer output wrapper when present; otherwise treat data itself as output.
+            const output = commandResult && typeof commandResult === 'object' && 'output' in commandResult
+                ? commandResult.output
+                : commandResult;
             return {
-                success: true,
-                output: response.output,
-                nextTask: response.nextTask || null,
-                executionId,
-                state: response.state
+                output: output ?? null,
+                outcome,
             };
         }
         catch (error) {
+            console.error(`[ActivityExecutor] ❌ Error evaluating expressions or executing activity:`, error);
             return {
-                success: false,
-                error: error.message || 'Failed to complete task',
-                nextTask: null
+                output: { error: error.message || 'Unknown error' },
+                outcome: 'Failed'
             };
         }
     }
     /**
-     * Execute workflow by ID (backward compatibility).
+     * Resolves command failure message text for workflow output: `@` keys via translate, MLS maps via resolve.
+     */
+    async resolveCommandMessageTextForError(value) {
+        if (value == null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value.startsWith('@') ? await this.translateService.translateAsync(value) : value;
+        }
+        return this.translateService.resolve(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ActivityExecutor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ActivityExecutor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ActivityExecutor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+//#endregion
+/**
+ * Workflow Manager - Facade for workflow lifecycle orchestration.
+ *
+ * This service is the ONLY interface the frontend uses to interact with workflows.
+ * It follows Clean Architecture principles and does NOT contain execution or business logic.
+ *
+ * Responsibilities:
+ * - Orchestrate workflow lifecycle (start, execute, complete, resume)
+ * - Delegate execution to ActivityExecutor
+ * - Cache workflow state in memory
+ * - Expose a stable API for UI
+ *
+ * Rules:
+ * - No HTTP calls (delegates to AXPWorkflowEngine)
+ * - No CommandBus / Command execution (delegates to ActivityExecutor)
+ * - No workflow branching logic (backend decides)
+ * - No business validation (backend validates)
+ * - No backend assumptions (uses abstract runtime service)
+ */
+class AXPWorkflowManager {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.workflowEngine = inject(AXP_WORKFLOW_ENGINE);
+        this.activityExecutor = inject(ActivityExecutor);
+        //#endregion
+        //#region ----   State Cache   ----
+        /**
+         * Cache workflow states in memory for quick access.
+         * Key: instanceId
+         * Value: AXPWorkflowInstanceState
+         */
+        this.stateCache = new Map();
+        /**
+         * Cache TTL in milliseconds (5 minutes).
+         */
+        this.CACHE_TTL = 5 * 60 * 1000;
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Execute frontend activities interactively until reaching workflow-activity:human-task or completion.
+     *
+     * Interactive = show form/popup immediately (user sees and acts). Only workflow-activity:human-task
+     * is not interactive (goes to task board). Other frontend activities (show-layout-popup, show-toast, etc.)
+     * even with taskType human-task in definition are executed here.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param task - Current task to execute
+     * @param state - Current workflow state
+     * @param lastActivityOutput - Last activity output (for expression evaluation)
+     * @returns Final result with nextTask (if workflow-activity:human-task) or completion status
+     */
+    async executeInteractiveFlow(instanceId, task, state, activityOutputs) {
+        let currentTask = task;
+        let currentState = state;
+        let currentActivityOutputs = {
+            ...(currentState.activityOutputs || {}),
+            ...(activityOutputs || {}),
+        };
+        const maxIterations = 100; // Prevent infinite loops
+        let iterationCount = 0;
+        while (currentTask && iterationCount < maxIterations) {
+            iterationCount++;
+            // Interactive = frontend executionMode and NOT task-board activities (human-task, cartable)
+            const isInteractive = (currentTask.executionMode === 'frontend' || currentTask.executionMode === 'both') &&
+                !axpIsWorkflowTaskBoardActivityType(currentTask.activityType);
+            if (isInteractive) {
+                // Execute frontend activity
+                const execResult = await this.activityExecutor.execute(currentTask, currentState, currentActivityOutputs);
+                // Track outputs locally (backend should also persist and return them)
+                currentActivityOutputs = {
+                    ...currentActivityOutputs,
+                    [currentTask.activityId]: execResult.output,
+                };
+                // Send result to backend
+                const completeResponse = await this.workflowEngine.frontActivtyComplete({
+                    instanceId,
+                    activityNode: currentTask.activityId,
+                    output: execResult.output || {},
+                    outcome: execResult.outcome,
+                });
+                // Update state cache
+                if (completeResponse.state) {
+                    const normalizedState = { ...completeResponse.state };
+                    if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                        normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
+                    }
+                    currentState = normalizedState;
+                    // Prefer outputs returned by backend; fallback to local cache
+                    currentActivityOutputs = {
+                        ...currentActivityOutputs,
+                        ...(normalizedState.activityOutputs || {}),
+                    };
+                    this.stateCache.set(instanceId, normalizedState);
+                }
+                // Backend decides: if no nextTask, workflow is completed
+                if (!completeResponse.nextTask) {
+                    return {
+                        nextTask: null,
+                        state: currentState,
+                        output: completeResponse.output,
+                    };
+                }
+                // Backend decides: if nextTask is task-board activity or not frontend, return it (task board or done)
+                const nextInteractive = (completeResponse.nextTask.executionMode === 'frontend' || completeResponse.nextTask.executionMode === 'both') &&
+                    !axpIsWorkflowTaskBoardActivityType(completeResponse.nextTask.activityType);
+                if (!nextInteractive) {
+                    return {
+                        nextTask: completeResponse.nextTask,
+                        state: currentState,
+                    };
+                }
+                // Continue with next interactive frontend task
+                currentTask = completeResponse.nextTask;
+            }
+            else {
+                // Not interactive (e.g. human-task / cartable) - return as-is for task board
+                return {
+                    nextTask: currentTask,
+                    state: currentState,
+                };
+            }
+        }
+        // Max iterations reached
+        if (iterationCount >= maxIterations) {
+            console.warn(`[AXPWorkflowManager] ⚠️ Maximum iterations (${maxIterations}) reached`);
+        }
+        return {
+            nextTask: currentTask,
+            state: currentState,
+        };
+    }
+    /**
+     * Start a new workflow instance.
      *
-     * @deprecated Use startWorkflow + executeTask + completeTask pattern instead.
-     * This method is kept for backward compatibility but will be removed.
+     * Creates a new workflow instance in backend and returns instance ID.
+     * Backend decides what to do: returns pendingTask or indicates completion.
+     *
+     * @param workflowId - Workflow ID to start
+     * @param input - Initial input data (optional)
+     * @returns Start result with instanceId, state, and nextTask
+     *
+     * @example
+     * ```typescript
+     * const result = await workflowManager.start('my-workflow', { userId: '123' });
+     *
+     * if (result.success && result.nextTask) {
+     *   // Execute task if frontend
+     *   if (result.nextTask.executionMode === 'frontend') {
+     *     const execResult = await workflowManager.execute(result.nextTask);
+     *     await workflowManager.complete(result.instanceId!, result.nextTask, execResult.outcome, execResult.output);
+     *   }
+     * }
+     * ```
      */
-    async executeWorkflowById(workflowId, input = {}) {
-        // Just start workflow - caller should handle task execution
-        return await this.startWorkflow(workflowId, input);
+    async start(workflowId, input = {}) {
+        try {
+            const response = await this.workflowEngine.start({
+                workflowId,
+                input,
+            });
+            // Cache state (normalize Date)
+            let startNormalizedState = { ...response.state };
+            if (startNormalizedState.lastUpdated && !(startNormalizedState.lastUpdated instanceof Date)) {
+                startNormalizedState.lastUpdated = new Date(startNormalizedState.lastUpdated);
+            }
+            this.stateCache.set(response.instanceId, startNormalizedState);
+            // 🎯 Interactive flow: Execute frontend activities that are NOT task-board types (those go to task board)
+            let finalNextTask = response.pendingTask || null;
+            let finalOutput = startNormalizedState.output;
+            const pendingTask = response.pendingTask;
+            if (pendingTask &&
+                (pendingTask.executionMode === 'frontend' || pendingTask.executionMode === 'both') &&
+                !axpIsWorkflowTaskBoardActivityType(pendingTask.activityType)) {
+                const interactiveResult = await this.executeInteractiveFlow(response.instanceId, pendingTask, startNormalizedState, response.activityOutputs || response.state.activityOutputs);
+                finalNextTask = interactiveResult.nextTask;
+                startNormalizedState = interactiveResult.state;
+                if (interactiveResult.output !== undefined) {
+                    finalOutput = interactiveResult.output;
+                }
+                // Update cache with final state
+                this.stateCache.set(response.instanceId, startNormalizedState);
+            }
+            // If backend returned null or non-executable task, return it as-is
+            // Backend already decided workflow status (suspended, completed, etc.)
+            return {
+                success: true,
+                instanceId: response.instanceId,
+                state: startNormalizedState,
+                nextTask: finalNextTask,
+                output: finalOutput,
+            };
+        }
+        catch (error) {
+            console.error('[AXPWorkflowManager] ❌ Error starting workflow:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to start workflow',
+            };
+        }
     }
     /**
      * Resume a suspended workflow (e.g., after user interaction).
      *
      * Backend determines nextStep based on outcome and outcomeConnections.
-     * Client only provides executionId, stepId, outcome, and optional userInput.
+     * Client only provides instanceId, stepId, outcome, and optional userInput.
      *
-     * @param executionId - Workflow execution ID
+     * @param instanceId - Workflow instance ID
      * @param stepId - Step ID that was waiting for user input
      * @param outcome - User action outcome (e.g., 'Confirmed', 'Cancelled', 'Submitted')
      * @param userInput - Optional user input data
+     * @param taskToken - Secure task token (required for secure resumption)
+     * @returns Resume result with next task (if any)
      */
-    async resumeWorkflow(executionId, stepId, outcome, userInput, taskToken) {
+    async resume(instanceId, stepId, outcome, userInput, taskToken) {
         try {
             // Ensure taskToken is provided for secure resumption
             if (!taskToken) {
-                throw new Error('Missing taskToken for resumeWorkflow');
+                throw new Error('Missing taskToken for resume operation');
             }
             // Backend handles everything: checks outcomeConnections and determines nextStep
-            const response = await this.workflowExecutionService.resumeExecution({
-                executionId,
+            const response = await this.workflowEngine.resume({
+                instanceId,
                 stepId,
                 taskToken,
                 outcome,
-                userInput
+                userInput,
             });
             // Update cache with state from backend
-            if (response.state) {
-                this.stateCache.set(executionId, response.state);
+            let normalizedState = response.state ? { ...response.state } : undefined;
+            if (normalizedState && normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
             }
+            if (normalizedState) {
+                this.stateCache.set(instanceId, normalizedState);
+            }
+            // 🎯 Interactive flow: Execute frontend activities that are NOT task-board types (those go to task board)
+            let finalNextTask = response.nextTask || null;
+            let finalOutput = response.output;
+            const nextTask = response.nextTask;
+            if (nextTask &&
+                (nextTask.executionMode === 'frontend' || nextTask.executionMode === 'both') &&
+                !axpIsWorkflowTaskBoardActivityType(nextTask.activityType)) {
+                const interactiveResult = await this.executeInteractiveFlow(instanceId, nextTask, normalizedState, normalizedState?.activityOutputs);
+                finalNextTask = interactiveResult.nextTask;
+                normalizedState = interactiveResult.state;
+                if (interactiveResult.output !== undefined) {
+                    finalOutput = interactiveResult.output;
+                }
+                // Update cache with final state
+                this.stateCache.set(instanceId, normalizedState);
+            }
+            // If backend returned null or non-executable task, return it as-is
+            // Backend already decided workflow status (suspended, completed, etc.)
             return {
                 success: true,
-                output: response.output,
-                nextTask: response.nextTask || null, // Backend determines this from outcomeConnections
-                executionId,
-                state: response.state
+                instanceId,
+                state: normalizedState || response.state,
+                nextTask: finalNextTask,
+                output: finalOutput,
             };
         }
         catch (error) {
+            const { message, code } = getWorkflowEngineErrorInfo(error);
             return {
                 success: false,
-                error: error.message || 'Failed to resume workflow',
-                nextTask: null
+                instanceId,
+                error: message,
+                errorCode: code,
             };
         }
     }
     /**
-     * Get workflow execution state (from cache or backend).
+     * Get workflow instance state.
+     *
+     * Retrieves state from cache (if valid) or from backend.
+     *
+     * @param instanceId - Workflow instance ID
+     * @returns Workflow instance state or null if not found
      */
-    async getWorkflowState(executionId) {
+    async getState(instanceId) {
         // Check cache first
-        const cached = this.stateCache.get(executionId);
+        const cached = this.stateCache.get(instanceId);
         if (cached) {
-            // Cache is valid for 5 minutes
-            const cacheAge = Date.now() - cached.lastUpdated.getTime();
-            if (cacheAge < 5 * 60 * 1000) {
-                return cached;
+            // Normalize lastUpdated to Date (for cache safety)
+            const normalizedCached = { ...cached };
+            if (normalizedCached.lastUpdated && !(normalizedCached.lastUpdated instanceof Date)) {
+                normalizedCached.lastUpdated = new Date(normalizedCached.lastUpdated);
+            }
+            // Validate cache age
+            const cacheAge = Date.now() - normalizedCached.lastUpdated.getTime();
+            if (cacheAge < this.CACHE_TTL) {
+                return normalizedCached;
             }
         }
         // Fetch from backend
         try {
-            const state = await this.workflowExecutionService.getExecutionState({
-                executionId
+            const state = await this.workflowEngine.getState({
+                instanceId,
             });
+            // Normalize lastUpdated to Date (for cache safety)
+            const normalizedState = { ...state };
+            if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
+            }
             // Update cache
-            this.stateCache.set(executionId, state);
-            return state;
+            this.stateCache.set(instanceId, normalizedState);
+            return normalizedState;
         }
-        catch {
+        catch (error) {
+            console.error('[AXPWorkflowManager] ❌ Error getting workflow state:', error);
             return null;
         }
     }
-    //#endregion
-    //#region ----   Private Methods   ----
     /**
-     * Execute a frontend activity using CommandBus.
-     *
-     * Frontend activities are executed in the browser using AXPCommandService.
-     * Activities can also be executed in both frontend and backend (hybrid mode).
-     *
-     * @param task - Frontend task to execute
-     * @returns Execution result with output and outcome
+     * Claim a pooled workflow task (assign current user on the bookmark without advancing the workflow).
+     * Supported only when the injected workflow engine implements {@link AXPWorkflowEngine.claimTask}.
      */
-    async executeFrontendActivity(task) {
+    async claimTask(instanceId, bookmarkId, stepId) {
+        const claim = this.workflowEngine.claimTask?.bind(this.workflowEngine);
+        if (!claim) {
+            return {
+                success: false,
+                instanceId,
+                error: 'Claim task is not supported by this workflow engine',
+            };
+        }
         try {
-            // Check if command exists
-            const commandExists = this.commandService.exists(task.activityType);
-            if (!commandExists) {
-                console.warn(`[WorkflowCoordinator] ⚠️ Frontend activity '${task.activityType}' is not registered. Skipping execution.`);
-                return {
-                    output: null,
-                    outcome: 'Done'
-                };
-            }
-            // Execute activity via CommandBus
-            // Activities registered as AXPCommand return {output, outcomes}
-            // 🎯 Flatten properties if nested (workflow-studio format)
-            let commandInput = task.input || task.config || {};
-            if (commandInput['properties'] && typeof commandInput['properties'] === 'object') {
-                // Flatten: {properties: {text: "..."}} -> {text: "..."}
-                commandInput = { ...commandInput['properties'] };
-            }
-            const result = await this.commandService.execute(task.activityType, commandInput);
-            if (!result) {
-                return {
-                    output: null,
-                    outcome: 'Failed',
-                };
-            }
-            if (!result.success) {
-                return {
-                    output: {
-                        error: result.message?.text,
-                    },
-                    outcome: 'Failed',
-                };
-            }
-            const commandResult = result.data;
-            const outcomes = commandResult?.outcomes ?? {};
-            let outcome = 'Done';
-            if (Object.keys(outcomes).length > 0) {
-                outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || 'Done';
-            }
+            const result = await claim({ instanceId, bookmarkId, stepId });
             return {
-                output: commandResult?.output ?? null,
-                outcome,
+                success: result.success,
+                instanceId,
+                error: result.error,
+                errorCode: result.errorCode,
             };
         }
         catch (error) {
-            console.error(`[WorkflowCoordinator] ❌ Error executing frontend activity '${task.activityType}':`, error);
+            const { message, code } = getWorkflowEngineErrorInfo(error);
             return {
-                output: { error: error.message || 'Unknown error' },
-                outcome: 'Failed'
+                success: false,
+                instanceId,
+                error: message,
+                errorCode: code,
             };
         }
     }
     /**
-     * Start workflow execution in backend.
-     * Backend returns executionId, initial state, and first task to execute.
+     * Reassign a human-task bookmark to the current user without advancing the workflow.
+     * Supported only when the injected workflow engine implements {@link AXPWorkflowEngine.reassignTaskToSelf}.
      */
-    async startWorkflowExecution(workflowId, input) {
-        const response = await this.workflowExecutionService.startExecution({
-            workflowId,
-            input
-        });
-        // Cache state
-        this.stateCache.set(response.executionId, response.state);
-        return {
-            executionId: response.executionId,
-            state: response.state,
-            pendingTask: response.pendingTask
-        };
+    async reassignTaskToSelf(instanceId, bookmarkId, stepId) {
+        const reassign = this.workflowEngine.reassignTaskToSelf?.bind(this.workflowEngine);
+        if (!reassign) {
+            return {
+                success: false,
+                instanceId,
+                error: 'Reassign task is not supported by this workflow engine',
+            };
+        }
+        try {
+            const result = await reassign({ instanceId, bookmarkId, stepId });
+            return {
+                success: result.success,
+                instanceId,
+                error: result.error,
+                errorCode: result.errorCode,
+            };
+        }
+        catch (error) {
+            const { message, code } = getWorkflowEngineErrorInfo(error);
+            return {
+                success: false,
+                instanceId,
+                error: message,
+                errorCode: code,
+            };
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowManager, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowManager, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 
+const AXP_WORKFLOW_PROVIDER = new InjectionToken('AXP_WORKFLOW_PROVIDER', {
+    factory: () => [],
+});
+const AXP_WORKFLOW_CATEGORY_PROVIDER = new InjectionToken('AXP_WORKFLOW_CATEGORY_PROVIDER', {
+    factory: () => [],
+});
+
+//#endregion
 /**
- * Types and interfaces for Workflow Execution Service.
+ * Local engine implementation that manages workflow progression and state.
+ *
+ * This engine:
+ * - Returns frontend/both activities as pendingTask (does NOT execute them)
+ * - Skips backend activities (does not error, continues execution)
+ * - Maintains workflow state in memory
+ * - Does not require backend API calls
+ *
+ * Execution of frontend tasks is handled by AXPWorkflowManager via ActivityExecutor.
+ * This engine only manages workflow progression and state storage.
+ *
+ * This is the DEFAULT engine provider. Applications can override it with
+ * an API-based engine implementation.
  */
-
-// Production Workflow Coordinator (Frontend/Backend Separation)
-
-// Workflow Definition Types (Storage/Database)
+class AXPWorkflowLocalEngine {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.activityDefinitionService = inject(AXPActivityDefinitionService);
+        this.workflowProviders = inject(AXP_WORKFLOW_PROVIDER, { optional: true }) || [];
+        this.multiLanguageResolver = inject(AXTranslationService);
+        //#endregion
+        //#region ----   Instance Storage   ----
+        /**
+         * In-memory storage for workflow instances.
+         * Key: instanceId
+         * Value: LocalWorkflowState
+         */
+        this.instances = new Map();
+        /**
+         * Task token storage for secure resume operations.
+         * Key: taskToken
+         * Value: { instanceId, activityId }
+         */
+        this.taskTokens = new Map();
+    }
+    //#endregion
+    //#region ----   Public Methods (AXPWorkflowEngine)   ----
+    /**
+     * Start a new workflow instance.
+     *
+     * Creates an in-memory workflow instance and progresses it.
+     * Frontend/both activities are returned as pendingTask for external execution.
+     * Backend activities are skipped.
+     */
+    async start(request) {
+        console.log(`[WorkflowLocalEngine] 🚀 Starting workflow: ${request.workflowId}`, request);
+        // Generate instance ID
+        const instanceId = AXPDataGenerator.uuid();
+        const now = new Date();
+        // Load workflow definition
+        console.log(`[WorkflowLocalEngine] 📥 Loading workflow definition: ${request.workflowId}`);
+        const definition = await this.getDefinition(request.workflowId);
+        if (!definition) {
+            console.error(`[WorkflowLocalEngine] ❌ Workflow definition not found: ${request.workflowId}`);
+            throw new Error(`Workflow definition not found: ${request.workflowId}`);
+        }
+        console.log(`[WorkflowLocalEngine] ✅ Definition loaded:`, {
+            name: definition.name,
+            activitiesCount: definition.graph?.activities?.length || 0,
+            connectionsCount: definition.graph?.connections?.length || 0,
+        });
+        // Initialize workflow state
+        const state = {
+            instanceId,
+            workflowId: request.workflowId,
+            status: 'running',
+            variables: {},
+            activityOutputs: {},
+            lastActivityOutput: undefined,
+            input: request.input || {},
+            output: undefined,
+            lastUpdated: now,
+        };
+        // Create local state
+        const localState = {
+            instanceId,
+            workflowId: request.workflowId,
+            definition,
+            state,
+            completedActivities: new Set(),
+            activityResults: new Map(),
+        };
+        // Store instance
+        this.instances.set(instanceId, localState);
+        // Execute workflow steps
+        console.log(`[WorkflowLocalEngine] ⚙️ Executing workflow steps...`);
+        const pendingTask = await this.executeWorkflowSteps(localState);
+        // Update state
+        localState.state.lastUpdated = new Date();
+        console.log(`[WorkflowLocalEngine] ✅ Workflow started:`, {
+            instanceId,
+            status: localState.state.status,
+            hasPendingTask: !!pendingTask,
+            pendingTaskType: pendingTask?.activityType,
+        });
+        return {
+            instanceId,
+            state: localState.state,
+            pendingTask: pendingTask || null,
+            activityOutputs: localState.state.activityOutputs,
+            lastActivityOutput: localState.state.lastActivityOutput,
+        };
+    }
+    /**
+     * Resume a suspended workflow instance.
+     *
+     * Validates task token, applies externally executed result,
+     * and continues progressing workflow steps.
+     */
+    async resume(request) {
+        // Validate task token
+        const tokenInfo = this.taskTokens.get(request.taskToken);
+        if (!tokenInfo || tokenInfo.instanceId !== request.instanceId || tokenInfo.activityId !== request.stepId) {
+            throw new Error('Invalid task token');
+        }
+        // Get instance
+        const localState = this.instances.get(request.instanceId);
+        if (!localState) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Store activity result (from external execution)
+        const outcome = request.outcome ?? 'Done';
+        localState.activityResults.set(request.stepId, {
+            output: request.userInput || {},
+            outcome,
+        });
+        localState.completedActivities.add(request.stepId);
+        // Store activity output for expression evaluation
+        localState.state.activityOutputs = {
+            ...(localState.state.activityOutputs || {}),
+            [request.stepId]: request.userInput || {},
+        };
+        localState.state.lastActivityOutput = request.userInput || {};
+        // Merge output/userInput into state variables
+        if (request.userInput) {
+            localState.state.variables = {
+                ...localState.state.variables,
+                ...(request.userInput || {}),
+            };
+        }
+        localState.state.variables = {
+            ...localState.state.variables,
+            [`${request.stepId}_outcome`]: outcome,
+            [`${request.stepId}_activityOutput`]: request.userInput || {},
+        };
+        // Mark activity as completed and continue progression
+        // Continue progressing workflow steps (skipping backend activities)
+        const nextTask = await this.executeWorkflowSteps(localState);
+        // Update state
+        localState.state.lastUpdated = new Date();
+        // Determine final status
+        if (!nextTask && localState.state.status === 'running') {
+            localState.state.status = 'completed';
+            localState.state.output = localState.state.variables;
+        }
+        return {
+            output: request.userInput || {},
+            outcomes: { [outcome]: true },
+            state: localState.state,
+            nextTask: nextTask || null,
+        };
+    }
+    /**
+     * Get current workflow instance state.
+     */
+    async getState(request) {
+        const localState = this.instances.get(request.instanceId);
+        if (!localState) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Normalize lastUpdated to Date (for cache safety)
+        const state = { ...localState.state };
+        if (state.lastUpdated && !(state.lastUpdated instanceof Date)) {
+            state.lastUpdated = new Date(state.lastUpdated);
+        }
+        return state;
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Get workflow definition from available providers.
+     */
+    async getDefinition(workflowId) {
+        // Try all providers in order
+        const resolvedProviders = await Promise.allSettled(this.workflowProviders);
+        for (const p of resolvedProviders) {
+            if (p.status === 'fulfilled' && p.value) {
+                const provider = p.value;
+                // Check if provider has getByName method
+                if (typeof provider.getByName === 'function') {
+                    try {
+                        const definition = await provider.getByName(workflowId);
+                        if (definition) {
+                            return definition;
+                        }
+                    }
+                    catch {
+                        // Continue on error - try other providers
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Progress workflow steps starting from the current position.
+     *
+     * For frontend/both activities: returns task immediately (suspends workflow).
+     * For backend activities: skips and continues.
+     *
+     * Returns the next pending task (if frontend activity found) or null (if completed).
+     */
+    async executeWorkflowSteps(localState) {
+        const graph = localState.definition.graph;
+        const activities = graph.activities || [];
+        const connections = graph.connections || [];
+        // Build activity map
+        const activityMap = new Map();
+        activities.forEach((activity) => {
+            activityMap.set(activity.id, activity);
+        });
+        // Build connection graph
+        const outgoingConnections = new Map();
+        const incomingConnections = new Map();
+        connections.forEach((conn) => {
+            const sourceId = conn.source.activtyName;
+            const targetId = conn.target.activtyName;
+            if (!outgoingConnections.has(sourceId)) {
+                outgoingConnections.set(sourceId, []);
+            }
+            outgoingConnections.get(sourceId).push(conn);
+            if (!incomingConnections.has(targetId)) {
+                incomingConnections.set(targetId, []);
+            }
+            incomingConnections.get(targetId).push(conn);
+        });
+        // Find starting activity (use startActivityId or no incoming connections, or first activity)
+        let currentActivityId = localState.currentActivityId;
+        if (!currentActivityId) {
+            // Use startActivityId if available
+            if (graph.startActivityId) {
+                currentActivityId = graph.startActivityId;
+            }
+            else {
+                // Find root activity (no incoming connections)
+                for (const activity of activities) {
+                    if (!incomingConnections.has(activity.id)) {
+                        currentActivityId = activity.id;
+                        break;
+                    }
+                }
+                // If no root found, use first activity
+                if (!currentActivityId && activities.length > 0) {
+                    currentActivityId = activities[0].id;
+                }
+            }
+        }
+        // Execute workflow steps
+        while (currentActivityId) {
+            const activity = activityMap.get(currentActivityId);
+            if (!activity) {
+                break;
+            }
+            // Skip if already completed
+            if (localState.completedActivities.has(currentActivityId)) {
+                // Move to next activity
+                const nextId = this.getNextActivityId(currentActivityId, outgoingConnections, localState.activityResults);
+                currentActivityId = nextId ?? undefined;
+                continue;
+            }
+            // Get activity definition to retrieve executionMode and title
+            console.log(`[WorkflowLocalEngine] 🔍 Getting activity definition for: ${activity.name}`);
+            const activityDefinition = await this.activityDefinitionService.getActivityByName(activity.name);
+            console.log(`[WorkflowLocalEngine] 📋 Activity definition:`, {
+                name: activityDefinition?.name,
+                type: activityDefinition?.type,
+                executionMode: activityDefinition?.executionMode,
+                title: activityDefinition?.title,
+                found: !!activityDefinition,
+            });
+            const executionMode = activityDefinition?.executionMode || 'frontend';
+            const activityTitle = this.multiLanguageResolver.resolve(activityDefinition?.title) || activityDefinition?.name;
+            // Handle backend activities: skip
+            if (executionMode === 'backend') {
+                console.log(`[WorkflowLocalEngine] ⏭️ Skipping backend activity: ${activity.name} (${activity.id})`);
+                localState.completedActivities.add(currentActivityId);
+                localState.activityResults.set(currentActivityId, {
+                    output: null,
+                    outcome: 'Done',
+                });
+                // Move to next activity
+                const nextId = this.getNextActivityId(currentActivityId, outgoingConnections, localState.activityResults);
+                currentActivityId = nextId ?? undefined;
+                continue;
+            }
+            // Handle frontend/both activities: return as pendingTask (do NOT execute)
+            if (executionMode === 'frontend' || executionMode === 'both') {
+                // Create task for external execution
+                // Note: Expression evaluation will be done by ActivityExecutor
+                const task = {
+                    taskToken: AXPDataGenerator.uuid(),
+                    activityId: activity.id,
+                    activityType: activity.name,
+                    activityName: activityTitle || undefined,
+                    executionMode: executionMode,
+                    input: activity.inputs || {}, // Pass raw inputs - executor will evaluate
+                };
+                // Store task token for secure resume
+                this.taskTokens.set(task.taskToken, {
+                    instanceId: localState.instanceId,
+                    activityId: activity.id,
+                });
+                // Update state to indicate suspension
+                localState.currentActivityId = currentActivityId;
+                localState.state.status = 'suspended';
+                localState.state.currentStepId = currentActivityId;
+                // Return task immediately - AXPWorkflowManager will execute it
+                return task;
+            }
+            // Move to next activity
+            const nextId = this.getNextActivityId(currentActivityId, outgoingConnections, localState.activityResults);
+            currentActivityId = nextId ?? undefined;
+        }
+        // Workflow completed
+        localState.state.status = 'completed';
+        localState.state.output = localState.state.variables;
+        localState.currentActivityId = undefined;
+        return null;
+    }
+    /**
+     * Get next activity ID based on connections and outcomes.
+     */
+    getNextActivityId(currentActivityId, outgoingConnections, activityResults) {
+        const connections = outgoingConnections.get(currentActivityId) || [];
+        if (connections.length === 0) {
+            return null; // No outgoing connections - workflow ends
+        }
+        // Get current activity result
+        const result = activityResults.get(currentActivityId);
+        const outcome = result?.outcome || 'Done';
+        // Find connection matching outcome
+        // Outcome matching is typically done via port name (e.g., "Done", "Failed")
+        for (const conn of connections) {
+            const sourcePort = conn.source.port || 'Done';
+            if (sourcePort === outcome) {
+                return conn.target.activtyName;
+            }
+        }
+        // If no matching outcome, use first connection (default path)
+        if (connections.length > 0) {
+            return connections[0].target.activtyName;
+        }
+        return null;
+    }
+    async frontActivtyComplete(request) {
+        const localState = this.instances.get(request.instanceId);
+        if (!localState) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Store activity result
+        const outcome = request.outcome ?? 'Done';
+        localState.activityResults.set(request.activityNode, {
+            output: request.output || {},
+            outcome,
+        });
+        localState.completedActivities.add(request.activityNode);
+        // Store outputs for expression evaluation
+        localState.state.activityOutputs = {
+            ...(localState.state.activityOutputs || {}),
+            [request.activityNode]: request.output || {},
+        };
+        localState.state.lastActivityOutput = request.output || {};
+        // Merge output into workflow variables
+        localState.state.variables = {
+            ...localState.state.variables,
+            ...(request.output || {}),
+        };
+        // Continue workflow progression
+        const nextTask = await this.executeWorkflowSteps(localState);
+        // Update state timestamp
+        localState.state.lastUpdated = new Date();
+        // Determine final status
+        if (!nextTask && localState.state.status === 'running') {
+            localState.state.status = 'completed';
+            localState.state.output = localState.state.variables;
+        }
+        return {
+            output: request.output || {},
+            outcomes: { [outcome]: true },
+            nextTask: nextTask || null,
+            state: localState.state,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowLocalEngine, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowLocalEngine }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowLocalEngine, decorators: [{
+            type: Injectable
+        }] });
+
+// Workflow Runtime Services
+
+//#region ----   Imports   ----
+//#endregion
+/**
+ * Optimized Workflow Definition Service
+ *
+ * Manages workflow definitions (metadata) for UI and tooling.
+ * Similar to AXPActivityDefinitionService - only handles metadata, not execution.
+ *
+ * Performance optimizations:
+ * 1. Uses childrenCount to determine if category has children (no query needed)
+ * 2. Uses itemsCount to determine if category has workflows (no query needed)
+ * 3. Aggressive caching prevents duplicate API calls
+ * 4. Single pending request per resource prevents race conditions
+ * 5. Lazy loading - only loads data when needed
+ */
+class AXPWorkflowDefinitionService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.categoryProviders = inject(AXP_WORKFLOW_CATEGORY_PROVIDER, { optional: true }) || [];
+        this.workflowProviders = inject(AXP_WORKFLOW_PROVIDER, { optional: true }) || [];
+        //#endregion
+        //#region ----   Cache Storage   ----
+        /** Cache for categories by id - O(1) lookup */
+        this.categoriesById = new Map();
+        /** Cache for categories by parentId - O(1) lookup */
+        this.categoriesByParentId = new Map();
+        /** Cache for workflow definitions by categoryId - O(1) lookup */
+        this.workflowsByCategory = new Map();
+        /** Cache for individual workflow definitions by name - O(1) lookup */
+        this.workflowsByName = new Map();
+        /** Track which provider index owns each category (by category ID) */
+        this.categoryOwnership = new Map(); // Maps categoryId → provider index
+        /** Pending API requests to prevent duplicate calls */
+        this.pendingCategoriesRequests = new Map();
+        this.pendingWorkflowsRequests = new Map();
+        this.pendingWorkflowRequests = new Map();
+    }
+    //#endregion
+    //#region ----   Public API: Categories   ----
+    /**
+     * Get categories by parentId with aggressive caching
+     *
+     * Optimization: Returns cached result immediately if available,
+     * preventing unnecessary API calls during navigation
+     *
+     * @param parentId - Parent category ID (undefined = root categories)
+     * @returns Array of categories with count metadata (childrenCount, itemsCount)
+     */
+    async getCategories(parentId) {
+        // ✅ Fast path: Return cached result
+        if (this.categoriesByParentId.has(parentId)) {
+            return this.categoriesByParentId.get(parentId);
+        }
+        // ✅ Prevent duplicate requests: Return pending promise
+        if (this.pendingCategoriesRequests.has(parentId)) {
+            return this.pendingCategoriesRequests.get(parentId);
+        }
+        // ✅ Create single request and cache it
+        const requestPromise = this.loadCategoriesFromProviders(parentId);
+        this.pendingCategoriesRequests.set(parentId, requestPromise);
+        return requestPromise;
+    }
+    /**
+     * Get single category by ID with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval, falls back to
+     * searching cache, then providers if not found
+     */
+    async getCategoryById(categoryId) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.categoriesById.has(categoryId)) {
+            return this.categoriesById.get(categoryId);
+        }
+        // ✅ Search in cached parent-child lists
+        for (const categories of this.categoriesByParentId.values()) {
+            const found = categories.find(cat => cat.id === categoryId);
+            if (found) {
+                this.categoriesById.set(categoryId, found);
+                return found;
+            }
+        }
+        // ✅ Load root categories if not loaded
+        if (!this.categoriesByParentId.has(undefined)) {
+            await this.getCategories();
+            if (this.categoriesById.has(categoryId)) {
+                return this.categoriesById.get(categoryId);
+            }
+        }
+        // ✅ Breadth-first search through hierarchy
+        return this.searchCategoryInHierarchy(categoryId);
+    }
+    /**
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
+     */
+    async getCategoriesPathById(categoryId) {
+        const path = [];
+        let currentCategoryId = categoryId;
+        while (currentCategoryId) {
+            const category = await this.getCategoryById(currentCategoryId);
+            if (!category) {
+                throw new Error(`Category '${currentCategoryId}' not found`);
+            }
+            path.unshift(category);
+            currentCategoryId = category.parentId;
+        }
+        return path;
+    }
+    //#endregion
+    //#region ----   Public API: Workflow Definitions   ----
+    /**
+     * Get workflow definitions for a category with smart caching
+     *
+     * Optimization: Checks itemsCount before querying
+     * - If itemsCount = 0, returns empty array (no API call)
+     * - If itemsCount > 0, loads and caches workflow definitions
+     * - Returns cached result on subsequent calls
+     *
+     * @param categoryId - Category ID to get workflow definitions from
+     * @returns Array of workflow definitions
+     */
+    async getWorkflowsByCategoryId(categoryId) {
+        // ✅ Fast path: Return cached result
+        if (this.workflowsByCategory.has(categoryId)) {
+            return this.workflowsByCategory.get(categoryId);
+        }
+        // ✅ Smart optimization: Check itemsCount before querying
+        const category = await this.getCategoryById(categoryId);
+        if (category && category.itemsCount !== undefined && category.itemsCount === 0) {
+            // Category has no workflows - cache empty array and skip API call
+            const emptyArray = [];
+            this.workflowsByCategory.set(categoryId, emptyArray);
+            return emptyArray;
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingWorkflowsRequests.has(categoryId)) {
+            return this.pendingWorkflowsRequests.get(categoryId);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadWorkflowsFromProviders(categoryId);
+        this.pendingWorkflowsRequests.set(categoryId, requestPromise);
+        return requestPromise;
+    }
+    /**
+     * Get single workflow definition by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Workflow name (unique identifier)
+     * @returns Workflow definition or undefined if not found
+     */
+    async getWorkflowByName(name) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.workflowsByName.has(name)) {
+            return this.workflowsByName.get(name);
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingWorkflowRequests.has(name)) {
+            return this.pendingWorkflowRequests.get(name);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadWorkflowFromProviders(name);
+        this.pendingWorkflowRequests.set(name, requestPromise);
+        return requestPromise;
+    }
+    /**
+     * Get category ID containing a specific workflow definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
+     */
+    async getCategoryIdByWorkflowName(workflowName) {
+        // ✅ Search in cached workflow definitions
+        for (const [categoryId, definitions] of this.workflowsByCategory.entries()) {
+            if (definitions.some(def => def.name === workflowName)) {
+                return categoryId;
+            }
+        }
+        // ✅ Try loading the workflow definition to find its category
+        // Note: AXPWorkflowDefinition doesn't have category field
+        // Category is managed separately through category providers
+        // This method searches through cached categories
+        const definition = await this.getWorkflowByName(workflowName);
+        if (definition) {
+            // Search through all categories to find which one contains this workflow
+            const categories = await this.getCategories();
+            for (const category of categories) {
+                const workflows = await this.getWorkflowsByCategoryId(category.id);
+                if (workflows.some(w => w.name === workflowName)) {
+                    return category.id;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get category path for a workflow
+     */
+    async getCategoriesPathByWorkflowName(workflowName) {
+        const categoryId = await this.getCategoryIdByWorkflowName(workflowName);
+        if (!categoryId) {
+            throw new Error(`Workflow '${workflowName}' not found in any category`);
+        }
+        return this.getCategoriesPathById(categoryId);
+    }
+    //#endregion
+    //#region ----   Private: Data Loading   ----
+    /**
+     * Load categories from providers and cache results
+     *
+     * Optimization: Tracks provider ownership to avoid unnecessary API calls
+     * - For root (parentId = undefined): Query ALL providers
+     * - For children: Only query the provider that owns the parent
+     */
+    async loadCategoriesFromProviders(parentId) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.categoryProviders);
+            const categories = [];
+            // Determine which provider(s) to query
+            const providerIndicesToQuery = parentId
+                ? this.getProviderIndexForCategory(parentId)
+                : null; // Root: query all providers
+            for (let i = 0; i < resolvedProviders.length; i++) {
+                const p = resolvedProviders[i];
+                // Skip if we have a specific provider index and this isn't it
+                if (providerIndicesToQuery !== null && !providerIndicesToQuery.includes(i)) {
+                    continue;
+                }
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getList === 'function') {
+                    try {
+                        const cats = await p.value.getList(parentId);
+                        if (Array.isArray(cats) && cats.length > 0) {
+                            categories.push(...cats);
+                            // ✅ Track ownership: This provider INDEX owns these categories
+                            cats.forEach(cat => this.categoryOwnership.set(cat.id, i));
+                        }
+                    }
+                    catch {
+                        // Continue on error - try other providers
+                    }
+                }
+            }
+            // ✅ Cache results for fast subsequent access
+            this.categoriesByParentId.set(parentId, categories);
+            categories.forEach(cat => this.categoriesById.set(cat.id, cat));
+            return categories;
+        }
+        finally {
+            this.pendingCategoriesRequests.delete(parentId);
+        }
+    }
+    /**
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
+     */
+    getProviderIndexForCategory(categoryId) {
+        const ownerIndex = this.categoryOwnership.get(categoryId);
+        if (ownerIndex !== undefined) {
+            return [ownerIndex];
+        }
+        // Ownership unknown - will query all providers (fallback)
+        return null;
+    }
+    /**
+     * Load workflow definitions from providers and cache results
+     *
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with workflow provider
+     */
+    async loadWorkflowsFromProviders(categoryId) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.workflowProviders);
+            const definitions = [];
+            // ✅ Smart routing: Get provider INDEX that owns this category
+            const ownerIndex = this.categoryOwnership.get(categoryId);
+            const providerIndicesToQuery = ownerIndex !== undefined ? [ownerIndex] : null;
+            for (let i = 0; i < resolvedProviders.length; i++) {
+                const p = resolvedProviders[i];
+                // Skip if we have a specific provider index and this isn't it
+                if (providerIndicesToQuery !== null && !providerIndicesToQuery.includes(i)) {
+                    continue;
+                }
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getList === 'function') {
+                    try {
+                        const defs = await p.value.getList(categoryId);
+                        if (Array.isArray(defs)) {
+                            definitions.push(...defs);
+                        }
+                    }
+                    catch {
+                        // Continue on error - try other providers
+                    }
+                }
+            }
+            // ✅ Cache results for fast subsequent access
+            this.workflowsByCategory.set(categoryId, definitions);
+            definitions.forEach(def => {
+                if (def.name) {
+                    this.workflowsByName.set(def.name, def);
+                }
+            });
+            return definitions;
+        }
+        finally {
+            this.pendingWorkflowsRequests.delete(categoryId);
+        }
+    }
+    /**
+     * Load single workflow definition from providers and cache result
+     */
+    async loadWorkflowFromProviders(name) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.workflowProviders);
+            // Try providers first
+            for (const p of resolvedProviders) {
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getByName === 'function') {
+                    try {
+                        const definition = await p.value.getByName(name);
+                        if (definition) {
+                            this.workflowsByName.set(name, definition);
+                            return definition;
+                        }
+                    }
+                    catch {
+                        // Continue on error
+                    }
+                }
+            }
+            // Fallback: Search in cached workflow definitions
+            for (const definitions of this.workflowsByCategory.values()) {
+                const found = definitions.find(def => def.name === name);
+                if (found) {
+                    this.workflowsByName.set(name, found);
+                    return found;
+                }
+            }
+            return undefined;
+        }
+        finally {
+            this.pendingWorkflowRequests.delete(name);
+        }
+    }
+    /**
+     * Breadth-first search through category hierarchy
+     */
+    async searchCategoryInHierarchy(categoryId) {
+        const searchQueue = [undefined];
+        const searched = new Set();
+        while (searchQueue.length > 0) {
+            const parentId = searchQueue.shift();
+            if (searched.has(parentId))
+                continue;
+            searched.add(parentId);
+            const categories = await this.getCategories(parentId);
+            const found = categories.find(cat => cat.id === categoryId);
+            if (found) {
+                return found;
+            }
+            // ✅ Optimization: Only search children if childrenCount > 0
+            for (const category of categories) {
+                if (category.childrenCount > 0 && !searched.has(category.id)) {
+                    searchQueue.push(category.id);
+                }
+            }
+        }
+        return undefined;
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /**
+     * Check if category has children (uses cached count)
+     */
+    categoryHasChildren(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? category.childrenCount > 0 : false;
+    }
+    /**
+     * Check if category has workflows (uses cached count)
+     */
+    categoryHasWorkflows(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? (category.itemsCount ?? 0) > 0 : false;
+    }
+    /**
+     * Clear all caches
+     */
+    clearAllCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.workflowsByCategory.clear();
+        this.workflowsByName.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
+        this.pendingWorkflowsRequests.clear();
+        this.pendingWorkflowRequests.clear();
+    }
+    /**
+     * Clear categories cache only
+     */
+    clearCategoriesCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
+    }
+    /**
+     * Clear workflows cache only
+     */
+    clearWorkflowsCache() {
+        this.workflowsByCategory.clear();
+        this.workflowsByName.clear();
+        this.pendingWorkflowsRequests.clear();
+        this.pendingWorkflowRequests.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDefinitionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+// Workflow Instance Types (Storage/Database)
+
+class AXPWorkflowModule {
+    static forRoot(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
+                        registry.registerAction('decide', AXPWorkflowDecideAction);
+                        //
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true,
+                },
+                ...Object.values(config?.actions ?? { AXPStartWorkflowAction }),
+                ...Object.values(config?.functions ?? {}),
+            ],
+        };
+    }
+    static forChild(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                // Built-in activities are already registered in forRoot via @NgModule providers
+                // No need to register again in forChild
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
+                        registry.registerAction('decide', AXPWorkflowDecideAction);
+                        //
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true,
+                },
+                ...Object.values(config?.actions ?? {}),
+                ...Object.values(config?.functions ?? {}),
+            ],
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach((f) => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, providers: [
+            AXPWorkflowLocalEngine,
+            {
+                provide: AXP_WORKFLOW_ENGINE,
+                useExisting: AXPWorkflowLocalEngine,
+            },
+            AXPWorkflowManager,
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        AXPWorkflowLocalEngine,
+                        {
+                            provide: AXP_WORKFLOW_ENGINE,
+                            useExisting: AXPWorkflowLocalEngine,
+                        },
+                        AXPWorkflowManager,
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPWorkflowModuleFactory']
+                }] }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, WorkflowCoordinator, createWorkFlowEvent, ofType };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowTaskBoardActivityType, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, ofType };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map