@acorex/platform 21.0.0-next.7 → 21.0.0-next.71

package/fesm2022/acorex-platform-workflow.mjs

@@ -2,7 +2,8 @@ import * as i0 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, AXPDataGenerator } 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,28 +402,28 @@ 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: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-/**
- * Injection token for workflow definition loaders.
- * Multiple loaders can be provided (multi: true).
- */
-const AXP_WORKFLOW_DEFINITION_LOADER = new InjectionToken('AXP_WORKFLOW_DEFINITION_LOADER');
-
 // ============================================
 // WORKFLOW INSTANCE v3.0.0 TYPES
 // Based on Elsa Workflow Instance schema: https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json
 // 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: () => [],
 });
@@ -598,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
      *
@@ -615,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?.id);
             if (found) {
                 return found.id;
             }
@@ -842,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',
@@ -858,61 +872,357 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  */
 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
 /**
- * Service responsible for executing frontend workflow tasks.
+ * 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).
+ *
+ * Responsibilities:
+ * - Build expression evaluation scope from workflow state
+ * - Provide context.eval() function for accessing workflow data
+ * - Manage workflow data structure (inputs, variables, outputs)
+ *
+ * This service does NOT:
+ * - Execute activities
+ * - Evaluate expressions (delegates to AXPExpressionEvaluatorService)
+ * - Manage workflow state (handled by runtime)
+ *
+ * @example
+ * ```typescript
+ * const scopeService = inject(WorkflowExpressionScopeService);
  *
- * This service handles the execution of frontend or hybrid tasks using
- * the command infrastructure. It translates command results into
- * workflow-compatible output and outcome format.
+ * // Build scope from workflow state
+ * const scope = scopeService.buildScope({
+ *   inputs: state.input || {},
+ *   variables: state.variables || {},
+ *   outputs: activityOutputs
+ * });
  *
- * This service is replaceable per platform and contains all execution logic.
+ * // Or build from state directly
+ * const scope = scopeService.buildScopeFromState(state, activityOutputs);
+ * ```
  */
-class FrontendTaskExecutor {
+class WorkflowExpressionScopeService {
+    //#region ----   Private Helpers (dot-notation input normalization) ----
+    /**
+     * 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.
+     */
+    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;
+    }
+    /**
+     * Expand flat keys with dots into nested objects.
+     * e.g. { "metadata.questionnaire.id": "x" } -> { metadata: { questionnaire: { id: "x" } } }.
+     */
+    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;
+        }
+        for (const [key, value] of simpleKeys) {
+            result[key] = value;
+        }
+        return result;
+    }
+    /**
+     * 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 frontend workflow task.
+     * Execute a workflow activity with expression evaluation.
      *
-     * Only executes tasks with executionMode 'frontend' or 'both'.
-     * Backend tasks should not be passed to this executor.
+     * Evaluates expressions in activity inputs using workflow state,
+     * then executes the activity via CommandBus.
      *
-     * @param task - Task to execute
+     * @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
-     *
-     * @throws Error if task is not a frontend task
      */
