@rytass/bpm-core-nestjs-module 0.1.3 → 0.1.5

package/src/lib/workflow-engine/workflow-engine.service.js

@@ -0,0 +1,2785 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEngineService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const attachment_service_1 = require("../attachment/attachment.service");
+const delegation_service_1 = require("../delegation/delegation.service");
+const form_definition_version_entity_1 = require("../form/form-definition-version.entity");
+const form_enums_1 = require("../form/form.enums");
+const notification_service_1 = require("../notification/notification.service");
+const notification_entity_1 = require("../notification/notification.entity");
+const signature_service_1 = require("../signature/signature.service");
+const condition_service_1 = require("../condition/condition.service");
+const manager_resolution_entity_1 = require("../organization/manager-resolution.entity");
+const membership_entity_1 = require("../organization/membership.entity");
+const org_unit_entity_1 = require("../organization/org-unit.entity");
+const organization_enums_1 = require("../organization/organization.enums");
+const approval_template_version_entity_1 = require("../template/approval-template-version.entity");
+const approval_template_entity_1 = require("../template/approval-template.entity");
+const template_enums_1 = require("../template/template.enums");
+const activity_log_entity_1 = require("./activity-log.entity");
+const approval_instance_entity_1 = require("./approval-instance.entity");
+const task_decision_entity_1 = require("./task-decision.entity");
+const task_candidate_entity_1 = require("./task-candidate.entity");
+const task_entity_1 = require("./task.entity");
+const workflow_engine_enums_1 = require("./workflow-engine.enums");
+const workflow_condition_evaluator_1 = require("./workflow-condition-evaluator");
+const workflow_dry_run_object_1 = require("./workflow-dry-run.object");
+const workflow_service_task_dispatcher_token_1 = require("./workflow-service-task-dispatcher.token");
+const workflow_token_entity_1 = require("./workflow-token.entity");
+const MAX_PROCESSING_STEPS = 500;
+const DEFAULT_APPROVAL_HISTORY_TASK_LIMIT = 50;
+const SYSTEM_DRY_RUN_INSTANCE_ID = 'dry-run-instance';
+const WORKFLOW_READ_ALL_PERMISSIONS = new Set([
+    'bpm:*',
+    'bpm.workflow.read_all',
+    'bpm:workflow:read_all',
+    'workflow.read_all',
+]);
+let WorkflowEngineService = class WorkflowEngineService {
+    constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, serviceTaskDispatcher = new workflow_service_task_dispatcher_token_1.DefaultWorkflowServiceTaskDispatcher()) {
+        this.approvalInstanceRepository = approvalInstanceRepository;
+        this.workflowTokenRepository = workflowTokenRepository;
+        this.taskRepository = taskRepository;
+        this.taskCandidateRepository = taskCandidateRepository;
+        this.taskDecisionRepository = taskDecisionRepository;
+        this.notificationRepository = notificationRepository;
+        this.activityLogRepository = activityLogRepository;
+        this.approvalTemplateRepository = approvalTemplateRepository;
+        this.approvalTemplateVersionRepository = approvalTemplateVersionRepository;
+        this.formDefinitionVersionRepository = formDefinitionVersionRepository;
+        this.attachmentService = attachmentService;
+        this.conditionService = conditionService;
+        this.delegationService = delegationService;
+        this.notificationService = notificationService;
+        this.signatureService = signatureService;
+        this.serviceTaskDispatcher = serviceTaskDispatcher;
+    }
+    async submitApprovalInstance(input) {
+        const formData = parseJsonObject(input.formDataJson, 'formDataJson');
+        const template = await this.getTemplateOrThrow(input.templateId);
+        if (!template.currentVersionId) {
+            throw new common_1.ConflictException('Approval template does not have a published version');
+        }
+        const templateVersion = await this.getPublishedTemplateVersionOrThrow(template.currentVersionId);
+        const formDefinitionVersion = await this.getPublishedFormVersionOrThrow(templateVersion.formDefinitionVersionId);
+        validateSubmittedFormData(formDefinitionVersion.schema, formData);
+        const initiatorMetadataSnapshot = input.initiatorMetadataSnapshotJson
+            ? parseJsonObject(input.initiatorMetadataSnapshotJson, 'initiatorMetadataSnapshotJson')
+            : await this.readDefaultInitiatorMetadataSnapshot(input.initiatorMemberId);
+        if (!this.conditionService.evaluateBoolean(templateVersion.initiatorPolicyCel, buildInitiatorPolicyContext(initiatorMetadataSnapshot), 'initiatorPolicyCel')) {
+            throw new common_1.ConflictException('Current member is not allowed to start this approval template');
+        }
+        const startedAt = new Date();
+        const startNode = templateVersion.workflowDefinition.nodes.find((node) => node.type === 'startEvent');
+        if (!startNode) {
+            throw new common_1.BadRequestException('Published workflow does not include a startEvent');
+        }
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+            const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+            const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+            const instance = await instanceRepository.save(instanceRepository.create({
+                completedAt: null,
+                formData,
+                formDefinitionSnapshot: {
+                    formDefinitionVersionId: formDefinitionVersion.id,
+                    schema: formDefinitionVersion.schema,
+                    uiSchema: formDefinitionVersion.uiSchema,
+                    version: formDefinitionVersion.version,
+                },
+                initiatorMemberId: input.initiatorMemberId,
+                initiatorMetadataSnapshot,
+                startedAt,
+                state: workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING,
+                templateId: template.id,
+                templateVersionId: templateVersion.id,
+                title: input.title?.trim() || template.name,
+                workflowSnapshot: templateVersion.workflowDefinition,
+            }));
+            await this.attachmentService.bindFormDataAttachmentsToInstance(manager, {
+                formData,
+                instanceId: instance.id,
+            });
+            const token = await tokenRepository.save(tokenRepository.create({
+                consumedAt: null,
+                currentNodeId: startNode.id,
+                instanceId: instance.id,
+                parentTokenId: null,
+                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+            }));
+            await activityRepository.save([
+                activityRepository.create({
+                    actorMemberId: input.initiatorMemberId,
+                    eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_STARTED,
+                    instanceId: instance.id,
+                    nodeId: startNode.id,
+                    payload: {
+                        templateId: template.id,
+                        templateVersionId: templateVersion.id,
+                    },
+                    taskId: null,
+                }),
+                activityRepository.create({
+                    actorMemberId: null,
+                    eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_CREATED,
+                    instanceId: instance.id,
+                    nodeId: startNode.id,
+                    payload: {
+                        tokenId: token.id,
+                    },
+                    taskId: null,
+                }),
+            ]);
+            await this.processRunningInstance(manager, instance);
+            return instance;
+        });
+    }
+    async processInstance(instanceId) {
+        await this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                instanceId,
+            ]);
+            const instance = await manager
+                .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+                .findOne({ where: { id: instanceId } });
+            if (!instance) {
+                throw new common_1.NotFoundException(`Approval instance ${instanceId} was not found`);
+            }
+            await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.ENGINE_PROCESS_REQUESTED,
+                instanceId,
+                nodeId: null,
+                payload: {
+                    state: instance.state,
+                },
+                taskId: null,
+            }));
+            if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+                return;
+            }
+            await this.processRunningInstance(manager, instance);
+        });
+    }
+    async decideTask(input) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+            const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+            const taskDecisionRepository = manager.getRepository(task_decision_entity_1.TaskDecisionEntity);
+            const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+            const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+            const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+            const task = await taskRepository.findOne({
+                where: { id: input.taskId },
+            });
+            if (!task) {
+                throw new common_1.NotFoundException(`Task ${input.taskId} was not found`);
+            }
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                task.instanceId,
+            ]);
+            if (task.status !== workflow_engine_enums_1.TaskStatusEnum.PENDING &&
+                task.status !== workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS) {
+                throw new common_1.ConflictException(`Task ${task.id} is not pending`);
+            }
+            const taskCandidates = await taskCandidateRepository.find({
+                where: { taskId: task.id },
+            });
+            const actorCandidate = taskCandidates.find((candidate) => candidate.memberId === input.decidedByMemberId);
+            const isDirectAssignee = task.assigneeMemberId === input.decidedByMemberId;
+            if (!isDirectAssignee && !actorCandidate) {
+                throw new common_1.ConflictException(`Task ${task.id} is assigned to another member`);
+            }
+            if (actorCandidate &&
+                actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING &&
+                actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED) {
+                throw new common_1.ConflictException(`Task ${task.id} was already decided by this member`);
+            }
+            if (input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
+                input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.REJECTED &&
+                input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.RETURNED &&
+                input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED) {
+                throw new common_1.ConflictException(`Task decision action ${input.action} is not supported yet`);
+            }
+            const decisionComment = input.comment?.trim() || null;
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.REJECTED &&
+                !decisionComment) {
+                throw new common_1.BadRequestException('Reject decision comment is required');
+            }
+            const transferToMemberId = input.transferToMemberId?.trim() || null;
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                !transferToMemberId) {
+                throw new common_1.BadRequestException('Transfer target member is required');
+            }
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                transferToMemberId === input.decidedByMemberId) {
+                throw new common_1.ConflictException('Transfer target must be a different member');
+            }
+            const instance = await instanceRepository.findOne({
+                where: { id: task.instanceId },
+            });
+            if (!instance) {
+                throw new common_1.NotFoundException(`Approval instance ${task.instanceId} was not found`);
+            }
+            if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} is not running`);
+            }
+            const returnToNodeId = input.action === workflow_engine_enums_1.TaskDecisionActionEnum.RETURNED
+                ? readReturnTargetNodeId(instance.workflowSnapshot, task.nodeId, input.returnToNodeId)
+                : null;
+            const decidedAt = new Date();
+            const claimedTask = await taskRepository.save({
+                ...task,
+                assigneeMemberId: task.assigneeMemberId ?? input.decidedByMemberId,
+                openedAt: task.openedAt ?? decidedAt,
+                originalAssigneeMemberId: task.originalAssigneeMemberId ??
+                    actorCandidate?.originalMemberId ??
+                    input.decidedByMemberId,
+                status: workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS,
+            });
+            const claimedCandidate = actorCandidate
+                ? await taskCandidateRepository.save({
+                    ...actorCandidate,
+                    claimedAt: actorCandidate.claimedAt ?? decidedAt,
+                    status: workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED,
+                })
+                : null;
+            const signature = await this.signatureService.signTaskDecision(manager, {
+                action: input.action,
+                comment: decisionComment,
+                decidedAt,
+                instance,
+                returnToNodeId,
+                signerMemberId: input.decidedByMemberId,
+                task: claimedTask,
+                transferToMemberId,
+            });
+            const decision = await taskDecisionRepository.save(taskDecisionRepository.create({
+                action: input.action,
+                comment: decisionComment,
+                decidedAt,
+                decidedByMemberId: input.decidedByMemberId,
+                returnToNodeId,
+                signatureId: signature.id,
+                taskId: task.id,
+                transferToMemberId,
+            }));
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED) {
+                await this.transferTask(manager, instance, claimedTask, decision, signature, transferToMemberId, decisionComment, decidedAt, claimedCandidate);
+                return decision;
+            }
+            const nextCandidateRows = await this.markTaskCandidateDecision({
+                action: input.action,
+                candidate: claimedCandidate,
+                candidates: taskCandidates,
+                decidedAt,
+                manager,
+                task: claimedTask,
+            });
+            const shouldCompleteTask = shouldCompleteTaskAfterDecision({
+                action: input.action,
+                candidates: nextCandidateRows,
+                decisionPolicy: readDecisionPolicySnapshot(claimedTask),
+            });
+            const completedTask = shouldCompleteTask
+                ? await taskRepository.save({
+                    ...claimedTask,
+                    completedAt: decidedAt,
+                    status: workflow_engine_enums_1.TaskStatusEnum.COMPLETED,
+                })
+                : await taskRepository.save({
+                    ...claimedTask,
+                    status: workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS,
+                });
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: input.decidedByMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_DECIDED,
+                instanceId: instance.id,
+                nodeId: claimedTask.nodeId,
+                payload: {
+                    action: input.action,
+                    comment: decisionComment,
+                    decisionId: decision.id,
+                    signatureId: signature.id,
+                    signedPayloadHash: signature.signedPayloadHash,
+                },
+                taskId: completedTask.id,
+            }));
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
+                shouldCompleteTask) {
+                const token = await tokenRepository.findOne({
+                    where: { id: claimedTask.tokenId },
+                });
+                if (!token) {
+                    throw new common_1.NotFoundException(`Workflow token ${claimedTask.tokenId} was not found`);
+                }
+                if (token.status !== workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING) {
+                    throw new common_1.ConflictException(`Workflow token ${token.id} is not waiting for a task decision`);
+                }
+                const activeToken = await tokenRepository.save({
+                    ...token,
+                    consumedAt: null,
+                    status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+                });
+                await this.advanceTokenToOutgoingNodes(manager, instance, activeToken, readWorkflowNodeOrThrow(instance.workflowSnapshot, claimedTask.nodeId));
+                await this.processRunningInstance(manager, instance);
+                return decision;
+            }
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED) {
+                return decision;
+            }
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.RETURNED) {
+                await this.returnInstanceToNode(manager, instance, completedTask, returnToNodeId, decidedAt);
+                return decision;
+            }
+            await this.rejectInstance(manager, instance, completedTask, decidedAt);
+            return decision;
+        });
+    }
+    async cancelApprovalInstance(input) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                input.instanceId,
+            ]);
+            const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+            const instance = await instanceRepository.findOne({
+                where: { id: input.instanceId },
+            });
+            if (!instance) {
+                throw new common_1.NotFoundException(`Approval instance ${input.instanceId} was not found`);
+            }
+            if (instance.initiatorMemberId !== input.cancelledByMemberId) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} can only be cancelled by its initiator`);
+            }
+            if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING &&
+                instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} is not cancellable`);
+            }
+            const cancelledAt = new Date();
+            await this.consumeOpenRuntimeState(manager, instance, cancelledAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
+            const cancelledInstance = await instanceRepository.save({
+                ...instance,
+                completedAt: cancelledAt,
+                state: workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED,
+            });
+            await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+                actorMemberId: input.cancelledByMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_CANCELLED,
+                instanceId: instance.id,
+                nodeId: null,
+                payload: {
+                    comment: input.comment?.trim() || null,
+                },
+                taskId: null,
+            }));
+            return cancelledInstance;
+        });
+    }
+    async resubmitApprovalInstance(input) {
+        const formData = parseJsonObject(input.formDataJson, 'formDataJson');
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                input.instanceId,
+            ]);
+            const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+            const instance = await instanceRepository.findOne({
+                where: { id: input.instanceId },
+            });
+            if (!instance) {
+                throw new common_1.NotFoundException(`Approval instance ${input.instanceId} was not found`);
+            }
+            if (instance.initiatorMemberId !== input.initiatorMemberId) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} can only be resubmitted by its initiator`);
+            }
+            if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED) {
+                throw new common_1.ConflictException(`Approval instance ${instance.id} is not returned`);
+            }
+            validateSubmittedFormData(readFormDefinitionSnapshotSchema(instance.formDefinitionSnapshot), formData);
+            const resubmittedInstance = await instanceRepository.save({
+                ...instance,
+                completedAt: null,
+                formData,
+                state: workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING,
+                title: input.title?.trim() || instance.title,
+            });
+            await this.attachmentService.bindFormDataAttachmentsToInstance(manager, {
+                formData,
+                instanceId: instance.id,
+            });
+            const returnedContext = await this.readLatestReturnedInstanceContext(manager, instance.id);
+            const runtimeInstance = returnedContext?.resubmitStrategy === 'FROM_RETURN_POINT'
+                ? await this.resumeReturnedInstanceFromReturnPoint(manager, resubmittedInstance, returnedContext, new Date())
+                : resubmittedInstance;
+            await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+                actorMemberId: input.initiatorMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_RESUBMITTED,
+                instanceId: instance.id,
+                nodeId: null,
+                payload: {
+                    resubmitStrategy: returnedContext?.resubmitStrategy ?? 'RESTART',
+                },
+                taskId: null,
+            }));
+            await this.processRunningInstance(manager, runtimeInstance);
+            return runtimeInstance;
+        });
+    }
+    dryRunApprovalWorkflow(input) {
+        const workflowDefinition = parseWorkflowDefinition(input.workflowDefinitionJson);
+        const formData = parseJsonObject(input.formDataJson, 'formDataJson');
+        const initiatorMetadataSnapshot = input.initiatorMetadataSnapshotJson
+            ? parseJsonObject(input.initiatorMetadataSnapshotJson, 'initiatorMetadataSnapshotJson')
+            : readDefaultInitiatorMetadataSnapshot(input.initiatorMemberId);
+        try {
+            return Object.assign(new workflow_dry_run_object_1.WorkflowDryRunResultObject(), {
+                errors: [],
+                steps: this.simulateWorkflow({
+                    formData,
+                    initiatorMemberId: input.initiatorMemberId,
+                    initiatorMetadataSnapshot,
+                    workflowDefinition,
+                }),
+                valid: true,
+            });
+        }
+        catch (error) {
+            return Object.assign(new workflow_dry_run_object_1.WorkflowDryRunResultObject(), {
+                errors: [error instanceof Error ? error.message : 'Dry run failed'],
+                steps: [],
+                valid: false,
+            });
+        }
+    }
+    simulateWorkflow(input) {
+        const startNode = input.workflowDefinition.nodes.find((node) => node.type === 'startEvent');
+        if (!startNode) {
+            throw new common_1.BadRequestException('Workflow does not include a startEvent');
+        }
+        return this.simulateWorkflowPath({
+            ...input,
+            depth: 0,
+            incomingEdge: null,
+            lastDecision: null,
+            nodeId: startNode.id,
+            steps: [],
+            visitedNodeIds: new Set(),
+        });
+    }
+    simulateWorkflowPath(input) {
+        if (input.depth > MAX_PROCESSING_STEPS) {
+            throw new common_1.ConflictException('Dry run exceeded maximum processing steps');
+        }
+        const node = readWorkflowNodeOrThrow(input.workflowDefinition, input.nodeId);
+        const visitKey = `${input.nodeId}:${input.incomingEdge?.id ?? 'start'}`;
+        const entryCondition = readNodeEntryCondition(node);
+        if (input.visitedNodeIds.has(visitKey)) {
+            return [
+                ...input.steps,
+                createDryRunStep({
+                    assigneeMemberId: null,
+                    edge: input.incomingEdge,
+                    edgeMatched: null,
+                    edgeReason: null,
+                    entryCondition,
+                    entryConditionMet: null,
+                    message: '偵測到循環路徑，已停止此分支。',
+                    node,
+                    status: 'STOPPED',
+                    stepIndex: input.steps.length,
+                }),
+            ];
+        }
+        const nextVisitedNodeIds = new Set([...input.visitedNodeIds, visitKey]);
+        const entryConditionMet = this.conditionService.evaluateBoolean(entryCondition, buildDryRunExpressionContext(input, input.lastDecision), `workflow.nodes.${node.id}.data.entryCondition`);
+        const assigneeMemberId = entryConditionMet && node.type === 'userTask'
+            ? this.resolveDryRunAssigneeMemberId(input, node.data.approverResolver, `workflow.nodes.${node.id}.data.approverResolver`)
+            : null;
+        const nextLastDecision = entryConditionMet && node.type === 'userTask'
+            ? {
+                action: workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED,
+                assigneeMemberId,
+                nodeId: node.id,
+            }
+            : input.lastDecision;
+        const nextSteps = [
+            ...input.steps,
+            createDryRunStep({
+                assigneeMemberId,
+                edge: input.incomingEdge,
+                edgeMatched: input.incomingEdge ? true : null,
+                edgeReason: readDryRunEdgeReason(input.incomingEdge),
+                entryCondition,
+                entryConditionMet,
+                message: readDryRunStepMessage(node, entryConditionMet),
+                node,
+                status: readDryRunStepStatus(node, entryConditionMet),
+                stepIndex: input.steps.length,
+            }),
+        ];
+        if (!entryConditionMet || node.type === 'endEvent') {
+            if (node.type === 'endEvent') {
+                return nextSteps;
+            }
+            return readOutgoingEdgesOrThrow(input.workflowDefinition, node.id).reduce((steps, edge) => this.simulateWorkflowPath({
+                ...input,
+                depth: input.depth + 1,
+                incomingEdge: edge,
+                lastDecision: nextLastDecision,
+                nodeId: edge.target,
+                steps,
+                visitedNodeIds: nextVisitedNodeIds,
+            }), nextSteps);
+        }
+        const outgoingEdges = this.readDryRunAvailableOutgoingEdges(input, node, nextLastDecision);
+        return outgoingEdges.reduce((steps, edge) => this.simulateWorkflowPath({
+            ...input,
+            depth: input.depth + 1,
+            incomingEdge: edge,
+            lastDecision: nextLastDecision,
+            nodeId: edge.target,
+            steps,
+            visitedNodeIds: nextVisitedNodeIds,
+        }), nextSteps);
+    }
+    readDryRunAvailableOutgoingEdges(input, node, lastDecision) {
+        if (node.type === 'endEvent') {
+            return [];
+        }
+        const outgoingEdges = readOutgoingEdgesOrThrow(input.workflowDefinition, node.id);
+        const conditionalEdges = outgoingEdges.filter((edge) => !edge.data.isDefault && edgeHasCondition(edge));
+        if (conditionalEdges.length === 0) {
+            return outgoingEdges;
+        }
+        const matchingEdges = conditionalEdges.filter((edge) => this.evaluateDryRunEdge(input, edge, lastDecision));
+        if (matchingEdges.length > 0) {
+            return node.type === 'exclusiveGateway'
+                ? [matchingEdges[0]]
+                : matchingEdges;
+        }
+        const defaultEdges = outgoingEdges.filter((edge) => edge.data.isDefault);
+        if (defaultEdges.length > 0) {
+            return node.type === 'exclusiveGateway'
+                ? [defaultEdges[0]]
+                : defaultEdges;
+        }
+        throw new common_1.ConflictException(`Workflow node ${node.id} has no matching outgoing edge`);
+    }
+    evaluateDryRunEdge(input, edge, lastDecision) {
+        const expression = edge.data.condition?.trim();
+        if (expression) {
+            return this.conditionService.evaluateBoolean(expression, buildDryRunExpressionContext(input, lastDecision), `workflow.edges.${edge.id}.data.condition`);
+        }
+        return (0, workflow_condition_evaluator_1.evaluateWorkflowEdgeCondition)(edge, { formData: input.formData });
+    }
+    resolveDryRunAssigneeMemberId(input, resolver, label) {
+        if (resolver.type === 'DIRECT') {
+            return readMemberIdFromValue(resolver.memberIds, label);
+        }
+        if (resolver.type === 'DYNAMIC_FORM') {
+            return readMemberIdFromValue(readValueAtPath(input.formData, resolver.formPath), `${label}.formPath`);
+        }
+        if (resolver.type === 'EXPRESSION') {
+            return readMemberIdFromValue(this.conditionService.evaluateValue(resolver.expression, buildDryRunExpressionContext(input, null), `${label}.expression`), `${label}.expression`);
+        }
+        if (resolver.type === 'POSITION') {
+            return `position:${resolver.positionId}`;
+        }
+        if (resolver.type === 'ORG_UNIT_MEMBER') {
+            return `orgUnitMember:${resolver.orgUnitId}`;
+        }
+        if (resolver.type === 'ORG_UNIT_POSITION') {
+            return `orgUnitPosition:${resolver.orgUnitId}:${resolver.positionId}`;
+        }
+        if (resolver.type === 'ORG_UNIT_MANAGER') {
+            return `orgUnitManager:${resolver.orgUnitId}`;
+        }
+        return readMemberIdFromValue(readManagerMemberIdFromInitiatorSnapshot(input.initiatorMetadataSnapshot, resolver.levelsUp), label);
+    }
+    async getApprovalInstance(id, scope) {
+        const instance = await this.approvalInstanceRepository.findOne({
+            where: { id },
+        });
+        if (!instance) {
+            throw new common_1.NotFoundException(`Approval instance ${id} was not found`);
+        }
+        if (scope &&
+            !canReadAllWorkflows(scope) &&
+            !(await this.isApprovalInstanceReadableByMember(instance, scope.memberId))) {
+            throw new common_1.NotFoundException(`Approval instance ${id} was not found`);
+        }
+        return instance;
+    }
+    async listApprovalInstances(scope, options = {}) {
+        const queryBuilder = await this.createFilteredApprovalInstanceQueryBuilder(scope, options);
+        if (!queryBuilder) {
+            return [];
+        }
+        queryBuilder.orderBy('"approvalInstance"."created_at"', 'DESC');
+        if (shouldPaginateList(options)) {
+            queryBuilder
+                .skip(readPageOffset(options.page, options.pageSize))
+                .take(normalizePageSize(options.pageSize));
+        }
+        return queryBuilder.getMany();
+    }
+    async countApprovalInstances(scope, options = {}) {
+        const queryBuilder = await this.createFilteredApprovalInstanceQueryBuilder(scope, options);
+        return queryBuilder ? queryBuilder.getCount() : 0;
+    }
+    async readApprovalInstancePageInfo(scope, options = {}) {
+        const totalCount = await this.countApprovalInstances(scope, options);
+        const page = normalizePage(options.page);
+        const pageSize = normalizePageSize(options.pageSize);
+        const totalPages = Math.max(Math.ceil(totalCount / pageSize), 1);
+        return {
+            hasNextPage: page < totalPages,
+            hasPreviousPage: page > 1,
+            page,
+            pageSize,
+            totalCount,
+            totalPages,
+        };
+    }
+    async createFilteredApprovalInstanceQueryBuilder(scope, options = {}) {
+        const queryBuilder = this.approvalInstanceRepository.createQueryBuilder('approvalInstance');
+        const hasReadableInstances = this.applyReadableInstanceFilter(queryBuilder, scope, options);
+        if (!hasReadableInstances) {
+            return null;
+        }
+        const templateId = normalizeText(options.templateId);
+        if (options.state?.length) {
+            queryBuilder.andWhere('"approvalInstance"."state" IN (:...states)', {
+                states: [...options.state],
+            });
+        }
+        if (templateId) {
+            queryBuilder.andWhere('"approvalInstance"."template_id" = :templateId', {
+                templateId,
+            });
+        }
+        applyApprovalInstanceSearchFilter(queryBuilder, options.searchText);
+        return queryBuilder;
+    }
+    applyReadableInstanceFilter(queryBuilder, scope, options) {
+        if (!scope) {
+            return true;
+        }
+        const view = options.view ?? workflow_engine_enums_1.ApprovalInstanceListViewEnum.ALL;
+        if (view === workflow_engine_enums_1.ApprovalInstanceListViewEnum.SENT) {
+            queryBuilder.andWhere('"approvalInstance"."initiator_member_id" = :readableMemberId', {
+                readableMemberId: scope.memberId,
+            });
+            return true;
+        }
+        if (view === workflow_engine_enums_1.ApprovalInstanceListViewEnum.CC) {
+            queryBuilder.andWhere(`
+          EXISTS (
+            SELECT 1
+            FROM "notifications" "readableNotification"
+            WHERE "readableNotification"."instance_id" = "approvalInstance"."id"
+              AND "readableNotification"."recipient_member_id" = :readableMemberId
+          )
+        `, {
+                readableMemberId: scope.memberId,
+            });
+            return true;
+        }
+        if (canReadAllWorkflows(scope)) {
+            return true;
+        }
+        queryBuilder.andWhere(`
+        (
+          "approvalInstance"."initiator_member_id" = :readableMemberId
+          OR EXISTS (
+            SELECT 1
+            FROM "tasks" "readableTask"
+            WHERE "readableTask"."instance_id" = "approvalInstance"."id"
+              AND (
+                "readableTask"."assignee_member_id" = :readableMemberId
+                OR "readableTask"."original_assignee_member_id" = :readableMemberId
+              )
+          )
+          OR EXISTS (
+            SELECT 1
+            FROM "task_candidates" "readableCandidate"
+            INNER JOIN "tasks" "readableCandidateTask"
+              ON "readableCandidateTask"."id" = "readableCandidate"."task_id"
+            WHERE "readableCandidateTask"."instance_id" = "approvalInstance"."id"
+              AND (
+                "readableCandidate"."member_id" = :readableMemberId
+                OR "readableCandidate"."original_member_id" = :readableMemberId
+              )
+          )
+          OR EXISTS (
+            SELECT 1
+            FROM "task_decisions" "readableDecision"
+            INNER JOIN "tasks" "readableDecisionTask"
+              ON "readableDecisionTask"."id" = "readableDecision"."task_id"
+            WHERE "readableDecisionTask"."instance_id" = "approvalInstance"."id"
+              AND "readableDecision"."decided_by_member_id" = :readableMemberId
+          )
+        )
+      `, {
+            readableMemberId: scope.memberId,
+        });
+        return true;
+    }
+    async readWorkflowDashboardSummary(scope, options = {}) {
+        const instances = (await this.listApprovalInstances(scope, {
+            view: workflow_engine_enums_1.ApprovalInstanceListViewEnum.ALL,
+        })).filter((instance) => isInstanceWithinRange(instance, options));
+        const instanceIds = instances.map((instance) => instance.id);
+        const openTasks = instanceIds.length
+            ? await this.taskRepository.find({
+                where: {
+                    instanceId: (0, typeorm_2.In)(instanceIds),
+                    status: (0, typeorm_2.In)([workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS]),
+                },
+            })
+            : [];
+        const now = Date.now();
+        return {
+            activeInstanceCount: instances.filter((instance) => instance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING).length,
+            completedInstanceCount: instances.filter((instance) => instance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED).length,
+            overdueTaskCount: openTasks.filter((task) => task.slaDueAt && task.slaDueAt.getTime() <= now).length,
+            pendingTaskCount: openTasks.length,
+            rejectedInstanceCount: instances.filter((instance) => instance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED).length,
+            totalInstanceCount: instances.length,
+        };
+    }
+    async listLaunchableApprovalTemplates(memberId) {
+        const templates = await this.approvalTemplateRepository.find({
+            order: { updatedAt: 'DESC' },
+        });
+        const currentVersionIds = templates
+            .map((template) => template.currentVersionId)
+            .filter((versionId) => Boolean(versionId));
+        if (!currentVersionIds.length) {
+            return [];
+        }
+        const versions = await this.approvalTemplateVersionRepository.find({
+            where: {
+                id: (0, typeorm_2.In)(currentVersionIds),
+                status: template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED,
+            },
+        });
+        const versionById = new Map(versions.map((version) => [
+            version.id,
+            version,
+        ]));
+        const initiatorMetadataSnapshot = await this.readDefaultInitiatorMetadataSnapshot(memberId);
+        return templates.filter((template) => {
+            const currentVersion = template.currentVersionId
+                ? (versionById.get(template.currentVersionId) ?? null)
+                : null;
+            if (!currentVersion?.formDefinitionVersionId) {
+                return false;
+            }
+            return this.conditionService.evaluateBoolean(currentVersion.initiatorPolicyCel, buildInitiatorPolicyContext(initiatorMetadataSnapshot), 'initiatorPolicyCel');
+        });
+    }
+    async listWorkflowTokens(instanceId, scope) {
+        await this.getApprovalInstance(instanceId, scope);
+        return this.workflowTokenRepository.find({
+            order: { createdAt: 'ASC' },
+            where: { instanceId },
+        });
+    }
+    async listTasks(instanceId, scope) {
+        await this.getApprovalInstance(instanceId, scope);
+        return this.attachTaskCandidateSummaries(await this.taskRepository.find({
+            order: { createdAt: 'ASC' },
+            where: { instanceId },
+        }));
+    }
+    async listInboxTasks(assigneeMemberId) {
+        const directTasks = await this.taskRepository.find({
+            order: { createdAt: 'DESC' },
+            where: [
+                {
+                    assigneeMemberId,
+                    status: (0, typeorm_2.In)([workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS]),
+                },
+            ],
+        });
+        const candidateRows = await this.taskCandidateRepository.find({
+            where: {
+                memberId: assigneeMemberId,
+                status: (0, typeorm_2.In)([
+                    workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+                    workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED,
+                ]),
+            },
+        });
+        const candidateTasks = candidateRows.length
+            ? await this.taskRepository.find({
+                order: { createdAt: 'DESC' },
+                where: {
+                    id: (0, typeorm_2.In)(candidateRows.map((candidate) => candidate.taskId)),
+                    status: (0, typeorm_2.In)([workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS]),
+                },
+            })
+            : [];
+        return this.attachTaskCandidateSummaries(uniqueTasksById([...directTasks, ...candidateTasks]));
+    }
+    async listApprovalHistoryTasks(assigneeMemberId) {
+        const directTasks = await this.taskRepository.find({
+            order: { completedAt: 'DESC', createdAt: 'DESC' },
+            take: DEFAULT_APPROVAL_HISTORY_TASK_LIMIT,
+            where: { assigneeMemberId, status: workflow_engine_enums_1.TaskStatusEnum.COMPLETED },
+        });
+        const candidateRows = await this.taskCandidateRepository.find({
+            where: {
+                memberId: assigneeMemberId,
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
+            },
+        });
+        const candidateTasks = candidateRows.length
+            ? await this.taskRepository.find({
+                order: { completedAt: 'DESC', createdAt: 'DESC' },
+                take: DEFAULT_APPROVAL_HISTORY_TASK_LIMIT,
+                where: {
+                    id: (0, typeorm_2.In)(candidateRows.map((candidate) => candidate.taskId)),
+                    status: workflow_engine_enums_1.TaskStatusEnum.COMPLETED,
+                },
+            })
+            : [];
+        return this.attachTaskCandidateSummaries(uniqueTasksById([...directTasks, ...candidateTasks]));
+    }
+    async listTaskDecisions(taskId, scope) {
+        await this.assertTaskReadable(taskId, scope);
+        return this.taskDecisionRepository.find({
+            order: { decidedAt: 'ASC' },
+            where: { taskId },
+        });
+    }
+    async listTaskCandidates(taskId, scope) {
+        await this.assertTaskReadable(taskId, scope);
+        return this.taskCandidateRepository.find({
+            order: { createdAt: 'ASC', id: 'ASC' },
+            where: { taskId },
+        });
+    }
+    async attachTaskCandidateSummaries(tasks) {
+        if (!tasks.length) {
+            return tasks;
+        }
+        const candidates = await this.taskCandidateRepository.find({
+            order: { createdAt: 'ASC', id: 'ASC' },
+            where: { taskId: (0, typeorm_2.In)(tasks.map((task) => task.id)) },
+        });
+        const candidatesByTaskId = candidates.reduce((currentMap, candidate) => {
+            const nextMap = new Map(currentMap);
+            const memberIds = nextMap.get(candidate.taskId) ?? [];
+            nextMap.set(candidate.taskId, [...memberIds, candidate.memberId]);
+            return nextMap;
+        }, new Map());
+        return tasks.map((task) => Object.assign(new task_entity_1.TaskEntity(), task, {
+            candidateMemberIds: candidatesByTaskId.get(task.id) ?? [],
+        }));
+    }
+    async readDefaultInitiatorMetadataSnapshot(memberId) {
+        const today = toDateOnlyString(new Date());
+        const memberships = (await this.approvalInstanceRepository.manager
+            .getRepository(membership_entity_1.MembershipEntity)
+            .find({ where: { memberId } }))
+            .filter((membership) => isDateRangeActive(membership, today))
+            .sort(compareMembership);
+        const primaryMembership = memberships[0] ?? null;
+        const positionIds = uniqueTexts(memberships
+            .map((membership) => membership.positionId)
+            .filter((positionId) => Boolean(positionId)));
+        return {
+            customFields: {},
+            memberId,
+            orgUnitIds: uniqueTexts(memberships.map((membership) => membership.orgUnitId)),
+            positionId: primaryMembership?.positionId ?? null,
+            positionIds,
+            primaryOrgUnitId: primaryMembership?.orgUnitId ?? null,
+        };
+    }
+    async listActivityLogs(instanceId, scope) {
+        await this.getApprovalInstance(instanceId, scope);
+        return this.activityLogRepository.find({
+            order: { createdAt: 'ASC' },
+            where: { instanceId },
+        });
+    }
+    async assertTaskReadable(taskId, scope) {
+        const task = await this.taskRepository.findOne({ where: { id: taskId } });
+        if (!task) {
+            throw new common_1.NotFoundException(`Task ${taskId} was not found`);
+        }
+        await this.getApprovalInstance(task.instanceId, scope);
+        return task;
+    }
+    async isApprovalInstanceReadableByMember(instance, memberId) {
+        if (instance.initiatorMemberId === memberId) {
+            return true;
+        }
+        const tasks = await this.taskRepository.find({
+            where: { instanceId: instance.id },
+        });
+        if (tasks.some((task) => isTaskRelatedToMember(task, memberId))) {
+            return true;
+        }
+        const taskIds = tasks.map((task) => task.id);
+        if (!taskIds.length) {
+            return false;
+        }
+        const candidates = await this.taskCandidateRepository.find({
+            where: { taskId: (0, typeorm_2.In)(taskIds) },
+        });
+        if (candidates.some((candidate) => candidate.memberId === memberId ||
+            candidate.originalMemberId === memberId)) {
+            return true;
+        }
+        const decisions = await this.taskDecisionRepository.find({
+            where: { taskId: (0, typeorm_2.In)(taskIds) },
+        });
+        return decisions.some((decision) => decision.decidedByMemberId === memberId);
+    }
+    async processActiveToken(manager, instance, token) {
+        const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, token.currentNodeId);
+        if (!(await this.isNodeEntryReady(manager, instance, token, node))) {
+            return;
+        }
+        if (!this.isNodeEntryConditionMet(instance, node)) {
+            await this.skipNodeByEntryCondition(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'startEvent') {
+            await this.advanceTokenToOutgoingNodes(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'endEvent') {
+            await this.completeTokenAtEndNode(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'userTask') {
+            await this.createUserTaskForToken(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'serviceTask') {
+            await this.executeServiceTask(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'exclusiveGateway') {
+            await this.processExclusiveGateway(manager, instance, token, node);
+            return;
+        }
+        if (node.type === 'parallelGateway') {
+            await this.advanceTokenToOutgoingNodes(manager, instance, token, node);
+            return;
+        }
+        return;
+    }
+    async processRunningInstance(manager, instance) {
+        for (let step = 0; step < MAX_PROCESSING_STEPS; step += 1) {
+            const token = await manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity).findOne({
+                order: { createdAt: 'ASC' },
+                where: {
+                    instanceId: instance.id,
+                    status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+                },
+            });
+            if (!token) {
+                await this.completeInstanceIfNoOpenRuntimeState(manager, instance);
+                return;
+            }
+            await this.processActiveToken(manager, instance, token);
+        }
+        throw new common_1.ConflictException(`Approval instance ${instance.id} exceeded maximum processing steps`);
+    }
+    async completeInstanceIfNoOpenRuntimeState(manager, instance) {
+        if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+            return;
+        }
+        const waitingTokens = await manager
+            .getRepository(workflow_token_entity_1.WorkflowTokenEntity)
+            .find({
+            where: {
+                instanceId: instance.id,
+                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+            },
+        });
+        if (waitingTokens.length > 0) {
+            return;
+        }
+        const completedAt = new Date();
+        const completedInstance = await manager
+            .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+            .save({
+            ...instance,
+            completedAt,
+            state: workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED,
+        });
+        await this.notificationService.createInstanceCompletedNotification({
+            instance: completedInstance,
+            manager,
+        });
+    }
+    async isNodeEntryReady(manager, instance, token, node) {
+        if (node.type === 'startEvent') {
+            return true;
+        }
+        const incomingEdges = readIncomingEdges(instance.workflowSnapshot, node.id);
+        if (incomingEdges.length < 2) {
+            return true;
+        }
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const activeOrWaitingTokens = (await tokenRepository.find({
+            where: { instanceId: instance.id },
+        })).filter((candidate) => candidate.currentNodeId === node.id &&
+            (candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+                candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING));
+        const arrivedTokens = activeOrWaitingTokens.some((candidate) => candidate.id === token.id)
+            ? activeOrWaitingTokens
+            : [...activeOrWaitingTokens, token];
+        if ((node.data.triggerMode ?? 'AND') === 'OR') {
+            await this.cancelAlternativeTokensForOrTrigger(manager, instance, token, node.id);
+            await this.consumeJoinedTokens(manager, arrivedTokens.filter((candidate) => candidate.id !== token.id));
+            return true;
+        }
+        const pendingTokensThatMayReachNode = (await tokenRepository.find({
+            where: { instanceId: instance.id },
+        })).filter((candidate) => candidate.id !== token.id &&
+            !arrivedTokens.some((arrivedToken) => arrivedToken.id === candidate.id) &&
+            (candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+                candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING) &&
+            hasPathToNode(instance.workflowSnapshot, candidate.currentNodeId, node.id));
+        if (arrivedTokens.length < incomingEdges.length &&
+            pendingTokensThatMayReachNode.length > 0) {
+            await tokenRepository.save({
+                ...token,
+                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+            });
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+                instanceId: instance.id,
+                nodeId: node.id,
+                payload: {
+                    arrivedCount: arrivedTokens.length,
+                    requiredCount: incomingEdges.length,
+                    tokenId: token.id,
+                    triggerMode: 'AND',
+                },
+                taskId: null,
+            }));
+            return false;
+        }
+        await this.consumeJoinedTokens(manager, arrivedTokens.filter((candidate) => candidate.id !== token.id));
+        return true;
+    }
+    async advanceTokenToOutgoingNodes(manager, instance, token, node) {
+        const edges = await this.readAvailableOutgoingEdges(manager, instance, node);
+        if (edges.length === 1) {
+            await this.advanceTokenAlongEdge(manager, instance, token, node, edges[0]);
+            return;
+        }
+        await this.forkTokenAlongEdges(manager, instance, token, node, edges);
+    }
+    isNodeEntryConditionMet(instance, node) {
+        const entryCondition = readNodeEntryCondition(node);
+        return this.conditionService.evaluateBoolean(entryCondition, buildWorkflowExpressionContext(instance), `workflow.nodes.${node.id}.data.entryCondition`);
+    }
+    async skipNodeByEntryCondition(manager, instance, token, node) {
+        await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+            instanceId: instance.id,
+            nodeId: node.id,
+            payload: {
+                skippedByEntryCondition: true,
+                tokenId: token.id,
+            },
+            taskId: null,
+        }));
+        await this.advanceTokenToOutgoingNodes(manager, instance, token, node);
+    }
+    async readAvailableOutgoingEdges(manager, instance, node) {
+        const outgoingEdges = readOutgoingEdgesOrThrow(instance.workflowSnapshot, node.id);
+        const conditionalEdges = outgoingEdges.filter((edge) => !edge.data.isDefault && edgeHasCondition(edge));
+        if (conditionalEdges.length === 0) {
+            return outgoingEdges;
+        }
+        const matchingEdges = (await Promise.all(conditionalEdges.map(async (edge) => (await this.evaluateWorkflowEdge(manager, instance, node, edge))
+            ? edge
+            : null))).filter((edge) => edge !== null);
+        if (matchingEdges.length > 0) {
+            return node.type === 'exclusiveGateway'
+                ? [matchingEdges[0]]
+                : matchingEdges;
+        }
+        const defaultEdges = outgoingEdges.filter((edge) => edge.data.isDefault);
+        if (defaultEdges.length > 0) {
+            return node.type === 'exclusiveGateway'
+                ? [defaultEdges[0]]
+                : defaultEdges;
+        }
+        throw new common_1.ConflictException(`Workflow node ${node.id} has no matching outgoing edge`);
+    }
+    async evaluateWorkflowEdge(manager, instance, node, edge) {
+        const expression = edge.data.condition?.trim();
+        if (expression) {
+            return this.conditionService.evaluateBoolean(expression, {
+                ...buildWorkflowExpressionContext(instance),
+                lastDecision: await this.readLastDecisionContext(manager, instance.id, node.id),
+            }, `workflow.edges.${edge.id}.data.condition`);
+        }
+        return (0, workflow_condition_evaluator_1.evaluateWorkflowEdgeCondition)(edge, { formData: instance.formData });
+    }
+    async readLastDecisionContext(manager, instanceId, nodeId) {
+        const tasks = await manager.getRepository(task_entity_1.TaskEntity).find({
+            where: { instanceId, nodeId },
+        });
+        const taskIds = tasks.map((task) => task.id);
+        if (taskIds.length === 0) {
+            return null;
+        }
+        const decision = (await manager.getRepository(task_decision_entity_1.TaskDecisionEntity).find({
+            order: { decidedAt: 'DESC' },
+            where: { taskId: (0, typeorm_2.In)(taskIds) },
+        }))[0];
+        if (!decision) {
+            return null;
+        }
+        return {
+            action: decision.action,
+            comment: decision.comment,
+            decidedAt: decision.decidedAt.toISOString(),
+            decidedByMemberId: decision.decidedByMemberId,
+            returnToNodeId: decision.returnToNodeId,
+            taskId: decision.taskId,
+            transferToMemberId: decision.transferToMemberId,
+        };
+    }
+    async advanceTokenAlongEdge(manager, instance, token, node, edge) {
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const nextToken = await tokenRepository.save({
+            ...token,
+            currentNodeId: edge.target,
+        });
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+            instanceId: instance.id,
+            nodeId: edge.target,
+            payload: {
+                edgeId: edge.id,
+                fromNodeId: node.id,
+                tokenId: nextToken.id,
+                toNodeId: edge.target,
+            },
+            taskId: null,
+        }));
+    }
+    async forkTokenAlongEdges(manager, instance, token, node, edges) {
+        const forkedAt = new Date();
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        await tokenRepository.save({
+            ...token,
+            consumedAt: forkedAt,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        });
+        const childTokens = await tokenRepository.save(edges.map((edge) => tokenRepository.create({
+            consumedAt: null,
+            currentNodeId: edge.target,
+            instanceId: instance.id,
+            parentTokenId: token.id,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+        })));
+        await activityRepository.save([
+            activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+                instanceId: instance.id,
+                nodeId: node.id,
+                payload: {
+                    edgeIds: edges.map((edge) => edge.id),
+                    fromNodeId: node.id,
+                    tokenId: token.id,
+                    toNodeIds: edges.map((edge) => edge.target),
+                },
+                taskId: null,
+            }),
+            ...childTokens.map((childToken, index) => activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_CREATED,
+                instanceId: instance.id,
+                nodeId: childToken.currentNodeId,
+                payload: {
+                    edgeId: edges[index]?.id,
+                    parentTokenId: token.id,
+                    tokenId: childToken.id,
+                },
+                taskId: null,
+            })),
+        ]);
+    }
+    async completeTokenAtEndNode(manager, instance, token, node) {
+        const completedAt = new Date();
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const endState = node.data.endState ?? 'APPROVED';
+        const instanceState = endState === 'REJECTED'
+            ? workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED
+            : workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED;
+        await tokenRepository.save({
+            ...token,
+            consumedAt: completedAt,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        });
+        const hasOpenToken = (await tokenRepository.find({
+            where: { instanceId: instance.id },
+        })).some((candidate) => candidate.id !== token.id &&
+            (candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+                candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING));
+        if (!hasOpenToken) {
+            const completedInstance = await instanceRepository.save({
+                ...instance,
+                completedAt,
+                state: instanceState,
+            });
+            if (instanceState === workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED) {
+                await this.notificationService.createInstanceCompletedNotification({
+                    instance: completedInstance,
+                    manager,
+                });
+            }
+        }
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+            instanceId: instance.id,
+            nodeId: node.id,
+            payload: {
+                endState,
+                instanceState,
+                tokenId: token.id,
+            },
+            taskId: null,
+        }));
+    }
+    async createUserTaskForToken(manager, instance, token, node) {
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const existingTask = await taskRepository.findOne({
+            where: {
+                nodeId: node.id,
+                tokenId: token.id,
+            },
+        });
+        if (existingTask) {
+            await tokenRepository.save({
+                ...token,
+                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+            });
+            return;
+        }
+        const candidates = await this.resolveRuntimeTaskCandidates(manager, instance, node);
+        const primaryCandidate = candidates[0];
+        const now = new Date();
+        const task = await taskRepository.save(taskRepository.create({
+            assigneeMemberId: candidates.length === 1 ? primaryCandidate.memberId : null,
+            assignmentType: candidates.length === 1
+                ? workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER
+                : workflow_engine_enums_1.TaskAssignmentTypeEnum.CANDIDATE_GROUP,
+            completedAt: null,
+            createdAt: now,
+            decisionPolicySnapshot: node.data.decisionPolicy,
+            delegationChain: candidates.length === 1 ? primaryCandidate.delegationChain : [],
+            instanceId: instance.id,
+            nodeId: node.id,
+            openedAt: null,
+            originalAssigneeMemberId: candidates.length === 1 ? primaryCandidate.originalMemberId : null,
+            slaDueAt: (0, notification_service_1.calculateTaskSlaDueAt)({ node, now }),
+            status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
+            tokenId: token.id,
+        }));
+        const savedCandidates = await taskCandidateRepository.save(candidates.map((candidate) => taskCandidateRepository.create({
+            claimedAt: null,
+            createdAt: now,
+            decidedAt: null,
+            delegationChain: candidate.delegationChain,
+            memberId: candidate.memberId,
+            originalMemberId: candidate.originalMemberId,
+            sourceType: candidate.sourceType,
+            status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+            taskId: task.id,
+        })));
+        task.candidateMemberIds = savedCandidates.map((candidate) => candidate.memberId);
+        const singleCandidate = savedCandidates.length === 1 ? savedCandidates[0] : null;
+        await tokenRepository.save({
+            ...token,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
+        });
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+            instanceId: instance.id,
+            nodeId: node.id,
+            payload: {
+                assignmentType: task.assignmentType,
+                assigneeMemberId: singleCandidate?.memberId ?? null,
+                candidateMemberIds: savedCandidates.map((candidate) => candidate.memberId),
+                originalAssigneeMemberId: singleCandidate?.originalMemberId ?? null,
+                tokenId: token.id,
+            },
+            taskId: task.id,
+        }));
+        await savedCandidates.reduce(async (previous, candidate) => {
+            await previous;
+            await this.notificationService.createTaskAssignedNotification({
+                instance,
+                manager,
+                node,
+                task: Object.assign(new task_entity_1.TaskEntity(), task, {
+                    assigneeMemberId: candidate.memberId,
+                    delegationChain: candidate.delegationChain,
+                    originalAssigneeMemberId: candidate.originalMemberId,
+                }),
+            });
+        }, Promise.resolve());
+    }
+    async markTaskCandidateDecision({ action, candidate, candidates, decidedAt, manager, task, }) {
+        const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+        if (!candidate && candidates.length === 0 && task.assigneeMemberId) {
+            const legacyCandidate = await taskCandidateRepository.save(taskCandidateRepository.create({
+                claimedAt: task.openedAt ?? decidedAt,
+                createdAt: task.createdAt,
+                decidedAt,
+                delegationChain: task.delegationChain,
+                memberId: task.assigneeMemberId,
+                originalMemberId: task.originalAssigneeMemberId ?? task.assigneeMemberId,
+                sourceType: 'DIRECT',
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
+                taskId: task.id,
+            }));
+            return [legacyCandidate];
+        }
+        const completedCandidate = candidate
+            ? Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), candidate, {
+                claimedAt: candidate.claimedAt ?? decidedAt,
+                decidedAt,
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED,
+            })
+            : null;
+        const decisionPolicy = readDecisionPolicySnapshot(task);
+        const shouldCancelOpenCandidates = action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED ||
+            decisionPolicy.type === 'SINGLE' ||
+            decisionPolicy.type === 'PARALLEL_ANY';
+        const nextCandidates = candidates.map((currentCandidate) => {
+            if (currentCandidate.id === completedCandidate?.id) {
+                return completedCandidate;
+            }
+            if (shouldCancelOpenCandidates &&
+                (currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
+                    currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED)) {
+                return Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), currentCandidate, {
+                    decidedAt,
+                    status: workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED,
+                });
+            }
+            return currentCandidate;
+        });
+        if (nextCandidates.length > 0) {
+            await taskCandidateRepository.save(nextCandidates);
+        }
+        return nextCandidates;
+    }
+    async transferTask(manager, instance, task, decision, signature, transferToMemberId, decisionComment, decidedAt, actorCandidate) {
+        if (!transferToMemberId) {
+            throw new common_1.BadRequestException('Transfer target member is required');
+        }
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const transferringMemberId = task.assigneeMemberId;
+        if (!transferringMemberId) {
+            throw new common_1.ConflictException('Task must be claimed before transfer');
+        }
+        const nextDelegationChain = [
+            ...readDelegationSteps(task.delegationChain),
+            {
+                from: transferringMemberId,
+                reason: 'MANUAL_TRANSFER',
+                ruleId: null,
+                to: transferToMemberId,
+            },
+        ];
+        const transferredTask = await taskRepository.save({
+            ...task,
+            completedAt: decidedAt,
+            delegationChain: nextDelegationChain,
+            status: workflow_engine_enums_1.TaskStatusEnum.TRANSFERRED,
+        });
+        const nextTask = await taskRepository.save(taskRepository.create({
+            assigneeMemberId: transferToMemberId,
+            assignmentType: workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER,
+            completedAt: null,
+            decisionPolicySnapshot: { type: 'SINGLE' },
+            delegationChain: nextDelegationChain,
+            instanceId: task.instanceId,
+            nodeId: task.nodeId,
+            openedAt: null,
+            originalAssigneeMemberId: task.originalAssigneeMemberId,
+            slaDueAt: task.slaDueAt,
+            status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
+            tokenId: task.tokenId,
+        }));
+        await taskCandidateRepository.save([
+            ...(actorCandidate
+                ? [
+                    taskCandidateRepository.create({
+                        ...actorCandidate,
+                        decidedAt,
+                        status: workflow_engine_enums_1.TaskCandidateStatusEnum.TRANSFERRED,
+                    }),
+                ]
+                : []),
+            taskCandidateRepository.create({
+                claimedAt: null,
+                createdAt: decidedAt,
+                decidedAt: null,
+                delegationChain: nextDelegationChain,
+                memberId: transferToMemberId,
+                originalMemberId: task.originalAssigneeMemberId ?? transferToMemberId,
+                sourceType: 'DIRECT',
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+                taskId: nextTask.id,
+            }),
+        ]);
+        await activityRepository.save([
+            activityRepository.create({
+                actorMemberId: task.assigneeMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_DECIDED,
+                instanceId: instance.id,
+                nodeId: task.nodeId,
+                payload: {
+                    action: workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED,
+                    comment: decisionComment,
+                    decisionId: decision.id,
+                    signatureId: signature.id,
+                    signedPayloadHash: signature.signedPayloadHash,
+                    transferToMemberId,
+                },
+                taskId: transferredTask.id,
+            }),
+            activityRepository.create({
+                actorMemberId: transferringMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+                instanceId: instance.id,
+                nodeId: task.nodeId,
+                payload: {
+                    assigneeMemberId: transferToMemberId,
+                    delegationChain: nextDelegationChain,
+                    originalAssigneeMemberId: task.originalAssigneeMemberId,
+                    tokenId: task.tokenId,
+                    transferredFromTaskId: task.id,
+                },
+                taskId: nextTask.id,
+            }),
+        ]);
+        const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, task.nodeId);
+        if (node.type === 'userTask') {
+            await this.notificationService.createTaskAssignedNotification({
+                instance,
+                manager,
+                node,
+                task: nextTask,
+                transferred: true,
+            });
+        }
+    }
+    async resolveRuntimeTaskCandidates(manager, instance, node) {
+        const resolvedCandidates = await this.resolveApproverResolver(manager, instance, node.data.approverResolver, `簽核節點「${node.data.label}」`);
+        const context = {
+            formData: instance.formData,
+            initiatorMemberId: instance.initiatorMemberId,
+            initiatorMetadataSnapshot: instance.initiatorMetadataSnapshot,
+            instanceId: instance.id,
+            nodeId: node.id,
+            state: instance.state,
+            templateId: instance.templateId,
+            templateVersionId: instance.templateVersionId,
+            title: instance.title,
+        };
+        const delegatedCandidates = await Promise.all(resolvedCandidates.map(async (candidate) => {
+            const delegationResolution = await this.delegationService.resolveAssignee(candidate.memberId, context);
+            return {
+                delegationChain: delegationResolution.delegationChain,
+                memberId: delegationResolution.finalAssigneeMemberId,
+                originalMemberId: candidate.memberId,
+                sourceType: candidate.sourceType,
+            };
+        }));
+        const uniqueCandidates = uniqueRuntimeCandidates(delegatedCandidates);
+        if (uniqueCandidates.length === 0) {
+            throw new common_1.ConflictException(`簽核節點「${node.data.label}」 did not resolve to any member id`);
+        }
+        return uniqueCandidates;
+    }
+    async resolveApproverResolver(manager, instance, resolver, label) {
+        if (resolver.type === 'DIRECT') {
+            return readMemberIdsFromValue(resolver.memberIds, label).map((memberId) => ({ memberId, sourceType: resolver.type }));
+        }
+        if (resolver.type === 'DYNAMIC_FORM') {
+            return readMemberIdsFromValue(readValueAtPath(instance.formData, resolver.formPath), `${label}.formPath`).map((memberId) => ({ memberId, sourceType: resolver.type }));
+        }
+        if (resolver.type === 'EXPRESSION') {
+            return readMemberIdsFromValue(this.conditionService.evaluateValue(resolver.expression, buildWorkflowExpressionContext(instance), `${label}.expression`), `${label}.expression`).map((memberId) => ({ memberId, sourceType: resolver.type }));
+        }
+        if (resolver.type === 'POSITION') {
+            return this.resolvePositionCandidates(manager, resolver.positionId, label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        }
+        if (resolver.type === 'ORG_UNIT_MEMBER') {
+            return this.resolveOrgUnitMemberCandidates(manager, resolver.orgUnitId, Boolean(resolver.includeDescendants), label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        }
+        if (resolver.type === 'ORG_UNIT_POSITION') {
+            return this.resolveOrgUnitPositionCandidates(manager, resolver.orgUnitId, resolver.positionId, Boolean(resolver.includeDescendants), label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        }
+        if (resolver.type === 'ORG_UNIT_MANAGER') {
+            return this.resolveOrgUnitManagerCandidates(manager, instance, resolver.orgUnitId, resolver.fallback, label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        }
+        return this.resolveInitiatorManagerCandidates(manager, instance, resolver.levelsUp, resolver.fallback, label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+    }
+    async resolvePositionCandidates(manager, positionId, label) {
+        const today = toDateOnlyString(new Date());
+        const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
+            where: { positionId },
+        });
+        const activeMemberships = memberships
+            .filter((membership) => membership.effectiveFrom <= today &&
+            (!membership.effectiveTo || membership.effectiveTo >= today))
+            .sort((first, second) => {
+            if (first.isPrimary !== second.isPrimary) {
+                return first.isPrimary ? -1 : 1;
+            }
+            return second.effectiveFrom.localeCompare(first.effectiveFrom);
+        });
+        if (!activeMemberships.length) {
+            throw new common_1.ConflictException(`${label} position ${positionId} has no active membership`);
+        }
+        return uniqueTexts(activeMemberships.map((membership) => membership.memberId));
+    }
+    async resolveInitiatorManagerCandidates(manager, instance, levelsUp, fallback, label) {
+        const normalizedLevelsUp = Math.max(Math.trunc(levelsUp), 1);
+        const resolvedManagerMemberIds = await this.resolveManagerMemberIdsFromOrganization(manager, instance.initiatorMemberId, normalizedLevelsUp);
+        if (resolvedManagerMemberIds.length) {
+            return resolvedManagerMemberIds;
+        }
+        return [
+            this.resolveFallbackAssignee(instance, fallback, label, `找不到發起人的第 ${normalizedLevelsUp} 層主管`),
+        ];
+    }
+    resolveFallbackAssignee(instance, fallback, label, failureReason) {
+        if (!fallback || fallback.type === 'NONE') {
+            throw new common_1.ConflictException(`${label} 無法建立待簽任務：${failureReason}，且未設定改派固定人。請聯絡流程管理員調整主管規則或模板 fallback。`);
+        }
+        if (!fallback.memberId.trim()) {
+            throw new common_1.ConflictException(`${label} 無法建立待簽任務：改派固定人未設定。`);
+        }
+        if (fallback.memberId === instance.initiatorMemberId &&
+            !fallback.allowInitiatorSelfApproval) {
+            throw new common_1.ConflictException(`${label} 無法建立待簽任務：改派固定人是申請人本人，且此節點未允許申請人自簽。`);
+        }
+        return fallback.memberId;
+    }
+    async resolveManagerMemberIdsFromOrganization(manager, memberId, levelsUp) {
+        return this.resolveManagerMemberIdsAtLevel(manager, memberId, toDateOnlyString(new Date()), levelsUp);
+    }
+    async resolveManagerMemberIdsAtLevel(manager, memberId, date, remainingLevels) {
+        const directManagerMemberIds = await this.resolveDirectManagerMemberIds(manager, memberId, date);
+        if (remainingLevels <= 1 || directManagerMemberIds.length === 0) {
+            return directManagerMemberIds;
+        }
+        const nextLevelGroups = await Promise.all(directManagerMemberIds.map((managerMemberId) => this.resolveManagerMemberIdsAtLevel(manager, managerMemberId, date, remainingLevels - 1)));
+        return uniqueTexts(nextLevelGroups.flat());
+    }
+    async resolveDirectManagerMemberIds(manager, memberId, date) {
+        const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
+            where: { memberId },
+        });
+        const activeMemberships = memberships.filter((membership) => isDateRangeActive(membership, date));
+        const directOrgUnitIds = activeMemberships.map((membership) => membership.orgUnitId);
+        const positionIds = activeMemberships
+            .map((membership) => membership.positionId)
+            .filter((positionId) => Boolean(positionId));
+        const orgUnitIds = await this.readOrgUnitAndAncestorIds(manager, directOrgUnitIds);
+        const candidatePairs = [
+            { scopeId: memberId, scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER },
+            ...orgUnitIds.map((scopeId) => ({
+                scopeId,
+                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
+            })),
+            ...positionIds.map((scopeId) => ({
+                scopeId,
+                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
+            })),
+        ];
+        return this.resolveManagerResolutionCandidates(manager, candidatePairs, date);
+    }
+    async resolveOrgUnitManagerCandidates(manager, instance, orgUnitId, fallback, label) {
+        const date = toDateOnlyString(new Date());
+        const orgUnitIds = await this.readOrgUnitAndAncestorIds(manager, [
+            orgUnitId,
+        ]);
+        const managerMemberIds = await this.resolveManagerResolutionCandidates(manager, orgUnitIds.map((scopeId) => ({
+            scopeId,
+            scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
+        })), date);
+        if (!managerMemberIds.length) {
+            return [
+                this.resolveFallbackAssignee(instance, fallback, label, `找不到指定組織的主管規則`),
+            ];
+        }
+        return managerMemberIds;
+    }
+    async readOrgUnitAndAncestorIds(manager, orgUnitIds) {
+        if (!orgUnitIds.length) {
+            return [];
+        }
+        const orgUnitRepository = manager.getRepository(org_unit_entity_1.OrgUnitEntity);
+        const directOrgUnits = await orgUnitRepository.find({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), id: (0, typeorm_2.In)([...orgUnitIds]) },
+        });
+        const ancestorGroups = await Promise.all(directOrgUnits.map((orgUnit) => orgUnitRepository
+            .createQueryBuilder('orgUnit')
+            .where('orgUnit.deleted_at IS NULL')
+            .andWhere('orgUnit.path @> :path', { path: orgUnit.path })
+            .getMany()));
+        const byId = new Map([...directOrgUnits, ...ancestorGroups.flat()].map((orgUnit) => [orgUnit.id, orgUnit]));
+        return [...byId.keys()];
+    }
+    async resolveManagerResolutionCandidates(manager, candidatePairs, date) {
+        const scopeIds = candidatePairs.map((pair) => pair.scopeId);
+        if (!scopeIds.length) {
+            return [];
+        }
+        const resolutions = await manager
+            .getRepository(manager_resolution_entity_1.ManagerResolutionEntity)
+            .find({
+            where: {
+                scopeId: (0, typeorm_2.In)([...scopeIds]),
+                scopeType: (0, typeorm_2.In)([
+                    organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER,
+                    organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
+                    organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
+                ]),
+            },
+        });
+        const active = resolutions
+            .filter((resolution) => candidatePairs.some((pair) => pair.scopeId === resolution.scopeId &&
+            pair.scopeType === resolution.scopeType))
+            .filter((resolution) => isDateRangeActive(resolution, date))
+            .sort(compareManagerResolution);
+        return uniqueTexts(active.map((resolution) => resolution.managerMemberId));
+    }
+    async resolveOrgUnitMemberCandidates(manager, orgUnitId, includeDescendants, label) {
+        const orgUnitIds = await this.readOrgUnitScopeIds(manager, orgUnitId, includeDescendants);
+        const today = toDateOnlyString(new Date());
+        const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
+            where: { orgUnitId: (0, typeorm_2.In)([...orgUnitIds]) },
+        });
+        const memberIds = memberships
+            .filter((membership) => isDateRangeActive(membership, today))
+            .sort(compareMembership)
+            .map((membership) => membership.memberId);
+        if (memberIds.length === 0) {
+            throw new common_1.ConflictException(`${label} orgUnit ${orgUnitId} has no active member`);
+        }
+        return uniqueTexts(memberIds);
+    }
+    async resolveOrgUnitPositionCandidates(manager, orgUnitId, positionId, includeDescendants, label) {
+        const orgUnitIds = await this.readOrgUnitScopeIds(manager, orgUnitId, includeDescendants);
+        const today = toDateOnlyString(new Date());
+        const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
+            where: { orgUnitId: (0, typeorm_2.In)([...orgUnitIds]), positionId },
+        });
+        const memberIds = memberships
+            .filter((membership) => isDateRangeActive(membership, today))
+            .sort(compareMembership)
+            .map((membership) => membership.memberId);
+        if (memberIds.length === 0) {
+            throw new common_1.ConflictException(`${label} orgUnit ${orgUnitId} and position ${positionId} has no active membership`);
+        }
+        return uniqueTexts(memberIds);
+    }
+    async readOrgUnitScopeIds(manager, orgUnitId, includeDescendants) {
+        const orgUnitRepository = manager.getRepository(org_unit_entity_1.OrgUnitEntity);
+        const orgUnit = await orgUnitRepository.findOne({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), id: orgUnitId },
+        });
+        if (!orgUnit) {
+            throw new common_1.ConflictException(`Org unit ${orgUnitId} was not found`);
+        }
+        if (!includeDescendants) {
+            return [orgUnit.id];
+        }
+        const descendants = await orgUnitRepository
+            .createQueryBuilder('orgUnit')
+            .where('orgUnit.deleted_at IS NULL')
+            .andWhere('orgUnit.path <@ :path', { path: orgUnit.path })
+            .getMany();
+        return uniqueTexts([orgUnit.id, ...descendants.map((unit) => unit.id)]);
+    }
+    async processExclusiveGateway(manager, instance, token, node) {
+        if (node.data.direction !== 'split') {
+            await this.advanceTokenToOutgoingNodes(manager, instance, token, node);
+            return;
+        }
+        const edge = (await this.readAvailableOutgoingEdges(manager, instance, node))[0];
+        await this.advanceTokenAlongEdge(manager, instance, token, node, edge);
+    }
+    async executeServiceTask(manager, instance, token, node) {
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const action = node.data.action;
+        if (action.type === 'WEBHOOK') {
+            const payload = typeof action.payload === 'string' && action.payload.trim()
+                ? this.conditionService.evaluateValue(action.payload, buildWorkflowExpressionContext(instance), `workflow.nodes.${node.id}.data.action.payload`)
+                : {
+                    instance: buildWorkflowExpressionContext(instance).instance,
+                    triggeredAt: new Date().toISOString(),
+                };
+            const result = await executeWebhookServiceAction(this.serviceTaskDispatcher, action, payload);
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: null,
+                eventType: result.ok
+                    ? workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_EXECUTED
+                    : workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_FAILED,
+                instanceId: instance.id,
+                nodeId: node.id,
+                payload: {
+                    action: 'WEBHOOK',
+                    error: result.error,
+                    ok: result.ok,
+                    status: result.status,
+                    tokenId: token.id,
+                    url: action.url,
+                },
+                taskId: null,
+            }));
+            await this.advanceTokenToOutgoingNodes(manager, instance, token, node);
+            return;
+        }
+        if (action.type === 'SET_FORM_FIELD') {
+            const value = this.conditionService.evaluateValue(action.value, buildWorkflowExpressionContext(instance), `workflow.nodes.${node.id}.data.action.value`);
+            const updatedFormData = writeValueAtPath(instance.formData, action.fieldPath, value);
+            const updatedInstance = await manager
+                .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+                .save({
+                ...instance,
+                formData: updatedFormData,
+            });
+            Object.assign(instance, updatedInstance);
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_EXECUTED,
+                instanceId: instance.id,
+                nodeId: node.id,
+                payload: {
+                    action: 'SET_FORM_FIELD',
+                    fieldPath: action.fieldPath,
+                    tokenId: token.id,
+                },
+                taskId: null,
+            }));
+            await this.advanceTokenToOutgoingNodes(manager, updatedInstance, token, node);
+            return;
+        }
+        const recipients = await this.resolveApproverResolver(manager, instance, action.recipients, `知會節點「${node.data.label}」`);
+        const recipientMemberIds = uniqueTexts(recipients.map((recipient) => recipient.memberId));
+        await this.notificationService.createServiceTaskNotifications({
+            instance,
+            manager,
+            node,
+            recipientMemberIds,
+        });
+        await manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity).save({
+            ...token,
+            consumedAt: new Date(),
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        });
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+            instanceId: instance.id,
+            nodeId: node.id,
+            payload: {
+                action: 'NOTIFY',
+                recipientMemberIds,
+                tokenId: token.id,
+            },
+            taskId: null,
+        }));
+    }
+    async rejectInstance(manager, instance, task, rejectedAt) {
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+        const activeTokens = await tokenRepository.find({
+            where: { instanceId: instance.id },
+        });
+        const consumedTokens = activeTokens
+            .filter((token) => token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+            token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING)
+            .map((token) => ({
+            ...token,
+            consumedAt: rejectedAt,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        }));
+        if (consumedTokens.length) {
+            await tokenRepository.save(consumedTokens);
+        }
+        await instanceRepository.save({
+            ...instance,
+            completedAt: rejectedAt,
+            state: workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED,
+        });
+        await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+            actorMemberId: task.assigneeMemberId,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
+            instanceId: instance.id,
+            nodeId: task.nodeId,
+            payload: {
+                action: 'REJECTED',
+                taskId: task.id,
+            },
+            taskId: task.id,
+        }));
+    }
+    async returnInstanceToNode(manager, instance, task, returnToNodeId, returnedAt) {
+        if (!returnToNodeId) {
+            throw new common_1.ConflictException('Return target node is required');
+        }
+        const targetNode = readWorkflowNodeOrThrow(instance.workflowSnapshot, returnToNodeId);
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        await this.consumeOpenRuntimeState(manager, instance, returnedAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
+        const returnedInstance = await instanceRepository.save({
+            ...instance,
+            completedAt: null,
+            state: targetNode.type === 'startEvent'
+                ? workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED
+                : workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING,
+        });
+        const resubmitStrategy = readReturnResubmitStrategy(task, instance);
+        const returnToken = await tokenRepository.save(tokenRepository.create({
+            consumedAt: null,
+            currentNodeId: targetNode.id,
+            instanceId: instance.id,
+            parentTokenId: null,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+        }));
+        await activityRepository.save([
+            activityRepository.create({
+                actorMemberId: task.assigneeMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_RETURNED,
+                instanceId: instance.id,
+                nodeId: task.nodeId,
+                payload: {
+                    resubmitStrategy,
+                    returnedFromNodeId: task.nodeId,
+                    returnToNodeId: targetNode.id,
+                    taskId: task.id,
+                },
+                taskId: task.id,
+            }),
+            activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_CREATED,
+                instanceId: instance.id,
+                nodeId: targetNode.id,
+                payload: {
+                    returnedFromNodeId: task.nodeId,
+                    tokenId: returnToken.id,
+                },
+                taskId: null,
+            }),
+        ]);
+        if (returnedInstance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+            await this.processRunningInstance(manager, returnedInstance);
+        }
+    }
+    async readLatestReturnedInstanceContext(manager, instanceId) {
+        const activity = await manager.getRepository(activity_log_entity_1.ActivityLogEntity).findOne({
+            order: { createdAt: 'DESC' },
+            where: {
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_RETURNED,
+                instanceId,
+            },
+        });
+        if (!activity) {
+            return null;
+        }
+        const returnToNodeId = readStringPayloadValue(activity.payload, 'returnToNodeId');
+        const returnedFromNodeId = readStringPayloadValue(activity.payload, 'returnedFromNodeId') ??
+            activity.nodeId;
+        if (!returnToNodeId || !returnedFromNodeId) {
+            return null;
+        }
+        return {
+            resubmitStrategy: readReturnResubmitStrategyFromPayload(activity.payload),
+            returnedFromNodeId,
+            returnToNodeId,
+        };
+    }
+    async resumeReturnedInstanceFromReturnPoint(manager, instance, context, resubmittedAt) {
+        const targetNode = readWorkflowNodeOrThrow(instance.workflowSnapshot, context.returnToNodeId);
+        if (targetNode.type !== 'startEvent') {
+            return instance;
+        }
+        readWorkflowNodeOrThrow(instance.workflowSnapshot, context.returnedFromNodeId);
+        await this.consumeOpenRuntimeState(manager, instance, resubmittedAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const returnPointToken = await tokenRepository.save(tokenRepository.create({
+            consumedAt: null,
+            currentNodeId: context.returnedFromNodeId,
+            instanceId: instance.id,
+            parentTokenId: null,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
+        }));
+        await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_CREATED,
+            instanceId: instance.id,
+            nodeId: context.returnedFromNodeId,
+            payload: {
+                resubmitStrategy: context.resubmitStrategy,
+                resumedFromNodeId: context.returnToNodeId,
+                tokenId: returnPointToken.id,
+            },
+            taskId: null,
+        }));
+        return instance;
+    }
+    async consumeOpenRuntimeState(manager, instance, consumedAt, taskStatus) {
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const tokens = await tokenRepository.find({
+            where: { instanceId: instance.id },
+        });
+        const openTokens = tokens.filter((token) => token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+            token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING);
+        const tasks = await taskRepository.find({
+            where: { instanceId: instance.id },
+        });
+        const openTasks = tasks.filter((task) => task.status === workflow_engine_enums_1.TaskStatusEnum.PENDING ||
+            task.status === workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS);
+        if (openTokens.length > 0) {
+            await tokenRepository.save(openTokens.map((token) => ({
+                ...token,
+                consumedAt,
+                status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+            })));
+        }
+        if (openTasks.length > 0) {
+            await taskRepository.save(openTasks.map((openTask) => Object.assign(new task_entity_1.TaskEntity(), openTask, {
+                completedAt: consumedAt,
+                status: taskStatus,
+            })));
+            await this.closeTaskCandidates(manager, openTasks.map((task) => task.id), readCandidateStatusForClosedTask(taskStatus));
+        }
+    }
+    async consumeJoinedTokens(manager, tokens) {
+        if (tokens.length === 0) {
+            return;
+        }
+        const consumedAt = new Date();
+        await manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity).save(tokens.map((token) => ({
+            ...token,
+            consumedAt,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        })));
+    }
+    async cancelAlternativeTokensForOrTrigger(manager, instance, token, targetNodeId) {
+        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const consumedAt = new Date();
+        const tokens = await tokenRepository.find({
+            where: { instanceId: instance.id },
+        });
+        const alternativeTokens = tokens.filter((candidate) => candidate.id !== token.id &&
+            (candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
+                candidate.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING) &&
+            hasPathToNode(instance.workflowSnapshot, candidate.currentNodeId, targetNodeId));
+        if (alternativeTokens.length === 0) {
+            return;
+        }
+        const alternativeTokenIds = alternativeTokens.map((candidate) => candidate.id);
+        const cancellableTasks = (await taskRepository.find({
+            where: { instanceId: instance.id },
+        })).filter((task) => alternativeTokenIds.includes(task.tokenId) &&
+            (task.status === workflow_engine_enums_1.TaskStatusEnum.PENDING ||
+                task.status === workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS));
+        await tokenRepository.save(alternativeTokens.map((candidate) => ({
+            ...candidate,
+            consumedAt,
+            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
+        })));
+        if (cancellableTasks.length) {
+            await taskRepository.save(cancellableTasks.map((task) => Object.assign(new task_entity_1.TaskEntity(), task, {
+                completedAt: consumedAt,
+                status: workflow_engine_enums_1.TaskStatusEnum.CANCELLED,
+            })));
+            await this.closeTaskCandidates(manager, cancellableTasks.map((task) => task.id), workflow_engine_enums_1.TaskCandidateStatusEnum.SUPERSEDED);
+        }
+    }
+    async closeTaskCandidates(manager, taskIds, status) {
+        if (taskIds.length === 0) {
+            return;
+        }
+        const candidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+        const candidates = (await candidateRepository.find({ where: { taskId: (0, typeorm_2.In)([...taskIds]) } })).filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
+            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED);
+        if (candidates.length === 0) {
+            return;
+        }
+        await candidateRepository.save(candidates.map((candidate) => Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), candidate, { status })));
+    }
+    async getTemplateOrThrow(templateId) {
+        const template = await this.approvalTemplateRepository.findOne({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), id: templateId },
+        });
+        if (!template) {
+            throw new common_1.NotFoundException(`Approval template ${templateId} was not found`);
+        }
+        return template;
+    }
+    async getPublishedTemplateVersionOrThrow(versionId) {
+        const version = await this.approvalTemplateVersionRepository.findOne({
+            where: { id: versionId },
+        });
+        if (!version) {
+            throw new common_1.NotFoundException(`Approval template version ${versionId} was not found`);
+        }
+        if (version.status !== template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED) {
+            throw new common_1.ConflictException('Approval template current version must be published');
+        }
+        return version;
+    }
+    async getPublishedFormVersionOrThrow(versionId) {
+        if (!versionId) {
+            throw new common_1.ConflictException('Approval template version does not bind a form version');
+        }
+        const version = await this.formDefinitionVersionRepository.findOne({
+            where: { id: versionId },
+        });
+        if (!version) {
+            throw new common_1.NotFoundException(`Form definition version ${versionId} was not found`);
+        }
+        if (version.status !== form_enums_1.FormDefinitionVersionStatusEnum.PUBLISHED) {
+            throw new common_1.ConflictException('Approval template must bind a published form version');
+        }
+        return version;
+    }
+};
+exports.WorkflowEngineService = WorkflowEngineService;
+exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(approval_instance_entity_1.ApprovalInstanceEntity)),
+    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(workflow_token_entity_1.WorkflowTokenEntity)),
+    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(task_entity_1.TaskEntity)),
+    tslib_1.__param(3, (0, typeorm_1.InjectRepository)(task_candidate_entity_1.TaskCandidateEntity)),
+    tslib_1.__param(4, (0, typeorm_1.InjectRepository)(task_decision_entity_1.TaskDecisionEntity)),
+    tslib_1.__param(5, (0, typeorm_1.InjectRepository)(notification_entity_1.NotificationEntity)),
+    tslib_1.__param(6, (0, typeorm_1.InjectRepository)(activity_log_entity_1.ActivityLogEntity)),
+    tslib_1.__param(7, (0, typeorm_1.InjectRepository)(approval_template_entity_1.ApprovalTemplateEntity)),
+    tslib_1.__param(8, (0, typeorm_1.InjectRepository)(approval_template_version_entity_1.ApprovalTemplateVersionEntity)),
+    tslib_1.__param(9, (0, typeorm_1.InjectRepository)(form_definition_version_entity_1.FormDefinitionVersionEntity)),
+    tslib_1.__param(15, (0, common_1.Optional)()),
+    tslib_1.__param(15, (0, common_1.Inject)(workflow_service_task_dispatcher_token_1.BPM_WORKFLOW_SERVICE_TASK_DISPATCHER)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        attachment_service_1.AttachmentService,
+        condition_service_1.ConditionService,
+        delegation_service_1.DelegationService,
+        notification_service_1.NotificationService,
+        signature_service_1.SignatureService, Object])
+], WorkflowEngineService);
+function parseJsonObject(value, label) {
+    try {
+        const parsedValue = JSON.parse(value);
+        if (isRecord(parsedValue)) {
+            return parsedValue;
+        }
+        throw new common_1.BadRequestException(`${label} must be a JSON object`);
+    }
+    catch (error) {
+        if (error instanceof common_1.BadRequestException) {
+            throw error;
+        }
+        throw new common_1.BadRequestException(error instanceof Error ? error.message : `${label} is invalid JSON`);
+    }
+}
+function readDefaultInitiatorMetadataSnapshot(memberId) {
+    return {
+        customFields: {},
+        memberId,
+    };
+}
+function parseWorkflowDefinition(value) {
+    try {
+        const parsedValue = JSON.parse(value);
+        if (isRecord(parsedValue) &&
+            Array.isArray(parsedValue.nodes) &&
+            Array.isArray(parsedValue.edges) &&
+            isRecord(parsedValue.meta)) {
+            return parsedValue;
+        }
+        throw new common_1.BadRequestException('workflowDefinitionJson must be a workflow definition object');
+    }
+    catch (error) {
+        if (error instanceof common_1.BadRequestException) {
+            throw error;
+        }
+        throw new common_1.BadRequestException(error instanceof Error
+            ? error.message
+            : 'workflowDefinitionJson is invalid JSON');
+    }
+}
+function buildInitiatorPolicyContext(initiatorMetadataSnapshot) {
+    return {
+        env: {
+            now: new Date().toISOString(),
+        },
+        initiator: initiatorMetadataSnapshot,
+        subject: initiatorMetadataSnapshot,
+    };
+}
+function buildWorkflowExpressionContext(instance) {
+    return {
+        env: {
+            now: new Date().toISOString(),
+        },
+        form: instance.formData,
+        formData: instance.formData,
+        initiator: {
+            ...instance.initiatorMetadataSnapshot,
+            memberId: instance.initiatorMemberId,
+        },
+        instance: {
+            id: instance.id,
+            state: instance.state,
+            templateId: instance.templateId,
+            templateVersionId: instance.templateVersionId,
+            title: instance.title,
+        },
+    };
+}
+function readDelegationSteps(value) {
+    return value
+        .map((step) => {
+        const from = readStringValue(step.from);
+        const to = readStringValue(step.to);
+        const reason = readStringValue(step.reason);
+        if (!from || !to || !reason) {
+            return null;
+        }
+        return {
+            from,
+            reason,
+            ruleId: readStringValue(step.ruleId),
+            to,
+        };
+    })
+        .filter((step) => step !== null);
+}
+function readStringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function buildDryRunExpressionContext(input, lastDecision) {
+    return {
+        env: {
+            now: new Date().toISOString(),
+        },
+        form: input.formData,
+        formData: input.formData,
+        initiator: {
+            ...input.initiatorMetadataSnapshot,
+            memberId: input.initiatorMemberId,
+        },
+        instance: {
+            id: SYSTEM_DRY_RUN_INSTANCE_ID,
+            state: workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING,
+            title: 'Dry Run',
+        },
+        lastDecision,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readWorkflowNodeOrThrow(workflow, nodeId) {
+    const node = workflow.nodes.find((candidate) => candidate.id === nodeId);
+    if (!node) {
+        throw new common_1.ConflictException(`Workflow node ${nodeId} was not found`);
+    }
+    return node;
+}
+function readOutgoingEdgesOrThrow(workflow, nodeId) {
+    const edges = workflow.edges.filter((edge) => edge.source === nodeId);
+    if (edges.length === 0) {
+        throw new common_1.ConflictException(`Workflow node ${nodeId} has no outgoing edge`);
+    }
+    return edges;
+}
+function readIncomingEdges(workflow, nodeId) {
+    return workflow.edges.filter((edge) => edge.target === nodeId);
+}
+function hasPathToNode(workflow, sourceNodeId, targetNodeId) {
+    return visitPathToNode(workflow, sourceNodeId, targetNodeId, new Set());
+}
+function visitPathToNode(workflow, sourceNodeId, targetNodeId, visitedNodeIds) {
+    if (sourceNodeId === targetNodeId) {
+        return true;
+    }
+    if (visitedNodeIds.has(sourceNodeId)) {
+        return false;
+    }
+    const nextVisitedNodeIds = new Set([...visitedNodeIds, sourceNodeId]);
+    return workflow.edges
+        .filter((edge) => edge.source === sourceNodeId)
+        .some((edge) => visitPathToNode(workflow, edge.target, targetNodeId, nextVisitedNodeIds));
+}
+function readReturnTargetNodeId(workflow, currentNodeId, requestedNodeId) {
+    const currentNode = readWorkflowNodeOrThrow(workflow, currentNodeId);
+    if (currentNode.type !== 'userTask') {
+        throw new common_1.ConflictException(`Workflow node ${currentNodeId} does not support return decisions`);
+    }
+    if (!currentNode.data.returnBehavior.allowReturn) {
+        throw new common_1.ConflictException(`User task ${currentNodeId} does not allow return decisions`);
+    }
+    const trimmedRequestedNodeId = requestedNodeId?.trim() || null;
+    const defaultTargetNodeId = readDefaultReturnTargetNodeId(workflow, currentNode);
+    if (currentNode.data.returnBehavior.allowedTargets === 'ANY') {
+        if (!trimmedRequestedNodeId) {
+            throw new common_1.BadRequestException('returnToNodeId is required');
+        }
+        readWorkflowNodeOrThrow(workflow, trimmedRequestedNodeId);
+        return trimmedRequestedNodeId;
+    }
+    if (trimmedRequestedNodeId &&
+        trimmedRequestedNodeId !== defaultTargetNodeId) {
+        throw new common_1.ConflictException(`User task ${currentNodeId} can only return to ${defaultTargetNodeId}`);
+    }
+    return defaultTargetNodeId;
+}
+function readDefaultReturnTargetNodeId(workflow, currentNode) {
+    if (currentNode.data.returnBehavior.allowedTargets === 'INITIATOR') {
+        const startNode = workflow.nodes.find((node) => node.type === 'startEvent');
+        if (!startNode) {
+            throw new common_1.ConflictException('Workflow does not include a startEvent');
+        }
+        return startNode.id;
+    }
+    const previousNodeId = readIncomingEdges(workflow, currentNode.id)[0]?.source;
+    if (!previousNodeId) {
+        throw new common_1.ConflictException(`User task ${currentNode.id} does not have a previous node to return to`);
+    }
+    return previousNodeId;
+}
+function readReturnResubmitStrategy(task, instance) {
+    const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, task.nodeId);
+    if (node.type !== 'userTask') {
+        return 'RESTART';
+    }
+    return node.data.returnBehavior.resubmitStrategy ?? 'RESTART';
+}
+function readReturnResubmitStrategyFromPayload(payload) {
+    return payload.resubmitStrategy === 'FROM_RETURN_POINT'
+        ? 'FROM_RETURN_POINT'
+        : 'RESTART';
+}
+function readStringPayloadValue(payload, key) {
+    const value = payload[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function readNodeEntryCondition(node) {
+    if (node.type === 'userTask' || node.type === 'serviceTask') {
+        return node.data.entryCondition?.trim() || null;
+    }
+    return null;
+}
+function edgeHasCondition(edge) {
+    return Boolean(edge.data.condition?.trim() ||
+        (edge.data.conditionFieldKey && edge.data.conditionOperator));
+}
+function readMemberIdFromValue(value, label) {
+    return readMemberIdsFromValue(value, label)[0] ?? '';
+}
+function readMemberIdsFromValue(value, label) {
+    if (typeof value === 'string' && value.trim()) {
+        return [value.trim()];
+    }
+    if (Array.isArray(value)) {
+        const memberIds = value
+            .filter((candidate) => typeof candidate === 'string' && Boolean(candidate.trim()))
+            .map((candidate) => candidate.trim());
+        if (memberIds.length > 0) {
+            return uniqueTexts(memberIds);
+        }
+    }
+    throw new common_1.ConflictException(`${label} did not resolve to a member id`);
+}
+function uniqueTexts(values) {
+    return [...new Set(values.filter((value) => value.trim()))];
+}
+function uniqueRuntimeCandidates(candidates) {
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate.memberId)) {
+            return false;
+        }
+        seen.add(candidate.memberId);
+        return true;
+    });
+}
+function uniqueTasksById(tasks) {
+    const seen = new Set();
+    return tasks.filter((task) => {
+        if (seen.has(task.id)) {
+            return false;
+        }
+        seen.add(task.id);
+        return true;
+    });
+}
+function normalizeText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function readPageOffset(page, pageSize) {
+    const normalizedPageSize = normalizePageSize(pageSize);
+    return (normalizePage(page) - 1) * normalizedPageSize;
+}
+function shouldPaginateList(options) {
+    return (typeof options.page !== 'undefined' ||
+        typeof options.pageSize !== 'undefined');
+}
+function normalizePage(value) {
+    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 1;
+}
+function normalizePageSize(value) {
+    if (!Number.isInteger(value) || Number(value) <= 0) {
+        return 20;
+    }
+    return Math.min(Number(value), 100);
+}
+function applyApprovalInstanceSearchFilter(queryBuilder, searchTextValue) {
+    const searchText = normalizeText(searchTextValue)?.toLocaleLowerCase();
+    if (!searchText) {
+        return;
+    }
+    queryBuilder.andWhere([
+        '(',
+        'LOWER("approvalInstance"."title") LIKE :approvalInstanceSearchText',
+        'OR LOWER("approvalInstance"."initiator_member_id") LIKE :approvalInstanceSearchText',
+        'OR LOWER(CAST("approvalInstance"."id" AS text)) LIKE :approvalInstanceSearchText',
+        ')',
+    ].join(' '), {
+        approvalInstanceSearchText: `%${escapeLikePattern(searchText)}%`,
+    });
+}
+function escapeLikePattern(value) {
+    return value
+        .replace(/\\/gu, '\\\\')
+        .replace(/%/gu, '\\%')
+        .replace(/_/gu, '\\_');
+}
+function isInstanceWithinRange(instance, options) {
+    const fromTime = options.from?.getTime() ?? null;
+    const toTime = options.to?.getTime() ?? null;
+    const candidateTime = (instance.completedAt ??
+        instance.startedAt ??
+        instance.createdAt).getTime();
+    return ((fromTime === null || candidateTime >= fromTime) &&
+        (toTime === null || candidateTime <= toTime));
+}
+function readDecisionPolicySnapshot(task) {
+    const value = task.decisionPolicySnapshot;
+    if (isRecord(value) &&
+        typeof value.type === 'string' &&
+        (value.type === 'SINGLE' ||
+            value.type === 'SEQUENTIAL' ||
+            value.type === 'PARALLEL_ALL' ||
+            value.type === 'PARALLEL_ANY')) {
+        return { type: value.type };
+    }
+    if (isRecord(value) &&
+        value.type === 'QUORUM' &&
+        typeof value.threshold === 'number' &&
+        (value.thresholdType === 'COUNT' || value.thresholdType === 'PERCENTAGE')) {
+        return {
+            threshold: value.threshold,
+            thresholdType: value.thresholdType,
+            type: 'QUORUM',
+        };
+    }
+    return { type: 'SINGLE' };
+}
+function shouldCompleteTaskAfterDecision({ action, candidates, decisionPolicy, }) {
+    if (action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED) {
+        return true;
+    }
+    if (decisionPolicy.type === 'SINGLE' ||
+        decisionPolicy.type === 'PARALLEL_ANY') {
+        return true;
+    }
+    const completedCount = candidates.filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED).length;
+    const totalCount = Math.max(candidates.length, 1);
+    if (decisionPolicy.type === 'PARALLEL_ALL' ||
+        decisionPolicy.type === 'SEQUENTIAL') {
+        return completedCount >= totalCount;
+    }
+    const threshold = decisionPolicy.thresholdType === 'PERCENTAGE'
+        ? Math.ceil((totalCount * decisionPolicy.threshold) / 100)
+        : decisionPolicy.threshold;
+    return completedCount >= Math.max(threshold, 1);
+}
+function readValueAtPath(value, path) {
+    return path
+        .split('.')
+        .filter((segment) => segment.trim())
+        .reduce((currentValue, segment) => {
+        if (!isRecord(currentValue)) {
+            return undefined;
+        }
+        return currentValue[segment];
+    }, value);
+}
+function writeValueAtPath(value, path, nextValue) {
+    const segments = normalizeFormFieldPath(path);
+    if (segments.length === 0) {
+        return value;
+    }
+    return writeNestedValue(value, segments, nextValue);
+}
+function writeNestedValue(value, segments, nextValue) {
+    const [currentSegment, ...remainingSegments] = segments;
+    if (!currentSegment) {
+        return value;
+    }
+    if (remainingSegments.length === 0) {
+        return { ...value, [currentSegment]: nextValue };
+    }
+    const currentValue = value[currentSegment];
+    const nestedValue = isRecord(currentValue) ? currentValue : {};
+    return {
+        ...value,
+        [currentSegment]: writeNestedValue(nestedValue, remainingSegments, nextValue),
+    };
+}
+function normalizeFormFieldPath(path) {
+    const segments = path
+        .split('.')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments[0] === 'form' || segments[0] === 'formData') {
+        return segments.slice(1);
+    }
+    return segments;
+}
+async function executeWebhookServiceAction(serviceTaskDispatcher, action, payload) {
+    try {
+        return await serviceTaskDispatcher.dispatchWebhook({
+            headers: action.headers,
+            payload,
+            url: action.url,
+        });
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : 'Unknown webhook error',
+            ok: false,
+            status: null,
+        };
+    }
+}
+function readManagerMemberIdFromInitiatorSnapshot(initiatorMetadataSnapshot, levelsUp) {
+    const managerChain = initiatorMetadataSnapshot.managerChain;
+    if (Array.isArray(managerChain)) {
+        return managerChain[Math.max(levelsUp - 1, 0)];
+    }
+    const managerMemberIds = initiatorMetadataSnapshot.managerMemberIds;
+    if (Array.isArray(managerMemberIds)) {
+        return managerMemberIds[Math.max(levelsUp - 1, 0)];
+    }
+    const customFields = initiatorMetadataSnapshot.customFields;
+    if (isRecord(customFields)) {
+        return customFields.managerMemberId;
+    }
+    return initiatorMetadataSnapshot.managerMemberId;
+}
+function isDateRangeActive(value, date) {
+    return (value.effectiveFrom <= date &&
+        (!value.effectiveTo || value.effectiveTo >= date));
+}
+function compareManagerResolution(left, right) {
+    const priorityDiff = right.priority - left.priority;
+    if (priorityDiff !== 0) {
+        return priorityDiff;
+    }
+    return (readManagerResolutionScopeRank(right.scopeType) -
+        readManagerResolutionScopeRank(left.scopeType) ||
+        right.effectiveFrom.localeCompare(left.effectiveFrom));
+}
+function readManagerResolutionScopeRank(scopeType) {
+    const ranks = {
+        [organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER]: 3,
+        [organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT]: 2,
+        [organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION]: 1,
+    };
+    return ranks[scopeType];
+}
+function compareMembership(left, right) {
+    if (left.isPrimary !== right.isPrimary) {
+        return left.isPrimary ? -1 : 1;
+    }
+    return right.effectiveFrom.localeCompare(left.effectiveFrom);
+}
+function toDateOnlyString(value) {
+    return value.toISOString().slice(0, 10);
+}
+function canReadAllWorkflows(scope) {
+    return (scope.roles.includes('BPM_ADMIN') ||
+        scope.permissions.some((permission) => WORKFLOW_READ_ALL_PERMISSIONS.has(permission)));
+}
+function isTaskRelatedToMember(task, memberId) {
+    return (task.assigneeMemberId === memberId ||
+        task.originalAssigneeMemberId === memberId);
+}
+function readCandidateStatusForClosedTask(taskStatus) {
+    if (taskStatus === workflow_engine_enums_1.TaskStatusEnum.TRANSFERRED) {
+        return workflow_engine_enums_1.TaskCandidateStatusEnum.TRANSFERRED;
+    }
+    if (taskStatus === workflow_engine_enums_1.TaskStatusEnum.COMPLETED) {
+        return workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED;
+    }
+    return workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED;
+}
+function validateSubmittedFormData(schema, formData) {
+    const missingFields = schema.fields.filter((field) => {
+        const fieldValue = formData[field.fieldKey];
+        return (isSubmittedFormFieldVisible(field, schema.fields, formData) &&
+            isSubmittedFormFieldRequired(field, schema.fields, formData) &&
+            !isSubmittedFieldValuePresent(fieldValue));
+    });
+    if (missingFields.length > 0) {
+        throw new common_1.BadRequestException(`Form data is missing required fields: ${missingFields
+            .map((field) => field.label || field.fieldKey)
+            .join(', ')}`);
+    }
+}
+function readFormDefinitionSnapshotSchema(snapshot) {
+    const schema = snapshot.schema;
+    if (isFormDefinitionSchema(schema)) {
+        return schema;
+    }
+    throw new common_1.BadRequestException('Approval instance form schema is invalid');
+}
+function isFormDefinitionSchema(value) {
+    return (isRecord(value) && value.schemaVersion === 1 && Array.isArray(value.fields));
+}
+function isSubmittedFormFieldVisible(field, fields, values) {
+    return field.visibleWhen
+        ? evaluateFormConditionExpression(field.visibleWhen, fields, values, true)
+        : true;
+}
+function isSubmittedFormFieldRequired(field, fields, values) {
+    return (field.required ||
+        Boolean(field.requiredWhen
+            ? evaluateFormConditionExpression(field.requiredWhen, fields, values, false)
+            : false));
+}
+function evaluateFormConditionExpression(expression, fields, values, fallback) {
+    const rule = parseFormConditionRule(expression);
+    if (!rule) {
+        return fallback;
+    }
+    const field = fields.find((candidate) => candidate.fieldKey === rule.fieldKey);
+    if (!field) {
+        return fallback;
+    }
+    return evaluateFormConditionRule(rule, field, values[field.fieldKey]);
+}
+function parseFormConditionRule(expression) {
+    const match = expression
+        .trim()
+        .match(/^form\.([A-Za-z][A-Za-z0-9_]*)\s*(==|!=|>=|<=|>|<)\s*(.+)$/u);
+    if (!match) {
+        return null;
+    }
+    const operator = readFormConditionOperatorFromSymbol(match[2]);
+    if (!operator) {
+        return null;
+    }
+    return {
+        fieldKey: match[1],
+        operator,
+        value: parseFormConditionLiteral(match[3]),
+    };
+}
+function evaluateFormConditionRule(rule, field, value) {
+    if (Array.isArray(value)) {
+        return evaluateArrayFormCondition(value, rule);
+    }
+    if (field.type === 'boolean') {
+        return compareFormConditionValues(value === true ? 'true' : 'false', rule.value, rule.operator);
+    }
+    if (isNumberFormField(field)) {
+        return compareNumericFormCondition(value, rule);
+    }
+    return compareFormConditionValues(typeof value === 'undefined' || value === null ? '' : String(value), rule.value, rule.operator);
+}
+function evaluateArrayFormCondition(value, rule) {
+    const stringValues = value.filter((entry) => typeof entry === 'string');
+    if (rule.operator === 'equals') {
+        return stringValues.includes(rule.value);
+    }
+    if (rule.operator === 'notEquals') {
+        return !stringValues.includes(rule.value);
+    }
+    return false;
+}
+function compareNumericFormCondition(value, rule) {
+    const actualValue = typeof value === 'number' ? value : Number(value);
+    const expectedValue = Number(rule.value);
+    if (!Number.isFinite(actualValue) || !Number.isFinite(expectedValue)) {
+        return false;
+    }
+    return compareFormConditionValues(actualValue, expectedValue, rule.operator);
+}
+function compareFormConditionValues(actualValue, expectedValue, operator) {
+    if (operator === 'equals') {
+        return actualValue === expectedValue;
+    }
+    if (operator === 'notEquals') {
+        return actualValue !== expectedValue;
+    }
+    if (operator === 'greaterThan') {
+        return actualValue > expectedValue;
+    }
+    if (operator === 'greaterThanOrEqual') {
+        return actualValue >= expectedValue;
+    }
+    if (operator === 'lessThan') {
+        return actualValue < expectedValue;
+    }
+    return actualValue <= expectedValue;
+}
+function readFormConditionOperatorFromSymbol(symbol) {
+    const operators = {
+        '!=': 'notEquals',
+        '<': 'lessThan',
+        '<=': 'lessThanOrEqual',
+        '==': 'equals',
+        '>': 'greaterThan',
+        '>=': 'greaterThanOrEqual',
+    };
+    return symbol ? (operators[symbol] ?? null) : null;
+}
+function parseFormConditionLiteral(value) {
+    const trimmedValue = value.trim();
+    if ((trimmedValue.startsWith('"') && trimmedValue.endsWith('"')) ||
+        (trimmedValue.startsWith("'") && trimmedValue.endsWith("'"))) {
+        return trimmedValue.slice(1, -1);
+    }
+    return trimmedValue;
+}
+function isSubmittedFieldValuePresent(value) {
+    if (typeof value === 'undefined' || value === null) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+function isNumberFormField(field) {
+    return field.type === 'number' || field.type === 'money';
+}
+function createDryRunStep(input) {
+    return Object.assign(new workflow_dry_run_object_1.WorkflowDryRunStepObject(), {
+        assigneeMemberId: input.assigneeMemberId,
+        edgeDefault: input.edge ? Boolean(input.edge.data.isDefault) : null,
+        edgeId: input.edge?.id ?? null,
+        edgeLabel: input.edge ? readDryRunEdgeLabel(input.edge) : null,
+        edgeMatched: input.edgeMatched,
+        edgeReason: input.edgeReason,
+        entryCondition: input.entryCondition,
+        entryConditionMatched: input.entryConditionMet,
+        id: `dry-run-step-${input.stepIndex + 1}`,
+        message: input.message,
+        nodeId: input.node.id,
+        nodeLabel: input.node.data.label,
+        nodeType: input.node.type,
+        status: input.status,
+    });
+}
+function readDryRunEdgeLabel(edge) {
+    return edge.data.label?.trim() || edge.id;
+}
+function readDryRunEdgeReason(edge) {
+    if (!edge) {
+        return null;
+    }
+    if (edge.data.isDefault) {
+        return '其他條件不符合時採用預設路徑。';
+    }
+    const expression = edge.data.condition?.trim();
+    if (expression) {
+        return `條件成立：${expression}`;
+    }
+    if (edge.data.conditionFieldKey && edge.data.conditionOperator) {
+        return `條件成立：${edge.data.conditionFieldKey} ${edge.data.conditionOperator}${edge.data.conditionValue ? ` ${edge.data.conditionValue}` : ''}`;
+    }
+    return '無條件路徑。';
+}
+function readDryRunStepStatus(node, entryConditionMet) {
+    if (!entryConditionMet) {
+        return 'SKIPPED';
+    }
+    if (node.type === 'userTask') {
+        return 'WAITING';
+    }
+    if (node.type === 'endEvent') {
+        return 'COMPLETED';
+    }
+    return 'PASSED';
+}
+function readDryRunStepMessage(node, entryConditionMet) {
+    if (!entryConditionMet) {
+        return '進入條件不符合，略過節點。';
+    }
+    if (node.type === 'userTask') {
+        return '將建立待簽任務。';
+    }
+    if (node.type === 'endEvent') {
+        return `流程結束：${node.data.endState ?? 'APPROVED'}`;
+    }
+    return '節點條件通過。';
+}
+//# sourceMappingURL=workflow-engine.service.js.map