@acorex/modules 21.0.0-next.65 → 21.0.0-next.67

package/fesm2022/acorex-modules-workflow-management.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { Injectable, inject, NgModule, Injector, runInInjectionContext, makeEnvironmentProviders, InjectionToken, Inject } from '@angular/core';
 import { AXPCommonMenuKeys, AXPWidgetsList } from '@acorex/modules/common';
 import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPEntityService, AXPEntityFormBuilderService, AXPEntityDefinitionRegistryService, entityDetailsCrudActions, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_DEFINITION_LOADER, AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD } from '@acorex/platform/layout/entity';
+import { AXPEntityService, AXPEntityFormBuilderService, AXPEntityDefinitionRegistryService, entityDetailsCrudActions, actionExists, ensureListActions, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_DEFINITION_LOADER, AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD } from '@acorex/platform/layout/entity';
 import { firstValueFrom } from 'rxjs';
 import { AXMCalendarManagementModule } from '@acorex/modules/calendar-management';
 import { AXPEntityCommandScope, AXPStatusProvider, AXPSystemStatusType, systemStatusToDefinition, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER, AXPSettingsService, AXPStatusDefinitionProviderService, AXPRegionalSetting, AXPSystemStatuses } from '@acorex/platform/common';
@@ -13,12 +13,12 @@ import { AXPWidgetGroupEnum, AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetSerialization
 import { AXPBarChartWidget, AXPHeatmapChartWidget, AXPDonutChartWidget, AXPLineChartWidget, AXPGaugeChartWidget, AXPFunnelChartWidget, AXPKpiDetailsWidget, AXPKpiProgressWidget, AXPKpiSegmentedWidget, AXPKpiStatCardWidget } from '@acorex/modules/dashboard-management';
 import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/layout/widgets';
 import { provideCommandSetups } from '@acorex/platform/runtime';
-import { AXPWorkflowDefinitionService, AXP_WORKFLOW_ENGINE, AXPWorkflowManager, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_ERROR_CODES, axpIsWorkflowTaskBoardActivityType, AXP_WORKFLOW_PROVIDER, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK } from '@acorex/platform/workflow';
+import { AXPWorkflowDefinitionService, axpShouldOfferWorkflowContinuationAfterStep, axpIsWorkflowInlineFrontendTask, axpResolveWorkflowContinuationBeforeInteractive, axpShouldSkipBeforeInteractiveFromMetadata, AXP_WORKFLOW_ENGINE, AXPWorkflowManager, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_ERROR_CODES, axpIsWorkflowTaskBoardActivityType, AXP_WORKFLOW_PROVIDER, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK } from '@acorex/platform/workflow';
 import { AXDialogService } from '@acorex/components/dialog';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPopupService } from '@acorex/components/popup';
 import { AXPDialogRendererComponent, AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
-import { cloneDeep } from 'lodash-es';
+import { cloneDeep, isString, trim, isEmpty, defaultTo } from 'lodash-es';
 import { AXToastService } from '@acorex/components/toast';
 import { AXP_WORKFLOW_TASK_PROVIDER, AXPWorkflowTaskProvider, matchesTaskBoardAssigneeUserIdsFilter, filterTasksOverlappingRange } from '@acorex/modules/task-management';
 import { AXFormatService } from '@acorex/core/format';
@@ -37,6 +37,11 @@ const RootConfig = {
         title: '@workflow-management:module.title',
         icon: 'fa-light fa-diagram-project',
     },
+    /** Task-board suspend activity type ids (match activity definition keys). */
+    activities: {
+        humanTask: 'workflow-activity:human-task',
+        cartable: 'workflow-activity:cartable',
+    },
     entities: {
         workflowDefinition: {
             name: 'WorkflowDefinition',
@@ -1502,39 +1507,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }] });
 
+//#region ----   Imports   ----
 //#endregion
+//#region ----   Sign-Off Activity   ----
 /**
- * CollectSignature Activity (Frontend)
+ * Sign-off activity (frontend).
  *
- * Collects a signature from a user through a dialog.
- * This activity runs on the frontend and requires user interaction.
- *
- * Execution Mode: frontend
- * Activity Type: workflow-activity:collect-signature
+ * Collects a required digital signature and optional note from the current user.
+ * Use after review/approval paths in workflows that require an auditable sign-off.
  *
- * Outcomes:
- * - Signed: User provided signature successfully
- * - Cancelled: User cancelled the signature dialog
+ * Activity type: `workflow-activity:sign-off`
+ * Outcomes: `Signed` | `Cancelled`
  */
