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

package/fesm2022/acorex-platform-workflow.mjs

@@ -1,14 +1,9 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, InjectionToken, Optional, SkipSelf, Inject, NgModule } from '@angular/core';
+import { Injectable, inject, InjectionToken, Optional, Inject, NgModule } from '@angular/core';
 import { Subject, filter } from 'rxjs';
 import { cloneDeep, get, set } from 'lodash-es';
-import { setSmart } from '@acorex/platform/core';
-import { AXPCommandService, AXPCommandRegistry, AXPQueryService, provideCommandSetups, AXP_COMMAND_SETUP } from '@acorex/platform/runtime';
-import { AXDialogService } from '@acorex/components/dialog';
-import { AXTranslationService } from '@acorex/core/translation';
-import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
-import { AXToastService } from '@acorex/components/toast';
-import { Router } from '@angular/router';
+import { setSmart, AXPDataGenerator } from '@acorex/platform/core';
+import { AXPCommandService } from '@acorex/platform/runtime';
 
 class AXPWorkflowError extends Error {
     constructor(message, inner = null) {
@@ -421,541 +416,652 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Multiple loaders can be provided (multi: true).
  */
 const AXP_WORKFLOW_DEFINITION_LOADER = new InjectionToken('AXP_WORKFLOW_DEFINITION_LOADER');
+
+// ============================================
+// WORKFLOW INSTANCE v3.0.0 TYPES
+// Based on Elsa Workflow Instance schema: https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json
+// Compatible with Elsa backend while using ACoreX naming conventions
+// ============================================
+
+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
 /**
- * Resolver service for workflow definitions.
- * Aggregates all registered loaders and resolves workflow definitions.
+ * 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 AXPWorkflowDefinitionResolver {
+class AXPActivityDefinitionService {
     constructor() {
-        this.loaders = inject(AXP_WORKFLOW_DEFINITION_LOADER, { optional: true });
+        //#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 workflow definition by name (unique key).
-     * Tries all registered loaders until one returns a definition.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
+     * 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 get(name) {
-        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
-        for (const loader of loaderArray) {
-            try {
-                const definition = await loader.get(name);
-                if (definition) {
-                    return definition;
-                }
+    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;
             }
-            catch (error) {
-                console.warn(`[AXPWorkflowDefinitionResolver] Loader failed for ${name}:`, error);
+        }
+        // ✅ Load root categories if not loaded
+        if (!this.categoriesByParentId.has(undefined)) {
+            await this.getCategories();
+            if (this.categoriesById.has(categoryId)) {
+                return this.categoriesById.get(categoryId);
             }
         }
-        return null;
+        // ✅ Breadth-first search through hierarchy
+        return this.searchCategoryInHierarchy(categoryId);
     }
     /**
-     * Get all available workflow names from all loaders.
-     * @returns Array of unique workflow names
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
      */
-    async getAllNames() {
-        const loaderArray = Array.isArray(this.loaders) ? this.loaders : this.loaders ? [this.loaders] : [];
-        const allNames = new Set();
-        for (const loader of loaderArray) {
-            if (loader.getAllNames) {
-                try {
-                    const names = await loader.getAllNames();
-                    names.forEach((name) => allNames.add(name));
-                }
-                catch (error) {
-                    console.warn('[AXPWorkflowDefinitionResolver] Failed to get names from loader:', error);
-                }
+    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 Array.from(allNames);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionResolver, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-/**
- * Registry service for workflow definitions.
- * Caches loaded definitions and provides change notifications.
- */
-class AXPWorkflowDefinitionRegistryService {
-    constructor() {
-        this.resolver = inject(AXPWorkflowDefinitionResolver);
-        this.cache = new Map();
-        this.onChanged = new Subject();
+        return path;
     }
+    //#endregion
+    //#region ----   Public API: Activity Definitions   ----
     /**
-     * Observable for workflow definition changes.
+     * 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
      */
-    get onChanged$() {
-        return this.onChanged.asObservable();
+    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 workflow definition by name (unique key).
-     * Uses cache if available, otherwise loads from resolver.
-     * @param name - The workflow name (unique key)
-     * @returns Workflow definition or null if not found
+     * 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 get(name) {
-        // Check cache first
-        if (this.cache.has(name)) {
-            return this.cache.get(name);
+    async getActivityByName(name) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.activitiesByName.has(name)) {
+            return this.activitiesByName.get(name);
         }
-        // Load from resolver
-        const definition = await this.resolver.get(name);
-        if (definition) {
-            this.cache.set(name, definition);
-            this.onChanged.next({ name, action: 'registered' });
+        // ✅ Prevent duplicate requests
+        if (this.pendingActivityRequests.has(name)) {
+            return this.pendingActivityRequests.get(name);
         }
-        return definition;
-    }
-    /**
-     * Register a workflow definition in the cache.
-     * @param definition - The workflow definition to register
-     */
-    register(definition) {
-        this.cache.set(definition.name, definition);
-        this.onChanged.next({ name: definition.name, action: 'registered' });
+        // ✅ Load from providers
+        const requestPromise = this.loadActivityFromProviders(name);
+        this.pendingActivityRequests.set(name, requestPromise);
+        return requestPromise;
     }
     /**
-     * Update a workflow definition in the cache.
-     * @param definition - The updated workflow definition
+     * Get category ID containing a specific activity definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
      */
-    update(definition) {
-        if (this.cache.has(definition.name)) {
-            this.cache.set(definition.name, definition);
-            this.onChanged.next({ name: definition.name, action: 'updated' });
+    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 || cat.title === definition.category);
+            if (found) {
+                return found.id;
+            }
         }
+        return undefined;
     }
     /**
-     * Remove a workflow definition from the cache.
-     * @param name - The workflow name to remove
+     * Get category path for an activity
      */
-    remove(name) {
-        if (this.cache.has(name)) {
-            this.cache.delete(name);
-            this.onChanged.next({ name, action: 'removed' });
+    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   ----
     /**
-     * Clear all cached workflow definitions.
+     * 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
      */
-    clear() {
-        this.cache.clear();
+    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);
+        }
     }
     /**
-     * Check if a workflow definition is cached.
-     * @param definitionId - The workflow definition ID
-     * @returns True if cached, false otherwise
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
      */
-    has(definitionId) {
-        return this.cache.has(definitionId);
+    getProviderIndexForCategory(categoryId) {
+        const ownerIndex = this.categoryOwnership.get(categoryId);
+        if (ownerIndex !== undefined) {
+            return [ownerIndex];
+        }
+        // Ownership unknown - will query all providers (fallback)
+        return null;
     }
     /**
-     * Get all cached workflow definition IDs.
-     * @returns Array of definition IDs (only those that have been loaded)
+     * 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
      */
-    getAllIds() {
-        return Array.from(this.cache.keys());
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-// ============================================
-// WORKFLOW INSTANCE v3.0.0 TYPES
-// Based on Elsa Workflow Instance schema: https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json
-// Compatible with Elsa backend while using ACoreX naming conventions
-// ============================================
-
-/**
- * Base abstract class for activities.
- * Extend this to create custom activities.
- */
-class Activity {
-    constructor(type, name) {
-        this.type = type;
-        this.name = name;
+    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);
+        }
     }
     /**
-     * Helper method that returns Done outcome by default.
+     * Load single activity definition from providers and cache result
      */
-    createResult(output, outcome = 'Done') {
-        return {
-            success: true,
-            data: {
-                output,
-                outcomes: { [outcome]: true },
-            },
-        };
-    }
-}
-/**
- * Activity registry for registering and creating activities.
- */
-class ActivityRegistry {
-    constructor() {
-        this.registry = new Map();
-        this.descriptors = new Map();
+    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);
+        }
     }
     /**
-     * Register an activity type.
+     * Breadth-first search through category hierarchy
      */
-    register(type, factory, descriptor) {
-        this.registry.set(type, factory);
-        this.descriptors.set(type, descriptor);
+    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   ----
     /**
-     * Create an activity instance.
+     * Check if category has children (uses cached count)
      */
-    create(type) {
-        const factory = this.registry.get(type);
-        if (!factory) {
-            throw new Error(`Unknown activity type: ${type}`);
-        }
-        return factory();
+    categoryHasChildren(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? category.childrenCount > 0 : false;
     }
     /**
-     * Get activity descriptor.
+     * Check if category has activities (uses cached count)
      */
-    getDescriptor(type) {
-        return this.descriptors.get(type);
+    categoryHasActivities(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? (category.itemsCount ?? 0) > 0 : false;
     }
     /**
-     * Get all registered types.
+     * Clear all caches
      */
-    getTypes() {
-        return Array.from(this.registry.keys());
+    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();
     }
     /**
-     * Get all descriptors.
+     * Clear categories cache only
      */
-    getAllDescriptors() {
-        return Array.from(this.descriptors.values());
+    clearCategoriesCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
     }
     /**
-     * Get descriptors by category.
+     * Clear activities cache only
      */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
-    }
+    clearActivitiesCache() {
+        this.activitiesByCategory.clear();
+        this.activitiesByName.clear();
+        this.pendingActivitiesRequests.clear();
+        this.pendingActivityRequests.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 /**
- * Injection token for activity providers.
+ * Injection token for workflow engine.
+ * Default implementation is AXPWorkflowLocalEngine.
  */
-const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER');
+const AXP_WORKFLOW_ENGINE = new InjectionToken('AXP_WORKFLOW_ENGINE');
+
+//#endregion
 /**
- * Activity Provider Service.
- * Collects all activity providers and manages activity registration.
+ * Service responsible for executing frontend workflow tasks.
+ *
+ * This service handles the execution of frontend or hybrid tasks using
+ * the command infrastructure. It translates command results into
+ * workflow-compatible output and outcome format.
+ *
+ * This service is replaceable per platform and contains all execution logic.
  */
-class AXPActivityProviderService {
+class FrontendTaskExecutor {
     constructor() {
-        this.activityDescriptors = new Map();
-        this.categories = [];
-        this.providers = [];
-        this.categoryProviders = [];
-        this.initialized = false;
+        //#region ----   Services & Dependencies   ----
         this.commandService = inject(AXPCommandService);
-        this.commandRegistry = inject(AXPCommandRegistry);
-    }
-    /**
-     * Register an activity provider.
-     */
-    registerProvider(provider) {
-        this.providers.push(provider);
-        if (this.initialized) {
-            this.initializeProvider(provider);
-        }
-    }
-    /**
-     * Register a category provider.
-     */
-    registerCategoryProvider(provider) {
-        this.categoryProviders.push(provider);
-        if (this.initialized) {
-            this.initializeCategoryProvider(provider);
-        }
     }
+    //#endregion
+    //#region ----   Public Methods   ----
     /**
-     * Initialize all providers.
+     * Execute a frontend workflow task.
+     *
+     * Only executes tasks with executionMode 'frontend' or 'both'.
+     * Backend tasks should not be passed to this executor.
+     *
+     * @param task - Task to execute
+     * @returns Execution result with output and outcome
+     *
+     * @throws Error if task is not a frontend task
      */
-    async initialize() {
-        if (this.initialized)
-            return;
-        // Initialize category providers first
-        for (const provider of this.categoryProviders) {
-            await this.initializeCategoryProvider(provider);
-        }
-        // Initialize activity providers
-        for (const provider of this.providers) {
-            await this.initializeProvider(provider);
+    async execute(task) {
+        // Validate execution mode
+        if (task.executionMode !== 'frontend' && task.executionMode !== 'both') {
+            throw new Error(`Task '${task.activityId}' is not a frontend task. ` +
+                `Execution mode: ${task.executionMode}. Backend tasks are handled automatically.`);
         }
-        this.initialized = true;
-    }
-    /**
-     * Get activity descriptor by key.
-     */
-    getDescriptor(key) {
-        return this.activityDescriptors.get(key);
-    }
-    /**
-     * Get all activity descriptors.
-     */
-    getAllDescriptors() {
-        return Array.from(this.activityDescriptors.values());
-    }
-    /**
-     * Get descriptors by category.
-     */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
-    }
-    /**
-     * Get all categories.
-     */
-    getCategories() {
-        return [...this.categories].sort((a, b) => (a.order || 999) - (b.order || 999));
-    }
-    /**
-     * Create an activity instance by key using AXPCommandService.
-     */
-    async createActivity(key) {
         try {
             // Check if command exists
-            if (!this.commandService.exists(key)) {
-                return null;
+            const commandExists = this.commandService.exists(task.activityType);
+            if (!commandExists) {
+                console.warn(`[FrontendTaskExecutor] ⚠️ Frontend activity '${task.activityType}' is not registered. ` +
+                    `Skipping execution.`);
+                return {
+                    output: null,
+                    outcome: 'Done'
+                };
+            }
+            // Prepare command input
+            // Flatten properties if nested (workflow-studio format)
+            let commandInput = task.input || task.config || {};
+            if (commandInput['properties'] && typeof commandInput['properties'] === 'object') {
+                // Flatten: {properties: {text: "..."}} -> {text: "..."}
+                commandInput = { ...commandInput['properties'] };
+            }
+            // Execute activity via CommandBus
+            // Activities registered as AXPCommand return {output, outcomes}
+            const result = await this.commandService.execute(task.activityType, commandInput);
+            if (!result) {
+                return {
+                    output: null,
+                    outcome: 'Failed',
+                };
+            }
+            if (!result.success) {
+                return {
+                    output: {
+                        error: result.message?.text,
+                    },
+                    outcome: 'Failed',
+                };
             }
-            // Get command loader from registry
-            const loader = this.commandRegistry.getLoader(key);
-            if (!loader) {
-                return null;
+            const commandResult = result.data;
+            const outcomes = commandResult?.outcomes ?? {};
+            // Determine outcome from command results
+            // Default to 'Done' if no outcomes specified
+            let outcome = 'Done';
+            if (Object.keys(outcomes).length > 0) {
+                outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || 'Done';
             }
-            // Create command instance
-            const command = await loader();
-            return command;
+            return {
+                output: commandResult?.output ?? null,
+                outcome,
+            };
         }
         catch (error) {
-            return null;
+            console.error(`[FrontendTaskExecutor] ❌ Error executing frontend activity '${task.activityType}':`, error);
+            return {
+                output: { error: error.message || 'Unknown error' },
+                outcome: 'Failed'
+            };
         }
     }
-    // ============================================
-    // PRIVATE METHODS
-    // ============================================
-    async initializeProvider(provider) {
-        const context = {
-            registerActivity: (config) => {
-                this.activityDescriptors.set(config.key, config.descriptor);
-            }
-        };
-        await provider.provide(context);
-    }
-    async initializeCategoryProvider(provider) {
-        const context = {
-            registerCategories: (categories) => {
-                this.categories.push(...categories);
-            }
-        };
-        await provider.provide(context);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: FrontendTaskExecutor, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
 
-/**
- * Injection token for activity category providers.
- */
-const AXP_ACTIVITY_CATEGORY_PROVIDER = new InjectionToken('AXP_ACTIVITY_CATEGORY_PROVIDER');
-class AXPActivityCategoryProviderService {
-    constructor(parent, providers = []) {
-        this.parent = parent;
-        this.providers = providers;
-        this.categories = new Map();
-        this.isInitialized = false;
-        if (!parent) {
-            this.initialize();
-        }
-    }
-    async initialize() {
-        if (this.isInitialized) {
-            return;
-        }
-        for (const provider of this.providers) {
-            await provider.provide({
-                registerCategories: (categories) => {
-                    categories.forEach(cat => this.categories.set(cat.name, cat));
-                }
-            });
-        }
-        this.isInitialized = true;
-    }
-    getAllCategories() {
-        return Array.from(this.categories.values()).sort((a, b) => (a.order || 0) - (b.order || 0));
-    }
-    getCategory(name) {
-        return this.categories.get(name);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, deps: [{ token: AXPActivityCategoryProviderService, optional: true, skipSelf: true }, { token: AXP_ACTIVITY_CATEGORY_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: AXPActivityCategoryProviderService, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [AXP_ACTIVITY_CATEGORY_PROVIDER]
-                }] }] });
-
-/**
- * Abstract service for workflow execution operations.
- *
- * This service handles communication with backend for workflow execution.
- *
- * Implementation should be provided in connectivity layer:
- * - Mock implementation: @acorex/connectivity/mock
- * - API implementation: @acorex/connectivity/api
- *
- * @example
- * ```typescript
- * // In connectivity/mock
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     // Mock implementation
- *   }
- * }
- *
- * // In connectivity/api
- * @Injectable()
- * export class AXCWorkflowExecutionService implements AXPWorkflowExecutionService {
- *   constructor(private http: HttpClient) {}
- *
- *   async startExecution(request: AXPStartWorkflowExecutionRequest): Promise<AXPStartWorkflowExecutionResponse> {
- *     return firstValueFrom(
- *       this.http.post<AXPStartWorkflowExecutionResponse>(
- *         `${this.config.baseUrl}/api/workflows/${request.workflowId}/start`,
- *         { input: request.input }
- *       )
- *     );
- *   }
- * }
- * ```
- */
-class AXPWorkflowExecutionService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowExecutionService, decorators: [{
-            type: Injectable
-        }] });
-
 //#endregion
 /**
- * Production Workflow Coordinator.
+ * 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.
  *
- * Separates frontend/backend execution:
- * - Frontend activities: Execute with AXPCommand in browser
- * - Backend activities: Execute via API calls to backend
- * - State caching: Caches workflow state in client for performance
+ * Responsibilities:
+ * - Orchestrate workflow lifecycle (start, execute, complete, resume)
+ * - Delegate execution to FrontendTaskExecutor
+ * - Cache workflow state in memory
+ * - Expose a stable API for UI
  *
+ * Rules:
+ * - No HTTP calls (delegates to AXPWorkflowEngine)
+ * - No CommandBus / Command execution (delegates to FrontendTaskExecutor)
+ * - No workflow branching logic (backend decides)
+ * - No business validation (backend validates)
+ * - No backend assumptions (uses abstract runtime service)
  */
-class WorkflowCoordinator {
+class AXPWorkflowManager {
     constructor() {
         //#region ----   Services & Dependencies   ----
-        this.workflowExecutionService = inject(AXPWorkflowExecutionService);
-        this.commandService = inject(AXPCommandService);
+        this.workflowEngine = inject(AXP_WORKFLOW_ENGINE);
+        this.frontendTaskExecutor = inject(FrontendTaskExecutor);
         //#endregion
-        //#region ----   State Cache (Client-side for Performance)   ----
+        //#region ----   State Cache   ----
         /**
          * Cache workflow states in memory for quick access.
-         * Key: executionId
-         * Value: AXPWorkflowExecutionState
+         * Key: instanceId
+         * Value: AXPWorkflowInstanceState
          */
         this.stateCache = new Map();
+        /**
+         * Cache TTL in milliseconds (5 minutes).
+         */
+        this.CACHE_TTL = 5 * 60 * 1000;
     }
     //#endregion
     //#region ----   Public Methods   ----
     /**
-     * Start workflow execution in backend.
+     * 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.
-     * Frontend only calls API - no business logic here.
      *
-     * @param workflowId - Workflow ID
-     * @param input - Initial input data
-     * @returns Execution result with pendingTask (if any)
+     * @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 coordinator.startWorkflow('my-workflow', { userId: '123' });
+     * const result = await workflowManager.start('my-workflow', { userId: '123' });
      *
-     * if (result.pendingTask) {
-     *   // Execute task if frontend, or wait for backend to complete
-     *   if (result.pendingTask.executionMode === 'frontend') {
-     *     await coordinator.executeTask(result.pendingTask);
-     *     await coordinator.completeTask(result.executionId, result.pendingTask, outcome, output);
+     * 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 startWorkflow(workflowId, input = {}) {
+    async start(workflowId, input = {}) {
         try {
-            const execution = await this.startWorkflowExecution(workflowId, input);
-            const result = {
+            const response = await this.workflowEngine.start({
+                workflowId,
+                input
+            });
+            // Cache state (normalize Date)
+            const startNormalizedState = { ...response.state };
+            if (startNormalizedState.lastUpdated && !(startNormalizedState.lastUpdated instanceof Date)) {
+                startNormalizedState.lastUpdated = new Date(startNormalizedState.lastUpdated);
+            }
+            this.stateCache.set(response.instanceId, startNormalizedState);
+            return {
                 success: true,
-                output: execution.state.output,
-                nextTask: execution.pendingTask || null,
-                executionId: execution.executionId,
-                state: execution.state
+                instanceId: response.instanceId,
+                state: startNormalizedState,
+                nextTask: response.pendingTask || null,
+                output: startNormalizedState.output
             };
-            return result;
         }
         catch (error) {
-            console.error('[WorkflowCoordinator] ❌ Error in startWorkflow', error);
+            console.error('[AXPWorkflowManager] ❌ Error starting workflow:', error);
             return {
                 success: false,
-                error: error.message || 'Failed to start workflow',
-                nextTask: null
+                error: error.message || 'Failed to start workflow'
             };
         }
     }
     /**
-     * Execute a frontend task using AXPCommand.
+     * Execute a frontend task.
      *
-     * Only executes if task.executionMode is 'frontend' or 'both'.
-     * Backend tasks are handled automatically by backend.
+     * Delegates to FrontendTaskExecutor for actual execution.
+     * Only executes tasks with executionMode 'frontend' or 'both'.
      *
      * @param task - Task to execute
      * @returns Execution result with output and outcome
+     *
+     * @throws Error if task is not a frontend task
      */
-    async executeTask(task) {
-        // Only execute frontend tasks
-        if (task.executionMode !== 'frontend' && task.executionMode !== 'both') {
-            throw new Error(`Task '${task.activityId}' is not a frontend task. Backend handles it automatically.`);
-        }
-        return await this.executeFrontendActivity(task);
+    async execute(task) {
+        return this.frontendTaskExecutor.execute(task);
     }
     /**
      * Complete a task and get next task from backend.
@@ -963,72 +1069,71 @@ class WorkflowCoordinator {
      * Sends task result to backend API.
      * Backend decides: next task, fail, or complete workflow.
      *
-     * @param executionId - Execution ID
+     * @param instanceId - Workflow instance ID
      * @param task - Completed task
      * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
-     * @param output - Task output/result
-     * @returns Next task from backend (if any)
+     * @param output - Task output/result (optional)
+     * @returns Complete result with next task (if any)
      */
-    async completeTask(executionId, task, outcome, output) {
+    async complete(instanceId, task, outcome, output) {
         try {
             // Send result to backend - backend decides next step
-            const response = await this.workflowExecutionService.resumeExecution({
-                executionId,
+            const response = await this.workflowEngine.resume({
+                instanceId,
                 stepId: task.activityId,
                 taskToken: task.taskToken,
                 outcome,
                 userInput: output
             });
             // Update cache
+            let completeNormalizedState = response.state;
             if (response.state) {
-                this.stateCache.set(executionId, response.state);
+                // Normalize lastUpdated to Date (for cache safety)
+                completeNormalizedState = { ...response.state };
+                if (completeNormalizedState.lastUpdated && !(completeNormalizedState.lastUpdated instanceof Date)) {
+                    completeNormalizedState.lastUpdated = new Date(completeNormalizedState.lastUpdated);
+                }
+                this.stateCache.set(instanceId, completeNormalizedState);
             }
             return {
                 success: true,
-                output: response.output,
+                instanceId,
+                state: completeNormalizedState,
                 nextTask: response.nextTask || null,
-                executionId,
-                state: response.state
+                output: response.output
             };
         }
         catch (error) {
+            console.error('[AXPWorkflowManager] ❌ Error completing task:', error);
             return {
                 success: false,
-                error: error.message || 'Failed to complete task',
-                nextTask: null
+                instanceId,
+                error: error.message || 'Failed to complete task'
             };
         }
     }
     /**
-     * Execute workflow by ID (backward compatibility).
-     *
-     * @deprecated Use startWorkflow + executeTask + completeTask pattern instead.
-     * This method is kept for backward compatibility but will be removed.
-     */
-    async executeWorkflowById(workflowId, input = {}) {
-        // Just start workflow - caller should handle task execution
-        return await this.startWorkflow(workflowId, input);
-    }
-    /**
-     * Resume a suspended workflow (e.g., after user interaction).
+     * Resume a suspended workflow (e.g., after user interaction).
      *
      * Backend determines nextStep based on outcome and outcomeConnections.
-     * Client only provides executionId, stepId, outcome, and optional userInput.
+     * Client only provides instanceId, stepId, outcome, and optional userInput.
      *
-     * @param executionId - Workflow execution ID
+     * @param instanceId - Workflow instance ID
      * @param stepId - Step ID that was waiting for user input
      * @param outcome - User action outcome (e.g., 'Confirmed', 'Cancelled', 'Submitted')
      * @param userInput - Optional user input data
+     * @param taskToken - Secure task token (required for secure resumption)
+     * @returns Resume result with next task (if any)
      */
-    async resumeWorkflow(executionId, stepId, outcome, userInput, taskToken) {
+    async resume(instanceId, stepId, outcome, userInput, taskToken) {
         try {
             // Ensure taskToken is provided for secure resumption
             if (!taskToken) {
-                throw new Error('Missing taskToken for resumeWorkflow');
+                throw new Error('Missing taskToken for resume operation');
             }
             // Backend handles everything: checks outcomeConnections and determines nextStep
-            const response = await this.workflowExecutionService.resumeExecution({
-                executionId,
+            const response = await this.workflowEngine.resume({
+                instanceId,
                 stepId,
                 taskToken,
                 outcome,
@@ -1036,1366 +1141,823 @@ class WorkflowCoordinator {
             });
             // Update cache with state from backend
             if (response.state) {
-                this.stateCache.set(executionId, response.state);
+                // Normalize lastUpdated to Date (for cache safety)
+                const normalizedState = { ...response.state };
+                if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                    normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
+                }
+                this.stateCache.set(instanceId, normalizedState);
+            }
+            // Normalize state Date for return
+            const normalizedState = response.state ? { ...response.state } : undefined;
+            if (normalizedState && normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
             }
             return {
                 success: true,
-                output: response.output,
+                instanceId,
+                state: normalizedState || response.state,
                 nextTask: response.nextTask || null, // Backend determines this from outcomeConnections
-                executionId,
-                state: response.state
+                output: response.output
             };
         }
         catch (error) {
+            console.error('[AXPWorkflowManager] ❌ Error resuming workflow:', error);
             return {
                 success: false,
-                error: error.message || 'Failed to resume workflow',
-                nextTask: null
+                instanceId,
+                error: error.message || 'Failed to resume workflow'
             };
         }
     }
     /**
-     * Get workflow execution state (from cache or backend).
+     * Get workflow instance state.
+     *
+     * Retrieves state from cache (if valid) or from backend.
+     *
+     * @param instanceId - Workflow instance ID
+     * @returns Workflow instance state or null if not found
      */
-    async getWorkflowState(executionId) {
+    async getState(instanceId) {
         // Check cache first
-        const cached = this.stateCache.get(executionId);
+        const cached = this.stateCache.get(instanceId);
         if (cached) {
-            // Cache is valid for 5 minutes
-            const cacheAge = Date.now() - cached.lastUpdated.getTime();
-            if (cacheAge < 5 * 60 * 1000) {
-                return cached;
+            // Normalize lastUpdated to Date (for cache safety)
+            const normalizedCached = { ...cached };
+            if (normalizedCached.lastUpdated && !(normalizedCached.lastUpdated instanceof Date)) {
+                normalizedCached.lastUpdated = new Date(normalizedCached.lastUpdated);
+            }
+            // Validate cache age
+            const cacheAge = Date.now() - normalizedCached.lastUpdated.getTime();
+            if (cacheAge < this.CACHE_TTL) {
+                return normalizedCached;
             }
         }
         // Fetch from backend
         try {
-            const state = await this.workflowExecutionService.getExecutionState({
-                executionId
+            const state = await this.workflowEngine.getState({
+                instanceId
             });
-            // Update cache
-            this.stateCache.set(executionId, state);
-            return state;
-        }
-        catch {
-            return null;
-        }
-    }
-    //#endregion
-    //#region ----   Private Methods   ----
-    /**
-     * Execute a frontend activity using CommandBus.
-     *
-     * Frontend activities are executed in the browser using AXPCommandService.
-     * Activities can also be executed in both frontend and backend (hybrid mode).
-     *
-     * @param task - Frontend task to execute
-     * @returns Execution result with output and outcome
-     */
-    async executeFrontendActivity(task) {
-        try {
-            // Check if command exists
-            const commandExists = this.commandService.exists(task.activityType);
-            if (!commandExists) {
-                console.warn(`[WorkflowCoordinator] ⚠️ Frontend activity '${task.activityType}' is not registered. Skipping execution.`);
-                return {
-                    output: null,
-                    outcome: 'Done'
-                };
-            }
-            // Execute activity via CommandBus
-            // Activities registered as AXPCommand return {output, outcomes}
-            // 🎯 Flatten properties if nested (workflow-studio format)
-            let commandInput = task.input || task.config || {};
-            if (commandInput['properties'] && typeof commandInput['properties'] === 'object') {
-                // Flatten: {properties: {text: "..."}} -> {text: "..."}
-                commandInput = { ...commandInput['properties'] };
-            }
-            const result = await this.commandService.execute(task.activityType, commandInput);
-            if (!result) {
-                return {
-                    output: null,
-                    outcome: 'Failed',
-                };
-            }
-            if (!result.success) {
-                return {
-                    output: {
-                        error: result.message?.text,
-                    },
-                    outcome: 'Failed',
-                };
-            }
-            const commandResult = result.data;
-            const outcomes = commandResult?.outcomes ?? {};
-            let outcome = 'Done';
-            if (Object.keys(outcomes).length > 0) {
-                outcome = outcomes['Done'] ? 'Done' : Object.keys(outcomes)[0] || 'Done';
+            // Normalize lastUpdated to Date (for cache safety)
+            const normalizedState = { ...state };
+            if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
             }
-            return {
-                output: commandResult?.output ?? null,
-                outcome,
-            };
+            // Update cache
+            this.stateCache.set(instanceId, normalizedState);
+            return normalizedState;
         }
         catch (error) {
-            console.error(`[WorkflowCoordinator] ❌ Error executing frontend activity '${task.activityType}':`, error);
-            return {
-                output: { error: error.message || 'Unknown error' },
-                outcome: 'Failed'
-            };
+            console.error('[AXPWorkflowManager] ❌ Error getting workflow state:', error);
+            return null;
         }
     }
-    /**
-     * Start workflow execution in backend.
-     * Backend returns executionId, initial state, and first task to execute.
-     */
-    async startWorkflowExecution(workflowId, input) {
-        const response = await this.workflowExecutionService.startExecution({
-            workflowId,
-            input
-        });
-        // Cache state
-        this.stateCache.set(response.executionId, response.state);
-        return {
-            executionId: response.executionId,
-            state: response.state,
-            pendingTask: response.pendingTask
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowManager, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: WorkflowCoordinator, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowManager, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
 
+//#endregion
 /**
- * Types and interfaces for Workflow Execution Service.
- */
-
-// Production Workflow Coordinator (Frontend/Backend Separation)
-
-/**
- * WriteLine Activity - Simple console logging activity.
+ * Local engine implementation that manages workflow progression and state.
  *
- * Usage:
- * ```typescript
- * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
- * ```
- */
-class WriteLine extends Activity {
-    constructor() {
-        super('WriteLine');
-    }
-    async execute(input) {
-        const text = input.text || '';
-        if (text !== undefined && text !== null) {
-            console.log(`[WriteLine] ${text}`);
-        }
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var writeLine_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    WriteLine: WriteLine
-});
-
-/**
- * Sequence Activity - Executes activities in sequential order.
+ * 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 FrontendTaskExecutor.
+ * This engine only manages workflow progression and state storage.
  *
- * Usage:
- * ```typescript
- * const sequence = new Sequence();
- * sequence.activities = [activity1, activity2, activity3];
- * await sequence.execute({});
- * ```
+ * This is the DEFAULT engine provider. Applications can override it with
+ * an API-based engine implementation.
  */
-class Sequence extends Activity {
-    constructor() {
-        super('Sequence');
+class AXPWorkflowLocalEngine {
+    //#region ----   Services & Dependencies   ----
+    constructor(definitionLoaders = null) {
+        this.definitionLoaders = definitionLoaders;
+        //#endregion
+        //#region ----   Instance Storage   ----
         /**
-         * Activities to execute in sequence.
+         * In-memory storage for workflow instances.
+         * Key: instanceId
+         * Value: LocalWorkflowState
          */
-        this.activities = [];
-    }
-    async execute(input) {
-        // Execute all activities in sequence
-        for (const activity of this.activities) {
-            const result = await activity.execute(input);
-            if (!result.success) {
-                return {
-                    success: false,
-                    message: result.message,
-                    data: {
-                        output: undefined,
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
-            }
-        }
-        return this.createResult(undefined, 'Done');
+        this.instances = new Map();
+        /**
+         * Task token storage for secure resume operations.
+         * Key: taskToken
+         * Value: { instanceId, activityId }
+         */
+        this.taskTokens = new Map();
     }
-}
-
-var sequence_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Sequence: Sequence
-});
-
-/**
- * Show Confirm Dialog Activity - Displays confirmation dialog to user.
- *
- * Has two outcomes:
- * - 'Confirmed': User clicked confirm/yes
- * - 'Cancelled': User clicked cancel/no
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowConfirmDialog();
- * await dialog.execute({
- *   title: 'Confirm Delete',
- *   message: 'Are you sure?',
- *   color: 'danger'
- * });
- * ```
- */
-class ShowConfirmDialog extends Activity {
     //#endregion
-    constructor() {
-        super('ShowConfirmDialog');
-        //#region ----   Services & Dependencies   ----
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { title = '', message = '', color = 'primary', defaultAction = 'cancel', align = 'horizontal', backdrop = false } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            const confirmResult = await this.dialogService.confirm(translatedTitle, translatedMessage, color, align, backdrop, defaultAction);
-            const result = confirmResult.result;
-            const action = result ? 'confirm' : 'cancel';
-            return this.createResult({
-                result,
-                action
-            }, result ? 'Confirmed' : 'Cancelled');
-        }
-        catch (err) {
-            console.error('[ShowConfirmDialog] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show confirm dialog',
-                },
-                data: {
-                    output: {
-                        result: false,
-                        action: 'error',
-                    },
-                    outcomes: {
-                        Cancelled: true,
-                    },
-                },
-            };
-        }
+    //#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) {
+            throw new Error(`Workflow definition not found: ${request.workflowId}`);
+        }
+        // Initialize workflow state
+        const state = {
+            instanceId,
+            workflowId: request.workflowId,
+            status: 'running',
+            variables: {},
+            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,
+        };
     }
-}
-
-var showConfirmDialog_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowConfirmDialog: ShowConfirmDialog
-});
-
-/**
- * Show Alert Dialog Activity - Displays alert dialog to user.
- *
- * Has one outcome:
- * - 'Done': User clicked OK
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowAlertDialog();
- * await dialog.execute({
- *   title: 'Alert',
- *   message: 'This is an alert',
- *   color: 'info'
- * });
- * ```
- */
-class ShowAlertDialog extends Activity {
-    //#endregion
-    constructor() {
-        super('ShowAlertDialog');
-        //#region ----   Services & Dependencies   ----
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { title = '', message = '', color = 'primary' } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            await this.dialogService.alert(translatedTitle, translatedMessage, color);
-            return this.createResult({
-                result: true,
-                action: 'ok'
-            }, 'Done');
-        }
-        catch (err) {
-            console.error('[ShowAlertDialog] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show alert dialog',
-                },
-                data: {
-                    output: {
-                        result: false,
-                        action: 'error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
+    /**
+     * 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)
+        localState.activityResults.set(request.stepId, {
+            output: request.userInput || {},
+            outcome: request.outcome,
+        });
+        localState.completedActivities.add(request.stepId);
+        // Merge output/userInput into state variables
+        if (request.userInput) {
+            localState.state.variables = {
+                ...localState.state.variables,
+                ...(request.userInput || {}),
             };
         }
-    }
-}
-
-var showAlertDialog_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowAlertDialog: ShowAlertDialog
-});
-
-/**
- * Show Dialog Layout Builder Activity - Displays dialog using Layout Builder.
- *
- * This activity allows you to create custom dialogs using the Layout Builder API.
- * It accepts JSON-serializable content (AXPWidgetNode) and actions configuration.
- *
- * The content can be created using Layout Builder and then converted to JSON:
- * ```typescript
- * const builder = layoutBuilderService.create();
- * builder.flex(flex => {
- *   flex.setDirection('column')
- *     .formField('First Name', field => {
- *       field.path('firstName');
- *       field.textBox({ placeholder: 'Enter first name' });
- *     });
- * });
- * const contentNode = builder.build();
- * ```
- *
- * Usage in Workflow:
- * ```typescript
- * const dialog = new ShowDialogLayoutBuilder();
- * await dialog.execute({
- *   title: 'User Information',
- *   size: 'md',
- *   context: { firstName: '', lastName: '' },
- *   content: {
- *     type: 'flex-layout',
- *     mode: 'edit',
- *     options: {
- *       flexDirection: 'column',
- *       gap: '16px'
- *     },
- *     children: [
- *       {
- *         type: 'form-field',
- *         mode: 'edit',
- *         options: {
- *           label: 'First Name',
- *           showLabel: true
- *         },
- *         children: [{
- *           type: 'text-editor',
- *           path: 'firstName',
- *           options: {
- *             placeholder: 'Enter first name'
- *           }
- *         }]
- *       }
- *     ]
- *   },
- *   actions: {
- *     cancel: '@general:actions.cancel.title',
- *     submit: '@general:actions.submit.title',
- *     custom: [{
- *       title: 'Save Draft',
- *       icon: 'fa-save',
- *       color: 'secondary',
- *       command: { name: 'save-draft' }
- *     }]
- *   }
- * });
- * ```
- *
- * Usage in JSON Workflow Definition:
- * ```json
- * {
- *   "type": "ShowDialogLayoutBuilder",
- *   "properties": {
- *     "title": "User Information",
- *     "size": "md",
- *     "context": { "firstName": "", "lastName": "" },
- *     "content": {
- *       "type": "flex-layout",
- *       "mode": "edit",
- *       "options": {
- *         "flexDirection": "column",
- *         "gap": "16px"
- *       },
- *       "children": [
- *         {
- *           "type": "form-field",
- *           "mode": "edit",
- *           "options": {
- *             "label": "First Name",
- *             "showLabel": true
- *           },
- *           "children": [{
- *             "type": "text-editor",
- *             "path": "firstName",
- *             "options": {
- *               "placeholder": "Enter first name"
- *             }
- *           }]
- *         }
- *       ]
- *     },
- *     "actions": {
- *       "cancel": "@general:actions.cancel.title",
- *       "submit": "@general:actions.submit.title"
- *     }
- *   }
- * }
- * ```
- */
-class ShowDialogLayoutBuilder extends Activity {
-    //#endregion
-    constructor() {
-        super('ShowDialogLayoutBuilder');
-        //#region ----   Services & Dependencies   ----
-        this.layoutBuilder = inject(AXPLayoutBuilderService);
-    }
-    async execute(input) {
-        const { title = '', size = 'md', context = {}, closeButton = false, message, content, actions } = input;
-        try {
-            // Create dialog using layout builder
-            const dialogRef = await this.layoutBuilder
-                .create()
-                .dialog(dialog => {
-                // Set basic dialog options
-                dialog
-                    .setTitle(title)
-                    .setSize(size)
-                    .setCloseButton(closeButton)
-                    .setContext(context);
-                // Set message if provided
-                if (message) {
-                    dialog.setMessage(message);
-                }
-                // Set content if provided
-                if (content) {
-                    // If content is already a flex-layout, use it directly
-                    // Otherwise, wrap it in a flex container with column direction
-                    if (content.type === 'flex-layout') {
-                        // Set content layout directly (accessing internal state of DialogContainerBuilder)
-                        dialog.contentLayout = content;
-                    }
-                    else {
-                        // Wrap content in a flex container
-                        const wrappedContent = {
-                            type: 'flex-layout',
-                            mode: 'edit',
-                            options: {
-                                flexDirection: 'column',
-                                gap: '10px',
-                            },
-                            children: [content],
-                        };
-                        dialog.contentLayout = wrappedContent;
-                    }
-                }
-                // Set actions if provided
-                if (actions) {
-                    dialog.setActions(actionBuilder => {
-                        if (actions.cancel) {
-                            actionBuilder.cancel(actions.cancel);
-                        }
-                        if (actions.submit) {
-                            actionBuilder.submit(actions.submit);
-                        }
-                        if (actions.custom) {
-                            actions.custom.forEach(action => {
-                                actionBuilder.custom(action);
-                            });
-                        }
-                    });
-                }
-            })
-                .show();
-            // Get user action and context
-            const action = dialogRef.action() || 'cancel';
-            const dialogContext = dialogRef.context();
-            // Determine outcomes
-            const cancelled = action === 'cancel';
-            const confirmed = action === 'submit' || (!cancelled && action !== 'error');
-            // Close dialog
-            dialogRef.close();
-            // Return result with appropriate outcome
-            const outcome = cancelled ? 'Cancelled' : confirmed ? 'Confirmed' : 'Done';
-            return this.createResult({
-                context: dialogContext,
-                action,
-                cancelled,
-                confirmed
-            }, outcome);
-        }
-        catch (err) {
-            console.error('[ShowDialogLayoutBuilder] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show dialog',
-                },
-                data: {
-                    output: {
-                        context: {},
-                        action: 'error',
-                        cancelled: true,
-                        confirmed: false,
-                    },
-                    outcomes: {
-                        Error: true,
-                    },
-                },
-            };
+        // 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: { [request.outcome]: true },
+            state: localState.state,
+            nextTask: nextTask || null,
+        };
     }
-}
-
-/**
- * Show Toast Activity - Displays toast notification to user.
- *
- * Usage:
- * ```typescript
- * const toast = new ShowToast();
- * await toast.execute({
- *   color: 'success',
- *   title: 'Success',
- *   message: 'Operation completed successfully!'
- * });
- * ```
- */
-class ShowToast extends Activity {
-    constructor() {
-        super('ShowToast');
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { color = 'primary', title = '', message = '', duration = 3000 } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            await this.toastService.show({
-                color: color,
-                title: translatedTitle,
-                content: translatedMessage,
-                closeButton: true,
-                timeOut: duration,
-                timeOutProgress: true,
-            });
-            return this.createResult(undefined, 'Done');
+    /**
+     * 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}`);
         }
-        catch (err) {
-            console.error('[ShowToast] Error showing toast:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show toast',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        // 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;
     }
-}
-
-var showToast_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowToast: ShowToast
-});
-
-/**
- * Navigate Activity - Navigates to different pages/routes.
- *
- * Usage:
- * ```typescript
- * const navigate = new Navigate();
- * await navigate.execute({
- *   mode: 'route',
- *   route: '/users',
- *   params: { id: '123' }
- * });
- * ```
- */
-class Navigate extends Activity {
-    constructor() {
-        super('Navigate');
-        this.router = inject(Router);
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Get workflow definition from available loaders.
+     */
+    async getDefinition(workflowId) {
+        // Try all loaders in order
+        const loaders = this.definitionLoaders || [];
+        for (const loader of loaders) {
+            const definition = await loader.get(workflowId);
+            if (definition) {
+                return definition;
+            }
+        }
+        return null;
     }
-    async execute(input) {
-        const { mode = 'route', route = '', params = {}, queryParams = {}, entity = '', entityId = '', url = '' } = input;
-        try {
-            switch (mode) {
-                case 'route':
-                    await this.router.navigate([route], { queryParams });
-                    break;
-                case 'entity-details':
-                    const detailsRoute = `/entities/${entity}/details/${entityId}`;
-                    await this.router.navigate([detailsRoute], { queryParams });
-                    break;
-                case 'entity-list':
-                    const listRoute = `/entities/${entity}`;
-                    await this.router.navigate([listRoute], { queryParams });
-                    break;
-                case 'external':
-                    if (url) {
-                        window.open(url, '_blank');
-                    }
+    /**
+     * 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 flowchart = localState.definition.root;
+        const activities = flowchart.activities || [];
+        const connections = flowchart.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.activity;
+            const targetId = conn.target.activity;
+            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 (no incoming connections, or first activity)
+        let currentActivityId = localState.currentActivityId;
+        if (!currentActivityId) {
+            // Find root activity (no incoming connections)
+            for (const activity of activities) {
+                if (!incomingConnections.has(activity.id)) {
+                    currentActivityId = activity.id;
                     break;
-                default:
-                    console.error(`[Navigate] Unknown navigation mode: ${mode}`);
-                    return {
-                        success: false,
-                        message: {
-                            text: `Unknown navigation mode: ${mode}`,
-                        },
-                        data: {
-                            output: undefined,
-                            outcomes: {
-                                Failed: true,
-                            },
-                        },
-                    };
+                }
+            }
+            // If no root found, use first activity
+            if (!currentActivityId && activities.length > 0) {
+                currentActivityId = activities[0].id;
             }
-            return this.createResult(undefined, 'Done');
-        }
-        catch (err) {
-            console.error('[Navigate] Error navigating:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to navigate',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
         }
+        // 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;
+            }
+            // Determine execution mode
+            const executionMode = activity.executionMode || 'frontend';
+            // Handle backend activities: skip
+            if (executionMode === 'backend') {
+                console.log(`[WorkflowLocalEngine] ⏭️ Skipping backend activity: ${activity.type} (${activity.id})`);
+                localState.completedActivities.add(currentActivityId);
+                localState.activityResults.set(currentActivityId, {
+                    output: null,
+                    outcome: 'Done',
+                });
+                // Move to next activity
+                const nextId = this.getNextActivityId(currentActivityId, outgoingConnections, localState.activityResults);
+                currentActivityId = nextId ?? undefined;
+                continue;
+            }
+            // Handle frontend/both activities: return as pendingTask (do NOT execute)
+            if (executionMode === 'frontend' || executionMode === 'both') {
+                // Create task for external execution
+                const task = {
+                    taskToken: AXPDataGenerator.uuid(),
+                    activityId: activity.id,
+                    activityType: activity.type,
+                    activityName: activity.name ? activity.name : undefined,
+                    executionMode: executionMode,
+                    input: activity['properties'] || {},
+                    config: activity.customProperties || {},
+                };
+                // 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;
     }
-}
-
-var navigate_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Navigate: Navigate
-});
-
-/**
- * Set Variable Activity - Sets a variable value in workflow context.
- *
- * Usage:
- * ```typescript
- * const setVar = new SetVariable();
- * await setVar.execute({
- *   variableName: 'userId',
- *   value: '12345'
- * });
- * ```
- */
-class SetVariable extends Activity {
-    constructor() {
-        super('workflow-activity:set-variable', 'Set Variable');
-    }
-    async execute(input) {
-        const { variableName, value } = input;
-        try {
-            // In a real implementation, this would set the variable in workflow context
-            // For now, we'll just log it
-            console.log(`[SetVariable] Setting ${variableName} = ${JSON.stringify(value)}`);
-            return this.createResult(undefined, 'Done');
+    /**
+     * 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.activity;
+            }
         }
-        catch (err) {
-            console.error('[SetVariable] Error setting variable:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to set variable',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        // If no matching outcome, use first connection (default path)
+        if (connections.length > 0) {
+            return connections[0].target.activity;
         }
+        return null;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine, deps: [{ token: AXP_WORKFLOW_DEFINITION_LOADER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowLocalEngine, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AXP_WORKFLOW_DEFINITION_LOADER]
+                }] }] });
+
+// Workflow Runtime Services
 
-var setVariable_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    SetVariable: SetVariable
+const AXP_WORKFLOW_PROVIDER = new InjectionToken('AXP_WORKFLOW_PROVIDER', {
+    factory: () => [],
+});
+const AXP_WORKFLOW_CATEGORY_PROVIDER = new InjectionToken('AXP_WORKFLOW_CATEGORY_PROVIDER', {
+    factory: () => [],
 });
 
+//#region ----   Imports   ----
+//#endregion
 /**
- * Dispatch Event Activity - Dispatches an event to the system.
+ * Optimized Workflow Definition Service
  *
- * Usage:
- * ```typescript
- * const dispatch = new DispatchEvent();
- * await dispatch.execute({
- *   eventName: 'user-created',
- *   eventData: { userId: '123', name: 'John' }
- * });
- * ```
+ * 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 DispatchEvent extends Activity {
+class AXPWorkflowDefinitionService {
     constructor() {
-        super('DispatchEvent');
+        //#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();
     }
-    async execute(input) {
-        const { eventName, eventData } = input;
-        try {
-            // In a real implementation, this would dispatch the event through an event bus
-            // For now, we'll just log it
-            console.log(`[DispatchEvent] Dispatching event: ${eventName}`, eventData);
-            return this.createResult(undefined, 'Done');
+    //#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);
         }
-        catch (err) {
-            console.error('[DispatchEvent] Error dispatching event:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to dispatch event',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        // ✅ 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;
     }
-}
-
-var dispatchEvent_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    DispatchEvent: DispatchEvent
-});
-
-/**
- * If Activity - Conditional execution based on a condition.
- *
- * Usage:
- * ```typescript
- * const ifActivity = new If();
- * ifActivity.condition = '{{user.isAdmin}}';
- * ifActivity.thenActivities = [activity1, activity2];
- * ifActivity.elseActivities = [activity3];
- * ```
- */
-class If extends Activity {
-    constructor() {
-        super('If');
-    }
-    async execute(input) {
-        const { condition, thenActivities = [], elseActivities = [] } = input;
-        try {
-            // Evaluate condition (simplified - in real implementation, use expression evaluator)
-            const conditionResult = this.evaluateCondition(condition);
-            let result;
-            let activities;
-            if (conditionResult) {
-                activities = thenActivities;
-                result = { branch: 'then' };
+    /**
+     * 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;
             }
-            else {
-                activities = elseActivities;
-                result = { branch: 'else' };
+        }
+        // ✅ Load root categories if not loaded
+        if (!this.categoriesByParentId.has(undefined)) {
+            await this.getCategories();
+            if (this.categoriesById.has(categoryId)) {
+                return this.categoriesById.get(categoryId);
             }
-            // Execute activities in the chosen branch
-            for (const activity of activities) {
-                const activityResult = await activity.execute(input);
-                if (!activityResult.success) {
-                    return {
-                        success: false,
-                        message: activityResult.message,
-                        data: {
-                            output: { branch: conditionResult ? 'then' : 'else', failedActivity: activity },
-                            outcomes: {
-                                Failed: true,
-                            },
-                        },
-                    };
-                }
+        }
+        // ✅ 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`);
             }
-            return this.createResult(result, conditionResult ? 'Then' : 'Else');
+            path.unshift(category);
+            currentCategoryId = category.parentId;
         }
-        catch (err) {
-            console.error('[If] Error evaluating condition:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to evaluate condition',
-                },
-                data: {
-                    output: { branch: 'error' },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        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 definition metadata
+     */
+    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 metadata by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Workflow name (unique identifier)
+     * @returns Workflow definition metadata or undefined if not found
+     */
+    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;
     }
-    evaluateCondition(condition) {
-        if (typeof condition === 'boolean') {
-            return condition;
+    /**
+     * 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;
+            }
         }
-        if (typeof condition === 'string') {
-            // Simple evaluation - in real implementation, use proper expression evaluator
-            return condition === 'true' || condition === '1' || condition === 'yes';
+        // ✅ Try loading the workflow definition to find its category
+        const definition = await this.getWorkflowByName(workflowName);
+        if (definition && definition.category) {
+            // Try to find category by name/id
+            const categories = await this.getCategories();
+            const found = categories.find(cat => cat.id === definition.category || cat.title === definition.category);
+            if (found) {
+                return found.id;
+            }
         }
-        return false;
+        return undefined;
     }
-}
-
-var if_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    If: If
-});
-
-/**
- * While Activity - Loop execution while condition is true.
- *
- * Usage:
- * ```typescript
- * const whileActivity = new While();
- * whileActivity.condition = '{{counter < 10}}';
- * whileActivity.activities = [incrementActivity, logActivity];
- * ```
- */
-class While extends Activity {
-    constructor() {
-        super('While');
+    /**
+     * 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);
     }
-    async execute(input) {
-        const { condition, activities = [], maxIterations = 1000 } = input;
+    //#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 {
-            let iteration = 0;
-            let conditionResult = this.evaluateCondition(condition);
-            while (conditionResult && iteration < maxIterations) {
-                // Execute activities in the loop
-                for (const activity of activities) {
-                    const activityResult = await activity.execute(input);
-                    if (!activityResult.success) {
-                        return {
-                            success: false,
-                            message: activityResult.message,
-                            data: {
-                                output: {
-                                    iterations: iteration,
-                                    completed: false,
-                                },
-                                outcomes: {
-                                    Failed: true,
-                                },
-                            },
-                        };
+            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
                     }
                 }
-                iteration++;
-                conditionResult = this.evaluateCondition(condition);
             }
-            const result = {
-                iterations: iteration,
-                completed: iteration < maxIterations
-            };
-            return this.createResult(result, 'Done');
+            // ✅ Cache results for fast subsequent access
+            this.categoriesByParentId.set(parentId, categories);
+            categories.forEach(cat => this.categoriesById.set(cat.id, cat));
+            return categories;
         }
-        catch (err) {
-            console.error('[While] Error in loop execution:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed during loop execution',
-                },
-                data: {
-                    output: { iterations: 0, completed: false },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        finally {
+            this.pendingCategoriesRequests.delete(parentId);
         }
     }
-    evaluateCondition(condition) {
-        if (typeof condition === 'boolean') {
-            return condition;
-        }
-        if (typeof condition === 'string') {
-            // Simple evaluation - in real implementation, use proper expression evaluator
-            return condition === 'true' || condition === '1' || condition === 'yes';
+    /**
+     * 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];
         }
-        return false;
-    }
-}
-
-var while_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    While: While
-});
-
-/**
- * ForEach Activity - Iterates over a collection of items.
- *
- * Usage:
- * ```typescript
- * const forEach = new ForEach();
- * await forEach.execute({
- *   items: ['item1', 'item2', 'item3'],
- *   activities: [processItemActivity]
- * });
- * ```
- */
-class ForEach extends Activity {
-    constructor() {
-        super('ForEach');
+        // Ownership unknown - will query all providers (fallback)
+        return null;
     }
-    async execute(input) {
-        const { items = [], activities = [], itemVariableName = 'currentItem', indexVariableName = 'currentIndex' } = input;
+    /**
+     * 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 results = [];
-            for (let index = 0; index < items.length; index++) {
-                const currentItem = items[index];
-                // Create context with current item and index
-                const itemContext = {
-                    ...input,
-                    [itemVariableName]: currentItem,
-                    [indexVariableName]: index
-                };
-                // Execute activities for current item
-                for (const activity of activities) {
-                    const activityResult = await activity.execute(itemContext);
-                    if (!activityResult.success) {
-                        return {
-                            success: false,
-                            message: activityResult.message,
-                            data: {
-                                output: {
-                                    totalItems: items.length,
-                                    processedItems: results.length,
-                                    results,
-                                },
-                                outcomes: {
-                                    Failed: true,
-                                },
-                            },
-                        };
+            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
                     }
                 }
-                results.push({
-                    item: currentItem,
-                    index,
-                    processed: true
-                });
             }
-            const result = {
-                totalItems: items.length,
-                processedItems: results.length,
-                results
-            };
-            return this.createResult(result, 'Done');
+            // ✅ 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;
         }
-        catch (err) {
-            console.error('[ForEach] Error in iteration:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed during iteration',
-                },
-                data: {
-                    output: { totalItems: 0, processedItems: 0, results: [] },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        finally {
+            this.pendingWorkflowsRequests.delete(categoryId);
         }
     }
-}
-
-var forEach_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ForEach: ForEach
-});
-
-/**
- * Execute Command Activity - Executes a command through Command Bus.
- *
- * Usage:
- * ```typescript
- * const executeCmd = new ExecuteCommand();
- * await executeCmd.execute({
- *   commandKey: 'UserManagement.CreateUser',
- *   input: { name: 'John', email: 'john@example.com' }
- * });
- * ```
- */
-class ExecuteCommand extends Activity {
-    constructor() {
-        super('workflow-activity:execute-command', 'Execute Command');
-        this.commandService = inject(AXPCommandService);
-    }
-    async execute(input) {
-        const { commandKey, input: commandInput = {} } = input;
+    /**
+     * Load single workflow definition from providers and cache result
+     */
+    async loadWorkflowFromProviders(name) {
         try {
-            // Check if command exists
-            if (!this.commandService.exists(commandKey)) {
-                console.warn(`[ExecuteCommand] Command '${commandKey}' is not registered. Simulating execution.`);
-                // Simulate command execution for unregistered commands
-                const result = {
-                    commandKey,
-                    success: true,
-                    output: commandInput,
-                    executedAt: new Date().toISOString(),
-                    simulated: true
-                };
-                return this.createResult(result, 'Done');
-            }
-            // Execute command through Command Bus
-            const result = await this.commandService.execute(commandKey, commandInput);
-            if (!result) {
-                return {
-                    success: false,
-                    message: {
-                        text: `Command '${commandKey}' returned no result`,
-                    },
-                    data: {
-                        output: {
-                            commandKey,
-                            success: false,
-                            executedAt: new Date().toISOString(),
-                        },
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
+            const resolvedProviders = await Promise.allSettled(this.workflowProviders);
+            // Try providers first
+            for (const p of resolvedProviders) {
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getById === 'function') {
+                    try {
+                        const result = await p.value.getById(name);
+                        if (result) {
+                            this.workflowsByName.set(name, result);
+                            return result;
+                        }
+                    }
+                    catch {
+                        // Continue on error
+                    }
+                }
             }
-            if (!result.success) {
-                return {
-                    success: false,
-                    message: result.message,
-                    data: {
-                        output: {
-                            commandKey,
-                            success: false,
-                            executedAt: new Date().toISOString(),
-                            error: result.message?.text,
-                        },
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
+            // 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 this.createResult({
-                commandKey,
-                success: true,
-                output: result.data,
-                executedAt: new Date().toISOString(),
-            }, 'Done');
+            return undefined;
         }
-        catch (err) {
-            console.error('[ExecuteCommand] Error executing command:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Unknown error',
-                },
-                data: {
-                    output: {
-                        commandKey,
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Unknown error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
+        finally {
+            this.pendingWorkflowRequests.delete(name);
         }
     }
-}
-
-var executeCommand_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ExecuteCommand: ExecuteCommand
-});
-
-/**
- * Execute Query Activity - Executes a query through Query Bus.
- *
- * Usage:
- * ```typescript
- * const executeQuery = new ExecuteQuery();
- * await executeQuery.execute({
- *   queryKey: 'UserManagement.GetUsers',
- *   input: { page: 1, pageSize: 10 }
- * });
- * ```
- */
-class ExecuteQuery extends Activity {
-    constructor() {
-        super('workflow-activity:execute-query', 'Execute Query');
-        this.queryService = inject(AXPQueryService);
-    }
-    async execute(input) {
-        const { queryKey, input: queryInput = {} } = input;
-        try {
-            // Check if query exists
-            if (!this.queryService.exists(queryKey)) {
-                console.warn(`[ExecuteQuery] Query '${queryKey}' is not registered. Simulating execution.`);
-                // Simulate query execution for unregistered queries
-                const result = {
-                    queryKey,
-                    success: true,
-                    data: [],
-                    totalCount: 0,
-                    executedAt: new Date().toISOString(),
-                    simulated: true
-                };
-                return this.createResult(result, 'Done');
+    /**
+     * 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);
+                }
             }
-            // Execute query through Query Bus
-            const result = await this.queryService.fetch(queryKey, queryInput);
-            return this.createResult({
-                queryKey,
-                success: true,
-                data: result,
-                totalCount: Array.isArray(result) ? result.length : (result?.totalCount || 0),
-                executedAt: new Date().toISOString()
-            }, 'Done');
-        }
-        catch (err) {
-            console.error('[ExecuteQuery] Error executing query:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Unknown error',
-                },
-                data: {
-                    output: {
-                        queryKey,
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Unknown error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
         }
+        return undefined;
     }
-}
-
-var executeQuery_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ExecuteQuery: ExecuteQuery
-});
-
-/**
- * Start Activity - Marks the start point of a workflow.
- *
- * This is a visual marker activity that doesn't perform any actual work.
- * It's used in workflow designers to clearly indicate where a workflow begins.
- *
- * Usage:
- * ```typescript
- * const start = new StartActivity();
- * await start.execute({});
- * ```
- */
-class StartActivity extends Activity {
-    constructor() {
-        super('StartActivity');
+    //#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;
     }
-    async execute(input) {
-        // This activity is a visual marker only
-        // It immediately completes and allows workflow to proceed
-        console.log('[StartActivity] Workflow started');
-        return this.createResult(undefined, 'Done');
+    /**
+     * Check if category has workflows (uses cached count)
+     */
+    categoryHasWorkflows(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? (category.itemsCount ?? 0) > 0 : false;
     }
-}
-
-var startActivity_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    StartActivity: StartActivity
-});
-
-/**
- * End Activity - Marks the end point of a workflow.
- *
- * This is a visual marker activity that terminates the workflow execution.
- * When this activity is reached, the workflow completes successfully.
- *
- * Usage:
- * ```typescript
- * const end = new EndActivity();
- * await end.execute({});
- * ```
- */
-class EndActivity extends Activity {
-    constructor() {
-        super('EndActivity');
+    /**
+     * 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();
     }
-    async execute(input) {
-        // This activity marks the end of workflow execution
-        console.log('[EndActivity] Workflow completed');
-        return this.createResult(undefined, 'Done');
+    /**
+     * 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: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, providedIn: 'root' }); }
 }
-
-var endActivity_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    EndActivity: EndActivity
-});
-
-/**
- * Command setups for all built-in workflow activities.
- * Registers activities as AXPCommand instances.
- */
-const provideWorkflowActivityCommands = () => provideCommandSetups([
-    // Workflow Markers
-    {
-        key: 'workflow-activity:start',
-        command: () => Promise.resolve().then(function () { return startActivity_activity; }).then(m => m.StartActivity),
-    },
-    {
-        key: 'workflow-activity:end',
-        command: () => Promise.resolve().then(function () { return endActivity_activity; }).then(m => m.EndActivity),
-    },
-    // Console Activities
-    {
-        key: 'workflow-activity:write-line',
-        command: () => Promise.resolve().then(function () { return writeLine_activity; }).then(m => m.WriteLine),
-    },
-    // Control Flow Activities
-    {
-        key: 'workflow-activity:sequence',
-        command: () => Promise.resolve().then(function () { return sequence_activity; }).then(m => m.Sequence),
-    },
-    {
-        key: 'workflow-activity:if',
-        command: () => Promise.resolve().then(function () { return if_activity; }).then(m => m.If),
-    },
-    {
-        key: 'workflow-activity:while',
-        command: () => Promise.resolve().then(function () { return while_activity; }).then(m => m.While),
-    },
-    {
-        key: 'workflow-activity:for-each',
-        command: () => Promise.resolve().then(function () { return forEach_activity; }).then(m => m.ForEach),
-    },
-    // Dialog Activities
-    {
-        key: 'workflow-activity:show-confirm-dialog',
-        command: () => Promise.resolve().then(function () { return showConfirmDialog_activity; }).then(m => m.ShowConfirmDialog),
-    },
-    {
-        key: 'workflow-activity:show-alert-dialog',
-        command: () => Promise.resolve().then(function () { return showAlertDialog_activity; }).then(m => m.ShowAlertDialog),
-    },
-    // Notification Activities
-    {
-        key: 'workflow-activity:show-toast',
-        command: () => Promise.resolve().then(function () { return showToast_activity; }).then(m => m.ShowToast),
-    },
-    // Event Activities
-    {
-        key: 'workflow-activity:dispatch-event',
-        command: () => Promise.resolve().then(function () { return dispatchEvent_activity; }).then(m => m.DispatchEvent),
-    },
-    // Variable Activities
-    {
-        key: 'workflow-activity:set-variable',
-        command: () => Promise.resolve().then(function () { return setVariable_activity; }).then(m => m.SetVariable),
-    },
-    // Command & Query Activities
-    {
-        key: 'workflow-activity:execute-command',
-        command: () => Promise.resolve().then(function () { return executeCommand_activity; }).then(m => m.ExecuteCommand),
-    },
-    {
-        key: 'workflow-activity:execute-query',
-        command: () => Promise.resolve().then(function () { return executeQuery_activity; }).then(m => m.ExecuteQuery),
-    },
-    // Navigation Activities
-    {
-        key: 'workflow-activity:navigate',
-        command: () => Promise.resolve().then(function () { return navigate_activity; }).then(m => m.Navigate),
-    },
-]);
-
-// Built-in Activities
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 // Workflow Definition Types (Storage/Database)
 
@@ -2404,7 +1966,6 @@ class AXPWorkflowModule {
         return {
             ngModule: AXPWorkflowModule,
             providers: [
-                provideWorkflowActivityCommands(),
                 {
                     provide: 'AXPWorkflowModuleFactory',
                     useFactory: (registry) => () => {
@@ -2479,8 +2040,6 @@ class AXPWorkflowModule {
      * @ignore
      */
     constructor(instances) {
-        // Inject AXP_COMMAND_SETUP to trigger command registration factory
-        this._commandSetup = inject(AXP_COMMAND_SETUP, { optional: true });
         instances?.forEach((f) => {
             f();
         });
@@ -2488,7 +2047,12 @@ class AXPWorkflowModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, providers: [
-            provideWorkflowActivityCommands(),
+            AXPWorkflowLocalEngine,
+            {
+                provide: AXP_WORKFLOW_ENGINE,
+                useExisting: AXPWorkflowLocalEngine,
+            },
+            AXPWorkflowManager,
         ] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, decorators: [{
@@ -2498,7 +2062,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                     exports: [],
                     declarations: [],
                     providers: [
-                        provideWorkflowActivityCommands(),
+                        AXPWorkflowLocalEngine,
+                        {
+                            provide: AXP_WORKFLOW_ENGINE,
+                            useExisting: AXPWorkflowLocalEngine,
+                        },
+                        AXPWorkflowManager,
                     ],
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
@@ -2512,5 +2081,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_PROVIDER, FrontendTaskExecutor, createWorkFlowEvent, ofType };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map