@acorex/platform 20.6.0-next.0 → 20.6.0-next.2

package/fesm2022/acorex-platform-workflow.mjs

@@ -1,8 +1,13 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, Optional, Inject, NgModule } from '@angular/core';
+import { Injectable, inject, InjectionToken, Optional, SkipSelf, 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 { AXToastService } from '@acorex/components/toast';
+import { Router } from '@angular/router';
 
 class AXPWorkflowError extends Error {
     constructor(message, inner = null) {
@@ -22,10 +27,10 @@ class AXPWorkflowEventService {
     get events$() {
         return this.eventSubject.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -115,10 +120,10 @@ class AXPWorkflowRegistryService {
             });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -157,17 +162,17 @@ class AXPWorkflowAction {
     dispatch(event) {
         this.eventService.dispatch(event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowAction, decorators: [{
             type: Injectable
         }] });
 class AXPWorkflowFunction {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowFunction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowFunction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
             type: Injectable
         }] });
 function createWorkFlowEvent(type) {
@@ -183,10 +188,10 @@ class AXPWorkflowDecideAction extends AXPWorkflowAction {
     async execute(context) {
         // its a fake action
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowDecideAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowDecideAction, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowDecideAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowDecideAction, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowDecideAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -372,10 +377,10 @@ class AXPWorkflowService {
         }
         return this.injector.get(functionType);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -400,21 +405,1456 @@ class AXPStartWorkflowAction extends AXPWorkflowAction {
             throw e;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
+/**
+ * Base abstract class for activities.
+ * Extend this to create custom activities.
+ */
+class Activity {
+    constructor(type, name) {
+        this.type = type;
+        this.name = name;
+    }
+    /**
+     * Helper method that returns Done outcome by default.
+     */
+    createResult(output, outcome = 'Done') {
+        return {
+            output,
+            outcomes: { [outcome]: true }
+        };
+    }
+}
+/**
+ * Activity registry for registering and creating activities.
+ */
+class ActivityRegistry {
+    constructor() {
+        this.registry = new Map();
+        this.descriptors = new Map();
+    }
+    /**
+     * Register an activity type.
+     */
+    register(type, factory, descriptor) {
+        this.registry.set(type, factory);
+        this.descriptors.set(type, descriptor);
+    }
+    /**
+     * Create an activity instance.
+     */
+    create(type) {
+        const factory = this.registry.get(type);
+        if (!factory) {
+            throw new Error(`Unknown activity type: ${type}`);
+        }
+        return factory();
+    }
+    /**
+     * Get activity descriptor.
+     */
+    getDescriptor(type) {
+        return this.descriptors.get(type);
+    }
+    /**
+     * Get all registered types.
+     */
+    getTypes() {
+        return Array.from(this.registry.keys());
+    }
+    /**
+     * Get all descriptors.
+     */
+    getAllDescriptors() {
+        return Array.from(this.descriptors.values());
+    }
+    /**
+     * Get descriptors by category.
+     */
+    getDescriptorsByCategory(category) {
+        return this.getAllDescriptors().filter(d => d.category === category);
+    }
+}
+
+/**
+ * Injection token for activity providers.
+ */
+const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER');
+/**
+ * Activity Provider Service.
+ * Collects all activity providers and manages activity registration.
+ */
+class AXPActivityProviderService {
+    constructor() {
+        this.activityDescriptors = new Map();
+        this.categories = [];
+        this.providers = [];
+        this.categoryProviders = [];
+        this.initialized = false;
+        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);
+        }
+    }
+    /**
+     * Initialize all providers.
+     */
+    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);
+        }
+        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;
+            }
+            // Get command loader from registry
+            const loader = this.commandRegistry.getLoader(key);
+            if (!loader) {
+                return null;
+            }
+            // Create command instance
+            const command = await loader();
+            return command;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    // ============================================
+    // 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.10", ngImport: i0, type: AXPActivityProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPActivityProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPActivityProviderService, 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.10", 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.10", ngImport: i0, type: AXPActivityCategoryProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", 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.10", ngImport: i0, type: AXPWorkflowExecutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowExecutionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowExecutionService, decorators: [{
+            type: Injectable
+        }] });
+
+//#endregion
+/**
+ * Production Workflow Coordinator.
+ *
+ * Separates frontend/backend execution:
+ * - Frontend activities: Execute with AXPCommand in browser
+ * - Backend activities: Execute via API calls to backend
+ * - State caching: Caches workflow state in client for performance
+ *
+ * ✅ Suitable for production use.
+ */
+class WorkflowCoordinator {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.workflowExecutionService = inject(AXPWorkflowExecutionService);
+        this.commandService = inject(AXPCommandService);
+        //#endregion
+        //#region ----   State Cache (Client-side for Performance)   ----
+        /**
+         * Cache workflow states in memory for quick access.
+         * Key: executionId
+         * Value: AXPWorkflowExecutionState
+         */
+        this.stateCache = new Map();
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Start workflow execution in backend.
+     *
+     * Backend decides what to do: returns pendingTask or indicates completion.
+     * Frontend only calls API - no business logic here.
+     *
+     * @param workflowId - Workflow ID
+     * @param input - Initial input data
+     * @returns Execution result with pendingTask (if any)
+     *
+     * @example
+     * ```typescript
+     * const result = await coordinator.startWorkflow('my-workflow', { userId: '123' });
+     *
+     * if (result.pendingTask) {
+     *   // Execute task if frontend, or wait for backend to complete
+     *   if (result.pendingTask.executionMode === 'frontend') {
+     *     await coordinator.executeTask(result.pendingTask);
+     *     await coordinator.completeTask(result.executionId, result.pendingTask, outcome, output);
+     *   }
+     * }
+     * ```
+     */
+    async startWorkflow(workflowId, input = {}) {
+        try {
+            const execution = await this.startWorkflowExecution(workflowId, input);
+            return {
+                success: true,
+                output: execution.state.output,
+                nextTask: execution.pendingTask || null,
+                executionId: execution.executionId,
+                state: execution.state
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to start workflow',
+                nextTask: null
+            };
+        }
+    }
+    /**
+     * Execute a frontend task using AXPCommand.
+     *
+     * Only executes if task.executionMode is 'frontend' or 'both'.
+     * Backend tasks are handled automatically by backend.
+     *
+     * @param task - Task to execute
+     * @returns Execution result with output and outcome
+     */
+    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);
+    }
+    /**
+     * Complete a task and get next task from backend.
+     *
+     * Sends task result to backend API.
+     * Backend decides: next task, fail, or complete workflow.
+     *
+     * @param executionId - Execution ID
+     * @param task - Completed task
+     * @param outcome - Task outcome (e.g., 'Done', 'Confirmed', 'Cancelled')
+     * @param output - Task output/result
+     * @returns Next task from backend (if any)
+     */
+    async completeTask(executionId, task, outcome, output) {
+        try {
+            // Send result to backend - backend decides next step
+            const response = await this.workflowExecutionService.resumeExecution({
+                executionId,
+                stepId: task.activityId,
+                outcome,
+                userInput: output
+            });
+            // Update cache
+            if (response.state) {
+                this.stateCache.set(executionId, response.state);
+            }
+            return {
+                success: true,
+                output: response.output,
+                nextTask: response.nextTask || null,
+                executionId,
+                state: response.state
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to complete task',
+                nextTask: null
+            };
+        }
+    }
+    /**
+     * 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).
+     *
+     * Backend determines nextStep based on outcome and outcomeConnections.
+     * Client only provides executionId, stepId, outcome, and optional userInput.
+     *
+     * @param executionId - Workflow execution 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
+     */
+    async resumeWorkflow(executionId, stepId, outcome, userInput) {
+        try {
+            // Backend handles everything: checks outcomeConnections and determines nextStep
+            const response = await this.workflowExecutionService.resumeExecution({
+                executionId,
+                stepId,
+                outcome,
+                userInput
+            });
+            // Update cache with state from backend
+            if (response.state) {
+                this.stateCache.set(executionId, response.state);
+            }
+            return {
+                success: true,
+                output: response.output,
+                nextTask: response.nextTask || null, // Backend determines this from outcomeConnections
+                executionId,
+                state: response.state
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to resume workflow',
+                nextTask: null
+            };
+        }
+    }
+    /**
+     * Get workflow execution state (from cache or backend).
+     */
+    async getWorkflowState(executionId) {
+        // Check cache first
+        const cached = this.stateCache.get(executionId);
+        if (cached) {
+            // Cache is valid for 5 minutes
+            const cacheAge = Date.now() - cached.lastUpdated.getTime();
+            if (cacheAge < 5 * 60 * 1000) {
+                return cached;
+            }
+        }
+        // Fetch from backend
+        try {
+            const state = await this.workflowExecutionService.getExecutionState({
+                executionId
+            });
+            // Update cache
+            this.stateCache.set(executionId, state);
+            return state;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Start step-based execution (only current step, not full workflow).
+     *
+     * Use this when you only need to execute one step at a time.
+     * Perfect for form-based workflows where user interacts with forms.
+     *
+     * @param workflowId - Workflow ID
+     * @param stepId - Initial step ID to execute
+     * @param input - Initial input data
+     * @returns Execution info with executionId and initial state
+     *
+     * @example
+     * ```typescript
+     * // Start login form step
+     * const execution = await coordinator.startStepExecution(
+     *   'login-workflow',
+     *   'login-form-step',
+     *   {}
+     * );
+     *
+     * // Save executionId for resume after refresh
+     * localStorage.setItem('execution-id', execution.executionId);
+     * ```
+     */
+    async startStepExecution(workflowId, stepId, input = {}) {
+        // Start workflow execution in backend
+        const execution = await this.startWorkflowExecution(workflowId, input);
+        // Update state with current step
+        const stateWithStep = {
+            ...execution.state,
+            currentStepId: stepId,
+            status: 'running'
+        };
+        // Update cache
+        this.stateCache.set(execution.executionId, stateWithStep);
+        return {
+            executionId: execution.executionId,
+            state: stateWithStep
+        };
+    }
+    /**
+     * Get next task from backend after backend task completion.
+     *
+     * Use this when backend task completes - backend will return next task.
+     * For frontend tasks, use executeTask + completeTask instead.
+     *
+     * @param executionId - Execution ID
+     * @returns Next task from backend (if any)
+     */
+    async getNextTask(executionId) {
+        try {
+            // Backend handles everything: executes backend tasks and returns next task
+            const response = await this.workflowExecutionService.executeCurrentStep({
+                executionId
+            });
+            // Update cache
+            if (response.state) {
+                this.stateCache.set(executionId, response.state);
+            }
+            return {
+                success: true,
+                output: response.output,
+                nextTask: response.nextTask || null,
+                executionId,
+                state: response.state
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to get next task',
+                nextTask: 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
+            if (!this.commandService.exists(task.activityType)) {
+                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}
+            const result = await this.commandService.execute(task.activityType, task.input || task.config || {});
+            // Extract outcome from outcomes (usually 'Done' or first key)
+            let outcome = 'Done';
+            if (result?.outcomes) {
+                // Prefer 'Done' if exists, otherwise use first outcome key
+                outcome = result.outcomes['Done'] ? 'Done' : Object.keys(result.outcomes)[0] || 'Done';
+            }
+            return {
+                output: result?.output || result,
+                outcome
+            };
+        }
+        catch (error) {
+            console.error(`[WorkflowCoordinator] Error executing frontend activity '${task.activityType}':`, error);
+            return {
+                output: { error: error.message || 'Unknown error' },
+                outcome: 'Failed'
+            };
+        }
+    }
+    /**
+     * 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.10", ngImport: i0, type: WorkflowCoordinator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: WorkflowCoordinator, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: WorkflowCoordinator, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Types and interfaces for Workflow Execution Service.
+ */
+
+// Production Workflow Coordinator (Frontend/Backend Separation)
+
+/**
+ * WriteLine Activity - Simple console logging activity.
+ *
+ * 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.
+ *
+ * Usage:
+ * ```typescript
+ * const sequence = new Sequence();
+ * sequence.activities = [activity1, activity2, activity3];
+ * await sequence.execute({});
+ * ```
+ */
+class Sequence extends Activity {
+    constructor() {
+        super('Sequence');
+        /**
+         * Activities to execute in sequence.
+         */
+        this.activities = [];
+    }
+    async execute(input) {
+        // Execute all activities in sequence
+        for (const activity of this.activities) {
+            await activity.execute(input);
+        }
+        return this.createResult(undefined, 'Done');
+    }
+}
+
+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 this.createResult({
+                result: false,
+                action: 'error'
+            }, 'Cancelled');
+        }
+    }
+}
+
+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 this.createResult({
+                result: false,
+                action: 'error'
+            }, 'Done');
+        }
+    }
+}
+
+var showAlertDialog_activity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ShowAlertDialog: ShowAlertDialog
+});
+
+/**
+ * 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');
+        }
+        catch (err) {
+            console.error('[ShowToast] Error showing toast:', err);
+            return this.createResult(undefined, 'Error');
+        }
+    }
+}
+
+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);
+    }
+    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');
+                    }
+                    break;
+                default:
+                    console.error(`[Navigate] Unknown navigation mode: ${mode}`);
+                    return this.createResult(undefined, 'Error');
+            }
+            return this.createResult(undefined, 'Done');
+        }
+        catch (err) {
+            console.error('[Navigate] Error navigating:', err);
+            return this.createResult(undefined, 'Error');
+        }
+    }
+}
+
+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');
+        }
+        catch (err) {
+            console.error('[SetVariable] Error setting variable:', err);
+            return this.createResult(undefined, 'Error');
+        }
+    }
+}
+
+var setVariable_activity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SetVariable: SetVariable
+});
+
+/**
+ * Dispatch Event Activity - Dispatches an event to the system.
+ *
+ * Usage:
+ * ```typescript
+ * const dispatch = new DispatchEvent();
+ * await dispatch.execute({
+ *   eventName: 'user-created',
+ *   eventData: { userId: '123', name: 'John' }
+ * });
+ * ```
+ */
+class DispatchEvent extends Activity {
+    constructor() {
+        super('DispatchEvent');
+    }
+    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');
+        }
+        catch (err) {
+            console.error('[DispatchEvent] Error dispatching event:', err);
+            return this.createResult(undefined, 'Error');
+        }
+    }
+}
+
+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' };
+            }
+            else {
+                activities = elseActivities;
+                result = { branch: 'else' };
+            }
+            // Execute activities in the chosen branch
+            for (const activity of activities) {
+                await activity.execute(input);
+            }
+            return this.createResult(result, conditionResult ? 'Then' : 'Else');
+        }
+        catch (err) {
+            console.error('[If] Error evaluating condition:', err);
+            return this.createResult({ branch: 'error' }, 'Error');
+        }
+    }
+    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';
+        }
+        return false;
+    }
+}
+
+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');
+    }
+    async execute(input) {
+        const { condition, activities = [], maxIterations = 1000 } = input;
+        try {
+            let iteration = 0;
+            let conditionResult = this.evaluateCondition(condition);
+            while (conditionResult && iteration < maxIterations) {
+                // Execute activities in the loop
+                for (const activity of activities) {
+                    await activity.execute(input);
+                }
+                iteration++;
+                conditionResult = this.evaluateCondition(condition);
+            }
+            const result = {
+                iterations: iteration,
+                completed: iteration < maxIterations
+            };
+            return this.createResult(result, 'Done');
+        }
+        catch (err) {
+            console.error('[While] Error in loop execution:', err);
+            return this.createResult({ iterations: 0, completed: false }, 'Error');
+        }
+    }
+    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';
+        }
+        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');
+    }
+    async execute(input) {
+        const { items = [], activities = [], itemVariableName = 'currentItem', indexVariableName = 'currentIndex' } = input;
+        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) {
+                    await activity.execute(itemContext);
+                }
+                results.push({
+                    item: currentItem,
+                    index,
+                    processed: true
+                });
+            }
+            const result = {
+                totalItems: items.length,
+                processedItems: results.length,
+                results
+            };
+            return this.createResult(result, 'Done');
+        }
+        catch (err) {
+            console.error('[ForEach] Error in iteration:', err);
+            return this.createResult({ totalItems: 0, processedItems: 0, results: [] }, 'Error');
+        }
+    }
+}
+
+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;
+        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);
+            return this.createResult({
+                commandKey,
+                success: true,
+                output: result,
+                executedAt: new Date().toISOString()
+            }, 'Done');
+        }
+        catch (err) {
+            console.error('[ExecuteCommand] Error executing command:', err);
+            return this.createResult({
+                commandKey,
+                success: false,
+                error: err instanceof Error ? err.message : 'Unknown error'
+            }, 'Failed');
+        }
+    }
+}
+
+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');
+            }
+            // 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 this.createResult({
+                queryKey,
+                success: false,
+                error: err instanceof Error ? err.message : 'Unknown error'
+            }, 'Failed');
+        }
+    }
+}
+
+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');
+    }
+    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');
+    }
+}
+
+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');
+    }
+    async execute(input) {
+        // This activity marks the end of workflow execution
+        console.log('[EndActivity] Workflow completed');
+        return this.createResult(undefined, 'Done');
+    }
+}
+
+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
+
+// Workflow Definition Types (Storage/Database)
+
 class AXPWorkflowModule {
     static forRoot(config) {
         return {
             ngModule: AXPWorkflowModule,
             providers: [
+                provideWorkflowActivityCommands(),
                 {
                     provide: 'AXPWorkflowModuleFactory',
                     useFactory: (registry) => () => {
@@ -451,6 +1891,8 @@ class AXPWorkflowModule {
         return {
             ngModule: AXPWorkflowModule,
             providers: [
+                // Built-in activities are already registered in forRoot via @NgModule providers
+                // No need to register again in forChild
                 {
                     provide: 'AXPWorkflowModuleFactory',
                     useFactory: (registry) => () => {
@@ -487,21 +1929,27 @@ 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();
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", 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.4", ngImport: i0, type: AXPWorkflowModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", 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.10", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowModule, providers: [
+            provideWorkflowActivityCommands(),
+        ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXPWorkflowModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
                     exports: [],
                     declarations: [],
-                    providers: [],
+                    providers: [
+                        provideWorkflowActivityCommands(),
+                    ],
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Optional
@@ -514,5 +1962,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, createWorkFlowEvent, ofType };
+export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map