@acorex-platform/framework-server 0.0.10

package/workflow/src/lib/runtime/workflow-definition.types.d.ts

@@ -0,0 +1,164 @@
+import { type AXPProperty, type AXPEntityOp, type AXPMetaData, type AXPOptionsData, type AXPMultiLanguageString } from './platform-core.types';
+export interface AXPWorkflowDefinition {
+    schemaVersion: 'acorex-platform-workflow/v1';
+    name: string;
+    title?: AXPMultiLanguageString | null;
+    description?: AXPMultiLanguageString | null;
+    variables?: AXPProperty[];
+    inputs?: AXPProperty[];
+    outputs?: AXPWorkflowOutputProperty[];
+    graph: AXPWorkflowGraph;
+    customProperties?: Record<string, any>;
+    /** engine specific (Elsa, ...) */
+    extensions?: AXPWorkflowExtensions;
+    /**
+     * Workflow bindings configuration.
+     * Defines which entities and events should trigger this workflow.
+     */
+    bindings?: AXPWorkflowBinding[];
+}
+export interface AXPWorkflowGraph {
+    startActivityId: string;
+    activities: AXPWorkflowActivityInstance[];
+    connections: AXPConnection[];
+    /** purely designer */
+    designer?: {
+        nodes?: Record<string, {
+            x: number;
+            y: number;
+            nodeId?: string;
+            width?: number;
+            height?: number;
+        }>;
+        edges?: Array<{
+            from: string;
+            to: string;
+            vertices?: Array<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+        /**
+         * When true, the Activities page has applied its initial auto-arrange (or the graph already had
+         * persisted node positions). Prevents re-running automatic layout on subsequent visits.
+         */
+        layoutArranged?: boolean;
+    };
+}
+export interface AXPWorkflowActivityInstance {
+    id: string;
+    nodeId?: string;
+    /**
+     * Activity name - references AXPActivityDefinition.name
+     * Used to lookup activity definition for metadata (executionMode, title, etc.)
+     */
+    name: string;
+    /**
+     * Input values for this activity instance.
+     * Key-value pairs where keys match {@link AXPProperty.name} from AXPActivityDefinition.inputs
+     * Example: { "message": "Hello", "duration": 5000 }
+     */
+    inputs?: AXPOptionsData;
+    title?: string;
+    /**
+     * Output mapping: process variable name → path in this activity's output (BPMN-style: activity → variable).
+     * When this activity completes, each entry sets variables[variableName] = output[outputPath].
+     * Example: { leaveRequestId: 'id' } → variables.leaveRequestId = activityOutput.id
+     */
+    outputToVariables?: AXPOptionsData;
+    metadata?: AXPMetaData;
+    /** engine-specific override */
+    extensions?: Record<string, any>;
+}
+export interface AXPConnection {
+    source: {
+        activtyName: string;
+        port?: string | null;
+    };
+    target: {
+        activtyName: string;
+        port?: string | null;
+    };
+    vertices?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+/**
+ * Workflow output: same as {@link AXPProperty} with optional source path and engine metadata.
+ */
+export interface AXPWorkflowOutputProperty extends AXPProperty {
+    /**
+     * Optional: where this output comes from in your context/memory.
+     * Example: "$.result.orderId" or "vars.orderId"
+     */
+    path?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Engine-specific extension bag for a workflow.
+ * Keep ALL engine-only fields here (Elsa, StepFunctions adapter, etc).
+ */
+export interface AXPWorkflowExtensions {
+    /**
+     * Elsa-specific extensions (optional).
+     */
+    elsa?: AXPElsaWorkflowExtensions;
+    /**
+     * Other engines (future-proof).
+     * Example: stepFunctions, logicApps, temporal, ...
+     */
+    [engine: string]: any;
+}
+/**
+ * Elsa-only fields (Optional).
+ * Put strategy/tool/schema/raw payload here to keep Core model global.
+ */
+export interface AXPElsaWorkflowExtensions {
+    /**
+     * Elsa schema URL (if you want to round-trip exact docs).
+     * Example: "https://elsaworkflows.io/schemas/workflow-definition/v3.0.0/schema.json"
+     */
+    schema?: string;
+    toolVersion?: string;
+    materializerName?: string;
+    /**
+     * Elsa strategy/options (engine-level concerns).
+     */
+    options?: {
+        activationStrategyType?: string | null;
+        incidentStrategyType?: string | null;
+        commitStrategyName?: string | null;
+        autoUpdateConsumingWorkflows?: boolean;
+        usableAsActivity?: boolean | null;
+        activityCategory?: string | null;
+    };
+    /**
+     * If you want lossless Elsa round-trip, keep the raw Elsa definition here.
+     */
+    rawDefinition?: any;
+}
+/**
+ * Workflow binding configuration.
+ * Defines which entities and events should trigger a workflow.
+ */
+export interface AXPWorkflowBinding {
+    /**
+     * Entity types this workflow applies to (e.g., ['ContentManagement.Promotion', 'ContentManagement.Article'])
+     * Empty array means applies to all entities with workflow plugin enabled.
+     */
+    entityTypes: string[];
+    /**
+     * Event types that trigger this workflow (e.g., ['create', 'update'])
+     * Uses AXPEntityOp directly (create, update, delete, etc.)
+     */
+    eventTypes: AXPEntityOp[];
+    /**
+     * Whether this binding is enabled
+     */
+    enabled: boolean;
+    /**
+     * Optional conditions for when to trigger (future enhancement)
+     */
+    conditions?: any;
+}

package/workflow/src/lib/runtime/workflow-definition.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//#endregion
+//# sourceMappingURL=workflow-definition.types.js.map

package/workflow/src/lib/runtime/workflow-definition.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-definition.types.js","sourceRoot":"","sources":["../../../../../../../../libs/framework/server/workflow/src/lib/runtime/workflow-definition.types.ts"],"names":[],"mappings":";;AA8LA,YAAY"}

package/workflow/src/lib/runtime/workflow-engine.errors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Stable workflow engine error codes for UI branching (toasts, take-over flow, etc.).
+ */
+export declare const AXP_WORKFLOW_ERROR_CODES: {
+    readonly TASK_NOT_ASSIGNEE: "WORKFLOW_TASK_NOT_ASSIGNEE";
+    readonly CLAIM_REQUIRED: "WORKFLOW_CLAIM_REQUIRED";
+    readonly REASSIGN_NOT_ALLOWED: "WORKFLOW_REASSIGN_NOT_ALLOWED";
+};
+export type AXPWorkflowErrorCode = (typeof AXP_WORKFLOW_ERROR_CODES)[keyof typeof AXP_WORKFLOW_ERROR_CODES];
+/**
+ * Business-rule failure from {@link AXPWorkflowEngine} (expected, user-facing).
+ */
+export declare class AXPWorkflowEngineError extends Error {
+    readonly code: AXPWorkflowErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: AXPWorkflowErrorCode, details?: Record<string, unknown>);
+}
+/**
+ * Resolves a stable error code from an unknown thrown value.
+ */
+export declare function getWorkflowEngineErrorCode(error: unknown): AXPWorkflowErrorCode | undefined;
+/**
+ * Resolves a user-facing message and optional code from an unknown thrown value.
+ */
+export declare function getWorkflowEngineErrorInfo(error: unknown): {
+    message: string;
+    code?: AXPWorkflowErrorCode;
+};

package/workflow/src/lib/runtime/workflow-engine.errors.js

@@ -0,0 +1,51 @@
+"use strict";
+//#region ----   Error Codes   ----
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXPWorkflowEngineError = exports.AXP_WORKFLOW_ERROR_CODES = void 0;
+exports.getWorkflowEngineErrorCode = getWorkflowEngineErrorCode;
+exports.getWorkflowEngineErrorInfo = getWorkflowEngineErrorInfo;
+/**
+ * Stable workflow engine error codes for UI branching (toasts, take-over flow, etc.).
+ */
+exports.AXP_WORKFLOW_ERROR_CODES = {
+    TASK_NOT_ASSIGNEE: 'WORKFLOW_TASK_NOT_ASSIGNEE',
+    CLAIM_REQUIRED: 'WORKFLOW_CLAIM_REQUIRED',
+    REASSIGN_NOT_ALLOWED: 'WORKFLOW_REASSIGN_NOT_ALLOWED',
+};
+//#endregion
+//#region ----   Engine Error   ----
+/**
+ * Business-rule failure from {@link AXPWorkflowEngine} (expected, user-facing).
+ */
+class AXPWorkflowEngineError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'AXPWorkflowEngineError';
+    }
+}
+exports.AXPWorkflowEngineError = AXPWorkflowEngineError;
+/**
+ * Resolves a stable error code from an unknown thrown value.
+ */
+function getWorkflowEngineErrorCode(error) {
+    if (error instanceof AXPWorkflowEngineError) {
+        return error.code;
+    }
+    return undefined;
+}
+/**
+ * Resolves a user-facing message and optional code from an unknown thrown value.
+ */
+function getWorkflowEngineErrorInfo(error) {
+    if (error instanceof AXPWorkflowEngineError) {
+        return { message: error.message, code: error.code };
+    }
+    if (error instanceof Error) {
+        return { message: error.message };
+    }
+    return { message: 'An unexpected workflow error occurred' };
+}
+//#endregion
+//# sourceMappingURL=workflow-engine.errors.js.map

