@acorex-platform/framework-client 0.0.10

package/fesm2022/acorex-platform-framework-client-workflow.mjs

@@ -0,0 +1,2836 @@
+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 } from '@acorex-platform/framework-shared/core';
+import { AXPContextEvalFactory, AXPExpressionEvaluatorService, AXPDebugService, AXPDataGenerator } from '@acorex-platform/framework-client/core';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPCommandService } from '@acorex-platform/framework-client/runtime';
+
+class AXPWorkflowError extends Error {
+    constructor(message, inner = null) {
+        super(message);
+        this.inner = inner;
+        this.name = 'AXPWorkflowError';
+    }
+}
+
+class AXPWorkflowEventService {
+    constructor() {
+        this.eventSubject = new Subject();
+    }
+    dispatch(event) {
+        this.eventSubject.next(event);
+    }
+    get events$() {
+        return this.eventSubject.asObservable();
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPWorkflowContext {
+    constructor(initialData = {}) {
+        this.variables = {};
+        this.stepOutputs = new Map();
+        this.variables = cloneDeep(initialData);
+    }
+    setVariable(key, value) {
+        setSmart(this.variables, key, value);
+    }
+    setVariables(context = {}) {
+        this.variables = { ...this.variables, ...context };
+    }
+    getVariable(key) {
+        return !key ? this.variables : get(this.variables, key);
+    }
+    setOutput(key, output) {
+        this.stepOutputs.set(key, output);
+    }
+    setOutputs(values) {
+        this.stepOutputs = new Map([...this.stepOutputs, ...values]);
+    }
+    getOutput(key) {
+        return this.stepOutputs.get(key);
+    }
+}
+class AXPWorkflowAction {
+    constructor() {
+        this.eventService = inject(AXPWorkflowEventService);
+    }
+    dispatch(event) {
+        this.eventService.dispatch(event);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowAction, decorators: [{
+            type: Injectable
+        }] });
+class 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: "21.2.9", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
+            type: Injectable
+        }] });
+function createWorkFlowEvent(type) {
+    const eventCreator = (payload) => ({ type, payload });
+    eventCreator.type = type;
+    return eventCreator;
+}
+function ofType(...allowedTypes) {
+    return filter((event) => allowedTypes.some((type) => event.type === type.type));
+}
+
+//#region ---- Contracts barrel ----
+//#endregion
+
+class AXPWorkflowRegistryService {
+    constructor() {
+        this.functionsMap = new Map();
+        this.actionsMap = new Map();
+        this.workflowsMap = new Map();
+    }
+    registerWorkflow(name, workflow) {
+        this.workflowsMap.set(name, workflow);
+    }
+    getWorkflow(name) {
+        return this.workflowsMap.get(name);
+    }
+    registerAction(name, action) {
+        this.actionsMap.set(name, action);
+    }
+    getAction(name) {
+        return this.actionsMap.get(name);
+    }
+    registerFunction(name, func) {
+        this.functionsMap.set(name, func);
+    }
+    getFunction(name) {
+        return this.functionsMap.get(name);
+    }
+    getFunctionNames() {
+        return Array.from(this.functionsMap.keys());
+    }
+    getStep(workflowName, stepName) {
+        const workflow = this.workflowsMap.get(workflowName);
+        if (workflow) {
+            const steps = workflow.steps;
+            return steps[stepName];
+        }
+        return undefined;
+    }
+    updateStepInWorkflow(workflowName, stepName, step) {
+        const workflow = this.workflowsMap.get(workflowName);
+        if (workflow) {
+            const steps = workflow.steps;
+            if (steps[stepName]) {
+                steps[stepName] = step;
+            }
+            else {
+                throw new Error(`Step with name ${stepName} does not exist in workflow ${workflowName}.`);
+            }
+        }
+        else {
+            throw new Error(`Workflow with name ${workflowName} does not exist.`);
+        }
+    }
+    addStepToWorkflow(workflowName, stepName, step) {
+        const workflow = this.workflowsMap.get(workflowName);
+        if (workflow) {
+            const steps = workflow.steps;
+            if (!steps[stepName]) {
+                steps[stepName] = step;
+            }
+            else {
+                throw new Error(`Step with name ${stepName} already exists in workflow ${workflowName}.`);
+            }
+        }
+        else {
+            throw new Error(`Workflow with name ${workflowName} does not exist.`);
+        }
+    }
+    addAfterStep(workflowId, stepId, newStepId, newStepAction, conditionExpression) {
+        const step = this.getStep(workflowId, stepId);
+        if (step != undefined) {
+            this.addStepToWorkflow(workflowId, newStepId, {
+                action: newStepAction,
+                nextSteps: step.nextSteps,
+            });
+            this.updateStepInWorkflow(workflowId, stepId, {
+                ...step,
+                nextSteps: [
+                    {
+                        conditions: [{ type: 'SINGLE', expression: conditionExpression }],
+                        nextStepId: newStepId,
+                    },
+                ],
+            });
+        }
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPWorkflowDecideAction extends AXPWorkflowAction {
+    async execute(context) {
+        // its a fake action
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPWorkflowService {
+    get events$() {
+        return this.eventService.events$;
+    }
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
+        this.eventService = inject(AXPWorkflowEventService);
+    }
+    exists(name) {
+        return !!this.registryService.getWorkflow(name);
+    }
+    async execute(workflow, initialContext = null) {
+        // Instantiate or retrieve the workflow
+        const wk = typeof workflow === 'string' ? this.getWorkflowInstance(workflow) : workflow;
+        let currentStepId = wk.startStepId;
+        const context = initialContext instanceof AXPWorkflowContext
+            ? initialContext
+            : new AXPWorkflowContext(this.processData(initialContext) ?? {});
+        // Initialize context with initial variables
+        while (currentStepId) {
+            const currentStep = wk.steps[currentStepId];
+            if (!currentStep) {
+                throw new AXPWorkflowError(`Step '${currentStepId}' not found in the workflow steps.`);
+            }
+            // Instantiate or retrieve the action
+            const action = typeof currentStep.action === 'string' ? this.getActionInstance(currentStep.action) : currentStep.action;
+            //
+            if (currentStep.input) {
+                let inputs = {};
+                await this.processInputs(cloneDeep(currentStep.input), inputs, '', context);
+                await new Promise((resolve) => setTimeout(async () => {
+                    Object.assign(action, inputs);
+                    resolve(0);
+                }));
+            }
+            try {
+                await new Promise((resolve) => setTimeout(async () => {
+                    await action.execute(context);
+                    resolve(0);
+                }, 0));
+            }
+            catch (error) {
+                console.error(error);
+                throw new AXPWorkflowError('Workflow Error', error);
+            }
+            // Determine the next step based on the conditions
+            const nextStepInfo = await this.determineNextStep(currentStep, context);
+            if (nextStepInfo) {
+                currentStepId = nextStepInfo.nextStepId;
+            }
+            else {
+                break; // Exit the loop if no next step is determined
+            }
+        }
+        return context;
+    }
+    processData(initialContext) {
+        //TODO: update values with expressions and return new object
+        return initialContext;
+    }
+    getActionInstance(actionName) {
+        const actionType = this.registryService.getAction(actionName);
+        if (!actionType) {
+            throw new AXPWorkflowError(`Action type '${actionName}' not found in the registry.`);
+        }
+        return this.injector.get(actionType);
+    }
+    getWorkflowInstance(workflowName) {
+        const workflowType = this.registryService.getWorkflow(workflowName);
+        if (!workflowType) {
+            throw new AXPWorkflowError(`Workflow type '${workflowName}' not found in the registry.`);
+        }
+        return workflowType;
+    }
+    async determineNextStep(currentStep, context) {
+        if (!currentStep.nextSteps) {
+            return null;
+        }
+        for (const nextStep of currentStep.nextSteps) {
+            if (await this.evaluateCondition(nextStep.conditions, context)) {
+                return nextStep;
+            }
+        }
+        return null;
+    }
+    async evaluateCondition(conditions, context) {
+        if (!conditions || conditions.length === 0) {
+            return true; // If no conditions, the step proceeds
+        }
+        // Map each condition to a promise using evaluateSingleCondition
+        const conditionPromises = conditions.map((condition) => this.evaluateSingleCondition(condition, context));
+        // Wait for all promises to resolve
+        const results = await Promise.all(conditionPromises);
+        // Check if every condition is true
+        return results.every((result) => result);
+    }
+    async evaluateSingleCondition(condition, context) {
+        switch (condition.type) {
+            case 'SINGLE':
+                return (!condition.expression ? true : await this.evaluateExpression(condition.expression, context));
+            case 'AND':
+                // Evaluate all conditions with 'AND' logic
+                const andConditions = condition.conditions ?? [];
+                const andResults = await Promise.all(andConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
+                return andResults.every((result) => result);
+            case 'OR':
+                // Evaluate all conditions with 'OR' logic
+                const orConditions = condition.conditions ?? [];
+                const orResults = await Promise.all(orConditions.map((cond) => this.evaluateSingleCondition(cond, context)));
+                return orResults.some((result) => result);
+            default:
+                throw new AXPWorkflowError(`Unsupported condition type: ${condition.type}`);
+        }
+    }
+    //TODO: return any and recursively update object, update scopes
+    async evaluateExpression(templateExpression, context) {
+        try {
+            let expression = '';
+            if (typeof templateExpression === 'string' && templateExpression.trim().includes('{{')) {
+                const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
+                if (!expressionMatch) {
+                    throw Error(`No valid expression found in "${templateExpression}"`);
+                }
+                expression = expressionMatch[1];
+            }
+            else {
+                expression = templateExpression;
+            }
+            // Create a scope that includes context and registered functions
+            const scope = { context, ...this.createFunctionScope() };
+            // Evaluating the expression within the created scope
+            const sandbox = new Function('scope', `return (async function() { with (scope) { return ${expression}; } })();`);
+            const result = await sandbox(scope);
+            return result;
+        }
+        catch (error) {
+            console.error('Error evaluating expression:', error);
+            return false;
+        }
+    }
+    async processInputs(obj, inputs, pathPrefix = '', context = {}) {
+        if (!obj) {
+            return;
+        }
+        for await (const i of Object.entries(obj)) {
+            const key = i[0];
+            const value = i[1];
+            const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+            if (typeof value === 'string' && value.trim().includes('{{')) {
+                const expValue = await this.evaluateExpression(value, context);
+                set(inputs, currentPath, expValue);
+            }
+            else if (typeof value === 'object' &&
+                value !== null &&
+                (value.constructor === Object || Array.isArray(value))) {
+                // Recursively handle nested objects
+                this.processInputs(value, inputs, currentPath, context);
+            }
+            else {
+                // Apply static values directly
+                set(inputs, currentPath, value);
+            }
+        }
+    }
+    createFunctionScope() {
+        const scope = {};
+        this.registryService.getFunctionNames().forEach((name) => {
+            scope[name] = this.getFunctionInstance(name).execute;
+        });
+        return { methods: { scope } };
+    }
+    getFunctionInstance(functionName) {
+        const functionType = this.registryService.getFunction(functionName);
+        if (!functionType) {
+            throw new AXPWorkflowError(`Function type '${functionName}' not found in the registry.`);
+        }
+        return this.injector.get(functionType);
+    }
+    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: "21.2.9", ngImport: i0, type: AXPWorkflowService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPWorkflowRegistryService }, { type: i0.Injector }] });
+
+class AXPStartWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.workflowService = inject(AXPWorkflowService);
+    }
+    async execute(context) {
+        //console.log("start WK current context", context);
+        //console.log("start WK input context", this.context);
+        if (this.context)
+            context.setVariables(this.context);
+        //console.log("start WK merged context", context);
+        try {
+            await this.workflowService.execute(this.workflow, context);
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    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: "21.2.9", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER', {
+    factory: () => [],
+});
+const AXP_ACTIVITY_CATEGORY_PROVIDER = new InjectionToken('AXP_ACTIVITY_CATEGORY_PROVIDER', {
+    factory: () => [],
+});
+
+//#region ----   Imports   ----
+//#endregion
+/**
+ * Optimized Activity Definition Service
+ *
+ * Manages activity definitions (metadata) for UI and tooling.
+ * Similar to AXPReportDefinitionService - 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 activities (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 AXPActivityDefinitionService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.categoryProviders = inject(AXP_ACTIVITY_CATEGORY_PROVIDER, { optional: true }) || [];
+        this.activityProviders = inject(AXP_ACTIVITY_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 activity definitions by categoryId - O(1) lookup */
+        this.activitiesByCategory = new Map();
+        /** Cache for individual activity definitions by name - O(1) lookup */
+        this.activitiesByName = 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.pendingActivitiesRequests = new Map();
+        this.pendingActivityRequests = new Map();
+    }
+    //#endregion
+    //#region ----   Initialization   ----
+    //#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: Activity Definitions   ----
+    /**
+     * Get activity 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 activity definitions
+     * - Returns cached result on subsequent calls
+     *
+     * @param categoryId - Category ID to get activity definitions from
+     * @returns Array of activity definitions
+     */
+    async getActivitiesByCategoryId(categoryId) {
+        // ✅ Fast path: Return cached result
+        if (this.activitiesByCategory.has(categoryId)) {
+            return this.activitiesByCategory.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 activities - cache empty array and skip API call
+            const emptyArray = [];
+            this.activitiesByCategory.set(categoryId, emptyArray);
+            return emptyArray;
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingActivitiesRequests.has(categoryId)) {
+            return this.pendingActivitiesRequests.get(categoryId);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadActivitiesFromProviders(categoryId);
+        this.pendingActivitiesRequests.set(categoryId, requestPromise);
+        return requestPromise;
+    }
+    /**
+     * Get single activity definition by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Activity name (unique identifier and command key)
+     * @returns Activity definition or undefined if not found
+     */
+    async getActivityByName(name) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.activitiesByName.has(name)) {
+            return this.activitiesByName.get(name);
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingActivityRequests.has(name)) {
+            return this.pendingActivityRequests.get(name);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadActivityFromProviders(name);
+        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
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
+     */
+    async getCategoryIdByActivityName(activityName) {
+        // ✅ Search in cached activity definitions
+        for (const [categoryId, definitions] of this.activitiesByCategory.entries()) {
+            if (definitions.some(def => def.name === activityName)) {
+                return categoryId;
+            }
+        }
+        // ✅ Try loading the activity definition to find its category
+        const definition = await this.getActivityByName(activityName);
+        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?.id);
+            if (found) {
+                return found.id;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get category path for an activity
+     */
+    async getCategoriesPathByActivityName(activityName) {
+        const categoryId = await this.getCategoryIdByActivityName(activityName);
+        if (!categoryId) {
+            throw new Error(`Activity '${activityName}' 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 activity definitions from providers and cache results
+     *
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with activity provider
+     */
+    async loadActivitiesFromProviders(categoryId) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.activityProviders);
+            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.activitiesByCategory.set(categoryId, definitions);
+            definitions.forEach(def => {
+                if (def.name) {
+                    this.activitiesByName.set(def.name, def);
+                }
+            });
+            return definitions;
+        }
+        finally {
+            this.pendingActivitiesRequests.delete(categoryId);
+        }
+    }
+    /**
+     * Load single activity definition from providers and cache result
+     */
+    async loadActivityFromProviders(name) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.activityProviders);
+            // Try providers first
+            for (const p of resolvedProviders) {
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getById === 'function') {
+                    try {
+                        const result = await p.value.getById(name);
+                        if (result) {
+                            this.activitiesByName.set(name, result);
+                            return result;
+                        }
+                    }
+                    catch {
+                        // Continue on error
+                    }
+                }
+            }
+            // Fallback: Search in cached activity definitions
+            for (const definitions of this.activitiesByCategory.values()) {
+                const found = definitions.find(def => def.name === name);
+                if (found) {
+                    this.activitiesByName.set(name, found);
+                    return found;
+                }
+            }
+            return undefined;
+        }
+        finally {
+            this.pendingActivityRequests.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 activities (uses cached count)
+     */
+    categoryHasActivities(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.activitiesByCategory.clear();
+        this.activitiesByName.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
+        this.pendingActivitiesRequests.clear();
+        this.pendingActivityRequests.clear();
+    }
+    /**
+     * Clear categories cache only
+     */
+    clearCategoriesCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
+    }
+    /**
+     * Clear activities cache only
+     */
+    clearActivitiesCache() {
+        this.activitiesByCategory.clear();
+        this.activitiesByName.clear();
+        this.pendingActivitiesRequests.clear();
+        this.pendingActivityRequests.clear();
+    }
+    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: "21.2.9", ngImport: i0, type: AXPActivityDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * 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);
+}
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+/** Trace namespace for platform workflow runtime diagnostics (gated by tenant Debug Mode). */
+const WORKFLOW_RUNTIME_TRACE_NS = 'platform-workflow';
+//#endregion
+//#region ---- Helpers ----
+function traceWorkflowRuntime(debug, area, message, data) {
+    debug?.trace(WORKFLOW_RUNTIME_TRACE_NS, area, message, data);
+}
+function warnWorkflowRuntime(debug, area, message, data) {
+    debug?.warn(WORKFLOW_RUNTIME_TRACE_NS, area, message, data);
+}
+function errorWorkflowRuntime(debug, area, message, data) {
+    debug?.error(WORKFLOW_RUNTIME_TRACE_NS, area, message, data);
+}
+//#endregion
+
+//#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).
+ *
+ * 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);
+ *
+ * // Build scope from workflow state
+ * const scope = scopeService.buildScope({
+ *   inputs: state.input || {},
+ *   variables: state.variables || {},
+ *   outputs: activityOutputs
+ * });
+ *
+ * // Or build from state directly
+ * const scope = scopeService.buildScopeFromState(state, activityOutputs);
+ * ```
+ */
+class WorkflowExpressionScopeService {
+    constructor() {
+        this.contextEvalFactory = inject(AXPContextEvalFactory);
+    }
+    //#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: this.contextEvalFactory.createScope(workflowData),
+        };
+        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);
+        this.debug = inject(AXPDebugService);
+    }
+    //#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 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 execute(task, workflowState, activityOutputs) {
+        try {
+            const activityName = task.activityType;
+            // Merge config + input, then evaluate expressions when workflow state is available.
+            const baseInputs = { ...(task.config || {}), ...(task.input || {}) };
+            let evaluatedInputs = baseInputs;
+            if (workflowState) {
+                const outputsForScope = activityOutputs ??
+                    workflowState.activityOutputs ??
+                    undefined;
+                const scope = this.expressionScopeService.buildScopeFromState(workflowState, outputsForScope);
+                evaluatedInputs = await this.expressionEvaluator.evaluate(baseInputs, scope);
+            }
+            // Check if command exists
+            const commandExists = this.commandService.exists(activityName);
+            if (!commandExists) {
+                if (!ENGINE_BUILTIN_ACTIVITY_TYPES.has(activityName)) {
+                    warnWorkflowRuntime(this.debug, 'executor', 'Activity is not registered as command; skipping execution', () => ({
+                        activityName,
+                    }));
+                }
+                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';
+                }
+            }
+            if (activityName.includes('AssessmentCase') && activityName.endsWith(':Fill')) {
+                if (!result.success) {
+                    warnWorkflowRuntime(this.debug, 'executor', 'Assessment fill activity failed', () => ({
+                        activityName,
+                        metadataOutcome: metadataOutcome ?? null,
+                        resolvedOutcome: outcome,
+                        caseId: commandInput?.['caseId'] ?? null,
+                        sessionId: commandInput?.['sessionId'] ?? null,
+                        error: result.message?.text ?? null,
+                    }));
+                }
+            }
+            // 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: output ?? null,
+                outcome,
+            };
+        }
+        catch (error) {
+            errorWorkflowRuntime(this.debug, 'executor', 'Error evaluating expressions or executing activity', () => ({
+                activityName: task.activityType,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            return {
+                output: {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+                outcome: 'Failed',
+            };
+        }
+    }
+    /**
+     * 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'
+                }]
+        }] });
+
+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.
+ *
+ * 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);
+        this.debug = inject(AXPDebugService);
+        this.continuationHook = inject(AXP_WORKFLOW_CONTINUATION_HOOK, { optional: true });
+        //#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 completedTask = currentTask;
+                const completeResponse = await this.workflowEngine.frontActivtyComplete({
+                    instanceId,
+                    activityNode: completedTask.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) {
+            warnWorkflowRuntime(this.debug, 'manager', 'Maximum interactive flow iterations reached', () => ({
+                maxIterations,
+                instanceId,
+            }));
+        }
+        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.
+     *
+     * 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 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.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: finalNextTask,
+                output: finalOutput,
+            };
+        }
+        catch (error) {
+            errorWorkflowRuntime(this.debug, 'manager', 'Error starting workflow', () => ({
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            return {
+                success: false,
+                error: error instanceof 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 instanceId, stepId, outcome, and optional userInput.
+     *
+     * @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 resume(instanceId, stepId, outcome, userInput, taskToken) {
+        try {
+            // Ensure taskToken is provided for secure resumption
+            if (!taskToken) {
+                throw new Error('Missing taskToken for resume operation');
+            }
+            // Backend handles everything: checks outcomeConnections and determines nextStep
+            const response = await this.workflowEngine.resume({
+                instanceId,
+                stepId,
+                taskToken,
+                outcome,
+                userInput,
+            });
+            // Update cache with state from backend
+            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;
+            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: 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) {
+            const { message, code } = getWorkflowEngineErrorInfo(error);
+            return {
+                success: false,
+                instanceId,
+                error: message,
+                errorCode: code,
+            };
+        }
+    }
+    /**
+     * 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 getState(instanceId) {
+        // Check cache first
+        const cached = this.stateCache.get(instanceId);
+        if (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.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(instanceId, normalizedState);
+            return normalizedState;
+        }
+        catch (error) {
+            errorWorkflowRuntime(this.debug, 'manager', 'Error getting workflow state', () => ({
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            return null;
+        }
+    }
+    /**
+     * 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: "21.2.9", ngImport: i0, type: AXPWorkflowManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    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.
+ *
+ * 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.
+ */
+class AXPWorkflowLocalEngine {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.activityDefinitionService = inject(AXPActivityDefinitionService);
+        this.workflowProviders = inject(AXP_WORKFLOW_PROVIDER, { optional: true }) || [];
+        this.multiLanguageResolver = inject(AXTranslationService);
+        this.debug = inject(AXPDebugService);
+        //#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) {
+        // Generate instance ID
+        const instanceId = AXPDataGenerator.uuid();
+        const now = new Date();
+        // Load workflow definition
+        const definition = await this.getDefinition(request.workflowId);
+        if (!definition) {
+            errorWorkflowRuntime(this.debug, 'local-engine', 'Workflow definition not found', () => ({
+                workflowId: request.workflowId,
+            }));
+            throw new Error(`Workflow definition not found: ${request.workflowId}`);
+        }
+        // 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
+        const pendingTask = await this.executeWorkflowSteps(localState);
+        // Update state
+        localState.state.lastUpdated = new Date();
+        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
+            const activityDefinition = await this.activityDefinitionService.getActivityByName(activity.name);
+            const executionMode = activityDefinition?.executionMode || 'frontend';
+            const activityTitle = this.multiLanguageResolver.resolve(activityDefinition?.title) || activityDefinition?.name;
+            // Handle backend activities: skip
+            if (executionMode === 'backend') {
+                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',
+                }]
+        }] });
+
+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, 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-framework-client-workflow.mjs.map