@rytass/bpm-core-shared 0.21.0 → 0.21.1

package/src/lib/workflow-graph.js

@@ -35,10 +35,15 @@ exports.toggleSelectedEdgeId = toggleSelectedEdgeId;
 exports.readWorkflowDefinitionIssue = readWorkflowDefinitionIssue;
 exports.readNotifyServiceTaskIssue = readNotifyServiceTaskIssue;
 exports.readExcludeInitiatorIssue = readExcludeInitiatorIssue;
+exports.readExcludeNodeActorsShapeIssue = readExcludeNodeActorsShapeIssue;
+exports.readExcludeNodeActorsIssues = readExcludeNodeActorsIssues;
 exports.isOrgManagerChainDecisionPolicyInvalid = isOrgManagerChainDecisionPolicyInvalid;
+exports.readOrgManagerChainIssue = readOrgManagerChainIssue;
 exports.readApproverResolverIssue = readApproverResolverIssue;
 exports.readNodeActorSourceSkipReasons = readNodeActorSourceSkipReasons;
 exports.readNodeActorSourceIssues = readNodeActorSourceIssues;
+exports.canUserTaskHaveMultipleApprovers = canUserTaskHaveMultipleApprovers;
+exports.readSingleApproverSourceIssues = readSingleApproverSourceIssues;
 exports.hasConfiguredConditionEdges = hasConfiguredConditionEdges;
 exports.readServiceTaskMemberIds = readServiceTaskMemberIds;
 exports.defaultNotifyWebhookTargetId = defaultNotifyWebhookTargetId;
@@ -71,6 +76,7 @@ exports.readConditionExpressionOperator = readConditionExpressionOperator;
 exports.readConditionExpressionValue = readConditionExpressionValue;
 const form_1 = require("./form");
 const workflow_1 = require("./workflow");
+const field_access_1 = require("./field-access");
 const workflow_reachability_1 = require("./workflow-reachability");
 exports.EXCLUDE_INITIATOR_WHEN_EMPTY_VALUES = ['FAIL', 'INITIATOR_MANAGER', 'SKIP_NODE'];
 exports.WORKFLOW_INPUT_HANDLE_ID = 'input';