-    async execute(task) {
-        // Validate execution mode
-        if (task.executionMode !== 'frontend' && task.executionMode !== 'both') {
-            throw new Error(`Task '${task.activityId}' is not a frontend task. ` +
-                `Execution mode: ${task.executionMode}. Backend tasks are handled automatically.`);
-        }
+    async execute(task, workflowState, activityOutputs) {
         try {
+            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(task.activityType);
+            const commandExists = this.commandService.exists(activityName);
             if (!commandExists) {
-                console.warn(`[FrontendTaskExecutor] ⚠️ Frontend activity '${task.activityType}' is not registered. ` +
-                    `Skipping execution.`);
+                if (!ENGINE_BUILTIN_ACTIVITY_TYPES.has(activityName)) {
+                    console.warn(`[ActivityExecutor] ⚠️ Activity '${activityName}' is not registered as Command. ` +
+                        `Skipping execution.`);
+                }
                 return {
                     output: null,
                     outcome: 'Done'
                 };
             }
-            // Prepare command input
-            // Flatten properties if nested (workflow-studio format)
-            let commandInput = task.input || task.config || {};
+            // 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 registered as AXPCommand return {output, outcomes}
-            const result = await this.commandService.execute(task.activityType, commandInput);
+            // Activities (AXPActivity) return {output, outcome}; legacy may return {output, outcomes}
+            const result = await this.commandService.execute(activityName, commandInput);
             if (!result) {
                 return {
                     output: null,
@@ -922,42 +1232,151 @@ class FrontendTaskExecutor {
             if (!result.success) {
                 return {
                     output: {
-                        error: result.message?.text,
+                        error: await this.resolveCommandMessageTextForError(result.message?.text),
                     },
                     outcome: 'Failed',
                 };
             }
             const commandResult = result.data;
-            const outcomes = commandResult?.outcomes ?? {};
-            // Determine outcome from command results
-            // Default to 'Done' if no outcomes specified
+            // Prefer unified outcome in result.metadata; fall back to legacy data.outcome/outcomes.
+            const metadataOutcome = result?.metadata?.['outcome'];
             let outcome = 'Done';
-            if (Object.keys(outcomes).length > 0) {
-                outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || '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 {
-                output: commandResult?.output ?? null,
+                output: output ?? null,
                 outcome,
             };
         }
         catch (error) {
-            console.error(`[FrontendTaskExecutor] ❌ Error executing frontend activity '${task.activityType}':`, error);
+            console.error(`[ActivityExecutor] ❌ Error evaluating expressions or executing activity:`, error);
             return {
                 output: { error: error.message || 'Unknown error' },
                 outcome: 'Failed'
             };
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, providedIn: 'root' }); }
+    /**
+     * 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: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ActivityExecutor, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
 
+const AXP_WORKFLOW_CONTINUATION_HOOK = new InjectionToken('AXP_WORKFLOW_CONTINUATION_HOOK');
+/** When true on resume `userInput`, skips the post-step continuation dialog (auto-advance). */
+const AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY = '_suppressWorkflowContinuation';
+function isWorkflowContinuationSuppressed(userInput) {
+    if (userInput == null || typeof userInput !== 'object') {
+        return false;
+    }
+    return userInput[AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY] === true;
+}
+//#endregion
+
+//#region ----   Inline frontend classification   ----
+/**
+ * Frontend step executed inline (dialog/popup), not suspended on the task board.
+ * Derived from execution mode and task-board activity types — no per-activity hardcoding.
+ */
+function axpIsWorkflowInlineFrontendTask(task) {
+    if (!task) {
+        return false;
+    }
+    if (axpIsWorkflowTaskBoardActivityType(task.activityType)) {
+        return false;
+    }
+    return task.executionMode === 'frontend' || task.executionMode === 'both';
+}
+/** @deprecated Use {@link axpIsWorkflowInlineFrontendTask}. */
+function axpIsWorkflowInteractiveFrontendTask(task) {
+    return axpIsWorkflowInlineFrontendTask(task);
+}
+//#endregion
+//#region ----   Continuation metadata on tasks   ----
+/** Resolved before-interactive behavior from task metadata (set by engine from activity definition). */
+function axpResolveWorkflowContinuationBeforeInteractive(task) {
+    return task?.continuation?.beforeInteractive ?? 'default';
+}
+/**
+ * Whether to skip the pre-interactive "continue?" prompt based on activity metadata.
+ * Assignee-specific rules are applied in workflow-management (needs session).
+ */
+function axpShouldSkipBeforeInteractiveFromMetadata(behavior, completedWasHumanTask) {
+    return behavior === 'skip-when-chained-from-human-task' && completedWasHumanTask;
+}
+/**
+ * Whether to show a "continue?" prompt before running inline frontend activities.
+ * Skips when the user already resumed a task-board step (primary action / resume).
+ */
+function axpShouldOfferBeforeInteractiveFlow(context) {
+    return !context.completedActivityId;
+}
+//#endregion
+//#region ----   Step advancement gate   ----
+/** Resume outcomes that do not advance the workflow graph (draft save, cancel, loop back). */
+const NON_ADVANCING_RESUME_OUTCOMES = new Set(['saved', 'cancelled', 'cancel', 'save', 'draft']);
+/**
+ * Whether the workflow advanced enough to consider a continuation prompt.
+ * Includes pending interactive steps when inbox bookmarks are already consumed.
+ */
+function axpShouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivityIds) {
+    const outcome = context.resumeOutcome?.trim().toLowerCase();
+    if (outcome && NON_ADVANCING_RESUME_OUTCOMES.has(outcome)) {
+        return false;
+    }
+    const pendingActivityId = context.pendingNextTask?.activityId;
+    const completedActivityId = context.completedActivityId;
+    if (pendingActivityId && completedActivityId && pendingActivityId === completedActivityId) {
+        return false;
+    }
+    if (activeBookmarkActivityIds.length === 0) {
+        const pending = context.pendingNextTask;
+        if (completedActivityId && pending && pending.activityId !== completedActivityId) {
+            if (axpIsWorkflowInlineFrontendTask(pending) ||
+                axpIsWorkflowTaskBoardActivityType(pending.activityType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** No continuation on bare workflow start (bookmarks exist before any step completes). */
+    if (!completedActivityId) {
+        return false;
+    }
+    return activeBookmarkActivityIds.some((id) => id !== completedActivityId);
+}
+//#endregion
+
 //#endregion
 /**
  * Workflow Manager - Facade for workflow lifecycle orchestration.
@@ -967,13 +1386,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  *
  * Responsibilities:
  * - Orchestrate workflow lifecycle (start, execute, complete, resume)
- * - Delegate execution to FrontendTaskExecutor
+ * - 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 FrontendTaskExecutor)
+ * - 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)
@@ -982,7 +1401,8 @@ class AXPWorkflowManager {
     constructor() {
         //#region ----   Services & Dependencies   ----
         this.workflowEngine = inject(AXP_WORKFLOW_ENGINE);
-        this.frontendTaskExecutor = inject(FrontendTaskExecutor);
+        this.activityExecutor = inject(ActivityExecutor);
+        this.continuationHook = inject(AXP_WORKFLOW_CONTINUATION_HOOK, { optional: true });
         //#endregion
         //#region ----   State Cache   ----
         /**
@@ -998,6 +1418,175 @@ class AXPWorkflowManager {
     }
     //#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) {
+                    const humanTaskNext = completeResponse.nextTask;
+                    let boundaryContinuationOffer;
+                    if (humanTaskNext &&
+                        axpIsWorkflowTaskBoardActivityType(humanTaskNext.activityType)) {
+                        boundaryContinuationOffer =
+                            (await this.continuationHook?.offerAfterWorkflowStep?.({
+                                instanceId,
+                                completedActivityId: currentTask.activityId,
+                                resumeOutcome: execResult.outcome,
+                                pendingNextTask: humanTaskNext,
+                            })) ?? 'not-offered';
+                    }
+                    return {
+                        nextTask: humanTaskNext,
+                        state: currentState,
+                        boundaryContinuationOffer,
+                    };
+                }
+                // 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,
+        };
+    }
+    /**
+     * Runs inline interactive activities when allowed, with an optional pre-flow continuation prompt.
+     */
+    async runInteractiveFlowWithContinuation(instanceId, pendingTask, state, continuationContext, suppressContinuation, activityOutputs) {
+        let continuationOffer = 'not-offered';
+        if (!suppressContinuation &&
+            axpShouldOfferBeforeInteractiveFlow(continuationContext) &&
+            axpIsWorkflowInlineFrontendTask(pendingTask) &&
+            this.continuationHook?.offerBeforeInteractiveFlow) {
+            continuationOffer =
+                (await this.continuationHook.offerBeforeInteractiveFlow({
+                    ...continuationContext,
+                    instanceId,
+                    pendingNextTask: pendingTask,
+                })) ?? 'not-offered';
+            if (continuationOffer === 'declined') {
+                await this.revertResumeAfterDeclinedInteractiveContinuation(instanceId, continuationContext, pendingTask);
+                const revertedState = this.stateCache.get(instanceId) ?? state;
+                return { nextTask: null, state: revertedState, continuationOffer };
+            }
+        }
+        const interactiveResult = await this.executeInteractiveFlow(instanceId, pendingTask, state, activityOutputs);
+        const boundaryOffer = interactiveResult.boundaryContinuationOffer;
+        if (boundaryOffer && boundaryOffer !== 'not-offered') {
+            continuationOffer = boundaryOffer;
+        }
+        return { ...interactiveResult, continuationOffer };
+    }
+    async invokeWorkflowContinuationAfterStep(context, priorOffer, suppressContinuation = false) {
+        if (suppressContinuation || priorOffer === 'declined') {
+            return;
+        }
+        if (priorOffer && priorOffer !== 'not-offered') {
+            return;
+        }
+        await this.continuationHook?.offerAfterWorkflowStep?.(context);
+    }
+    /**
+     * Restores the suspended task-board step when the user declines a pre-interactive continuation prompt.
+     */
+    async revertResumeAfterDeclinedInteractiveContinuation(instanceId, context, abortedTask) {
+        const suspendedStepId = context.completedActivityId;
+        if (!suspendedStepId) {
+            return;
+        }
+        const revert = this.workflowEngine.revertResumeAfterDeclinedInteractiveContinuation?.bind(this.workflowEngine);
+        if (!revert) {
+            return;
+        }
+        const result = await revert({
+            instanceId,
+            suspendedStepId,
+            abortedStepId: abortedTask.activityId,
+            bookmarkId: context.completedBookmarkId,
+        });
+        if (result.success && result.state) {
+            let normalizedState = { ...result.state };
+            if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
+            }
+            this.stateCache.set(instanceId, normalizedState);
+        }
+    }
     /**
      * Start a new workflow instance.
      *
@@ -1025,90 +1614,44 @@ class AXPWorkflowManager {
         try {
             const response = await this.workflowEngine.start({
                 workflowId,
-                input
+                input,
             });
             // Cache state (normalize Date)
-            const startNormalizedState = { ...response.state };
+            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.runInteractiveFlowWithContinuation(response.instanceId, pendingTask, startNormalizedState, { instanceId: response.instanceId, pendingNextTask: pendingTask }, isWorkflowContinuationSuppressed(input), (response.activityOutputs ?? response.state.activityOutputs));
+                finalNextTask = interactiveResult.nextTask;
+                startNormalizedState = interactiveResult.state;
+                if (interactiveResult.output != null) {
+                    finalOutput = interactiveResult.output;
+                }
+                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: response.pendingTask || null,
-                output: startNormalizedState.output
+                nextTask: finalNextTask,
+                output: finalOutput,
             };
         }
         catch (error) {
             console.error('[AXPWorkflowManager] ❌ Error starting workflow:', error);
             return {
                 success: false,
-                error: error.message || 'Failed to start workflow'
-            };
-        }
-    }
-    /**
-     * Execute a frontend task.
-     *
-     * Delegates to FrontendTaskExecutor for actual execution.
-     * Only executes tasks with executionMode 'frontend' or 'both'.
-     *
-     * @param task - Task to execute
-     * @returns Execution result with output and outcome
-     *
-     * @throws Error if task is not a frontend task
-     */
-    async execute(task) {
-        return this.frontendTaskExecutor.execute(task);
-    }
-    /**
-     * Complete a task and get next task from backend.
-     *
-     * Sends task result to backend API.
-     * Backend decides: next task, fail, or complete workflow.
-     *
-     * @param instanceId - Workflow instance ID
-     * @param task - Completed task
-     * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
-     * @param output - Task output/result (optional)
-     * @returns Complete result with next task (if any)
-     */
-    async complete(instanceId, task, outcome, output) {
-        try {
-            // Send result to backend - backend decides next step
-            const response = await this.workflowEngine.resume({
-                instanceId,
-                stepId: task.activityId,
-                taskToken: task.taskToken,
-                outcome,
-                userInput: output
-            });
-            // Update cache
-            let completeNormalizedState = response.state;
-            if (response.state) {
-                // Normalize lastUpdated to Date (for cache safety)
-                completeNormalizedState = { ...response.state };
-                if (completeNormalizedState.lastUpdated && !(completeNormalizedState.lastUpdated instanceof Date)) {
-                    completeNormalizedState.lastUpdated = new Date(completeNormalizedState.lastUpdated);
-                }
-                this.stateCache.set(instanceId, completeNormalizedState);
-            }
-            return {
-                success: true,
-                instanceId,
-                state: completeNormalizedState,
-                nextTask: response.nextTask || null,
-                output: response.output
-            };
-        }
-        catch (error) {
-            console.error('[AXPWorkflowManager] ❌ Error completing task:', error);
-            return {
-                success: false,
-                instanceId,
-                error: error.message || 'Failed to complete task'
+                error: error.message || 'Failed to start workflow',
             };
         }
     }
@@ -1137,36 +1680,70 @@ class AXPWorkflowManager {
                 stepId,
                 taskToken,
                 outcome,
-                userInput
+                userInput,
             });
             // Update cache with state from backend
-            if (response.state) {
-                // Normalize lastUpdated to Date (for cache safety)
-                const normalizedState = { ...response.state };
-                if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
-                    normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
-                }
-                this.stateCache.set(instanceId, normalizedState);
-            }
-            // Normalize state Date for return
-            const normalizedState = response.state ? { ...response.state } : undefined;
+            let normalizedState = response.state ? { ...response.state } : undefined;
             if (normalizedState && normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
                 normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
             }
-            return {
+            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;
+            let resumeContinuationOffer;
+            if (nextTask &&
+                (nextTask.executionMode === 'frontend' || nextTask.executionMode === 'both') &&
+                !axpIsWorkflowTaskBoardActivityType(nextTask.activityType)) {
+                const completedBookmarkId = typeof userInput === 'object' && userInput != null && 'bookmarkId' in userInput
+                    ? String(userInput.bookmarkId ?? '')
+                    : undefined;
+                const interactiveResult = await this.runInteractiveFlowWithContinuation(instanceId, nextTask, normalizedState, {
+                    instanceId,
+                    completedActivityId: stepId,
+                    completedBookmarkId: completedBookmarkId || undefined,
+                    resumeOutcome: outcome,
+                    pendingNextTask: nextTask,
+                }, isWorkflowContinuationSuppressed(userInput), normalizedState?.activityOutputs);
+                finalNextTask = interactiveResult.nextTask;
+                normalizedState = interactiveResult.state;
+                resumeContinuationOffer = interactiveResult.continuationOffer;
+                if (interactiveResult.output != null) {
+                    finalOutput = interactiveResult.output;
+                }
+                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.)
+            const resumeResult = {
                 success: true,
                 instanceId,
                 state: normalizedState || response.state,
-                nextTask: response.nextTask || null, // Backend determines this from outcomeConnections
-                output: response.output
+                nextTask: finalNextTask,
+                output: finalOutput,
             };
+            const completedBookmarkIdForContinuation = typeof userInput === 'object' && userInput != null && 'bookmarkId' in userInput
+                ? String(userInput.bookmarkId ?? '')
+                : undefined;
+            await this.invokeWorkflowContinuationAfterStep({
+                instanceId,
+                completedActivityId: stepId,
+                completedBookmarkId: completedBookmarkIdForContinuation || undefined,
+                resumeOutcome: outcome,
+                pendingNextTask: finalNextTask,
+            }, resumeContinuationOffer, isWorkflowContinuationSuppressed(userInput));
+            return resumeResult;
         }
         catch (error) {
-            console.error('[AXPWorkflowManager] ❌ Error resuming workflow:', error);
+            const { message, code } = getWorkflowEngineErrorInfo(error);
             return {
                 success: false,
                 instanceId,
-                error: error.message || 'Failed to resume workflow'
+                error: message,
+                errorCode: code,
             };
         }
     }
@@ -1196,7 +1773,7 @@ class AXPWorkflowManager {
         // Fetch from backend
         try {
             const state = await this.workflowEngine.getState({
-                instanceId
+                instanceId,
             });
             // Normalize lastUpdated to Date (for cache safety)
             const normalizedState = { ...state };
@@ -1212,16 +1789,87 @@ class AXPWorkflowManager {
             return null;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowManager, providedIn: 'root' }); }
+    /**
+     * 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 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 {
+            const result = await claim({ 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,
+            };
+        }
+    }
+    /**
+     * 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 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: "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: AXPWorkflowManager, 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
 /**
  * Local engine implementation that manages workflow progression and state.
@@ -1232,16 +1880,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * - Maintains workflow state in memory
  * - Does not require backend API calls
  *
- * Execution of frontend tasks is handled by AXPWorkflowManager via FrontendTaskExecutor.
+ * 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.
  */
 class AXPWorkflowLocalEngine {
-    //#region ----   Services & Dependencies   ----
-    constructor(definitionLoaders = null) {
-        this.definitionLoaders = definitionLoaders;
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.activityDefinitionService = inject(AXPActivityDefinitionService);
+        this.workflowProviders = inject(AXP_WORKFLOW_PROVIDER, { optional: true }) || [];
+        this.multiLanguageResolver = inject(AXTranslationService);
         //#endregion
         //#region ----   Instance Storage   ----
         /**
@@ -1267,20 +1917,30 @@ class AXPWorkflowLocalEngine {
      * 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,
@@ -1297,13 +1957,22 @@ class AXPWorkflowLocalEngine {
         // 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,
         };
     }
     /**
@@ -1324,11 +1993,18 @@ class AXPWorkflowLocalEngine {
             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: request.outcome,
+            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 = {
@@ -1336,6 +2012,11 @@ class AXPWorkflowLocalEngine {
                 ...(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);
@@ -1348,7 +2029,7 @@ class AXPWorkflowLocalEngine {
         }
         return {
             output: request.userInput || {},
-            outcomes: { [request.outcome]: true },
+            outcomes: { [outcome]: true },
             state: localState.state,
             nextTask: nextTask || null,
         };
@@ -1371,15 +2052,26 @@ class AXPWorkflowLocalEngine {
     //#endregion
     //#region ----   Private Methods   ----
     /**
-     * Get workflow definition from available loaders.
+     * Get workflow definition from available providers.
      */
     async getDefinition(workflowId) {
-        // Try all loaders in order
-        const loaders = this.definitionLoaders || [];
-        for (const loader of loaders) {
-            const definition = await loader.get(workflowId);
-            if (definition) {
-                return definition;
+        // 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;
@@ -1393,20 +2085,20 @@ class AXPWorkflowLocalEngine {
      * Returns the next pending task (if frontend activity found) or null (if completed).
      */
     async executeWorkflowSteps(localState) {
-        const flowchart = localState.definition.root;
-        const activities = flowchart.activities || [];
-        const connections = flowchart.connections || [];
+        const graph = localState.definition.graph;
+        const activities = graph.activities || [];
+        const connections = graph.connections || [];
         // Build activity map
         const activityMap = new Map();
-        activities.forEach(activity => {
+        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.activity;
-            const targetId = conn.target.activity;
+        connections.forEach((conn) => {
+            const sourceId = conn.source.activtyName;
+            const targetId = conn.target.activtyName;
             if (!outgoingConnections.has(sourceId)) {
                 outgoingConnections.set(sourceId, []);
             }
@@ -1416,19 +2108,25 @@ class AXPWorkflowLocalEngine {
             }
             incomingConnections.get(targetId).push(conn);
         });
-        // Find starting activity (no incoming connections, or first activity)
+        // Find starting activity (use startActivityId or no incoming connections, or first activity)
         let currentActivityId = localState.currentActivityId;
         if (!currentActivityId) {
-            // Find root activity (no incoming connections)
-            for (const activity of activities) {
-                if (!incomingConnections.has(activity.id)) {
-                    currentActivityId = activity.id;
-                    break;
-                }
+            // Use startActivityId if available
+            if (graph.startActivityId) {
+                currentActivityId = graph.startActivityId;
             }
-            // If no root found, use first activity
-            if (!currentActivityId && activities.length > 0) {
-                currentActivityId = activities[0].id;
+            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
@@ -1444,11 +2142,21 @@ class AXPWorkflowLocalEngine {
                 currentActivityId = nextId ?? undefined;
                 continue;
             }
-            // Determine execution mode
-            const executionMode = activity.executionMode || 'frontend';
+            // 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.type} (${activity.id})`);
+                console.log(`[WorkflowLocalEngine] ⏭️ Skipping backend activity: ${activity.name} (${activity.id})`);
                 localState.completedActivities.add(currentActivityId);
                 localState.activityResults.set(currentActivityId, {
                     output: null,
@@ -1462,14 +2170,14 @@ class AXPWorkflowLocalEngine {
             // 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.type,
-                    activityName: activity.name ? activity.name : undefined,
+                    activityType: activity.name,
+                    activityName: activityTitle || undefined,
                     executionMode: executionMode,
-                    input: activity['properties'] || {},
-                    config: activity.customProperties || {},
+                    input: activity.inputs || {}, // Pass raw inputs - executor will evaluate
                 };
                 // Store task token for secure resume
                 this.taskTokens.set(task.taskToken, {
@@ -1509,36 +2217,63 @@ class AXPWorkflowLocalEngine {
         for (const conn of connections) {
             const sourcePort = conn.source.port || 'Done';
             if (sourcePort === outcome) {
-                return conn.target.activity;
+                return conn.target.activtyName;
             }
         }
         // If no matching outcome, use first connection (default path)
         if (connections.length > 0) {
-            return connections[0].target.activity;
+            return connections[0].target.activtyName;
         }
         return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine, deps: [{ token: AXP_WORKFLOW_DEFINITION_LOADER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine }); }
+    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: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowLocalEngine, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [AXP_WORKFLOW_DEFINITION_LOADER]
-                }] }] });
+        }] });
 
 // Workflow Runtime Services
 
-const AXP_WORKFLOW_PROVIDER = new InjectionToken('AXP_WORKFLOW_PROVIDER', {
-    factory: () => [],
-});
-const AXP_WORKFLOW_CATEGORY_PROVIDER = new InjectionToken('AXP_WORKFLOW_CATEGORY_PROVIDER', {
-    factory: () => [],
-});
-
 //#region ----   Imports   ----
 //#endregion
 /**
@@ -1659,7 +2394,7 @@ class AXPWorkflowDefinitionService {
      * - Returns cached result on subsequent calls
      *
      * @param categoryId - Category ID to get workflow definitions from
-     * @returns Array of workflow definition metadata
+     * @returns Array of workflow definitions
      */
     async getWorkflowsByCategoryId(categoryId) {
         // ✅ Fast path: Return cached result
@@ -1684,12 +2419,12 @@ class AXPWorkflowDefinitionService {
         return requestPromise;
     }
     /**
-     * Get single workflow definition metadata by name with O(1) lookup
+     * 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 metadata or undefined if not found
+     * @returns Workflow definition or undefined if not found
      */
     async getWorkflowByName(name) {
         // ✅ Fast path: O(1) lookup in cache
@@ -1718,13 +2453,18 @@ class AXPWorkflowDefinitionService {
             }
         }
         // ✅ 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 && definition.category) {
-            // Try to find category by name/id
+        if (definition) {
+            // Search through all categories to find which one contains this workflow
             const categories = await this.getCategories();
-            const found = categories.find(cat => cat.id === definition.category || cat.title === definition.category);
-            if (found) {
-                return found.id;
+            for (const category of categories) {
+                const workflows = await this.getWorkflowsByCategoryId(category.id);
+                if (workflows.some(w => w.name === workflowName)) {
+                    return category.id;
+                }
             }
         }
         return undefined;
@@ -1850,12 +2590,12 @@ class AXPWorkflowDefinitionService {
             const resolvedProviders = await Promise.allSettled(this.workflowProviders);
             // Try providers first
             for (const p of resolvedProviders) {
-                if (p.status === 'fulfilled' && p.value && typeof p.value.getById === 'function') {
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getByName === 'function') {
                     try {
-                        const result = await p.value.getById(name);
-                        if (result) {
-                            this.workflowsByName.set(name, result);
-                            return result;
+                        const definition = await p.value.getByName(name);
+                        if (definition) {
+                            this.workflowsByName.set(name, definition);
+                            return definition;
                         }
                     }
                     catch {
@@ -1949,17 +2689,17 @@ class AXPWorkflowDefinitionService {
         this.pendingWorkflowsRequests.clear();
         this.pendingWorkflowRequests.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, providedIn: 'root' }); }
+    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: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowDefinitionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-// Workflow Definition Types (Storage/Database)
+// Workflow Instance Types (Storage/Database)
 
 class AXPWorkflowModule {
     static forRoot(config) {
@@ -2044,9 +2784,9 @@ class AXPWorkflowModule {
             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, providers: [
+    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,
@@ -2055,7 +2795,7 @@ class AXPWorkflowModule {
             AXPWorkflowManager,
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
@@ -2081,5 +2821,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_PROVIDER, FrontendTaskExecutor, 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_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowInlineFrontendTask, axpIsWorkflowInteractiveFrontendTask, axpIsWorkflowTaskBoardActivityType, axpResolveWorkflowContinuationBeforeInteractive, axpShouldOfferBeforeInteractiveFlow, axpShouldOfferWorkflowContinuationAfterStep, axpShouldSkipBeforeInteractiveFromMetadata, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map