package/workflow/src/lib/runtime/workflow-engine.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-engine.errors.js","sourceRoot":"","sources":["../../../../../../../../libs/framework/server/workflow/src/lib/runtime/workflow-engine.errors.ts"],"names":[],"mappings":";AAAA,mCAAmC;;;AAkCnC,gEAKC;AAKD,gEAQC;AAlDD;;GAEG;AACU,QAAA,wBAAwB,GAAG;IACtC,iBAAiB,EAAE,4BAA4B;IAC/C,cAAc,EAAE,yBAAyB;IACzC,oBAAoB,EAAE,+BAA+B;CAC7C,CAAC;AAIX,YAAY;AAEZ,oCAAoC;AAEpC;;GAEG;AACH,MAAa,sBAAuB,SAAQ,KAAK;IAC/C,YACE,OAAe,EACC,IAA0B,EAC1B,OAAiC;QAEjD,KAAK,CAAC,OAAO,CAAC,CAAC;QAHC,SAAI,GAAJ,IAAI,CAAsB;QAC1B,YAAO,GAAP,OAAO,CAA0B;QAGjD,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AATD,wDASC;AAED;;GAEG;AACH,SAAgB,0BAA0B,CAAC,KAAc;IACvD,IAAI,KAAK,YAAY,sBAAsB,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,SAAgB,0BAA0B,CAAC,KAAc;IACvD,IAAI,KAAK,YAAY,sBAAsB,EAAE,CAAC;QAC5C,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;IACtD,CAAC;IACD,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,uCAAuC,EAAE,CAAC;AAC9D,CAAC;AAED,YAAY"}