@@ -658,16 +664,23 @@ function toggleSelectedEdgeId(edgeIds, edgeId) {
 }
 // ── Validation ─────────────────────────────────────────────────────────────
 function readWorkflowDefinitionIssue(definition) {
-    var _a, _b;
+    var _a, _b, _c;
     const incompleteUserTaskNode = definition.nodes.find((node) => node.type === 'userTask' &&
         Boolean(readApproverResolverIssue(node.data.approverResolver)));
     const unsatisfiableQuorumNode = definition.nodes.find((node) => node.type === 'userTask' &&
         isDecisionPolicyUnsatisfiable(node.data.decisionPolicy, node.data.approverResolver));
     const excludeInitiatorNode = definition.nodes.find((node) => node.type === 'userTask' &&
         Boolean(readExcludeInitiatorIssue(node.data.excludeInitiator)));
-    const notifyNodeIssue = (_a = definition.nodes
-        .map((node) => readNotifyServiceTaskIssue(node))
+    // Shape only: whether the stages sit upstream is a publish-time graph rule
+    // (`readExcludeNodeActorsIssues`), so a draft can be saved unfinished.
+    const excludeNodeActorsIssue = (_a = definition.nodes
+        .map((node) => node.type === 'userTask'
+        ? readExcludeNodeActorsShapeIssue(node.data.excludeNodeActors)
+        : null)
         .find((issue) => issue !== null)) !== null && _a !== void 0 ? _a : null;
+    const notifyNodeIssue = (_b = definition.nodes
+        .map((node) => readNotifyServiceTaskIssue(node))
+        .find((issue) => issue !== null)) !== null && _b !== void 0 ? _b : null;
     const incompleteConditionEdge = definition.edges.find((edge) => isExclusiveGatewaySourceEdge(edge, definition.nodes) &&
         !edge.data.isDefault &&
         !edge.data.condition);
@@ -690,7 +703,7 @@ function readWorkflowDefinitionIssue(definition) {
     }
     if (unsatisfiableQuorumNode &&
         unsatisfiableQuorumNode.type === 'userTask' &&
-        ((_b = unsatisfiableQuorumNode.data.decisionPolicy) === null || _b === void 0 ? void 0 : _b.type) === 'QUORUM') {
+        ((_c = unsatisfiableQuorumNode.data.decisionPolicy) === null || _c === void 0 ? void 0 : _c.type) === 'QUORUM') {
         return (`簽核節點「${unsatisfiableQuorumNode.data.label}」的門檻人數為 ` +
             `${unsatisfiableQuorumNode.data.decisionPolicy.threshold}，` +
             `但只指定了 ${readDesignTimeApproverCount(unsatisfiableQuorumNode.data.approverResolver)} 位簽核者，` +
@@ -699,6 +712,9 @@ function readWorkflowDefinitionIssue(definition) {
     if (excludeInitiatorNode && excludeInitiatorNode.type === 'userTask') {
         return readExcludeInitiatorIssue(excludeInitiatorNode.data.excludeInitiator);
     }
+    if (excludeNodeActorsIssue) {
+        return excludeNodeActorsIssue;
+    }
     if (notifyNodeIssue) {
         return notifyNodeIssue;
     }
@@ -750,6 +766,106 @@ function readExcludeInitiatorIssue(config) {
         ? null
         : '簽核節點的「申請人不可簽核自己的單」需要指定沒有其他簽核人時的處理方式。';
 }
+/**
+ * The shape problem of a node's `excludeNodeActors` setting, or `null` when it
+ * is absent or well-formed: at least one id, text only, no repeats, and a
+ * known `whenEmpty`. Needs no graph, so it can block saving a draft the way
+ * {@link readExcludeInitiatorIssue} does; the graph rules are
+ * {@link readExcludeNodeActorsIssues}.
+ */
+function readExcludeNodeActorsShapeIssue(config) {
+    if (config === undefined) {
+        return null;
+    }
+    // Raw JSON that has not been linted yet can carry anything here.
+    const rawNodeIds = config === null || config === void 0 ? void 0 : config.nodeIds;
+    const nodeIds = Array.isArray(rawNodeIds)
+        ? rawNodeIds
+        : [];
+    if (nodeIds.length === 0) {
+        return '簽核節點的「不可與前面關卡同一人」需要指定前面的簽核關卡。';
+    }
+    if (nodeIds.some((id) => typeof id !== 'string' || id.trim() === '') ||
+        new Set(nodeIds).size !== nodeIds.length) {
+        return '「不可與前面關卡同一人」所選的前面關卡不可重複，也不可留白。';
+    }
+    return exports.EXCLUDE_INITIATOR_WHEN_EMPTY_VALUES.includes(config.whenEmpty)
+        ? null
+        : '簽核節點的「不可與前面關卡同一人」需要指定沒有其他簽核人時的處理方式。';
+}
+/**
+ * The designer-facing issues for a node's `excludeNodeActors` setting ("this
+ * stage's approver cannot be the person who approved an earlier stage");
+ * `[]` when it is absent or sound. `nodeId` is the node that carries the
+ * setting. The setting is checked in this order and stops at the first group
+ * that fails:
+ *
+ * 1. shape ({@link readExcludeNodeActorsShapeIssue}) and never the node itself;
+ * 2. every listed node exists and is a `userTask`;
+ * 3. each listed node on its own passes the source rules that
+ *    {@link readNodeActorSourceIssues} applies to a `NODE_ACTOR` source (same
+ *    judgement, wording about the exclusion):
+ *    - it may not be skipped or pass without a signer
+ *      ({@link readNodeActorSourceSkipReasons});
+ *    - every path from the start to `nodeId` goes through it, checked for
+ *      each listed node separately (never "one of them covers it");
+ *    - it is upstream of `nodeId`;
+ * 4. `whenEmpty: 'SKIP_NODE'` is refused on a node whose approver fills
+ *    fields in, for the same reason `excludeInitiator` is.
+ *
+ * Why every listed node has to be on every path: the engine reads the newest
+ * round of approvals of a node, and a return can send the instance back to the
+ * start. A listed node that this round did not pass would leave its previous
+ * round's approver in the exclusion list, and the node would refuse a person
+ * who never signed an earlier stage in this round. Requiring a listed node to
+ * be run, and signed by a person, every time rules that out.
+ *
+ * The `NODE_ACTOR` rule "two sources on different branches of one parallel
+ * split" is not applied a second time. A listed node that sits on a parallel
+ * branch is still refused by the coverage rule above, though: coverage reads a
+ * parallel gateway like an exclusive one, the same limit `NODE_ACTOR` has, so
+ * such stages have to be chained one after another instead.
+ */
+function readExcludeNodeActorsIssues(definition, nodeId, config) {
+    if (config === undefined) {
+        return [];
+    }
+    const shapeIssue = readExcludeNodeActorsShapeIssue(config);
+    if (shapeIssue !== null) {
+        return [shapeIssue];
+    }
+    const sourceNodeIds = config.nodeIds;
+    if (sourceNodeIds.includes(nodeId)) {
+        return ['「不可與前面關卡同一人」所選的前面關卡不可以是自己。'];
+    }
+    const labelOf = (id) => {
+        const node = definition.nodes.find((candidate) => candidate.id === id);
+        return (node === null || node === void 0 ? void 0 : node.data.label) ? `「${node.data.label}」` : `「${id}」`;
+    };
+    const sourceNodes = sourceNodeIds.map((id) => definition.nodes.find((candidate) => candidate.id === id));
+    const missingId = sourceNodeIds.find((id, index) => sourceNodes[index] === undefined);
+    if (missingId !== undefined) {
+        return [`「不可與前面關卡同一人」所選的前面關卡「${missingId}」不存在。`];
+    }
+    const notUserTaskId = sourceNodeIds.find((id, index) => { var _a; return ((_a = sourceNodes[index]) === null || _a === void 0 ? void 0 : _a.type) !== 'userTask'; });
+    if (notUserTaskId !== undefined) {
+        return [
+            `「不可與前面關卡同一人」所選的前面關卡 ${labelOf(notUserTaskId)} 不是簽核關卡。`,
+        ];
+    }
+    const stageIssues = readSourceStageIssues(definition, nodeId, sourceNodeIds, sourceNodeIds.map((id) => [id]), EXCLUDE_NODE_ACTORS_STAGE_TEXTS);
+    if (stageIssues.length > 0) {
+        return stageIssues;
+    }
+    const self = definition.nodes.find((node) => node.id === nodeId);
+    return config.whenEmpty === 'SKIP_NODE' &&
+        (self === null || self === void 0 ? void 0 : self.type) === 'userTask' &&
+        (0, field_access_1.readNodeFillableFieldKeys)(self).size > 0
+        ? [
+            `簽核節點 ${labelOf(nodeId)} 有可由簽核人填寫的欄位，「不可與前面關卡同一人」不能選擇略過此節點。`,
+        ]
+        : [];
+}
 /**
  * `true` when an `ORG_MANAGER_CHAIN` node uses a decision policy that lets one
  * manager close the node (`SINGLE`, `PARALLEL_ANY`, `QUORUM`) or has none at
@@ -765,6 +881,57 @@ function isOrgManagerChainDecisionPolicyInvalid(resolver, decisionPolicy) {
         (decisionPolicy === null || decisionPolicy === void 0 ? void 0 : decisionPolicy.type) !== 'SEQUENTIAL' &&
         (decisionPolicy === null || decisionPolicy === void 0 ? void 0 : decisionPolicy.type) !== 'PARALLEL_ALL');
 }
+/**
+ * The designer-facing issue with the two optional settings of an
+ * `ORG_MANAGER_CHAIN` (`minPositionLevel`, `startFrom`, `startPositionLevel`),
+ * or `null` when all are well-formed. `subject` names the node kind in the
+ * sentence; a notify node's chain may only start at the initiator (it has no
+ * earlier stage and no form pick to start from). Reads defensively: on the
+ * backend the definition is parsed JSON that no DTO has validated. The form
+ * field and the earlier stages the start names are checked elsewhere, against
+ * the form schema and the graph.
+ */
+function readOrgManagerChainIssue(resolver, subject) {
+    // Checked first, for both subjects: without a whole-number level the climb
+    // never stops (`level >= undefined` is always false) and collects every
+    // manager up to the top.
+    if (!Number.isInteger(resolver.minPositionLevel)) {
+        return `${subject}需要指定有效的職等門檻。`;
+    }
+    const startFrom = resolver.startFrom;
+    if (startFrom !== undefined && startFrom !== null) {
+        const start = startFrom;
+        if (typeof start !== 'object' ||
+            typeof start.type !== 'string' ||
+            (0, workflow_1.readUnsupportedOrgManagerChainStartType)({ type: start.type }) !== null) {
+            return `${subject}的主管鏈起點不在這個版本支援的範圍內，請改選其他起點。`;
+        }
+        if (start.type === 'FORM_MEMBER' &&
+            (typeof start.formPath !== 'string' || !start.formPath.trim())) {
+            return `${subject}需要指定主管鏈起點的表單欄位。`;
+        }
+        if (start.type === 'NODE_ACTOR' &&
+            (!Array.isArray(start.nodeIds) || start.nodeIds.length === 0)) {
+            return `${subject}需要指定主管鏈起點的前面簽核關卡。`;
+        }
+    }
+    if (subject === '知會節點' &&
+        !(0, workflow_1.isOrgManagerChainStartedFromInitiator)(resolver)) {
+        return '知會節點的主管鏈只能從發起人開始。';
+    }
+    const rawStartLevel = resolver.startPositionLevel;
+    if (rawStartLevel === undefined || rawStartLevel === null) {
+        return null;
+    }
+    const startLevel = (0, workflow_1.readOrgManagerChainStartPositionLevel)(resolver);
+    if (startLevel === null || !Number.isInteger(startLevel)) {
+        return `${subject}需要指定有效的起始職等。`;
+    }
+    return Number.isInteger(resolver.minPositionLevel) &&
+        startLevel > resolver.minPositionLevel
+        ? `${subject}的起始職等不可高於職等門檻。`
+        : null;
+}
 function readApproverResolverIssue(resolver) {
     var _a, _b;
     if ((0, workflow_1.readUnsupportedApproverResolverType)(resolver) !== null) {
@@ -786,9 +953,12 @@ function readApproverResolverIssue(resolver) {
         (!resolver.orgUnitId.trim() || !resolver.positionId.trim())) {
         return '簽核節點需要指定組織與職位。';
     }
-    if (resolver.type === 'ORG_MANAGER_CHAIN' &&
-        !Number.isInteger(resolver.minPositionLevel)) {
-        return '簽核節點需要指定有效的職等門檻。';
+    if (resolver.type === 'ORG_MANAGER_CHAIN') {
+        // The level is checked first inside `readOrgManagerChainIssue`.
+        const chainIssue = readOrgManagerChainIssue(resolver, '簽核節點');
+        if (chainIssue !== null) {
+            return chainIssue;
+        }
     }
     if ((resolver.type === 'FORM_MEMBER_MANAGER' ||
         resolver.type === 'FORM_ORG_UNIT_MANAGER') &&
@@ -826,13 +996,16 @@ function readApproverResolverIssue(resolver) {
     return null;
 }
 function readNodeActorSourceSkipReasons(node) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return [
         ...(((_a = node.data.entryCondition) === null || _a === void 0 ? void 0 : _a.trim()) ? ['entryCondition'] : []),
         ...(((_b = node.data.excludeInitiator) === null || _b === void 0 ? void 0 : _b.whenEmpty) === 'SKIP_NODE'
             ? ['skipNode']
             : []),
-        ...(((_c = node.data.sla) === null || _c === void 0 ? void 0 : _c.onTimeout) === 'AUTO_APPROVE'
+        ...(((_c = node.data.excludeNodeActors) === null || _c === void 0 ? void 0 : _c.whenEmpty) === 'SKIP_NODE'
+            ? ['skipNodeByNodeActors']
+            : []),
+        ...(((_d = node.data.sla) === null || _d === void 0 ? void 0 : _d.onTimeout) === 'AUTO_APPROVE'
             ? ['autoApprove']
             : []),
     ];
@@ -841,7 +1014,61 @@ const NODE_ACTOR_SOURCE_SKIP_ISSUES = {
     autoApprove: (label) => `簽核來源的前面關卡 ${label} 設有逾時自動核准，可能沒有人實際簽核。`,
     entryCondition: (label) => `簽核來源的前面關卡 ${label} 設有進入條件，可能被跳過、沒有人簽核。`,
     skipNode: (label) => `簽核來源的前面關卡 ${label} 在排除發起人後沒人時會跳過此關，可能沒有人簽核。`,
+    skipNodeByNodeActors: (label) => `簽核來源的前面關卡 ${label} 在排除前面關卡的簽核者後沒人時會跳過此關，可能沒有人簽核。`,
+};
+const NODE_ACTOR_SOURCE_STAGE_TEXTS = {
+    coverage: (stageLabels, nodeLabel) => `有一條路徑不會經過所選的前面關卡（${stageLabels.join('、')}）就走到 ${nodeLabel}，那一趟沒有人可以當簽核人。`,
+    notUpstream: (stageLabel, nodeLabel) => `前面關卡 ${stageLabel} 不在 ${nodeLabel} 的上游，走不到這個節點，不能當簽核來源。`,
+    skip: NODE_ACTOR_SOURCE_SKIP_ISSUES,
 };
+const EXCLUDE_NODE_ACTORS_STAGE_TEXTS = {
+    coverage: (stageLabels, nodeLabel) => `有一條路徑不會經過排除對象的前面關卡 ${stageLabels.join('、')} 就走到 ${nodeLabel}，那一趟排除不到本輪的簽核者（退回重送後還會讀到上一輪的簽核者）。請改用分流，把兩關放在同一條路線上。`,
+    notUpstream: (stageLabel, nodeLabel) => `前面關卡 ${stageLabel} 不在 ${nodeLabel} 的上游，走不到這個節點，無法排除該關的簽核者。`,
+    skip: {
+        autoApprove: (stageLabel) => `排除對象的前面關卡 ${stageLabel} 設有逾時自動核准，可能沒有人實際簽核，這一關就排除不到任何人。請移除逾時自動核准，或改選其他關卡。`,
+        entryCondition: (stageLabel) => `排除對象的前面關卡 ${stageLabel} 設有進入條件，可能被跳過；被跳過時會改讀到上一輪的簽核者。請改用分流，把兩關放在同一條路線上。`,
+        skipNode: (stageLabel) => `排除對象的前面關卡 ${stageLabel} 在排除發起人後沒人時會跳過此關，可能被跳過；被跳過時會改讀到上一輪的簽核者。請改選其他處理方式。`,
+        skipNodeByNodeActors: (stageLabel) => `排除對象的前面關卡 ${stageLabel} 在排除前面關卡的簽核者後沒人時會跳過此關，可能被跳過；被跳過時會改讀到上一輪的簽核者。請改選其他處理方式。`,
+    },
+};
+/**
+ * The checks every "who signed an earlier stage" reader needs, shared by the
+ * `NODE_ACTOR` source ({@link readNodeActorSourceIssues}) and
+ * `excludeNodeActors` ({@link readExcludeNodeActorsIssues}). In this order,
+ * all of them reported together:
+ *
+ * 1. a stage that may be skipped or pass without a signer
+ *    ({@link readNodeActorSourceSkipReasons});
+ * 2. coverage: for each group in `coverageGroups`, walking from the start
+ *    without entering any stage of the group must not reach `nodeId`. A
+ *    `NODE_ACTOR` source passes its whole list as one group ("one of them
+ *    covers every path"); an exclusion passes one group per stage;
+ * 3. every stage is upstream of `nodeId`.
+ *
+ * The caller has already checked that every id exists and is a `userTask`.
+ */
+function readSourceStageIssues(definition, nodeId, stageIds, coverageGroups, texts) {
+    const labelOf = (id) => {
+        const node = definition.nodes.find((candidate) => candidate.id === id);
+        return (node === null || node === void 0 ? void 0 : node.data.label) ? `「${node.data.label}」` : `「${id}」`;
+    };
+    const skippableIssues = stageIds.flatMap((id) => {
+        const node = definition.nodes.find((candidate) => candidate.id === id);
+        return (node === null || node === void 0 ? void 0 : node.type) === 'userTask'
+            ? readNodeActorSourceSkipReasons(node).map((reason) => texts.skip[reason](labelOf(node.id)))
+            : [];
+    });
+    const startNodeIds = definition.nodes
+        .filter((node) => node.type === 'startEvent')
+        .map((node) => node.id);
+    const coverageIssues = coverageGroups.flatMap((group) => (0, workflow_reachability_1.readReachableWorkflowNodeIds)(definition.edges, startNodeIds, new Set(group)).has(nodeId)
+        ? [texts.coverage(group.map(labelOf), labelOf(nodeId))]
+        : []);
+    const notUpstreamIssues = stageIds
+        .filter((id) => !(0, workflow_reachability_1.readReachableWorkflowNodeIds)(definition.edges, [id]).has(nodeId))
+        .map((id) => texts.notUpstream(labelOf(id), labelOf(nodeId)));
+    return [...skippableIssues, ...coverageIssues, ...notUpstreamIssues];
+}
 /**
  * The graph checks behind a `NODE_ACTOR` / `NODE_ACTOR_MANAGER` node: the
  * "who signed earlier" source only works when every case reaches `nodeId`
@@ -886,34 +1113,88 @@ function readNodeActorSourceIssues(definition, nodeId, sourceNodeIds) {
     if (notUserTaskId !== undefined) {
         return [`簽核來源的前面關卡 ${labelOf(notUserTaskId)} 不是簽核關卡。`];
     }
-    const skippableIssues = sourceNodes.flatMap((node) => (node === null || node === void 0 ? void 0 : node.type) === 'userTask'
-        ? readNodeActorSourceSkipReasons(node).map((reason) => NODE_ACTOR_SOURCE_SKIP_ISSUES[reason](labelOf(node.id)))
-        : []);
-    const startNodeIds = definition.nodes
-        .filter((node) => node.type === 'startEvent')
-        .map((node) => node.id);
-    const reachableWithoutSource = (0, workflow_reachability_1.readReachableWorkflowNodeIds)(definition.edges, startNodeIds, new Set(sourceNodeIds));
-    const coverageIssues = reachableWithoutSource.has(nodeId)
-        ? [
-            `有一條路徑不會經過所選的前面關卡（${sourceNodeIds
-                .map(labelOf)
-                .join('、')}）就走到 ${labelOf(nodeId)}，那一趟沒有人可以當簽核人。`,
-        ]
-        : [];
-    const notUpstreamIssues = sourceNodeIds
-        .filter((id) => !(0, workflow_reachability_1.readReachableWorkflowNodeIds)(definition.edges, [id]).has(nodeId))
-        .map((id) => `前面關卡 ${labelOf(id)} 不在 ${labelOf(nodeId)} 的上游，走不到這個節點，不能當簽核來源。`);
+    const stageIssues = readSourceStageIssues(definition, nodeId, sourceNodeIds, [sourceNodeIds], NODE_ACTOR_SOURCE_STAGE_TEXTS);
     const parallelBranches = (0, workflow_reachability_1.readWorkflowParallelBranchSets)(definition);
     const parallelIssues = sourceNodeIds.flatMap((id, index) => sourceNodeIds
         .slice(index + 1)
         .filter((otherId) => parallelBranches.some((branches) => (0, workflow_reachability_1.isOnOwnParallelBranch)(branches, id, otherId)))
         .map((otherId) => `前面關卡 ${labelOf(id)} 與 ${labelOf(otherId)} 在平行分支的不同路線上，兩關會同時簽核，不能一起當簽核來源。`));
-    return [
-        ...skippableIssues,
-        ...coverageIssues,
-        ...notUpstreamIssues,
-        ...parallelIssues,
-    ];
+    return [...stageIssues, ...parallelIssues];
+}
+/**
+ * `true` when a user task can end with more than one person having approved
+ * it, judged from its definition alone. The engine reads "who signed this
+ * stage" as the people with an approval in its newest batch, so a source that
+ * several people approve gives a start that is not one person.
+ *
+ * - `SINGLE` and `PARALLEL_ANY` end on the first approval: one person;
+ * - `PARALLEL_ALL` and `SEQUENTIAL` wait for every seat: several;
+ * - `QUORUM` ends once the threshold is met: several when a `COUNT` threshold
+ *   is above 1 (the engine reads anything below 1 as 1), and always for a
+ *   `PERCENTAGE` threshold, whose head count only the org chart at run time
+ *   knows;
+ * - a `DIRECT` resolver that lists one member can only ever give one person,
+ *   whatever the policy ({@link readDesignTimeApproverCount}), unless the
+ *   stage keeps the initiator (`excludeInitiator`) or an earlier stage's
+ *   approvers (`excludeNodeActors`) out with `whenEmpty: 'INITIATOR_MANAGER'`:
+ *   when that one member is excluded the stage goes to the initiator's
+ *   manager instead, who may be several people, so the policy decides.
+ *
+ * Deliberately conservative on the unknown side: a policy this build does not
+ * recognise reads as one person, because the structural lint reports it.
+ * The designer's stage picker for a manager chain's `NODE_ACTOR` start reads
+ * this too, so it and {@link readSingleApproverSourceIssues} agree.
+ */
+function canUserTaskHaveMultipleApprovers(node) {
+    var _a, _b;
+    // `approverResolver` and `decisionPolicy` can be missing on raw JSON that has
+    // not been linted yet.
+    const resolver = node.data.approverResolver;
+    const policy = node.data.decisionPolicy;
+    const designTimeCount = resolver
+        ? readDesignTimeApproverCount(resolver)
+        : null;
+    // Who the initiator's manager is (and how many share the level) is only known
+    // at run time, so a lone listed member is no guarantee of one person here.
+    // Either exclusion can empty the stage and hand it over.
+    const mayHandOverToInitiatorManagers = ((_a = node.data.excludeInitiator) === null || _a === void 0 ? void 0 : _a.whenEmpty) === 'INITIATOR_MANAGER' ||
+        ((_b = node.data.excludeNodeActors) === null || _b === void 0 ? void 0 : _b.whenEmpty) === 'INITIATOR_MANAGER';
+    if (!mayHandOverToInitiatorManagers &&
+        designTimeCount !== null &&
+        designTimeCount <= 1) {
+        return false;
+    }
+    if ((policy === null || policy === void 0 ? void 0 : policy.type) === 'PARALLEL_ALL' || (policy === null || policy === void 0 ? void 0 : policy.type) === 'SEQUENTIAL') {
+        return true;
+    }
+    return ((policy === null || policy === void 0 ? void 0 : policy.type) === 'QUORUM' &&
+        (policy.thresholdType === 'PERCENTAGE' || policy.threshold > 1));
+}
+/**
+ * The publish-time issues with the stages a manager chain's `NODE_ACTOR`
+ * start names, beyond what {@link readNodeActorSourceIssues} checks: every
+ * stage must end with one person's approval. A stage several people approve
+ * would make the start ambiguous, and the engine can only say so when the last
+ * of them approves, inside that decision's own transaction, which then never
+ * commits. Returns Chinese issue lines; `[]` means every named stage is a
+ * single-signer stage.
+ *
+ * `NODE_ACTOR_MANAGER` takes the managers of everyone who signed and so has no
+ * such limit; this check is deliberately not part of
+ * {@link readNodeActorSourceIssues}. A stage that does not exist or is not a
+ * user task is reported there, not here.
+ */
+function readSingleApproverSourceIssues(definition, sourceNodeIds) {
+    return sourceNodeIds.flatMap((id) => {
+        const node = definition.nodes.find((candidate) => candidate.id === id);
+        if ((node === null || node === void 0 ? void 0 : node.type) !== 'userTask' || !canUserTaskHaveMultipleApprovers(node)) {
+            return [];
+        }
+        const label = node.data.label ? `「${node.data.label}」` : `「${id}」`;
+        return [
+            `主管鏈起點的前面關卡 ${label} 可能有多位實際簽核人，無法決定從誰的主管開始。請改選只會有一位簽核人的關卡。`,
+        ];
+    });
 }
 function hasConfiguredConditionEdges(definition) {
     return definition.edges.some((edge) => isExclusiveGatewaySourceEdge(edge, definition.nodes) &&
@@ -988,12 +1269,20 @@ function readNotifyRecipientsIssue(recipients) {
         (!recipients.orgUnitId.trim() || !recipients.positionId.trim())) {
         return '知會節點需要指定組織與職位。';
     }
+    // Hand-written or AI-written JSON may carry no `orgUnitId` at all.
+    if (recipients.type === 'ORG_UNIT_MANAGER' &&
+        (typeof recipients.orgUnitId !== 'string' || !recipients.orgUnitId.trim())) {
+        return '知會節點需要指定組織。';
+    }
     if (recipients.type === 'DYNAMIC_FORM' && !recipients.formPath.trim()) {
         return '知會節點需要指定知會對象的表單欄位。';
     }
     if (recipients.type === 'EXPRESSION' && !recipients.expression.trim()) {
         return '知會節點需要指定知會對象的運算式。';
     }
+    if (recipients.type === 'ORG_MANAGER_CHAIN') {
+        return readOrgManagerChainIssue(recipients, '知會節點');
+    }
     return null;
 }
 /**