-class CollectSignatureActivity {
+class SignOffActivity {
     constructor() {
         //#region ----   Services & Dependencies   ----
         this.layoutBuilder = inject(AXPLayoutBuilderService);
         this.translationService = inject(AXTranslationService);
     }
     //#endregion
-    //#region ----   AXPCommand Implementation   ----
+    //#region ----   Command Implementation   ----
     async execute(input) {
         try {
-            console.log(`[CollectSignatureActivity] Collecting signature from user: ${input.signerId}`);
-            // Translate message if provided
             const message = input.message
                 ? await this.translationService.translateAsync(input.message)
-                : await this.translationService.translateAsync('@workflow-management:signature.activities.collect-signature.default-message');
-            // Show signature collection dialog
-            const dialogResult = await this.showSignatureDialog(message);
+                : await this.translationService.translateAsync('@workflow-management:sign-off.activities.sign-off.default-message');
+            const dialogResult = await this.showSignOffDialog(message);
             if (dialogResult.cancelled) {
-                console.log(`[CollectSignatureActivity] User cancelled signature collection`);
                 return {
                     success: true,
                     data: {
@@ -1547,7 +1546,6 @@ class CollectSignatureActivity {
                 };
             }
             const signedAt = new Date().toISOString();
-            console.log(`[CollectSignatureActivity] Signature collected successfully at ${signedAt}`);
             return {
                 success: true,
                 data: {
@@ -1561,11 +1559,11 @@ class CollectSignatureActivity {
             };
         }
         catch (error) {
-            console.error(`[CollectSignatureActivity] Failed to collect signature:`, error);
+            const message = error instanceof Error ? error.message : 'Failed to collect sign-off';
             return {
                 success: false,
                 message: {
-                    text: error.message || 'Failed to collect signature',
+                    text: message,
                 },
                 data: {
                     signature: '',
@@ -1578,36 +1576,33 @@ class CollectSignatureActivity {
         }
     }
     //#endregion
-    //#region ----   Dialog Logic   ----
-    /**
-     * Shows a dialog to collect signature from the user.
-     */
-    async showSignatureDialog(message) {
+    //#region ----   Dialog   ----
+    async showSignOffDialog(message) {
         const result = await this.layoutBuilder
             .create()
             .dialog((dialog) => {
             dialog
-                .setTitle('@workflow-management:signature.activities.collect-signature.dialog-title')
+                .setTitle('@workflow-management:sign-off.activities.sign-off.dialog-title')
                 .setMessage(message)
                 .setContext({ signature: '', note: '' })
                 .content((flex) => {
                 flex
                     .setDirection('column')
-                    .formField('@workflow-management:signature.activities.collect-signature.note-label', (field) => {
+                    .formField('@workflow-management:sign-off.activities.sign-off.note-label', (field) => {
                     field.path('note');
                     field.largeTextBox({
-                        placeholder: '@workflow-management:signature.activities.collect-signature.note-placeholder',
+                        placeholder: '@workflow-management:sign-off.activities.sign-off.note-placeholder',
                         maxLength: 1000,
                     });
                 })
-                    .formField('@workflow-management:signature.activities.collect-signature.signature-label', (field) => {
+                    .formField('@workflow-management:sign-off.activities.sign-off.signature-label', (field) => {
                     field.path('signature');
                     field.customWidget(AXPWidgetsList.Editors.SignatureBox, {
                         validations: [
                             {
                                 rule: 'required',
                                 options: {
-                                    message: '@workflow-management:signature.activities.collect-signature.signature-required',
+                                    message: '@workflow-management:sign-off.activities.sign-off.signature-required',
                                 },
                             },
                         ],
@@ -1617,7 +1612,7 @@ class CollectSignatureActivity {
                 .setActions((actions) => {
                 actions
                     .cancel('@general:actions.cancel.title')
-                    .submit('@workflow-management:signature.activities.collect-signature.submit-text');
+                    .submit('@workflow-management:sign-off.activities.sign-off.submit-text');
             })
                 .onAction(async (dialogRef) => {
                 const context = dialogRef.context();
@@ -1626,9 +1621,13 @@ class CollectSignatureActivity {
                     return { signature: '', note: undefined, cancelled: true };
                 }
                 const formData = context;
+                const signature = isString(formData.signature) ? trim(formData.signature) : '';
+                if (isEmpty(signature)) {
+                    return { signature: '', note: undefined, cancelled: true };
+                }
                 return {
-                    signature: formData['signature'] || '',
-                    note: formData['note'],
+                    signature,
+                    note: formData.note,
                     cancelled: false,
                 };
             });
@@ -1636,10 +1635,150 @@ class CollectSignatureActivity {
             .show();
         return result;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: CollectSignatureActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: CollectSignatureActivity }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SignOffActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SignOffActivity }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: CollectSignatureActivity, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SignOffActivity, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Rejection Reason Activity   ----
+/**
+ * Rejection-reason activity (frontend).
+ *
+ * Shows a dialog to capture rejection reason and optional note.
+ * Use on workflow reject branches instead of ad-hoc show-layout-popup layouts.
+ *
+ * Activity type: `workflow-activity:rejection-reason`
+ * Outcomes: `Submitted` | `Cancelled`
+ */
+class RejectionReasonActivity {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ----   Command Implementation   ----
+    async execute(input) {
+        try {
+            const requireReason = input.requireReason !== false;
+            const message = input.message
+                ? await this.translationService.translateAsync(input.message)
+                : await this.translationService.translateAsync('@workflow-management:sign-off.activities.rejection-reason.message');
+            const dialogResult = await this.showRejectionDialog(message, requireReason);
+            if (dialogResult.cancelled) {
+                return {
+                    success: true,
+                    data: {
+                        reason: '',
+                        rejectedAt: new Date().toISOString(),
+                    },
+                    metadata: {
+                        outcome: 'Cancelled',
+                    },
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    reason: dialogResult.reason,
+                    note: dialogResult.note,
+                    rejectedAt: new Date().toISOString(),
+                },
+                metadata: {
+                    outcome: 'Submitted',
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to capture rejection reason';
+            return {
+                success: false,
+                message: {
+                    text: message,
+                },
+                data: {
+                    reason: '',
+                    rejectedAt: new Date().toISOString(),
+                },
+                metadata: {
+                    outcome: 'Cancelled',
+                },
+            };
+        }
+    }
+    //#endregion
+    //#region ----   Dialog   ----
+    async showRejectionDialog(message, requireReason) {
+        const reasonValidations = requireReason
+            ? [
+                {
+                    rule: 'required',
+                    options: {
+                        message: '@workflow-management:sign-off.activities.rejection-reason.reason-required',
+                    },
+                },
+            ]
+            : [];
+        const result = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle('@general:actions.reject.title')
+                .setMessage(message)
+                .setContext({ reason: '', note: '' })
+                .content((flex) => {
+                flex
+                    .setDirection('column')
+                    .formField('@workflow-management:sign-off.activities.rejection-reason.reason-label', (field) => {
+                    field.path('reason');
+                    field.largeTextBox({
+                        placeholder: '@workflow-management:sign-off.activities.rejection-reason.reason-placeholder',
+                        maxLength: 500,
+                        validations: reasonValidations,
+                    });
+                })
+                    .formField('@workflow-management:sign-off.activities.rejection-reason.note-label', (field) => {
+                    field.path('note');
+                    field.largeTextBox({
+                        placeholder: '@workflow-management:sign-off.activities.rejection-reason.note-placeholder',
+                        maxLength: 1000,
+                    });
+                });
+            })
+                .setActions((actions) => {
+                actions
+                    .cancel('@general:actions.cancel.title')
+                    .submit('@general:actions.reject.title');
+            })
+                .onAction(async (dialogRef) => {
+                const context = dialogRef.context();
+                const action = dialogRef.action();
+                if (!context || action === 'cancel') {
+                    return { reason: '', note: undefined, cancelled: true };
+                }
+                const formData = context;
+                const reason = isString(formData.reason) ? trim(formData.reason) : '';
+                if (requireReason && isEmpty(reason)) {
+                    return { reason: '', note: undefined, cancelled: true };
+                }
+                return {
+                    reason: defaultTo(reason, ''),
+                    note: formData.note,
+                    cancelled: false,
+                };
+            });
+        })
+            .show();
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RejectionReasonActivity, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RejectionReasonActivity }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RejectionReasonActivity, decorators: [{
             type: Injectable
         }] });
 
@@ -2059,12 +2198,13 @@ var index = /*#__PURE__*/Object.freeze({
     AXMWorkflowActivitiesDefinitionProvider: AXMWorkflowActivitiesDefinitionProvider,
     AXPCreateEntityActivity: AXPCreateEntityActivity,
     CartableTaskActivity: CartableTaskActivity,
-    CollectSignatureActivity: CollectSignatureActivity,
     CreateEntityFormActivity: CreateEntityFormActivity,
     HumanTaskActivity: HumanTaskActivity,
+    RejectionReasonActivity: RejectionReasonActivity,
     ShowConfirmPopupActivity: ShowConfirmPopupActivity,
     ShowLayoutPopupActivity: ShowLayoutPopupActivity,
-    ShowToastActivity: ShowToastActivity
+    ShowToastActivity: ShowToastActivity,
+    SignOffActivity: SignOffActivity
 });
 
 //#region ----   Imports   ----
@@ -2126,43 +2266,175 @@ const automationPlugin = {
 };
 //#endregion
 
+//#region ---- Workflow run command keys ----
+/** Commands for workflow-backed domain list rows (continue, cancel, take over). */
+const AXMWorkflowManagementCommandKeys = {
+    WorkflowRun: {
+        Continue: 'WorkflowManagement.WorkflowRun:Continue',
+        CancelRun: 'WorkflowManagement.WorkflowRun:CancelRun',
+        TakeOver: 'WorkflowManagement.WorkflowRun:TakeOver',
+    },
+};
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Constants ----
+const CRUD_ROW_COMMANDS = new Set(['Entity:Update', 'delete-entity', 'show-file-uploader-popup', 'open-entity']);
+/** Hidden when the row has no linked instance or is in a terminal domain status. */
+const WORKFLOW_RUN_ROW_ACTIONS_HIDDEN = '{{ !context.eval("workflowInfo.instanceId") || context.eval("statusId") === "completed" || context.eval("statusId") === "cancelled" }}';
+//#endregion
+//#region ---- Helpers ----
+function resolveListOptions(options) {
+    const list = options?.list ?? {};
+    const mode = list.mode ?? 'crud';
+    const isWorkflowRun = mode === 'workflow-run';
+    return {
+        mode,
+        suppressCrudRowActions: list.suppressCrudRowActions ?? isWorkflowRun,
+        suppressAttachmentListAction: list.suppressAttachmentListAction ?? isWorkflowRun,
+        viewInReadonlyPopup: list.viewInReadonlyPopup ?? isWorkflowRun,
+    };
+}
+function getActionCommandName(action) {
+    if (typeof action.command === 'string') {
+        return action.command;
+    }
+    return action.command?.name;
+}
+function shouldSuppressListAction(action, listOptions) {
+    const commandName = getActionCommandName(action);
+    if (!commandName) {
+        return false;
+    }
+    if (listOptions.suppressCrudRowActions && CRUD_ROW_COMMANDS.has(commandName)) {
+        return true;
+    }
+    if (listOptions.suppressAttachmentListAction) {
+        if (commandName === 'show-file-uploader-popup' || action.type === 'upload') {
+            return true;
+        }
+        if (action.name?.startsWith('attachments-')) {
+            return true;
+        }
+    }
+    return false;
+}
+function registerWorkflowRunRowActions(ctx, listOptions) {
+    const entityKey = `${ctx.entity.module}.${ctx.entity.name}`;
+    ctx.interfaces.update((interfaces) => {
+        const list = interfaces.master?.list;
+        const actions = list?.actions ?? [];
+        if (listOptions.viewInReadonlyPopup && !actionExists(actions, 'Entity:View', 'workflow-run-view')) {
+            actions.push({
+                name: 'workflow-run-view',
+                title: '@general:actions.view.title',
+                icon: 'fa-light fa-eye',
+                command: 'Entity:View',
+                priority: 'secondary',
+                type: 'view',
+                scope: AXPEntityCommandScope.Individual,
+            });
+        }
+        if (!actionExists(actions, AXMWorkflowManagementCommandKeys.WorkflowRun.Continue, 'workflow-run-continue')) {
+            actions.push({
+                name: 'workflow-run-continue',
+                title: '@workflow-management:workflow-run.actions.continue.title',
+                icon: 'fa-light fa-play',
+                command: {
+                    name: AXMWorkflowManagementCommandKeys.WorkflowRun.Continue,
+                    options: {
+                        entitySource: entityKey,
+                    },
+                },
+                priority: 'primary',
+                type: 'action',
+                scope: AXPEntityCommandScope.Individual,
+                default: true,
+                hidden: WORKFLOW_RUN_ROW_ACTIONS_HIDDEN,
+            });
+        }
+        if (!actionExists(actions, AXMWorkflowManagementCommandKeys.WorkflowRun.CancelRun, 'workflow-run-cancel')) {
+            actions.push({
+                name: 'workflow-run-cancel',
+                title: '@workflow-management:workflow-run.actions.cancel-run.title',
+                icon: 'fa-light fa-ban',
+                command: {
+                    name: AXMWorkflowManagementCommandKeys.WorkflowRun.CancelRun,
+                    options: {
+                        entitySource: entityKey,
+                    },
+                },
+                priority: 'secondary',
+                type: 'action',
+                scope: AXPEntityCommandScope.Individual,
+                hidden: WORKFLOW_RUN_ROW_ACTIONS_HIDDEN,
+            });
+        }
+        if (!actionExists(actions, AXMWorkflowManagementCommandKeys.WorkflowRun.TakeOver, 'workflow-run-take-over')) {
+            actions.push({
+                name: 'workflow-run-take-over',
+                title: '@workflow-management:workflow-run.actions.take-over.title',
+                icon: 'fa-light fa-user-check',
+                command: {
+                    name: AXMWorkflowManagementCommandKeys.WorkflowRun.TakeOver,
+                    options: {
+                        entitySource: entityKey,
+                    },
+                },
+                priority: 'secondary',
+                type: 'action',
+                scope: AXPEntityCommandScope.Individual,
+                hidden: WORKFLOW_RUN_ROW_ACTIONS_HIDDEN,
+            });
+        }
+        return interfaces;
+    });
+}
+//#endregion
+//#region ---- Plugin ----
 /**
- * Workflow Plugin
- *
- * Marks an entity as workflow-capable. This plugin does NOT configure workflows;
- * it only indicates that the entity can participate in workflows.
- *
- * Workflow bindings are configured in Workflow Management (workflow definition → bindings),
- * not in the entity definition.
- *
- * This plugin:
- * - Adds workflow capability marker to entity extensions
- * - Enables workflow trigger middleware to detect workflow-capable entities
- * - Domain rows link runs via `workflowInfo` on the entity model (see `AXPRecordWorkflowInfo`),
- *   not as entity definition properties
- * - Provides UI hooks for workflow-related features (future enhancement)
+ * Workflow plugin — marks entities as workflow-capable and optionally configures
+ * workflow-run list behavior (suppress CRUD row actions, inject continue/cancel/take-over).
  *
- * Usage:
- * ```typescript
- * plugins: [
- *   { name: 'workflow' }, // Entity is workflow-capable
- * ]
- * ```
+ * Domain rows link runs via `workflowInfo` on the entity model ({@link AXPRecordWorkflowInfo}).
  */
 const workflowPlugin = {
     name: 'workflow',
-    order: 50, // After core plugins (40-45), before status/archive (60-70)
-    apply: (ctx) => {
-        // Mark entity as workflow-capable in extensions
-        ctx.entity.extensions ??= {};
-        ctx.entity.extensions.workflow = {
+    order: 50,
+    apply: (ctx, options) => {
+        const listOptions = resolveListOptions(options);
+        const isWorkflowRun = listOptions.mode === 'workflow-run';
+        const entityExt = ctx.entity;
+        entityExt.extensions ??= {};
+        entityExt.extensions['workflow'] = {
             enabled: true,
+            list: listOptions,
         };
-        // Note: No properties, actions, or views are added by this plugin.
-        // It only marks the entity as workflow-capable.
-        // Actual workflow bindings are configured in Workflow Management.
+        if (!isWorkflowRun) {
+            return;
+        }
+        ensureListActions(ctx);
+        ctx.interfaces.update((interfaces) => {
+            const master = interfaces.master;
+            const list = master?.list;
+            if (!list) {
+                return interfaces;
+            }
+            list.actions = (list.actions ?? []).filter((action) => !shouldSuppressListAction(action, listOptions));
+            // Clear default flag on remaining CRUD/view actions so Continue becomes the row default.
+            for (const action of list.actions) {
+                const commandName = getActionCommandName(action);
+                if (commandName === 'open-entity' || commandName === 'Entity:Update') {
+                    action.default = false;
+                }
+            }
+            return interfaces;
+        });
+        registerWorkflowRunRowActions(ctx, listOptions);
     },
 };
+//#endregion
 
 /**
  * Workflow Plugin Module
@@ -2643,11 +2915,6 @@ function getWorkflowInstanceInitiatorUserId(instance) {
     const id = instance.auditInfo?.created?.by?.id;
     return id != null && String(id).length > 0 ? String(id) : null;
 }
-/** Demo/platform operator accounts that bypass permission checks in mock auth. */
-function isWorkflowPlatformRootUser(sessionService) {
-    const username = sessionService.user?.name?.trim();
-    return username === 'root' || username === 'root2' || username === 'super-root';
-}
 //#endregion
 //#region ----   Bookmark payload helpers   ----
 /** Bookmark types rendered on the workflow task board. */
@@ -2690,29 +2957,160 @@ function parseWorkflowTaskContinuationPayload(bookmark) {
 }
 //#endregion
 //#region ----   Step advancement gate   ----
-/** Resume outcomes that do not advance the workflow graph (draft save, cancel, loop back). */
-const NON_ADVANCING_RESUME_OUTCOMES = new Set(['saved', 'cancelled', 'cancel', 'save', 'draft']);
 /**
  * Whether the workflow moved forward enough to prompt "continue to next step".
  * Skips draft save / cancel on questionnaire (same human-task bookmark remains).
  */
 function shouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivityIds) {
-    const outcome = context.resumeOutcome?.trim().toLowerCase();
-    if (outcome && NON_ADVANCING_RESUME_OUTCOMES.has(outcome)) {
+    return axpShouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivityIds);
+}
+//#endregion
+//#region ----   Human-task assignee lookup   ----
+/**
+ * Assignee of the first active human-task / cartable bookmark (used for interactive-step continuation).
+ */
+function findActiveHumanTaskAssigneeId(bookmarks) {
+    for (const bookmark of bookmarks) {
+        const payload = parseWorkflowTaskContinuationPayload(bookmark);
+        if (!payload || !isWorkflowTaskBoardBookmarkPayload(payload)) {
+            continue;
+        }
+        const assigned = normalizeWorkflowTaskUserIds(payload.assignedUserIds);
+        if (assigned[0]) {
+            return assigned[0];
+        }
+    }
+    return null;
+}
+/**
+ * Assignee on a completed human-task activity (when inbox bookmarks are already consumed).
+ */
+function findHumanTaskAssigneeIdForActivity(bookmarks, activityId) {
+    for (const bookmark of bookmarks) {
+        if (bookmark.activityId !== activityId) {
+            continue;
+        }
+        const payload = parseWorkflowTaskContinuationPayload(bookmark);
+        if (!payload || !isWorkflowTaskBoardBookmarkPayload(payload)) {
+            continue;
+        }
+        const assigned = normalizeWorkflowTaskUserIds(payload.assignedUserIds);
+        if (assigned[0]) {
+            return assigned[0];
+        }
+    }
+    return null;
+}
+/** Latest human-task assignee on the instance (active first, then any bookmark). */
+function resolveWorkflowHumanTaskAssigneeId(instance, preferredActivityId) {
+    const wi = instance.workflowInstance;
+    const all = wi?.bookmarks ?? [];
+    const active = all.filter((b) => !b.isConsumed && !b.consumed);
+    const fromActive = findActiveHumanTaskAssigneeId(active);
+    if (fromActive) {
+        return fromActive;
+    }
+    if (preferredActivityId) {
+        const fromPreferred = findHumanTaskAssigneeIdForActivity(all, preferredActivityId);
+        if (fromPreferred) {
+            return fromPreferred;
+        }
+    }
+    for (let i = all.length - 1; i >= 0; i--) {
+        const payload = parseWorkflowTaskContinuationPayload(all[i]);
+        if (!payload || !isWorkflowTaskBoardBookmarkPayload(payload)) {
+            continue;
+        }
+        const assigned = normalizeWorkflowTaskUserIds(payload.assignedUserIds);
+        if (assigned[0]) {
+            return assigned[0];
+        }
+    }
+    return null;
+}
+//#endregion
+//#region ----   Interactive step continuation   ----
+/**
+ * Whether a bookmark row (including consumed) was a task-board human-task / cartable step.
+ */
+function wasWorkflowTaskBoardActivity(bookmarks, activityId) {
+    for (const bookmark of bookmarks) {
+        if (bookmark.activityId !== activityId) {
+            continue;
+        }
+        const payload = parseWorkflowTaskContinuationPayload(bookmark);
+        if (payload && isWorkflowTaskBoardBookmarkPayload(payload)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether to show "continue?" before an inline interactive activity (sign-off, assessment, etc.).
+ */
+function shouldOfferWorkflowInteractiveStepContinuation(instance, sessionService, humanTaskAssigneeId) {
+    const currentUserId = sessionService.user?.id;
+    if (currentUserId == null) {
         return false;
     }
-    const pendingActivityId = context.pendingNextTask?.activityId;
-    const completedActivityId = context.completedActivityId;
-    if (pendingActivityId && completedActivityId && pendingActivityId === completedActivityId) {
+    const current = String(currentUserId);
+    const initiatorId = getWorkflowInstanceInitiatorUserId(instance);
+    const isInitiator = initiatorId != null && current === initiatorId;
+    if (isInitiator) {
+        return true;
+    }
+    if (canReassignWorkflowTaskToSelf(sessionService)) {
+        return true;
+    }
+    if (humanTaskAssigneeId && current === humanTaskAssigneeId) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Skips a redundant pre-interactive prompt when the next UI would run immediately anyway.
+ */
+function shouldSkipContinuationBeforeInteractive(context, nextTask, sessionService, instance, bookmarks, humanTaskAssigneeId) {
+    if (!axpIsWorkflowInlineFrontendTask(nextTask)) {
         return false;
     }
-    if (activeBookmarkActivityIds.length === 0) {
+    const currentUserId = sessionService.user?.id;
+    if (currentUserId == null) {
         return false;
     }
-    if (!completedActivityId) {
+    const current = String(currentUserId);
+    const completedActivityId = context.completedActivityId;
+    // Resume consumes the human-task bookmark before the inline activity runs; search all bookmarks.
+    const allBookmarks = instance.workflowInstance
+        ?.bookmarks ?? bookmarks;
+    const completedWasHumanTask = !!completedActivityId && wasWorkflowTaskBoardActivity(allBookmarks, completedActivityId);
+    const beforeInteractive = axpResolveWorkflowContinuationBeforeInteractive(nextTask);
+    if (axpShouldSkipBeforeInteractiveFromMetadata(beforeInteractive, completedWasHumanTask)) {
+        return true;
+    }
+    if (beforeInteractive === 'skip-for-assignee' && humanTaskAssigneeId && current === humanTaskAssigneeId) {
+        const initiatorId = getWorkflowInstanceInitiatorUserId(instance);
+        if (initiatorId != null && current === initiatorId) {
+            return false;
+        }
+        if (canReassignWorkflowTaskToSelf(sessionService)) {
+            return false;
+        }
         return true;
     }
-    return activeBookmarkActivityIds.some((id) => id !== completedActivityId);
+    return false;
+}
+/** Take-over copy before interactive steps when a human-task is owned by someone else. */
+function needsTakeOverForWorkflowInteractiveContinuation(instance, sessionService, humanTaskAssigneeId) {
+    const currentUserId = sessionService.user?.id;
+    if (currentUserId == null || !humanTaskAssigneeId) {
+        return false;
+    }
+    const current = String(currentUserId);
+    if (current === humanTaskAssigneeId) {
+        return false;
+    }
+    return canReassignWorkflowTaskToSelf(sessionService);
 }
 //#endregion
 //#region ----   Continuation eligibility   ----
@@ -2723,6 +3121,16 @@ function shouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivit
  * - Workflow initiator and assignee are the same person and that person is the current user.
  * - Current user may take over a human-task assigned to someone else.
  */
+/**
+ * Resolves assignee id from bookmark payload, falling back to instance bookmarks / pending task input.
+ */
+function resolveWorkflowTaskContinuationAssigneeId(instance, payload, pendingActivityId) {
+    const fromPayload = normalizeWorkflowTaskUserIds(payload.assignedUserIds)[0] ?? null;
+    if (fromPayload) {
+        return fromPayload;
+    }
+    return resolveWorkflowHumanTaskAssigneeId(instance, pendingActivityId);
+}
 function shouldOfferWorkflowTaskContinuation(ctx) {
     const currentUserId = ctx.sessionService.user?.id;
     if (currentUserId == null) {
@@ -2735,10 +3143,8 @@ function shouldOfferWorkflowTaskContinuation(ctx) {
     if (isWorkflowPooledClaimablePayload(ctx.payload)) {
         return false;
     }
-    const assigned = normalizeWorkflowTaskUserIds(ctx.payload.assignedUserIds);
-    const assigneeId = assigned[0] ?? null;
+    const assigneeId = resolveWorkflowTaskContinuationAssigneeId(ctx.instance, ctx.payload, ctx.bookmark.activityId);
     const initiatorId = getWorkflowInstanceInitiatorUserId(ctx.instance);
-    const isPlatformRoot = isWorkflowPlatformRootUser(ctx.sessionService);
     const isInitiator = initiatorId != null && current === initiatorId;
     if (assigneeId && current === assigneeId) {
         return true;
@@ -2747,14 +3153,15 @@ function shouldOfferWorkflowTaskContinuation(ctx) {
         return true;
     }
     /** User who started the workflow may continue (take over when not assignee). */
-    if (isInitiator && assigneeId) {
+    if (isInitiator && assigneeId && current !== assigneeId) {
         return true;
     }
-    /** Platform operators (e.g. super-root) may continue any pending human task. */
-    if (isPlatformRoot) {
+    if (isInitiator &&
+        canReassignWorkflowTaskToSelf(ctx.sessionService) &&
+        isWorkflowReassignableHumanTaskPayload(ctx.payload)) {
         return true;
     }
-    if (!canReassignWorkflowTaskToSelf(ctx.sessionService) && !isPlatformRoot) {
+    if (!canReassignWorkflowTaskToSelf(ctx.sessionService)) {
         return false;
     }
     if (!isWorkflowReassignableHumanTaskPayload(ctx.payload)) {
@@ -2772,13 +3179,11 @@ function needsTakeOverForWorkflowTaskContinuation(ctx) {
         return false;
     }
     const current = String(currentUserId);
-    const assigned = normalizeWorkflowTaskUserIds(ctx.payload.assignedUserIds);
-    const assigneeId = assigned[0] ?? null;
+    const assigneeId = resolveWorkflowTaskContinuationAssigneeId(ctx.instance, ctx.payload, ctx.bookmark.activityId);
     if (!assigneeId || current === assigneeId) {
         return false;
     }
-    const canTakeOver = canReassignWorkflowTaskToSelf(ctx.sessionService) || isWorkflowPlatformRootUser(ctx.sessionService);
-    return canTakeOver && isWorkflowReassignableHumanTaskPayload(ctx.payload);
+    return (canReassignWorkflowTaskToSelf(ctx.sessionService) && isWorkflowReassignableHumanTaskPayload(ctx.payload));
 }
 //#endregion
 
@@ -2799,13 +3204,34 @@ function createWorkflowInstanceBookmarkAccess(entityService = inject(AXPEntitySe
         .data();
     return {
         async loadInstance(instanceId) {
-            let instance = await workflowInstanceData.byKey(instanceId);
-            if (instance && getActiveBookmarks(instance).length > 0) {
-                return instance;
+            return this.loadInstanceForContinuation(instanceId);
+        },
+        /**
+         * Reloads the instance until the expected human-task bookmark exists (post-submit race).
+         */
+        async loadInstanceForContinuation(instanceId, expectedPendingActivityId) {
+            const maxAttempts = 6;
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                const instance = await workflowInstanceData.byKey(instanceId);
+                if (instance) {
+                    const active = getActiveBookmarks(instance);
+                    if (expectedPendingActivityId) {
+                        if (active.some((b) => b.activityId === expectedPendingActivityId)) {
+                            return instance;
+                        }
+                    }
+                    else if (active.length > 0) {
+                        return instance;
+                    }
+                }
+                if (attempt < maxAttempts - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+                }
+                else {
+                    return instance ?? null;
+                }
             }
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            instance = await workflowInstanceData.byKey(instanceId);
-            return instance ?? null;
+            return null;
         },
         getActiveBookmarks,
         async findActiveBookmark(instanceId, activityId) {
@@ -3016,35 +3442,72 @@ class AXPWorkflowTaskContinuationService {
     }
     //#endregion
     //#region ----   Hook   ----
+    async offerBeforeInteractiveFlow(context) {
+        try {
+            // Resume from task board already means the user chose to act on this step.
+            if (context.completedActivityId) {
+                return 'not-offered';
+            }
+            const nextTask = context.pendingNextTask;
+            if (!nextTask || !axpIsWorkflowInlineFrontendTask(nextTask)) {
+                return 'not-offered';
+            }
+            const instance = await this.bookmarkAccess.loadInstanceForContinuation(context.instanceId);
+            if (!instance) {
+                return 'not-offered';
+            }
+            const bookmarks = this.bookmarkAccess.getActiveBookmarks(instance);
+            const activeActivityIds = bookmarks.map((b) => b.activityId);
+            if (!shouldOfferWorkflowContinuationAfterStep(context, activeActivityIds)) {
+                return 'not-offered';
+            }
+            const humanTaskAssigneeId = resolveWorkflowHumanTaskAssigneeId(instance, context.completedActivityId);
+            if (shouldSkipContinuationBeforeInteractive(context, nextTask, this.sessionService, instance, bookmarks, humanTaskAssigneeId)) {
+                return 'not-offered';
+            }
+            if (!shouldOfferWorkflowInteractiveStepContinuation(instance, this.sessionService, humanTaskAssigneeId)) {
+                return 'not-offered';
+            }
+            const takeOver = needsTakeOverForWorkflowInteractiveContinuation(instance, this.sessionService, humanTaskAssigneeId);
+            const confirmed = await this.confirmContinueToNextStep(takeOver);
+            return confirmed ? 'confirmed' : 'declined';
+        }
+        catch (error) {
+            console.warn('[AXPWorkflowTaskContinuationService] offerBeforeInteractiveFlow failed', error);
+            return 'not-offered';
+        }
+    }
     async offerAfterWorkflowStep(context) {
         try {
-            const instance = await this.bookmarkAccess.loadInstance(context.instanceId);
+            const expectedActivityId = context.pendingNextTask?.activityId;
+            const instance = await this.bookmarkAccess.loadInstanceForContinuation(context.instanceId, expectedActivityId);
             if (!instance) {
-                return;
+                return 'not-offered';
             }
             const activeActivityIds = this.bookmarkAccess
                 .getActiveBookmarks(instance)
                 .map((b) => b.activityId);
             if (!shouldOfferWorkflowContinuationAfterStep(context, activeActivityIds)) {
-                return;
+                return 'not-offered';
             }
             if (context.pendingNextTask &&
                 axpIsWorkflowTaskBoardActivityType(context.pendingNextTask.activityType)) {
                 const offered = await this.offerFromPendingNextTask(instance, context, context.pendingNextTask);
-                if (offered) {
-                    return;
+                if (offered !== 'not-offered') {
+                    return offered;
                 }
             }
-            await this.offerFromInstanceBookmarks(instance, context);
+            return this.offerFromInstanceBookmarks(instance, context);
         }
         catch (error) {
             console.warn('[AXPWorkflowTaskContinuationService] offerAfterWorkflowStep failed', error);
+            return 'not-offered';
         }
     }
     //#endregion
     //#region ----   Offer paths   ----
     async offerFromPendingNextTask(instance, context, nextTask) {
-        const payload = this.buildPayloadFromWorkflowTask(nextTask);
+        const payload = this.enrichPayloadFromInstance(instance, this.buildPayloadFromWorkflowTask(nextTask), nextTask.activityId);
         const bookmark = this.bookmarkAccess
             .getActiveBookmarks(instance)
             .find((b) => b.activityId === nextTask.activityId);
@@ -3057,19 +3520,20 @@ class AXPWorkflowTaskContinuationService {
             completedActivityId: context.completedActivityId,
         };
         if (!shouldOfferWorkflowTaskContinuation(continuationCtx)) {
-            return false;
+            return 'not-offered';
         }
-        return this.confirmAndAdvance(instance.id, context, continuationCtx, nextTask.activityId, bookmark?.id);
+        return this.confirmAndAdvance(instance.id, continuationCtx, nextTask.activityId, bookmark?.id);
     }
     async offerFromInstanceBookmarks(instance, context) {
         for (const bookmark of this.bookmarkAccess.getActiveBookmarks(instance)) {
             if (this.isCompletedBookmark(bookmark, context)) {
                 continue;
             }
-            const payload = parseWorkflowTaskContinuationPayload(bookmark);
-            if (!payload) {
+            const parsed = parseWorkflowTaskContinuationPayload(bookmark);
+            if (!parsed) {
                 continue;
             }
+            const payload = this.enrichPayloadFromInstance(instance, parsed, bookmark.activityId);
             const continuationCtx = {
                 instance,
                 bookmark,
@@ -3081,15 +3545,15 @@ class AXPWorkflowTaskContinuationService {
             if (!shouldOfferWorkflowTaskContinuation(continuationCtx)) {
                 continue;
             }
-            await this.confirmAndAdvance(instance.id, context, continuationCtx, bookmark.activityId, bookmark.id);
-            return;
+            return this.confirmAndAdvance(instance.id, continuationCtx, bookmark.activityId, bookmark.id);
         }
+        return 'not-offered';
     }
-    async confirmAndAdvance(instanceId, context, continuationCtx, nextActivityId, nextBookmarkId) {
+    async confirmAndAdvance(instanceId, continuationCtx, nextActivityId, nextBookmarkId) {
         const takeOver = needsTakeOverForWorkflowTaskContinuation(continuationCtx);
         const confirmed = await this.confirmContinueToNextStep(takeOver);
         if (!confirmed) {
-            return true;
+            return 'declined';
         }
         if (takeOver) {
             let bookmarkIdToUse = nextBookmarkId;
@@ -3098,18 +3562,18 @@ class AXPWorkflowTaskContinuationService {
                 bookmarkIdToUse = found?.bookmark.id;
             }
             if (!bookmarkIdToUse) {
-                return true;
+                return 'confirmed';
             }
             const reassigned = await this.humanTaskService.reassignBookmarkToCurrentUser(instanceId, bookmarkIdToUse, nextActivityId);
             if (!reassigned) {
-                return true;
+                return 'confirmed';
             }
         }
         await this.humanTaskService.executePrimaryHumanTaskAction(instanceId, nextActivityId, {
             suppressContinuation: true,
             notifyViews: true,
         });
-        return true;
+        return 'confirmed';
     }
     //#endregion
     //#region ----   Helpers   ----
@@ -3122,6 +3586,13 @@ class AXPWorkflowTaskContinuationService {
         }
         return false;
     }
+    enrichPayloadFromInstance(instance, payload, activityId) {
+        const assigneeId = resolveWorkflowHumanTaskAssigneeId(instance, activityId);
+        if (assigneeId && normalizeWorkflowTaskUserIds(payload.assignedUserIds).length === 0) {
+            return { ...payload, assignedUserIds: [assigneeId] };
+        }
+        return payload;
+    }
     buildPayloadFromWorkflowTask(task) {
         const input = task.input ?? {};
         const assigned = input['assignedUserIds'];
@@ -3210,8 +3681,24 @@ class AXMWorkflowManagementModule {
                     command: () => Promise.resolve().then(function () { return index; }).then((c) => c.CartableTaskActivity),
                 },
                 {
-                    key: 'workflow-activity:collect-signature',
-                    command: () => Promise.resolve().then(function () { return index; }).then((c) => c.CollectSignatureActivity),
+                    key: 'workflow-activity:sign-off',
+                    command: () => Promise.resolve().then(function () { return index; }).then((c) => c.SignOffActivity),
+                },
+                {
+                    key: 'workflow-activity:rejection-reason',
+                    command: () => Promise.resolve().then(function () { return index; }).then((c) => c.RejectionReasonActivity),
+                },
+                {
+                    key: 'WorkflowManagement.WorkflowRun:Continue',
+                    command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.ContinueWorkflowRunCommand),
+                },
+                {
+                    key: 'WorkflowManagement.WorkflowRun:CancelRun',
+                    command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.CancelWorkflowRunCommand),
+                },
+                {
+                    key: 'WorkflowManagement.WorkflowRun:TakeOver',
+                    command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.TakeOverWorkflowRunCommand),
                 },
             ]),
             // provideEntity([RootConfig.entities.activityDefinition.fullName]),
@@ -3222,7 +3709,7 @@ class AXMWorkflowManagementModule {
                 multi: true,
             },
             provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-DC_9M9dk.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
-            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-BhVZ1Bcw.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-CdaVEEgn.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
             // Automation condition builder: default automation.rules(refType, refId); modules override for their refTypes
             {
                 provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
@@ -3280,7 +3767,8 @@ class AXMWorkflowManagementModule {
             HumanTaskActivity,
             CartableTaskActivity,
             ShowToastActivity,
-            CollectSignatureActivity,
+            RejectionReasonActivity,
+            SignOffActivity,
             // Per-workflow task provider (lazy-loaded). Import provideGenericWorkflowTaskProvider from provider.task.ts:
             // provideGenericWorkflowTaskProvider({
             //   name: 'leave-request',
@@ -3352,8 +3840,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                                 command: () => Promise.resolve().then(function () { return index; }).then((c) => c.CartableTaskActivity),
                             },
                             {
-                                key: 'workflow-activity:collect-signature',
-                                command: () => Promise.resolve().then(function () { return index; }).then((c) => c.CollectSignatureActivity),
+                                key: 'workflow-activity:sign-off',
+                                command: () => Promise.resolve().then(function () { return index; }).then((c) => c.SignOffActivity),
+                            },
+                            {
+                                key: 'workflow-activity:rejection-reason',
+                                command: () => Promise.resolve().then(function () { return index; }).then((c) => c.RejectionReasonActivity),
+                            },
+                            {
+                                key: 'WorkflowManagement.WorkflowRun:Continue',
+                                command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.ContinueWorkflowRunCommand),
+                            },
+                            {
+                                key: 'WorkflowManagement.WorkflowRun:CancelRun',
+                                command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.CancelWorkflowRunCommand),
+                            },
+                            {
+                                key: 'WorkflowManagement.WorkflowRun:TakeOver',
+                                command: () => import('./acorex-modules-workflow-management-index-CxheG2ry.mjs').then((c) => c.TakeOverWorkflowRunCommand),
                             },
                         ]),
                         // provideEntity([RootConfig.entities.activityDefinition.fullName]),
@@ -3364,7 +3868,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                             multi: true,
                         },
                         provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-DC_9M9dk.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
-                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-BhVZ1Bcw.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-CdaVEEgn.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
                         // Automation condition builder: default automation.rules(refType, refId); modules override for their refTypes
                         {
                             provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
@@ -3422,7 +3926,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         HumanTaskActivity,
                         CartableTaskActivity,
                         ShowToastActivity,
-                        CollectSignatureActivity,
+                        RejectionReasonActivity,
+                        SignOffActivity,
                         // Per-workflow task provider (lazy-loaded). Import provideGenericWorkflowTaskProvider from provider.task.ts:
                         // provideGenericWorkflowTaskProvider({
                         //   name: 'leave-request',
@@ -4682,7 +5187,7 @@ class AXPGenericWorkflowTaskProvider extends AXPWorkflowTaskProvider {
     //#endregion
     //#region ----   Component   ----
     getComponent() {
-        return () => import('./acorex-modules-workflow-management-workflow-task-popover.component-DjYDwHWU.mjs').then((m) => m.AXMWorkflowTaskPopoverComponent);
+        return () => import('./acorex-modules-workflow-management-workflow-task-popover.component-B4hEv2-a.mjs').then((m) => m.AXMWorkflowTaskPopoverComponent);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider, deps: [{ token: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider }); }
@@ -4704,5 +5209,5 @@ var genericWorkflowTask_provider = /*#__PURE__*/Object.freeze({
  * Generated bundle index. Do not edit.
  */
 
-export { AXCCategoryProvider, AXMMenuProvider, AXMPermissionsKeys, AXMWorkflowActivitiesDefinitionProvider, AXMWorkflowManagementModule, AXMWorkflowManagementModuleEntityProvider, AXPCreateEntityActivity, AXPGenericWorkflowTaskProvider, AXPWorkflowInstanceHumanTaskService, AXPWorkflowTaskContinuationService, AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY, AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY, CartableTaskActivity, CollectSignatureActivity, CreateEntityFormActivity, HumanTaskActivity, RootConfig, ShowConfirmPopupActivity, ShowLayoutPopupActivity, ShowToastActivity, createWorkflowInstanceBookmarkAccess, getWorkflowInstanceInitiatorUserId, isWorkflowPlatformRootUser, isWorkflowPooledClaimablePayload, isWorkflowReassignableHumanTaskPayload, isWorkflowTaskBoardBookmarkPayload, needsTakeOverForWorkflowTaskContinuation, normalizeWorkflowTaskUserIds, parseWorkflowTaskContinuationPayload, provideGenericWorkflowTaskProvider, provideTaskWorkflow, shouldOfferWorkflowContinuationAfterStep, shouldOfferWorkflowTaskContinuation };
+export { AXCCategoryProvider, AXMMenuProvider, AXMPermissionsKeys, AXMWorkflowActivitiesDefinitionProvider, AXMWorkflowManagementModule, AXMWorkflowManagementModuleEntityProvider, AXPCreateEntityActivity, AXPGenericWorkflowTaskProvider, AXPWorkflowInstanceHumanTaskService, AXPWorkflowTaskContinuationService, AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY, AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY, CartableTaskActivity, CreateEntityFormActivity, HumanTaskActivity, RejectionReasonActivity, RootConfig, ShowConfirmPopupActivity, ShowLayoutPopupActivity, ShowToastActivity, SignOffActivity, createWorkflowInstanceBookmarkAccess, findActiveHumanTaskAssigneeId, findHumanTaskAssigneeIdForActivity, getWorkflowInstanceInitiatorUserId, isWorkflowPooledClaimablePayload, isWorkflowReassignableHumanTaskPayload, isWorkflowTaskBoardBookmarkPayload, needsTakeOverForWorkflowInteractiveContinuation, needsTakeOverForWorkflowTaskContinuation, normalizeWorkflowTaskUserIds, parseWorkflowTaskContinuationPayload, provideGenericWorkflowTaskProvider, provideTaskWorkflow, resolveWorkflowHumanTaskAssigneeId, resolveWorkflowTaskContinuationAssigneeId, shouldOfferWorkflowContinuationAfterStep, shouldOfferWorkflowInteractiveStepContinuation, shouldOfferWorkflowTaskContinuation, shouldSkipContinuationBeforeInteractive, wasWorkflowTaskBoardActivity };
 //# sourceMappingURL=acorex-modules-workflow-management.mjs.map