package/workflow/src/lib/runtime/workflow-engine.service.d.ts

@@ -0,0 +1,373 @@
+import { EntityStorageMiddlewareService } from '@acorex-platform/framework-server/core';
+import { WorkflowRequestSessionAdapter } from '../activities/workflow-request-session.adapter';
+import { type AXPClaimWorkflowTaskRequest, type AXPClaimWorkflowTaskResponse, type AXPFrontActivityCompleteRequest, type AXPFrontActivityCompleteResponse, type AXPGetWorkflowStateRequest, type AXPResumeWorkflowRequest, type AXPResumeWorkflowResponse, type AXPRevertResumeAfterDeclinedInteractiveContinuationRequest, type AXPRevertResumeAfterDeclinedInteractiveContinuationResponse, type AXPStartWorkflowRequest, type AXPStartWorkflowResponse, type AXPReassignWorkflowTaskToSelfRequest, type AXPReassignWorkflowTaskToSelfResponse, type AXPWorkflowInstanceState } from './workflow-runtime.types';
+import { WorkflowActivityDefinitionService } from './workflow-activity-definition.service';
+import { WorkflowActivityRegistryService } from '../activities/workflow-activity.registry';
+import { WorkflowExpressionEvaluatorService } from './workflow-expression-evaluator.service';
+import { WorkflowExpressionScopeService } from './workflow-expression-scope.service';
+import { WorkflowExecutionStoreService } from './workflow-execution-store.service';
+/**
+ * Backend workflow runtime engine (ported from mock connectivity).
+ * Persists instances/bookmarks via {@link WorkflowExecutionStoreService}.
+ */
+export declare class BackendWorkflowEngineService {
+    private readonly store;
+    private readonly entityStorageService;
+    private readonly activityDefinitionService;
+    private readonly expressionScopeService;
+    private readonly expressionEvaluator;
+    private readonly sessionService;
+    private readonly activityRegistry;
+    constructor(store: WorkflowExecutionStoreService, entityStorageService: EntityStorageMiddlewareService, activityDefinitionService: WorkflowActivityDefinitionService, expressionScopeService: WorkflowExpressionScopeService, expressionEvaluator: WorkflowExpressionEvaluatorService, sessionService: WorkflowRequestSessionAdapter, activityRegistry: WorkflowActivityRegistryService);
+    /** Minimal session user shape used by workflow runtime. */
+    private getSessionUser;
+    /**
+     * Load workflow definition by name from entity storage.
+     */
+    private getDefinition;
+    /**
+     * Secure task token storage.
+     * Key: token (UUID)
+     * Value: { instanceId, activityId, expiresAt }
+     */
+    private taskTokens;
+    /**
+     * Token expiration time: 30 minutes.
+     * Tasks in task board (human-task) may wait days; resume is allowed via bookmark fallback when token is expired.
+     */
+    private readonly TOKEN_EXPIRATION_MS;
+    /**
+     * Generate secure, non-guessable task token (UUID).
+     */
+    private generateTaskToken;
+    /**
+     * Validate task token.
+     * Returns true if token exists, not expired, and matches instanceId + activityId.
+     */
+    private validateTaskToken;
+    /**
+     * Allow resume when token is missing/expired but instance is suspended and has an active bookmark for this step.
+     * Used for task board tasks that may wait days (token is in-memory and expires after 30 min).
+     */
+    private canResumeByBookmark;
+    /**
+     * Remove task token after completion to prevent replay.
+     */
+    private removeTaskToken;
+    /**
+     * Cleanup expired tokens (lightweight).
+     */
+    private cleanupExpiredTokens;
+    /**
+     * Start a new workflow instance.
+     * Creates a workflow instance and stores it in IndexedDB.
+     */
+    start(request: AXPStartWorkflowRequest): Promise<AXPStartWorkflowResponse>;
+    /**
+     * Terminates a non-finished workflow instance (e.g. superseded lifecycle run).
+     */
+    cancelInstance(instanceId: string, reason?: string): Promise<void>;
+    /**
+     * Find activity in Graph by ID.
+     */
+    private findActivityInGraph;
+    /**
+     * Default outcome used when the requested outcome is not in the allowed list (standard scenario).
+     */
+    private static readonly DEFAULT_UNMATCHED_OUTCOME;
+    /**
+     * Resolve allowed outcomes for the current activity from the workflow definition.
+     * - First: use outgoing connection ports from the workflow graph (so workflow-defined ports like 'Submitted'/'Cancelled' are accepted).
+     * - For human-task: parse activity instance inputs.actions (prefix/suffix) and use action names as outcomes.
+     * - Otherwise: use activity definition outcomes or ['Done'].
+     */
+    private getActivityAllowedOutcomes;
+    /**
+     * Coerces workflow outcome/port values (string or legacy object shapes) to a plain label.
+     */
+    private resolveOutcomeLabel;
+    private normalizeAllowedOutcomeList;
+    /**
+     * Normalize outcome: if it is in the allowed list, return as-is; otherwise use standard fallback and log.
+     */
+    private normalizeOutcome;
+    /**
+     * Maps mistaken `Done` outcomes from `create-entity-form` when `persistInWorkflow` is true
+     * but command metadata was lost on the client (payload still contains `output.result`).
+     */
+    private coerceCreateEntityFormOutcome;
+    private findWorkflowConnection;
+    /**
+     * Normalize value to a plain object for use as scope.outputs.
+     * Used when building expression scope so that outputs.* (e.g. outputs.result, outputs.action) is available.
+     */
+    private ensureOutputsForScope;
+    /**
+     * Extracts persisted create-entity-form payload (`data.result`) from a frontend step output.
+     */
+    private extractPersistedEntityFormResult;
+    /**
+     * Coerces date-like workflow values to a {@link Date} (local calendar date when input is `yyyy-mm-dd`).
+     */
+    private coerceWorkflowDateValue;
+    /**
+     * Promotes `create-entity-form` submit payload (`output.result`) onto workflow variables
+     * so downstream steps and human tasks see form values (e.g. effectiveDate), not start inputs.
+     */
+    private buildPersistedEntityFormVariablePromotions;
+    /**
+     * Resume a suspended workflow instance.
+     *
+     * After frontend completes its task:
+     * 1. Validates taskToken (secure, non-guessable)
+     * 2. Verifies resumed activity matches currentStepId/bookmark
+     * 3. Marks related bookmark as consumed
+     * 4. Applies frontend outputs into workflow state
+     * 5. Traverses to next activity based on outcomes
+     * 6. Executes ALL backend activities until hitting frontend activity or completion
+     * 7. Returns either pendingTask (with new secure token) or completed status
+     */
+    resume(request: AXPResumeWorkflowRequest): Promise<AXPResumeWorkflowResponse>;
+    /**
+     * Get current workflow execution state.
+     */
+    getState(request: AXPGetWorkflowStateRequest): Promise<AXPWorkflowInstanceState>;
+    /**
+     * Restores a suspended task-board step when the user declines a pre-interactive continuation prompt.
+     * Re-opens the human-task bookmark on the task board and removes the aborted inline step bookmark.
+     */
+    revertResumeAfterDeclinedInteractiveContinuation(request: AXPRevertResumeAfterDeclinedInteractiveContinuationRequest): Promise<AXPRevertResumeAfterDeclinedInteractiveContinuationResponse>;
+    /**
+     * Claim a pooled task (cartable or human-task with candidates only): assign current user without resuming.
+     */
+    claimTask(request: AXPClaimWorkflowTaskRequest): Promise<AXPClaimWorkflowTaskResponse>;
+    /**
+     * Claim when execution state lives only on `WorkflowManagement.WorkflowInstance` (seeded / entity-only rows).
+     */
+    private claimTaskOnWorkflowInstanceEntity;
+    /**
+     * Reassign a human-task bookmark to the current user (permission-gated; does not resume).
+     */
+    reassignTaskToSelf(request: AXPReassignWorkflowTaskToSelfRequest): Promise<AXPReassignWorkflowTaskToSelfResponse>;
+    /**
+     * Reassign when execution state lives only on `WorkflowManagement.WorkflowInstance` (entity-only rows).
+     */
+    private reassignTaskOnWorkflowInstanceEntity;
+    private canReassignTaskToSelf;
+    private validateHumanTaskReassignPayload;
+    private buildReassignAuditVariablePatch;
+    /**
+     * Activities that suspend for the task board (inbox), same completion path as human-task.
+     */
+    private isTaskBoardSuspendGraphActivity;
+    /**
+     * Cache for activity definitions to avoid repeated queries.
+     */
+    private activityDefinitionCache;
+    /**
+     * Cache TTL: 5 minutes
+     */
+    private readonly CACHE_TTL_MS;
+    /**
+     * Determine execution mode for an activity (async).
+     *
+     * Priority (highest to lowest):
+     * 1. Activity instance's executionMode (from AXPActivity in workflow definition)
+     * 2. ActivityDefinition's executionMode (from ActivityDefinitionService)
+     * 3. Default: 'frontend'
+     *
+     * @param activityType - Activity type (e.g., 'workflow-activity:show-toast')
+     * @param activity - Activity from workflow definition (AXPActivity)
+     * @returns Promise of execution mode: 'frontend', 'backend', or 'both'
+     */
+    private determineExecutionMode;
+    /**
+     * Create a task from a workflow activity.
+     * Inspired by Temporal's Activity Task and Elsa's Bookmark pattern.
+     * Uses same expression scope (inputs, variables, outputs, context.eval) as backend execution.
+     */
+    private createTaskFromActivity;
+    /**
+     * Build variables table for entity: only variables defined in workflow definition (name, title, value).
+     */
+    private computeWorkflowVariablesTable;
+    /**
+     * Compute overview display fields for entity model (statusDisplay, step progress, etc.).
+     */
+    private computeOverviewDisplayFields;
+    /**
+     * Compute runtime details for task board style overview fields.
+     */
+    private computeRuntimeDetails;
+    /**
+     * Human-task / cartable bookmark types that surface on the task board.
+     */
+    private isTaskBoardHumanBookmarkPayload;
+    /**
+     * Primary user id for assignee column: suspended task-board bookmark (assigned, then candidate users),
+     * otherwise last completed step with a persisted user id.
+     */
+    private resolvePrimaryAssignUserId;
+    /**
+     * Last completed activity's `completedByUserId` from workflow state properties.
+     */
+    private resolveLastPerformerUserId;
+    /**
+     * Lookup user row for WorkflowInstance list/detail lookup column.
+     */
+    private resolveAssignUserLookupFields;
+    /**
+     * Resolve current step from active bookmark first, then running context.
+     */
+    private resolveCurrentStepId;
+    /**
+     * Resolve friendly activity title using payload/title inputs and fallback label.
+     */
+    private resolveActivityTitle;
+    /**
+     * Resolve next activity title from workflow graph and known outcome.
+     */
+    private resolveNextActivityTitle;
+    /**
+     * Parse bookmark payload safely.
+     */
+    private parseBookmarkPayloadJson;
+    /**
+     * Convert technical identifier to readable title-case label.
+     */
+    private formatReadableLabel;
+    /**
+     * Build a user-friendly task board status from workflow status and sub-status.
+     * Returns plain English labels instead of translation keys.
+     */
+    private getWorkflowStatusDisplay;
+    /**
+     * Save workflow instance to entity service for entity-based access.
+     */
+    private saveInstanceToEntityService;
+    /**
+     * Update workflow instance in entity service.
+     * Uses upsert pattern: try update first, if fails then insert.
+     */
+    private updateInstanceInEntityService;
+    /**
+     * Evaluates activity inputs against current workflow scope (same as backend execution).
+     */
+    private evaluateActivityInputs;
+    /**
+     * After entity-create: link instance entity ref and persist {@link AXPRecordWorkflowInfo} on the row.
+     */
+    private linkEntityRecordAfterCreate;
+    /**
+     * Execute backend activities locally via {@link WorkflowActivityRegistryService}.
+     *
+     * Uses WorkflowExpressionScopeService + WorkflowExpressionEvaluatorService for expression
+     * evaluation (inputs, variables, outputs, context.eval) so backend activities get the
+     * same expression handling as the platform ActivityExecutor.
+     */
+    private executeBackendActivityLocally;
+    /**
+     * Build variable updates from activity output using activity's outputToVariables (BPMN-style: activity → variable).
+     * For each entry in activity.outputToVariables, sets variables[variableName] = output[outputPath].
+     */
+    private getVariableUpdatesFromOutput;
+    /**
+     * Resolves human-task bookmark title from evaluated inputs, then context, then activity definition.
+     */
+    private resolveHumanTaskBookmarkTitle;
+    /**
+     * Builds title from `context._taskTitleParts` when activity title input did not resolve.
+     */
+    private composeHumanTaskTitleFromContext;
+    private humanTaskContextLabel;
+    /**
+     * Normalize user/role id field to array for bookmark payload (task board expects array).
+     * Expression may evaluate to single string (e.g. {{ variables.managerId }}) or already array.
+     */
+    private normalizeUserIds;
+    /**
+     * Diagnostic logging for human-task bookmark assignment (task board assignee).
+     * Filter the browser console by `[WFM-LifecycleTaskTrace]`.
+     */
+    private logHumanTaskBookmarkAssignmentTrace;
+    /**
+     * Create a bookmark for a workflow instance.
+     * Aligns with ERD: BOOKMARK table structure.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param activityId - Activity ID where bookmark is created
+     * @param type - Bookmark type (e.g., 'user-task', 'event', 'timer')
+     * @param payload - Bookmark payload data
+     * @returns Bookmark ID
+     */
+    private createBookmark;
+    /**
+     * Consume (mark as consumed) a bookmark for a workflow instance.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param activityId - Activity ID of the bookmark to consume
+     */
+    private consumeBookmark;
+    /**
+     * Get active bookmarks for a workflow instance.
+     *
+     * @param instanceId - Workflow instance ID
+     * @returns Array of active (non-consumed) bookmarks
+     */
+    private getActiveBookmarks;
+    /**
+     * Convert workflow instance to instance state.
+     *
+     * Aligns with ERD structure:
+     * - WORKFLOW_INSTANCE: header fields (status, subStatus, timestamps)
+     * - WORKFLOW_INSTANCE_STATE: heavy state (input, output, properties, stateJson)
+     * - BOOKMARK: separate table (used to derive currentStepId)
+     */
+    private instanceToInstanceState;
+    /**
+     * Update instance state in instance and save to IndexedDB.
+     *
+     * Aligns with ERD structure:
+     * - WORKFLOW_INSTANCE: header fields (status, subStatus, timestamps, correlationId)
+     * - WORKFLOW_INSTANCE_STATE: heavy state (input, output, properties, stateJson)
+     *
+     * Handles status transitions correctly:
+     * - running → suspended (when frontend activity encountered)
+     * - suspended → running → completed (when workflow finishes)
+     * - any → error (on errors)
+     */
+    private updateInstanceFromState;
+    /**
+     * Get workflow instance from IndexedDB.
+     */
+    private getInstance;
+    /**
+     * Update workflow instance in store.
+     */
+    private updateInstance;
+    /**
+     * Complete a frontend activity and continue workflow execution.
+     *
+     * This method is called when a frontend activity (ui-activity) completes execution.
+     * It applies the frontend output to workflow state, finds the next activity based on outcome,
+     * and executes all backend activities until reaching the next frontend activity or completion.
+     *
+     * Flow:
+     * 1. Apply frontend output to workflow state
+     * 2. Find next activity based on outcome from connections
+     * 3. Execute ALL backend activities until hitting frontend activity or completion
+     * 4. Return either nextTask (with new secure token) or completed status
+     *
+     * @param request - Front activity completion request with instanceId, activityNode, output, and outcome
+     * @returns Response with nextTask (if frontend activity) or completion status
+     */
+    frontActivtyComplete(request: AXPFrontActivityCompleteRequest): Promise<AXPFrontActivityCompleteResponse>;
+    /**
+     * Cleans up stale UI activities (form/popup) when user refreshed without submitting.
+     * - Suspended instances with non-human-task bookmark → resume with outcome 'cancel'.
+     * - Running instances with non-human-task bookmark (e.g. rejectionReasonDialog) → frontActivtyComplete with outcome 'cancel'.
+     * So e.g. leave request: manager clicks Reject, dialog opens, user refreshes → dialog is "cancelled" and workflow goes back to managerConfirm (task board).
+     */
+    resumeStaleNonHumanTaskSuspensions(): Promise<void>;
+    private parseBookmarkPayload;
+}