@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/lanes/rule-graph.js

@@ -0,0 +1,1846 @@
+/**
+ * Rule graph single source of truth — shared by the businessrule contract
+ * (shape templates surfaced through `omc contract businessrule`), the
+ * rule.save pre-flight dry lint, and the fake evaluator. Every rule here is
+ * evidence-backed by .scratch/omc-app-management/evidence/production-rule-shapes-20260911.md
+ * (production capture, ticket 09) plus tickets 02/09 live findings.
+ *
+ * The validator NEVER repairs: a violation is a structured blocker naming the
+ * node, the key, and what is missing. It runs client-side before any wire
+ * call (dry lint) so a mis-shaped graph cannot reach the platform.
+ */
+import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "../json-column.js";
+export const RULE_VALUE_TYPES = ["DYNAMIC", "FIXED", "EMPTY", "VARIABLE", "EXPRESSION", "SYSTEM", "AGGREGATION"];
+/**
+ * Allowed `ruleValueType` for a CONDITION LEAF (filter/exit/dataCondition).
+ * Superset of a data-action's set with the frontend condition editor's dynamic
+ * DATE value types (admin 12404/19497 enum: SpecifyDate/`specifyDate`,
+ * Today/`today`, Yesterday/`yesterday`, Tomorrow/`tomorrow`,
+ * SpecifyRange/`specifyRange`, DynamicRange/`dynamicRange` with value like
+ * `thisWeek`/`thisMonth`/`latelyDay`..., SELF_P/SELF_D). `SYSTEM` is NOT valid in
+ * a condition (it is a CREATE/UPDATE target system value) — a leaf
+ * `ruleValueType:"SYSTEM"` with empty value rendered 「字段 小于 (空)」 live
+ * 2026-10-08. A date comparison must use FIXED (literal `yyyy-MM-dd HH:mm:ss`),
+ * `today`/`yesterday`/`tomorrow`, or `dynamicRange`+value.
+ */
+export const RULE_CONDITION_VALUE_TYPES = [...RULE_VALUE_TYPES, "today", "yesterday", "tomorrow", "dynamicRange", "specifyDate", "specifyRange", "SELF_P", "SELF_D"];
+export const RULE_ACTION_TYPES = ["EQUALS", "INCREASE", "DECREASE"];
+export const RULE_CONDITION_TYPES = ["EQ", "NEQ", "GT", "LT", "GTEQ", "LTEQ", "CT", "NCT", "EP", "NEP"];
+/**
+ * Node types are the 8.6.26 `RuleNodeType` enum (RuleNodeType.java:16-43) restricted to the
+ * system/timing/flow-event families added by ticket 27 on top of the ticket-14 data/logic core.
+ * `EXECUTE_CODE`/`ONLINE_DEVELOP` stay out (permanent boundary: platform on-device code).
+ */
+export const RULE_NODE_TYPES = ["START", "END", "UPDATE", "CREATE", "DELETE", "QUERY", "BRANCH", "ASSIGN", "MESSAGE", "BIZ_ACTION", "CUSTOM_NODE", "SYSTEM_CREATE", "SYSTEM_UPDATE", "SYSTEM_DELETE", "GET_LIST", "LOAD", "AVAILABLE", "CANCEL", "SCHEDULER", "EXCEPTION", "HINT"];
+/** 8.6.26 `DataSourceType` enum names (DataSourceType.java:13-17); the node stores the name string (production shape). */
+export const RULE_DATA_SOURCE_TYPES = ["GET_LIST", "BIZ_SERVICE", "SELECT_DATA", "NONE"];
+/**
+ * CFG-26 — route match semantics. `matchType` is a route-level enum
+ * (research/desensitized-config-shapes.md §1.4; live default rule carries
+ * `"ANY"` on plain sequential edges, BRANCH exits carry ANY/ALL/CUSTOM).
+ */
+export const RULE_ROUTE_MATCH_TYPES = ["ANY", "ALL", "CUSTOM"];
+/**
+ * 8.6.26 子表触发数据范围（节点 `childTriggerConditionType`）。平台 i18n 权威标签
+ * （HANDOFF C.2 / evidence/form-conditions-and-rules-truth.md §4）：
+ * `ADD/MODIFY/DELETE` = 子表数据新增/修改/删除时触发。
+ */
+export const RULE_CHILD_TRIGGER_CONDITION_TYPES = ["ADD", "MODIFY", "DELETE"];
+/**
+ * 8.6.26 `CodeType` enum (metadata/bizmodel/CodeType.java:23-31), serialized as the int index by
+ * both fastjson (CodeTypeSerializer) and jackson (@JsonValue). A methodMapping input/output
+ * element with codeType PROPERTY(1) maps a schema data item (bizCode+propertyName); CONST(0)
+ * maps a constant. Ticket 35: the old template prose "codeType(0=字段)" was wrong — 0 is CONST.
+ */
+export const RULE_CODE_TYPES = ["CONST", "PROPERTY", "LIST", "OBJECT", "RULE_VARIABLE", "MAIN_TABLE", "SYSTEM", "EXPRESSION"];
+export const RULE_POINT = /^-?\d+(?:\.\d+)?,\s*-?\d+(?:\.\d+)?$/;
+/**
+ * Semantic keys of a methodMapping input/output element — the ONLY keys the
+ * validator polices (8.6.26 `MappingModel`, MappingModel.java:19-34):
+ * `codeType` (int 0-7), `serviceMethodParameterCode` (non-empty), `bizCode`
+ * (required when codeType=1 PROPERTY). Ticket 96: every OTHER key is
+ * NON-semantic passthrough — the tool neither adds, removes, nor reorders
+ * them by platform version (8.6.26 fastjson ignores unknown keys; the fwb
+ * v2 `index/displayName/required/bizCodeName` ride along verbatim). The set
+ * below stays exported as the documentary union of keys evidenced across the
+ * 8.6 family; `required` is mirrored from the method parameter face by
+ * rule-support before the write, never guessed locally.
+ */
+export const RULE_MAPPING_ELEMENT_KEYS = new Set([
+    "propertyName", "bizCode", "bizPropertyType", "externParameterType", "codeType", "serviceMethodParameterCode", "subParameters",
+    "id", "remarks", "createdTime", "modifiedTime", "deleted", "createdBy", "modifiedBy",
+    "index", "displayName", "required", "bizCodeName",
+]);
+/** 8.6.26 `SchedulerSetting.TriggerTimeType` enum names (SchedulerSetting.java:372-376). */
+export const RULE_SCHEDULER_TRIGGER_TIME_TYPES = ["SELECTED_TIME", "DATE_FIELD"];
+/** 8.6.26 `SchedulerExecuteType` enum names (SchedulerExecuteType.java); @JsonValue index 0/1 accepted too. */
+export const RULE_SCHEDULER_EXECUTE_TYPES = ["POLLING", "CYCLE", "0", "1"];
+/** 8.6.26 `CycleType` enum names (CycleType.java:8-16). */
+export const RULE_SCHEDULER_CYCLE_TYPES = ["NEVER", "HOUR", "DAY", "WEEK", "MONTH", "YEAR", "LAST_DAY_OF_MONTH", "CUSTOM"];
+/** 8.6.26 `EndType` enum names (EndType.java:8-11). */
+export const RULE_SCHEDULER_END_TYPES = ["NEVER", "CUSTOM"];
+export const RULE_NODE_TYPES_SET = new Set(RULE_NODE_TYPES);
+export const RULE_TRIGGER_INPUT_PARAM = "_input";
+export const RULE_OUTPUT_PARAM_SUFFIX = "_output";
+/**
+ * Node types whose platform behavior resolves its input schema from `inputParam`
+ * (e.g. `RuleBranchQuoteImpl.getCurrentBizSchema → getBizSchemaByArg(inputParam)
+ * → getBizSchemaByPath(null)`); a missing/empty value makes
+ * `businessrule/publish` refuse with errcode 300010
+ * (`BIZ_SCHEMA_CODE_EMPTY`「数据模型编码不能为空」).
+ *
+ * BRANCH/UPDATE were already defaulted. Confirmed live 2026-10-08 (MES sandbox):
+ * a hand-authored graph whose **CREATE** node dropped `inputParam` refused
+ * publish with 300010 while the byte-identical graph with `inputParam:"_input"`
+ * succeeded — and the agent misread that platform errcode as a capability
+ * boundary ("must go 二开"). `prepareRuleGraph` now defaults `"_input"` for every
+ * node type in this set, so no node template's required key can silently drop
+ * and no errcode can be mistaken for a capability limit.
+ */
+export const RULE_NODES_NEEDING_INPUT_PARAM = Object.freeze([
+    "BRANCH",
+    "UPDATE",
+    "CREATE",
+    "DELETE",
+    "ASSIGN",
+    "BIZ_ACTION",
+    "MESSAGE",
+    "QUERY",
+]);
+export const DYNAMIC_CONDITION_SOURCE_KEY = "currentSchemaDataItem";
+export const DYNAMIC_ACTION_SOURCE_KEY = "currentDataItemValue";
+/**
+ * BRANCH `exitConditionGroups` deserialize into `DataFilterCondition`, whose
+ * operator property is `ruleDataConditionType` and whose left/source property
+ * is `currentSchemaDataItem` (Condition.java:16,42; DataFilterCondition.java).
+ * The UI-shaped `ruleConditionType` is `@JsonIgnore`'d and `targetSchemaDataItem`
+ * is not a DataFilterCondition property — using them passes save+publish but the
+ * engine reads a null source/operator and `data.submit` 50000s (live 2026-09-25).
+ */
+export const BRANCH_EXIT_OPERATOR_KEY = "ruleDataConditionType";
+export const NODE_TYPE_TO_DATA_TRIGGER = Object.freeze({
+    CREATE: "CREATE",
+    UPDATE: "UPDATE",
+    DELETE: "DELETE",
+});
+/**
+ * Platform preset trigger rules persist the trigger row through a SYSTEM node
+ * (`SYSTEM_CREATE`/`SYSTEM_UPDATE`/`SYSTEM_DELETE`) that the rule executor runs
+ * as part of the graph (DefaultBusinessRule.createDefaultNode/createDefaultRoute,
+ * cloudpivot-metadata 8.6.26: Start → SYSTEM_* → End). Overwriting the graph
+ * without that node silently drops the row write.
+ *
+ * Live evidence (2026-09-12): a declaration submitted while bound to a Create
+ * rule whose graph was Start → UPDATE_1 → End stayed `DRAFT` forever — the
+ * engine executed the rule (docker logs `BizRuleLog ruleCode=Create` for every
+ * node) but the DRAFT→PROCESSING/COMPLETED write never happened because
+ * `DomainServiceImpl.batchUpdate` routes the update through the rule graph
+ * (`updateOverriding`), and the graph no longer contained SYSTEM_CREATE.
+ */
+export const DEFAULT_SYSTEM_NODE_BY_RULE_CODE = Object.freeze({
+    Create: { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE" },
+    Update: { nodeCode: "Update", nodeName: "更新数据", nodeType: "SYSTEM_UPDATE" },
+    Delete: { nodeCode: "Delete", nodeName: "删除数据", nodeType: "SYSTEM_DELETE" },
+});
+/**
+ * Ticket 80 — the platform trigger rule codes (rule-node graph description):
+ * data-event and system trigger rules addressed by ruleCode. They are NOT
+ * button/flow rules, so they never get the CUSTOM_NODE trigger synthesized.
+ */
+export const PLATFORM_TRIGGER_RULE_CODES = new Set(["Create", "Update", "Delete", "GetList", "Load", "Available", "Cancel"]);
+/**
+ * Tolerant node/route array coercion shared by the graph adapters (nodes and
+ * routes may arrive as objects or pre-serialized JSON strings; non-object
+ * entries are dropped rather than crashing the lint).
+ */
+function asRecordArray(value) {
+    return (Array.isArray(value) ? value : []).filter((entry) => Boolean(entry && typeof entry === "object"));
+}
+/**
+ * Shared system-node splice: when the trigger node is absent, insert the
+ * supplied node immediately after START and re-route through it (explicit
+ * routes are re-pointed; empty routes become the implied-linear chain over the
+ * new order). Returns the graph untouched when the node is already present or
+ * the graph has no START.
+ */
+/**
+ * Seat `node` immediately AFTER the LAST node of `anchorType`, re-pointing that
+ * node's outgoing edge through the new one. Used when the injected node must
+ * follow a persistence-sensitive action (ASSIGN / BIZ_ACTION) rather than sit
+ * right after START (see injectNodeAfterStart).
+ */
+function injectAfterNodeOfType(nodeRecords, routeRecords, anchorType, node) {
+    const anchorIndex = nodeRecords.map((entry) => String(entry.nodeType ?? "")).lastIndexOf(anchorType);
+    if (anchorIndex < 0)
+        return { nodes: nodeRecords, routes: routeRecords, injected: false };
+    const anchor = nodeRecords[anchorIndex];
+    const anchorCode = String(anchor.nodeCode ?? "");
+    const numberOr = (value, fallback) => (Number.isFinite(Number(value)) ? Number(value) : fallback);
+    node.x = numberOr(anchor.x, RULE_CANONICAL_LAYOUT.x);
+    node.y = numberOr(anchor.y, RULE_CANONICAL_LAYOUT.y0) + RULE_CANONICAL_LAYOUT.gap;
+    node.width = RULE_CANONICAL_LAYOUT.width;
+    node.height = RULE_CANONICAL_LAYOUT.height;
+    const nodeCode = String(node.nodeCode ?? "node");
+    const nextNodes = [...nodeRecords.slice(0, anchorIndex + 1), node, ...nodeRecords.slice(anchorIndex + 1)];
+    if (routeRecords.length > 0) {
+        const outRoute = routeRecords.find((route) => route.preNode === anchorCode);
+        const after = outRoute ? String(outRoute.postNode ?? "End") : "End";
+        const nextRoutes = routeRecords
+            .filter((route) => !(route.preNode === anchorCode && route.postNode === after))
+            .concat([{ preNode: anchorCode, postNode: nodeCode }, { preNode: nodeCode, postNode: after }]);
+        return { nodes: nextNodes, routes: nextRoutes, injected: true };
+    }
+    const codes = nextNodes.map((entry, index) => String(entry.nodeCode ?? `node_${index}`));
+    const linearRoutes = codes.slice(0, -1).map((pre, index) => ({ preNode: pre, postNode: codes[index + 1] }));
+    return { nodes: nextNodes, routes: linearRoutes, injected: true };
+}
+function injectNodeAfterStart(nodesInput, routesInput, alreadyPresent, makeNode, afterTypes = []) {
+    const nodeRecords = asRecordArray(parseMaybeJson(nodesInput));
+    const routeRecords = asRecordArray(parseMaybeJson(routesInput));
+    if (alreadyPresent(nodeRecords))
+        return { nodes: nodeRecords, routes: routeRecords, injected: false };
+    // Some action nodes must run BEFORE the persistence node for their result to be
+    // saved: ASSIGN merges into the input the system node persists, and BIZ_ACTION
+    // outputMappings likewise (live 2026-09-28: an ASSIGN after SYSTEM_CREATE read
+    // back no change). For those graphs the system node is seated AFTER the last
+    // such action node, not right after START.
+    const anchorType = [...afterTypes].reverse().find((type) => nodeRecords.some((entry) => entry.nodeType === type));
+    if (anchorType !== undefined)
+        return injectAfterNodeOfType(nodeRecords, routeRecords, anchorType, makeNode());
+    const startIndex = nodeRecords.findIndex((node) => node.nodeType === "START");
+    if (startIndex < 0)
+        return { nodes: nodeRecords, routes: routeRecords, injected: false };
+    const startCode = String(nodeRecords[startIndex].nodeCode ?? "Start");
+    const node = makeNode();
+    const nodeCode = String(node.nodeCode ?? "node");
+    // CFG-26 follow-up (live 2026-09-17): a node injected off-column with no
+    // size (the CUSTOM_NODE used to hardcode x=558/y=233) is neither "missing
+    // geometry" nor "overlapping", so `canonicalizeNodeLayout` left it there and
+    // the route Start→it drew a diagonal across the canvas — the exact broken
+    // wiring a user had to hand-fix. Seat it one slot below START in START's own
+    // column (so a deliberate layout keeps its column) with platform box size.
+    //
+    // For a LINEAR chain on the canonical column that seat overlaps the next
+    // node, which is the trigger `canonicalizeNodeLayout` needs to re-lay the
+    // whole chain out canonically. A BRANCH graph is never repositioned by that
+    // step, so there the injection must make room itself by pushing later nodes
+    // down.
+    const numberOr = (value, fallback) => (Number.isFinite(Number(value)) ? Number(value) : fallback);
+    const startX = numberOr(nodeRecords[startIndex].x, RULE_CANONICAL_LAYOUT.x);
+    const startY = numberOr(nodeRecords[startIndex].y, RULE_CANONICAL_LAYOUT.y0);
+    const insertedY = startY + RULE_CANONICAL_LAYOUT.gap;
+    node.x = startX;
+    node.y = insertedY;
+    node.width = RULE_CANONICAL_LAYOUT.width;
+    node.height = RULE_CANONICAL_LAYOUT.height;
+    const hasBranch = nodeRecords.some((entry) => entry.nodeType === "BRANCH");
+    const shifted = hasBranch
+        ? nodeRecords.map((entry) => entry !== nodeRecords[startIndex] && numberOr(entry.y, -Infinity) >= insertedY
+            ? { ...entry, y: numberOr(entry.y, insertedY) + RULE_CANONICAL_LAYOUT.gap }
+            : entry)
+        : nodeRecords;
+    if (routeRecords.length > 0) {
+        const startRoute = routeRecords.find((route) => route.preNode === startCode);
+        const after = startRoute ? String(startRoute.postNode ?? "End") : "End";
+        const nextNodes = [...shifted.slice(0, startIndex + 1), node, ...shifted.slice(startIndex + 1)];
+        const nextRoutes = routeRecords
+            .filter((route) => !(route.preNode === startCode && route.postNode === after))
+            .concat([{ preNode: startCode, postNode: nodeCode }, { preNode: nodeCode, postNode: after }]);
+        return { nodes: nextNodes, routes: nextRoutes, injected: true };
+    }
+    // Empty routes = platform implied-linear order (node-array order).
+    const ordered = [...shifted.slice(0, startIndex + 1), node, ...shifted.slice(startIndex + 1)];
+    const codes = ordered.map((entry, index) => String(entry.nodeCode ?? `node_${index}`));
+    const linearRoutes = codes.slice(0, -1).map((pre, index) => ({ preNode: pre, postNode: codes[index + 1] }));
+    return { nodes: ordered, routes: linearRoutes, injected: true };
+}
+/**
+ * Ensure a preset trigger rule graph keeps the platform system node. If the
+ * caller already provided it, the graph is returned untouched; otherwise the
+ * node is spliced immediately after START (the platform's canonical position)
+ * and the START route is re-pointed through it, preserving every other edge.
+ * Non-preset rule codes are returned untouched. This is an adapter, not a
+ * repair of caller mistakes: the injected node is exactly the platform default.
+ */
+export function injectDefaultSystemNode(ruleCode, nodesInput, routesInput) {
+    const spec = DEFAULT_SYSTEM_NODE_BY_RULE_CODE[ruleCode];
+    if (!spec)
+        return { nodes: asRecordArray(parseMaybeJson(nodesInput)), routes: asRecordArray(parseMaybeJson(routesInput)), injected: false };
+    return injectNodeAfterStart(nodesInput, routesInput, (nodes) => nodes.some((node) => node.nodeType === spec.nodeType), 
+    // Geometry is assigned by injectNodeAfterStart (START column, later nodes
+    // pushed down); a hardcoded seat here is what produced off-column nodes.
+    () => ({ nodeCode: spec.nodeCode, nodeName: spec.nodeName, nodeType: spec.nodeType, isSystemNode: true }), 
+    // ASSIGN / BIZ_ACTION merge their result into the input the system node
+    // persists, so they must run BEFORE it (live 2026-09-28). Seat the injected
+    // system node after the last such action node instead of right after START.
+    ["ASSIGN", "BIZ_ACTION"]);
+}
+/**
+ * Ticket 80 — the platform's button/flow trigger node. A rule invoked from a
+ * custom button or a workflow/button handler (not a data event) carries a
+ * CUSTOM_NODE 「自定义按钮/流程触发」 system node right after START, named after
+ * the rule code (live capture: Start x684/y122 → CUSTOM_NODE x558/y233 →
+ * actions → End, vertical string-coordinate routes). Node keys follow the
+ * yst/fwb instance shape (§2.2: nodeCode, nodeName, nodeType,
+ * isSystemNode:true, nodeCategory:"systemNode" — 43+102 published rules).
+ * rule.save synthesizes it by default for custom rule codes and lets
+ * `customTrigger:false` opt out.
+ */
+export function injectCustomTriggerNode(ruleCode, nodesInput, routesInput) {
+    return injectNodeAfterStart(nodesInput, routesInput, (nodes) => nodes.some((node) => node.nodeType === "CUSTOM_NODE"), () => ({ nodeCode: ruleCode, nodeName: ruleCode, nodeType: "CUSTOM_NODE", isSystemNode: true, nodeCategory: "systemNode" }));
+}
+/**
+ * Ticket 80 + CFG-26 — route layout fidelity. The platform standard route is
+ * `{ preNode, postNode, points:["x, y", ...], routeCondition:true|false,
+ * matchType:"ANY", lineName? }` (research/desensitized-config-shapes.md §1.4;
+ * live default rule `9ef75fea…` carries all three on every edge). Missing
+ * `points` breaks the designer canvas lines; missing `routeCondition`/
+ * `matchType` persists a non-canonical shape (CFG-26: routes written by an
+ * older build kept neither key).
+ *
+ * Adapter contract: only ABSENT keys are defaulted (`routeCondition:true`,
+ * `matchType:"ANY"`); an explicit value — including `routeCondition:false` for
+ * an else exit and a real branch `matchType` — is preserved verbatim.
+ *
+ * Geometry (live-verified against the platform default rule `9ef75fea…`):
+ * a vertical edge's endpoints are the SOURCE node's bottom-center and the
+ * TARGET node's top-center — NOT the node origin. Example: Start x327/y36
+ * 158×40 → Update x327/y116 gives points ["406, 76","406, 116"] where
+ * 406 = 327 + 158/2, 76 = 36 + 40, 116 = the target's y. Deriving points from
+ * the node origin (the pre-fix behaviour) drew lines from the top-left corners
+ * and looked visibly offset. Same-row/upward edges fall back to the facing
+ * side-center points. Node box defaults: 158×40 (the platform's standard).
+ */
+export function ensureRouteShape(nodesInput, routesInput, forceDerivePoints = false) {
+    const nodeRecords = asRecordArray(parseMaybeJson(nodesInput));
+    const routeRecords = asRecordArray(parseMaybeJson(routesInput));
+    const numberOrDefault = (value, fallback) => (Number.isFinite(Number(value)) ? Number(value) : fallback);
+    const boxOf = (nodeCode) => {
+        const node = nodeRecords.find((candidate) => String(candidate.nodeCode ?? "") === nodeCode);
+        if (!node)
+            return { x: 0, y: 0, width: 158, height: 40 };
+        return {
+            x: numberOrDefault(node.x, 0),
+            y: numberOrDefault(node.y, 0),
+            width: numberOrDefault(node.width, 158),
+            height: numberOrDefault(node.height, 40),
+        };
+    };
+    const edgePoints = (pre, post) => {
+        const s = boxOf(pre);
+        const t = boxOf(post);
+        const scx = s.x + s.width / 2;
+        const tcx = t.x + t.width / 2;
+        const scy = s.y + s.height / 2;
+        const tcy = t.y + t.height / 2;
+        if (t.y > s.y)
+            return [`${scx}, ${s.y + s.height}`, `${tcx}, ${t.y}`]; // downward: source bottom → target top (platform standard)
+        if (t.y < s.y)
+            return [`${scx}, ${s.y}`, `${tcx}, ${t.y + t.height}`]; // upward
+        if (t.x >= s.x)
+            return [`${s.x + s.width}, ${scy}`, `${t.x}, ${tcy}`]; // same row, rightward
+        return [`${s.x}, ${scy}`, `${t.x + t.width}, ${tcy}`]; // same row, leftward
+    };
+    const validPoints = (points) => Array.isArray(points) && points.length > 0 && points.every((point) => typeof point === "string" && point.trim().length > 0);
+    return routeRecords.map((route) => {
+        const pre = String(route.preNode ?? "");
+        const post = String(route.postNode ?? "");
+        return {
+            ...route,
+            // `forceDerivePoints` is set when the tool just re-laid-out the nodes: any
+            // points the caller echoed from a previous (origin-collapsed) read are
+            // stale and must be re-derived from the new geometry.
+            ...(!forceDerivePoints && validPoints(route.points) ? {} : { points: edgePoints(pre, post) }),
+            ...(route.routeCondition === undefined || route.routeCondition === null ? { routeCondition: true } : {}),
+            ...(route.matchType === undefined || route.matchType === null || String(route.matchType).trim() === "" ? { matchType: "ANY" } : {}),
+        };
+    });
+}
+/**
+ * CFG-26 — the platform's canonical single-column node layout. Live-verified
+ * against the platform default rule `9ef75fea…`: every node sits in one column
+ * at x=327, 158×40, spaced 80px down (y = 36, 116, 196, …). A graph that is
+ * submitted with missing geometry or overlapping boxes renders wrong in the
+ * designer (nodes piled up, lines crossing) — the tool must emit the canonical
+ * layout itself instead of requiring a hand-fix afterwards.
+ */
+export const RULE_CANONICAL_LAYOUT = Object.freeze({ x: 327, y0: 36, gap: 80, width: 158, height: 40 });
+/**
+ * The identity match for a self-update: "target row's id == the row being
+ * processed". It is the only sane filter for the common case — an UPDATE node
+ * whose `targetObjectCode` is the rule's own model. `prepareRuleGraph` defaults
+ * it (with a warning) when omitted; a cross-model UPDATE must pass one explicitly.
+ */
+export const RULE_IDENTITY_FILTER = Object.freeze({
+    mainConditions: Object.freeze([
+        Object.freeze([Object.freeze({ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "id" })]),
+    ]),
+    sheetConditions: Object.freeze([]),
+});
+/**
+ * Order a linear chain from START through every node, or null when the graph is
+ * not a simple chain (a BRANCH node, a split, a cycle, unreachable/missing
+ * nodes). Only linear graphs are auto-laid-out; branch canvases keep whatever
+ * layout the author designed (their geometry is meaningful).
+ */
+function linearChainOrder(nodes, routes) {
+    const codes = nodes.map((node) => String(node.nodeCode ?? ""));
+    if (codes.some((code) => !code) || new Set(codes).size !== codes.length)
+        return null;
+    if (codes.length !== routes.length + 1)
+        return null;
+    if (nodes.some((node) => node.nodeType === "BRANCH"))
+        return null;
+    const codeSet = new Set(codes);
+    if (nodes.filter((node) => node.nodeType === "START").length !== 1)
+        return null;
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const route of routes) {
+        const pre = String(route.preNode ?? "");
+        const post = String(route.postNode ?? "");
+        if (!codeSet.has(pre) || !codeSet.has(post))
+            return null;
+        const list = outgoing.get(pre) ?? [];
+        list.push(post);
+        outgoing.set(pre, list);
+        incoming.set(post, (incoming.get(post) ?? 0) + 1);
+    }
+    if ([...outgoing.values()].some((targets) => targets.length > 1))
+        return null;
+    const startCode = String(nodes.find((node) => node.nodeType === "START").nodeCode);
+    const order = [];
+    let cursor = startCode;
+    while (cursor !== undefined) {
+        if (order.includes(cursor))
+            return null; // cycle
+        order.push(cursor);
+        cursor = outgoing.get(cursor)?.[0];
+    }
+    if (order.length !== codes.length)
+        return null;
+    // A chain has exactly one sink: END must be last and every other node feeds forward.
+    const endCode = String(nodes.find((node) => node.nodeType === "END")?.nodeCode ?? "");
+    if (!endCode || order[order.length - 1] !== endCode)
+        return null;
+    for (const [code, count] of incoming)
+        if (count !== 1)
+            return null;
+    return order;
+}
+/**
+ * CFG-26 — normalize node geometry. A graph whose geometry is MISSING (any node
+ * without x/y) is laid out by the tool: a linear chain in the platform's
+ * canonical single column, a branch/DAG in a layered tree. A deliberate,
+ * renderable layout is preserved verbatim; a branch graph that already has
+ * geometry is never repositioned (its geometry is meaningful).
+ *
+ * Live 2026-09-28 (bench60): an intent's 3-tier branch (compact `actions` cannot
+ * express branches, so the author sent a full nodeGraph) arrived with NO geometry
+ * at all. The old code skipped every BRANCH graph, so the rule persisted with all
+ * nodes at the origin and every route point the same fallback `["158, 20","0, 20"]`
+ * — the designer piled the boxes up and drew garbled lines. A branch graph with
+ * missing geometry MUST be laid out, not left to the platform's default origin.
+ */
+export function canonicalizeNodeLayout(nodesInput, routesInput) {
+    const nodes = asRecordArray(parseMaybeJson(nodesInput));
+    const routes = asRecordArray(parseMaybeJson(routesInput));
+    const boxOf = (node) => ({
+        x: Number.isFinite(Number(node.x)) ? Number(node.x) : Number.NaN,
+        y: Number.isFinite(Number(node.y)) ? Number(node.y) : Number.NaN,
+        width: Number.isFinite(Number(node.width)) ? Number(node.width) : RULE_CANONICAL_LAYOUT.width,
+        height: Number.isFinite(Number(node.height)) ? Number(node.height) : RULE_CANONICAL_LAYOUT.height,
+    });
+    const boxes = nodes.map(boxOf);
+    const missingGeometry = boxes.some((box) => Number.isNaN(box.x) || Number.isNaN(box.y));
+    const overlap = boxes.some((a, ai) => boxes.some((b, bi) => bi > ai && !Number.isNaN(a.x) && !Number.isNaN(b.x) && a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height));
+    const order = linearChainOrder(nodes, routes);
+    if (missingGeometry) {
+        // Missing geometry: lay the whole graph out. A linear chain keeps the
+        // platform's single column; a branch/DAG gets a layered tree.
+        if (order)
+            return layLinearColumn(nodes, order);
+        return layLayeredDag(nodes, routes);
+    }
+    // Geometry present: preserve it unless a linear chain's boxes collide (the
+    // platform's own renderer needs a clean column); never reposition a branch
+    // graph that already carries geometry.
+    if (!order || !overlap)
+        return nodes;
+    return layLinearColumn(nodes, order);
+}
+function layLinearColumn(nodes, order) {
+    return nodes.map((node) => {
+        const index = order.indexOf(String(node.nodeCode ?? ""));
+        return {
+            ...node,
+            x: RULE_CANONICAL_LAYOUT.x,
+            y: RULE_CANONICAL_LAYOUT.y0 + index * RULE_CANONICAL_LAYOUT.gap,
+            width: RULE_CANONICAL_LAYOUT.width,
+            height: RULE_CANONICAL_LAYOUT.height,
+        };
+    });
+}
+/**
+ * Layered auto-layout for a branch/DAG with missing geometry. Layer = longest
+ * path from a root (START / indegree-0), so a branch and its reconvergence land
+ * on consecutive rows; within a layer nodes spread horizontally around the
+ * canonical column center. Deterministic (input order breaks ties), so the same
+ * graph always yields the same planHash.
+ */
+function layLayeredDag(nodes, routes) {
+    const codes = nodes.map((node) => String(node.nodeCode ?? ""));
+    if (codes.some((code) => code.length === 0) || new Set(codes).size !== codes.length)
+        return nodes;
+    const codeSet = new Set(codes);
+    const outgoing = new Map();
+    const indegree = new Map();
+    for (const code of codes) {
+        outgoing.set(code, []);
+        indegree.set(code, 0);
+    }
+    for (const route of routes) {
+        const pre = String(route.preNode ?? "");
+        const post = String(route.postNode ?? "");
+        if (!codeSet.has(pre) || !codeSet.has(post))
+            continue;
+        outgoing.get(pre).push(post);
+        indegree.set(post, (indegree.get(post) ?? 0) + 1);
+    }
+    // Kahn longest-path layering; a cycle leaves nodes unqueued and they fall to a
+    // trailing layer (still rendered, never dropped).
+    const layer = new Map();
+    const queue = codes.filter((code) => (indegree.get(code) ?? 0) === 0);
+    for (const code of queue)
+        layer.set(code, 0);
+    const remaining = new Map(indegree);
+    let head = 0;
+    while (head < queue.length) {
+        const code = queue[head++];
+        for (const post of outgoing.get(code) ?? []) {
+            layer.set(post, Math.max(layer.get(post) ?? 0, (layer.get(code) ?? 0) + 1));
+            remaining.set(post, (remaining.get(post) ?? 1) - 1);
+            if (remaining.get(post) === 0)
+                queue.push(post);
+        }
+    }
+    const maxLayer = Math.max(0, ...[...layer.values()]);
+    for (const code of codes)
+        if (!layer.has(code))
+            layer.set(code, maxLayer + 1);
+    const byLayer = new Map();
+    for (const code of codes) {
+        const depth = layer.get(code);
+        byLayer.set(depth, [...(byLayer.get(depth) ?? []), code]);
+    }
+    const { x: columnX, y0, gap, width, height } = RULE_CANONICAL_LAYOUT;
+    const centerX = columnX + width / 2;
+    const hgap = 60;
+    const position = new Map();
+    for (const [depth, members] of byLayer) {
+        const total = members.length;
+        members.forEach((code, index) => {
+            const x = Math.round(centerX - ((total - 1) / 2) * (width + hgap) + index * (width + hgap));
+            position.set(code, { x, y: y0 + depth * gap });
+        });
+    }
+    return nodes.map((node) => {
+        const spot = position.get(String(node.nodeCode ?? ""));
+        return { ...node, x: spot.x, y: spot.y, width, height };
+    });
+}
+/**
+ * True when a route's stored points do NOT sit on the current node boxes — i.e.
+ * they are stale (echoed from a prior origin-collapsed read where every node was
+ * at 0,0, producing `["158, 20","0, 20"]`). The platform draws a straight edge
+ * between node borders, so a point that is not on its endpoint box's perimeter
+ * cannot be valid for the geometry and must be re-derived. Legitimate hand-drawn
+ * multi-point routes keep their endpoints on the boxes, so they are preserved.
+ */
+function routePointsConsistentWithGeometry(nodes, routes) {
+    const boxOf = (code) => {
+        const node = nodes.find((candidate) => String(candidate.nodeCode ?? "") === code);
+        if (!node || !Number.isFinite(Number(node.x)) || !Number.isFinite(Number(node.y)))
+            return null;
+        return {
+            x: Number(node.x),
+            y: Number(node.y),
+            width: Number.isFinite(Number(node.width)) ? Number(node.width) : RULE_CANONICAL_LAYOUT.width,
+            height: Number.isFinite(Number(node.height)) ? Number(node.height) : RULE_CANONICAL_LAYOUT.height,
+        };
+    };
+    const onBox = (point, box) => {
+        if (typeof point !== "string")
+            return false;
+        const match = /^(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/.exec(point.trim());
+        if (!match)
+            return false;
+        const px = Number(match[1]);
+        const py = Number(match[2]);
+        const eps = 1.5;
+        const withinX = px >= box.x - eps && px <= box.x + box.width + eps;
+        const withinY = py >= box.y - eps && py <= box.y + box.height + eps;
+        const onEdge = Math.abs(px - box.x) <= eps || Math.abs(px - (box.x + box.width)) <= eps || Math.abs(py - box.y) <= eps || Math.abs(py - (box.y + box.height)) <= eps;
+        return withinX && withinY && onEdge;
+    };
+    for (const route of routes) {
+        const points = route.points;
+        if (!Array.isArray(points) || points.length < 2)
+            continue;
+        const s = boxOf(String(route.preNode ?? ""));
+        const t = boxOf(String(route.postNode ?? ""));
+        if (!s || !t)
+            continue;
+        if (!onBox(points[0], s) || !onBox(points[points.length - 1], t))
+            return false;
+    }
+    return true;
+}
+export function graphGeometryNeedsLayout(nodesInput, routesInput) {
+    const nodes = asRecordArray(parseMaybeJson(nodesInput));
+    const routes = asRecordArray(parseMaybeJson(routesInput));
+    const hasMissing = nodes.some((node) => !Number.isFinite(Number(node.x)) || !Number.isFinite(Number(node.y)));
+    if (hasMissing)
+        return true;
+    const order = linearChainOrder(nodes, routes);
+    if (!order)
+        return false;
+    const boxOf = (node) => ({
+        x: Number(node.x),
+        y: Number(node.y),
+        width: Number.isFinite(Number(node.width)) ? Number(node.width) : RULE_CANONICAL_LAYOUT.width,
+        height: Number.isFinite(Number(node.height)) ? Number(node.height) : RULE_CANONICAL_LAYOUT.height,
+    });
+    const boxes = nodes.map(boxOf);
+    return boxes.some((a, ai) => boxes.some((b, bi) => bi > ai && a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height));
+}
+/**
+ * The single rule-graph normalization used by BOTH the write preflight and the
+ * executor, so preview and execute validate the SAME prepared graph (CFG-02
+ * class: a mismatched preflight either waves through a graph the executor would
+ * reject, or refuses one the executor would have normalized).
+ *
+ * Steps (order matters): inject the preset system node → inject the
+ * button/flow CUSTOM_NODE trigger for custom rule codes → default missing node
+ * names from the platform's own `RuleNodeType.getName()` vocabulary →
+ * canonicalize node geometry → derive route points/keys. Pure: no wire, no I/O.
+ *
+ * Missing `nodeName` is adapter-shaped, not a caller error: the platform stores
+ * the name verbatim and never defaults it, so an unnamed node publishes with a
+ * blank canvas label. Every defaulted name is surfaced as a `warning` blocker
+ * in `warnings` (never gating) so the caller can replace it with a domain name.
+ */
+export function prepareRuleGraph(ruleCode, graph, customTrigger, schemaCode) {
+    const injected = injectDefaultSystemNode(ruleCode, graph.nodes ?? graph.node, graph.routes ?? graph.route);
+    let finalNodes = injected.nodes;
+    let finalRoutes = injected.routes;
+    const warnings = [];
+    // SCHEDULER ⇒ TIMING_TASK: the platform dispatches a schedule ONLY when the
+    // RULE ROW's bizRuleType = 2 (BizRuleScheduling.java:202-205; see
+    // lanes/businessrule-contract.ts:42). A caller who authors a SCHEDULER node but
+    // omits bizRuleType would otherwise get bizRuleType 0 (data-event) PLUS a
+    // synthesized CUSTOM_NODE trigger — the rule saves and enables but the timer
+    // never fires it. Observed live 2026-10-06 (sandbox): the agent read the
+    // contract and passed bizRuleType:2 by hand. Infer it here so the authored
+    // graph carries the timing face without the caller having to know the code.
+    const hasSchedulerNode = finalNodes.some((node) => String(node.nodeType ?? "") === "SCHEDULER");
+    const explicitBizRuleType = typeof graph.bizRuleType === "number" ? graph.bizRuleType : undefined;
+    if (hasSchedulerNode && explicitBizRuleType === undefined) {
+        warnings.push({ code: "rule-graph-bizruletype-inferred-timing-task", key: "bizRuleType", severity: "warning", message: "图含 SCHEDULER 节点但未传 bizRuleType，已按定时入口推断 bizRuleType=2（TIMING_TASK）；平台只对 bizRuleType=2 的行建调度任务（BizRuleScheduling.java:202-205）" });
+    }
+    const effectiveBizRuleType = hasSchedulerNode && explicitBizRuleType === undefined ? 2 : explicitBizRuleType ?? 0;
+    const wantsCustomTrigger = customTrigger !== false && effectiveBizRuleType === 0 && !PLATFORM_TRIGGER_RULE_CODES.has(ruleCode) && !hasSchedulerNode;
+    if (wantsCustomTrigger) {
+        const triggered = injectCustomTriggerNode(ruleCode, finalNodes, finalRoutes);
+        finalNodes = triggered.nodes;
+        finalRoutes = triggered.routes;
+    }
+    // CONST codeType=0: the platform reads the literal from `bizCode`
+    // (MapOps.getBizCode; designer 0===codeType → componentValue=bizCode), NOT
+    // from `value`/`expressionValue` (both arrive as literal "null" at runtime —
+    // 2026-10-06 live). Agents naturally write `value`/an expression, so fill it
+    // into `bizCode` rather than refusing: a value under value/expressionValue is
+    // moved to bizCode; only an element with NO value anywhere is a hard error
+    // (raised by the lint below).
+    finalNodes = finalNodes.map((node) => {
+        const mapping = node?.methodMapping;
+        if (!mapping || typeof mapping !== "object")
+            return node;
+        let changed = false;
+        for (const listKey of ["inputMappings", "outputMappings"]) {
+            const list = mapping[listKey];
+            if (!Array.isArray(list))
+                continue;
+            mapping[listKey] = list.map((element) => {
+                if (!element || typeof element !== "object" || Array.isArray(element))
+                    return element;
+                const row = element;
+                if (row.codeType !== 0)
+                    return row;
+                const hasBizCode = typeof row.bizCode === "string" && row.bizCode.trim().length > 0;
+                if (hasBizCode)
+                    return row;
+                const literal = row.value !== undefined ? row.value : row.expressionValue;
+                if (literal === undefined)
+                    return row;
+                changed = true;
+                const next = { ...row, bizCode: typeof literal === "string" ? literal : String(literal) };
+                delete next.value;
+                return next;
+            });
+        }
+        if (changed)
+            warnings.push({ code: "rule-graph-const-value-moved-to-bizcode", nodeCode: String(node.nodeCode ?? ""), key: "methodMapping", severity: "warning", message: "codeType=0(CONST) 的值已从 value/expressionValue 移到 bizCode（平台 CONST 只读 bizCode；value/expressionValue 运行时会变字面 null）" });
+        return node;
+    });
+    finalNodes = finalNodes.map((node) => {
+        const nodeType = String(node.nodeType ?? "");
+        if (nodeType === "START" || nodeType === "END" || node.isSystemNode === true)
+            return node;
+        // Apply the constant-key defaults first, THEN fall through to the nodeName
+        // default — the earlier early-return skipped nodeName, which the platform
+        // needs (a node without nodeName was silently dropped on save).
+        let current = node;
+        if (nodeType === "BRANCH") {
+            if (current.inputParam === undefined || current.inputParam === null || String(current.inputParam) === "") {
+                current = { ...current, inputParam: "_input" };
+                warnings.push({ code: "rule-graph-branch-input-param-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "inputParam", severity: "warning", message: `BRANCH "${String(node.nodeCode ?? "")}" 缺 inputParam，已默认补 "_input"` });
+            }
+            if (current.judgeMethod === undefined || current.judgeMethod === null || String(current.judgeMethod) === "") {
+                current = { ...current, judgeMethod: "DEFAULT" };
+                warnings.push({ code: "rule-graph-branch-judge-method-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "judgeMethod", severity: "warning", message: `BRANCH "${String(node.nodeCode ?? "")}" 缺 judgeMethod，已默认补 "DEFAULT"` });
+            }
+        }
+        if (nodeType === "UPDATE") {
+            if (current.inputParam === undefined || current.inputParam === null || String(current.inputParam) === "") {
+                current = { ...current, inputParam: "_input" };
+                warnings.push({ code: "rule-graph-update-input-param-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "inputParam", severity: "warning", message: `UPDATE "${String(node.nodeCode ?? "")}" 缺 inputParam，已默认补 "_input"` });
+            }
+            if (schemaCode !== undefined && String(node.targetObjectCode ?? "") === schemaCode && (current.filterCondition === undefined || current.filterCondition === null)) {
+                warnings.push({ code: "rule-graph-filter-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "filterCondition", severity: "warning", message: `UPDATE "${String(node.nodeCode ?? "")}" 缺 filterCondition，已按自更新身份匹配默认补` });
+                current = { ...current, filterCondition: RULE_IDENTITY_FILTER };
+            }
+        }
+        // Every other action/behavior node (CREATE/DELETE/ASSIGN/BIZ_ACTION/MESSAGE/
+        // QUERY) also resolves its input schema from `inputParam`; a missing value
+        // refuses publish with 300010 (BIZ_SCHEMA_CODE_EMPTY). Default it so a
+        // hand-authored graph cannot drop the key (live 2026-10-08: CREATE without
+        // `inputParam` → 300010; with `"_input"` → errcode 0).
+        if (nodeType !== "BRANCH" && nodeType !== "UPDATE" && RULE_NODES_NEEDING_INPUT_PARAM.includes(nodeType)) {
+            if (current.inputParam === undefined || current.inputParam === null || String(current.inputParam) === "") {
+                current = { ...current, inputParam: "_input" };
+                warnings.push({ code: "rule-graph-input-param-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "inputParam", severity: "warning", message: `${nodeType} "${String(node.nodeCode ?? "")}" 缺 inputParam，已默认补 "_input"（平台按 inputParam 解析节点输入 schema，缺则 publish 300010「数据模型编码不能为空」）` });
+            }
+        }
+        if (String(current.nodeName ?? "").trim())
+            return current;
+        const nodeCode = String(current.nodeCode ?? "");
+        const fallback = RULE_NODE_DEFAULT_NAMES[nodeType] ?? nodeCode;
+        warnings.push({
+            code: "rule-graph-node-name-defaulted",
+            nodeCode,
+            key: "nodeName",
+            severity: "warning",
+            message: `节点 "${nodeCode}"（${nodeType}）缺 nodeName，已按平台 RuleNodeType 默认名补为 "${fallback}"；如需业务语义名称请在 nodeGraph 显式传 nodeName`,
+        });
+        return { ...current, nodeName: fallback };
+    });
+    const relayout = graphGeometryNeedsLayout(finalNodes, finalRoutes);
+    finalNodes = canonicalizeNodeLayout(finalNodes, finalRoutes);
+    // Re-derive points when the tool laid the nodes out, OR when the stored points
+    // are stale (not on the current node boxes — the origin-collapsed echo).
+    const forcePoints = relayout || !routePointsConsistentWithGeometry(finalNodes, finalRoutes);
+    finalRoutes = ensureRouteShape(finalNodes, finalRoutes, forcePoints);
+    return { graph: { ...graph, ...(hasSchedulerNode && explicitBizRuleType === undefined ? { bizRuleType: 2 } : {}), nodes: finalNodes, routes: finalRoutes }, nodes: finalNodes, routes: finalRoutes, warnings };
+}
+/**
+ * Rule-level scheduler shape (8.6.26 `SchedulerSetting.java:27-52`). The
+ * SCHEDULER node itself carries NO timing config — `GetListNode`/`ScheduleNode`
+ * are bare `Node` subclasses; the schedule lives in the rule row's
+ * `schedulerSetting` JSON string (BusinessRuleModel.java:52-53) and only applies
+ * when `bizRuleType = 2` (TIMING_TASK). Transcribed from the DTO field list plus
+ * the desensitized observed keys (research/desensitized-config-shapes.md §1.5).
+ */
+export const RULE_SCHEDULER_SETTING_TEMPLATE = Object.freeze({
+    triggerTimeType: "SELECTED_TIME",
+    cycleType: "DAY",
+    executeType: "CYCLE",
+    execCycle: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    startTime: "<yyyy-MM-dd HH:mm:ss>",
+    endType: "NEVER",
+    dataSourceType: "NONE",
+    filterConditionGroups: [],
+    // latestVersion MUST be true: JobModelBuilder.buildJob routes on it — false
+    // takes the legacy builder (buildJobByRule) which reads startDate/endDate
+    // (null in the new-schedule shape) → NPE/无调度; true takes
+    // buildJobByNewScheduleSetting which reads startTime/endTime + cron. The old
+    // template shipped false and agents blindly copied it, hitting a
+    // businessrule/publish 50000 NPE (2026-10-06 live). The SCHEDULER node
+    // template already carried true; this aligns the rule-level setting.
+    latestVersion: true,
+    consolidation: false,
+});
+/**
+ * Platform default node display names per nodeType, transcribed verbatim from
+ * `RuleNodeType.getName()` (cloudpivot-metadata-8.6.26.jar, javap 2026-09-18).
+ * The platform stores whatever name the caller sends and does NOT default it —
+ * a graph published without nodeName keeps a null label. Every authored node
+ * must carry a name; this map is the platform's own vocabulary for the
+ * refusal message.
+ */
+export const RULE_NODE_DEFAULT_NAMES = Object.freeze({
+    START: "开始",
+    END: "结束",
+    MESSAGE: "消息",
+    LOGIC_VERIFY: "逻辑验证",
+    DATA_VERIFY: "数据验证",
+    DELETE: "数据删除",
+    UPDATE: "数据更新",
+    CREATE: "数据新增",
+    BIZ_ACTION: "业务动作",
+    GET_LIST: "获取集合",
+    LOAD: "查询数据",
+    CANCEL: "流程作废",
+    AVAILABLE: "流程生效",
+    SCHEDULER: "定时作业",
+    SYSTEM_DELETE: "删除数据",
+    SYSTEM_UPDATE: "更新数据",
+    SYSTEM_CREATE: "新增数据",
+    EXECUTE_CODE: "代码执行",
+    CUSTOM_NODE: "自定义节点",
+    DATA_CHECK: "数据校验",
+    ASSIGN: "数据赋值",
+    EXIST_VERIFY: "存在校验",
+    ONLINE_DEVELOP: "在线开发",
+    EXCEPTION: "异常中止",
+    BRANCH: "分支",
+    HINT: "提示信息",
+    QUERY: "查询节点",
+});
+/** Canonical node shapes per nodeType, transcribed from the production capture. */
+export const RULE_NODE_TEMPLATES = Object.freeze({
+    UPDATE: {
+        description: "数据更新：`filterCondition` = **查找满足条件的主表数据**（要更新哪条；DYNAMIC 过滤来源=currentSchemaDataItem，value 不出现）；**空 mainConditions = 无条件下更新整表**（bench23 病灶，干 lint 给 warning）。`filterSubCondition` = 查找满足条件的子表数据。`dataActions` 赋值（DYNAMIC 来源=currentDataItemValue，value 留空；**EXPRESSION 公式赋值**：`ruleValueType:\"EXPRESSION\"` + `value` 为含非空 `formula` 的对象（可带 `editorText`/`editorMark`，平台编辑器解析要用到）。字段引用语法是 `{字段code}`，如 `{\"formula\":\"{amount}-{cost}\"}`；日期差用 **`DATEDIF({end},{begin},\"<unit>\")`**（unit 小写：`y` 年 / `M` 月 / `d` 日 / `h` 时 / `m` 分 / `s` 秒；两个日期字段直接相减不成立）。公式语言**支持 IF/比较运算符**（真机 2026-10-07：`IF(DATEDIF({actual},{eta},\"h\")>0,INTDOWN(DATEDIF({actual},{eta},\"h\")),0)` 计算正确）；取整用 `INTDOWN`(floor)/`INTUP`(ceil)/`ROUND`；**`MAX`/`MIN` 是集合聚合函数，不是逐值函数**——`MAX(0,x)` 报 `Wrong number of args (2) passed to: MAX` 50000，两值取大用 `IF(x>y,x,y)`。无效公式会让整个 rule.save/update 50000（非静默）。公式只在**数据更新(Update)** 触发链持久化，Create 触发的自更新本 build 不落库；同批更新内公式读**更新前**值——`UPDATE 算 X → BRANCH 判 X` 这类同链两步也读旧值，不成立）；`dataCondition` = 输入数据满足条件时才执行；`childTriggerConditionType` = 子表触发范围 ADD/MODIFY/DELETE。inputParam 必须是 \"_input\"（或 \"_<QUERY节点>_output\"）。平台标签证据：i18n 模块 196233 节点属性表 + evidence/form-conditions-and-rules-truth.md §4。",
+        template: {
+            nodeCode: "UPDATE_1", nodeName: "数据更新", nodeType: "UPDATE", targetObjectCode: "<target schemaCode>", inputParam: "_input", updateNodeType: "UPDATE_MODEL", execFormMapping: false,
+            filterCondition: { mainConditions: [[{ targetSchemaDataItem: "<target field>", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "<trigger field>" }]], sheetConditions: [] },
+            dataActions: [{ targetDataItem: "<target field>", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "<trigger field>" }],
+        },
+    },
+    QUERY: {
+        description: "查找数据：targetSchemaCode 可带子表（schemaCode.sheetCode），targetConditionGroups 与 UPDATE 的 filterCondition 同构；下游节点以 inputParam:\"_<本节点nodeCode>_output\" 消费查询输出。**要按「查询到的值」做分支/判断，把比较直接写进 targetConditionGroups（查询条件）**，或让下游节点 inputParam 指向本节点输出后用 FIXED/DYNAMIC 比该数据集字段；**条件叶不要用 ruleValueType:\"VARIABLE\" 引用查询结果**——save/publish 会过但运行时 NPE（SingletonDataset.getBizObjectProperty）、data.submit 50000（真机 2026-10-08；工具 fail closed rule-graph-condition-variable-unsupported）。",
+        template: {
+            nodeCode: "SearchData_1", nodeName: "查询节点", nodeType: "QUERY", inputParam: "_input", targetSchemaCode: "<schemaCode 或 schemaCode.sheetCode>",
+            targetConditionGroups: { mainConditions: [[{ targetSchemaDataItem: "<field>", ruleConditionType: "EQ", ruleValueType: "FIXED", value: "<literal>" }]], sheetConditions: [] },
+            joinConditions: [],
+        },
+    },
+    BRANCH: {
+        description: "数据判断（条件分支）。**运行时可用（2026-09-25 8.6.26 真机验证）：预置 Create 行 enabled 后，`Start→SYSTEM_CREATE→BRANCH→UPDATE→End` + 一条 else 路由，提交命中阈值的走条件分支、未命中走 else。** 铁律——**出口条件叶是 `DataFilterCondition` 形状**：左值键 `currentSchemaDataItem`、操作符键 `ruleDataConditionType`（`EQ/NEQ/GT/LT/GTEQ/LTEQ/...`）、`ruleValueType`、`value`；**不能**用 UI/连线形状的 `targetSchemaDataItem` + `ruleConditionType`——save+publish 会通过（未知键被忽略），但引擎读到 null 来源/操作符，`data.submit` 稳定 50000 且回滚（真机前后对照已证）。`judgeMethod:DEFAULT`=判断当前/输入数据（`value` 走 FIXED 或 DYNAMIC）；`OTHER`=判断其它模型（配 `targetInputMethod`/`targetConditionGroups`）。`sourceInputMethod` 必填（PRE_OUT/OTHER_MODEL，缺即 550018）；**出口叶 `ruleValueType:DYNAMIC`（字段比字段）在本 build 真机 `data.update` 稳定 50000**（真机 2026-10-06，任意字段类型）；要按字段间关系分支，别用 DYNAMIC 叶——改用 `FIXED` 值比较、或先由公式/接口把结果落入一个数值字段再 `FIXED` 比它、或落二开；**`inputParam`（\"_input\"）与 `judgeMethod`（DEFAULT）可省——工具会默认补并发 warning（真机验证）；若手工绕过工具，缺它们平台 enable/publish 会 300010**。`SYSTEM_CREATE` 必须显式（工具注入对分支图不可靠）。出路由用布尔 `routeCondition`：条件分支默认 `true`（可省）、兜底 else `false`（引擎按 `matchAll`：全部输入命中走 true，否则走 false；多条条件=多个 true 路由 + 一个 false 兜底）。只做「满足条件才执行某动作」也可用动作节点自身 `filterCondition`（单分支更省事）。**出口是「全部命中即走」不是「首个命中即停」**：多个 `true` 出口的条件若可能同时成立，全部路由、动作按顺序执行（后者覆盖前者；真机 2026-10-06 风险分级 高/中 同时命中→写成中）。分级互斥（高/中/低）要用**嵌套 BRANCH**：外层条件出口 + else 兜底进入下一层，而不是并列多个条件组。**BRANCH 本身可用、别轻易判定不可用**（真机 2026-10-06：2/3 出口图 `rule.save` errcode 0 可发布可运行）：若 `rule.save` 报 50000，多半是**形状错**——对照 `describe`/`--example business-rule-branch-conditional` 配方（出口固定值 `value` 用数字而非字符串、UPDATE 节点别多带 `inputParam`/`updateNodeType`/`filterCondition`、别漏 `START`），先读 lint/refusal 修正，**不要据此转二开**。",
+        template: {
+            nodeCode: "Branch_1", nodeName: "分支", nodeType: "BRANCH", matchType: "ANY", sourceInputMethod: "PRE_OUT", inputParam: "_input", judgeMethod: "DEFAULT",
+            exitConditionGroups: [[{ currentSchemaDataItem: "<field>", ruleDataConditionType: "EQ", ruleValueType: "FIXED", value: "<literal>" }]],
+        },
+    },
+    CREATE: {
+        description: "新增数据（含跨表新增）：**字段映射 = `dataActions`**（UI「主表字段值设置→目标字段/选择数据项」，每目标字段一条叶，DYNAMIC 用 `currentDataItemValue` 指来源字段 / FIXED 用 `value`）。**自触发禁区：`Create` 触发规则里的 CREATE 节点若目标又是本模型，每新增一行都会再次触发本 Create 规则 → 无界递归 → 运行时 550009「业务规则执行异常」（工具 fail closed `rule-graph-self-trigger-create-loop`）；CREATE 写别的模型才安全，或把该步移出 Create 规则。跨模型 CREATE（含 QUERY 取列表后逐条新增，即 N→N 扇出）真机验证可用（2026-10-07：QUERY 查 N 行→CREATE 生成 N 行，同/跨模型、TIMING/Create 触发均 OK）**——`execFormMapping` 只是展示开关，**不是**映射来源，空 `dataActions` 会让新增行业务字段全为 null（工具 fail closed `rule-graph-create-mapping-missing`）。`findMainData` = **查找满足条件的主表数据**（有没有符合的只影响「是否新增」；[[叶]]，DYNAMIC 叶同过滤规则）；`filterCondition` = **若存在符合条件的主表数据，则不新增**（`<模型>存在则不新增`）；`aggregation` = 主表数据新增方式：true=分组新增 / false=单条依次新增（存在时必须是布尔）。originatorValueType FIXED(完整用户对象 JSON 串)/DYNAMIC(字段 code) + originatorValue；startWorkflow:true 必须带 targetWorkflowCode。**下游记录要带齐业务字段**：`dataActions` 要把需求需要的字段（编号/日期/金额/满意度/状态/备注…）**逐条映射**，别只挂一个关联 id（真机 2026-10-08：只映射了关联字段，下游记录其余业务字段全 null，属残缺生成）。**originatorValueType:DYNAMIC 必须指向人员字段**（STAFF_SELECTOR 等），指向文本/编号字段会致发起人错误或为空（真机 2026-10-08）。**`SYSTEM` 值按目标字段类型取系统值**：日期字段用 `value:\"triggerTime\"`（触发时间）、人员字段用 `value:\"triggerPerson\"`（触发者）（前端源码 cloudpivot-form dateOptions/staffOptions 核验）；`SYSTEM`+空 `value` 会落空（真机 2026-10-08：回访日期用 triggerTime 才落值）。平台标签证据：i18n 模块 196233 节点属性表 + evidence/form-conditions-and-rules-truth.md §4。",
+        template: {
+            nodeCode: "Create_1", nodeName: "数据新增", nodeType: "CREATE", targetObjectCode: "<target schemaCode>", inputParam: "_input",
+            originatorValueType: "DYNAMIC", originatorValue: "<trigger field code>", startWorkflow: false,
+            execFormMapping: false, aggregation: false, finishStartActivity: false,
+            dataActions: [{ targetDataItem: "<target field>", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "<source field>" }],
+        },
+    },
+    DELETE: {
+        description: "删除数据：dataTriggerType:\"DELETE\"，仅 filterCondition（sheetConditions 删子表行），dataActions 必须为空。",
+        template: {
+            nodeCode: "Delete_1", nodeName: "数据删除", nodeType: "DELETE", dataTriggerType: "DELETE", targetObjectCode: "<target schemaCode>", inputParam: "_input",
+            filterCondition: { mainConditions: [[{ targetSchemaDataItem: "<field>", ruleConditionType: "EQ", ruleValueType: "FIXED", value: "<literal>" }]], sheetConditions: [] },
+            dataActions: [],
+        },
+    },
+    ASSIGN: {
+        description: "数据赋值（真机 2026-09-28 复核：可发布、可运行）。**`dataCondition` = 执行门**（输入数据满足条件才执行该节点，\"输入数据满足条件时触发执行动作\"）；**`filterCondition` = 按条件在输入数据源中匹配要取值的行**（\"根据此条件在输入数据源中进行匹配。匹配到多条数据时，会按第一条数据执行赋值\"）——**两者是两码事，别混**：要\"满足条件才赋值\"用 `dataCondition`，不是 `filterCondition`（后者不拦执行）。`triggerType` ∈ CURRENT(当前数据)/RULE_VARIABLE(规则变量)；CURRENT 时 `targetObjectCode` 默认 `\"_input\"`(=当前/输入对象)，dataActions 写目标字段；RULE_VARIABLE 时 targetObjectCode 隐藏、dataActions 写 `_var_*`、`orderBys` 有默认 `[{code:\"createdTime\",direction:\"ASC\"}]`。**CURRENT+dataActions 必须排在系统持久化节点(SYSTEM_CREATE/SYSTEM_UPDATE)之前**（Start→ASSIGN→SYSTEM_CREATE→End），否则赋值合并进 _input 晚于持久化、读回无变化（工具 fail closed `rule-graph-assign-persistence-order`；工具注入系统节点时也会自动排到 ASSIGN/BIZ_ACTION 之后）。平台设计器键（SHEET_ASSIGN）required：nodeCode/nodeName/targetObjectCode/ruleVariableDataActions/dataActions/orderBys/addChildDataActions；dataCondition 默认 `{conditionGroup:[]}`、filterCondition 默认 `{mainConditions:[],sheetConditions:[]}`、nonMatchingAdded 默认 false、children/addChildDataActions 默认 []。",
+        template: {
+            nodeCode: "Assign_1", nodeName: "数据赋值", nodeType: "ASSIGN", nodeCategory: "actionNode", triggerType: "CURRENT", inputParam: "_input",
+            dataCondition: { conditionGroup: [] }, dataConditionVisible: false,
+            ruleVariableDataActions: [], orderBys: [], targetObjectCode: "_input",
+            filterCondition: { mainConditions: [], sheetConditions: [] },
+            dataActions: [{ targetDataItem: "<当前模型字段 code>", ruleValueType: "FIXED", value: "<字面量>", ruleActionType: "EQUALS" }],
+            children: [], nonMatchingAdded: false, addChildDataActions: [],
+        },
+    },
+    MESSAGE: {
+        description: "消息通知。**receiver 是 MessageReceiver（8.6.26 MessageNode.java），键是 users/departments/roles/selections**（不是 receiverType/receiverValue——那是旧模板的错误形状，平台无此字段）：users/departments 放组织选择对象 `[{id,type,unitType,name}]`，**`type`/`unitType` 必须是 UnitType 的整数索引（不是枚举名字符串）**——`Selection$UnitTypeCodec` 用 `Integer.parseInt` 反序列化，传 `\"USER\"` 会 NumberFormatException→50000（2026-09-30 R5 实测）；**用户=3、部门=1**。roles 放角色码，selections 放选择码。站内消息在 `stationSetting`：`linkType`(INTERNAL_LINKS/FORM_LINKS/EXTERNAL_LINKS)、`title`/`content` 是 `MessageDataItem[]`，**元素键是 `{type, code}`——`type` 是变量类型整数（0=固定文案 STRING、1=字段引用 DATA_ITEM；前端 formula/variable 编辑器 77877：STRING=0/DATA_ITEM=1/VARIABLE=2），`code` 是字段 code 或文案**，另可带 `sheetCode`/`url`。**别用 `isDataItem` 作键**（真机 2026-10-08：agent 写 `{code,isDataItem}`，设计器「站内消息通知」点开**渲染空白**——`parseStringToNode` 按 `type` 查字段变量、查不到即丢弃该 token；后端 `MessageSetting.toJson` 反写的 `isDataItem` 只是运行时字符串形态，不是节点对象的键）。**必须带 `stationSettingVisible:true`**（MessageNode.getStationSettingVisible：顶层 title/content 均非空才默认 true，否则 null=FALSE→`StationDispatcherImpl.distributeMessage` 直接跳过、站内信**静默不发**；真机 2026-10-08：节点跑成功但 h_im_message_station 0 行）。`messageChannel` 可选（如 [\"station\"]）。可用 dataCondition 作节点执行门。**静态运行支持已证（ActivityBehaviorFactory→MessageActivityBehavior→MessageDispatcherImpl），但端到端送达未验证**——写后须真实触发并读回收件箱，别只凭 save 成功断言已通知。",
+        template: {
+            nodeCode: "Message_1", nodeName: "消息", nodeType: "MESSAGE", inputParam: "_input",
+            receiver: { users: [{ id: "<user id>", type: 3, unitType: 3, name: "<user name>" }], departments: [], roles: [], selections: [] },
+            messageChannel: ["station"],
+            stationSettingVisible: true,
+            stationSetting: {
+                linkType: "INTERNAL_LINKS",
+                title: [{ type: 0, code: "业务规则通知" }],
+                content: [{ type: 1, code: "<field code>" }, { type: 0, code: "<固定文案>" }],
+                sheetCode: "<schemaCode>",
+            },
+        },
+    },
+    BIZ_ACTION: {
+        description: "BizMethod 绑定（二开动作路径）：`execConditionGroups` = **满足条件时执行业务方法**（条件组与 filterCondition 同构：[[{targetSchemaDataItem,ruleConditionType,ruleValueType,...}]]）。serviceType:\"BIZ_METHOD\" + methodMapping{schemaCode,serviceCode,serviceName?,serviceMethodCode,serviceMethodName?,methodCode?,inputMappings[],outputMappings[]}；serviceCode+serviceMethodCode 指向集成服务方法（存在性校验用这对），methodCode 是模型级 BizMethod 注册槽。映射元素 = 8.6.26 MappingModel{propertyName,bizCode,bizPropertyType?,externParameterType?,codeType,serviceMethodParameterCode,subParameters?,expressionValue?}，codeType 按 int 序列化：0=CONST 常量 / 1=PROPERTY 字段（须带 bizCode；quote 只消费 PROPERTY 的 bizCode+propertyName）/ 2-7=LIST/OBJECT/RULE_VARIABLE/MAIN_TABLE/SYSTEM/EXPRESSION。**常量值放 `bizCode`**：codeType=0(CONST) 时平台 `MapOps` 取 `mapping.getBizCode()`、设计器写 `componentValue=bizCode`——**不要用 value/expressionValue**（平台对 CONST 不读它们，运行时静默变字面 null；expressionValue 仅 codeType=7 EXPRESSION 用）。映射元素只校验语义键，其余键原样透传（工具不按版本增删）；`required` 以方法参数面为权威自动镜像（面缺席则映射保持缺席）。**codeType=1 的 `bizCode` 必须是当前模型的源字段 code（不是 schemaCode！）**。**outputMappings 落库（真机 2026-10-06）**：方法出参经 SYSTEM_UPDATE 回写时，映射元素的 `serviceMethodParameterCode` 必须**同时**命中①集成服务方法已声明的出参 code、②扩展接口响应**根级**键；`bizCode` 是目标字段 code。三者任一不符平台以 550018「业务模型字段不存在」类错误拒绝（真机：把响应根级键 `cumOutput` 写成别的键、或目标字段 code 与声明出参不一致都被拒）。注意 Controller 若用 `getOkResponseResult` 返回 `ResponseResult{errcode,data}` 信封，出参被包在 `data` 里、根级无业务键 ⇒ **静默不回写**；要走出参映射回写，接口需根级平铺业务键，或改用「服务内部自回写」由 Java 直接落库（后者不依赖 outputMappings）。**另观察到（真机两次复现，2026-10-06）**：目标字段 code 含 `output`（如 `big_cum_output`、`big_total_output`）作规则写入目标时被平台以 550018 拒，改名去掉 `output`（如 `big_prod_sum`）后通过——语义未明；遇 550018 且目标字段 code 含 `output` 时，优先改名排查（源码字段 code 与目标字段 code 都试）。平台设计器产出的范例形状（真机核验，供对齐；缺 serviceName/serviceMethodName/methodCode/bizCodeName+bizPropertyType 时设计器「绑定业务方法」弹窗可能显示空映射）：node 级带 nodeName:\"业务方法\"、nodeCategory:\"actionNode\"、serviceType:\"BIZ_METHOD\"、invoiceBusiness:\"\"、invoiceSetting:null；映射元素带 index/propertyName(字段类型名)/bizPropertyType/displayName/required/bizCodeName(源字段名)。证据 8.6.26 BizActionNode.java:19 + BizMethodMappingModel.java + MappingModel.java:19-34 + CodeType.java:23-31 + MapOps.java(getBizMethodValue)。",
+        template: {
+            nodeCode: "BizAction_1", nodeName: "业务方法", nodeType: "BIZ_ACTION", nodeCategory: "actionNode", inputParam: "_input",
+            serviceType: "BIZ_METHOD", invoiceBusiness: "", invoiceSetting: null,
+            methodMapping: {
+                schemaCode: "<schemaCode>", serviceCode: "<serviceCode>", serviceName: "<serviceName>",
+                serviceMethodCode: "<serviceMethodCode>", serviceMethodName: "<serviceMethodName>", methodCode: "<methodCode>",
+                inputMappings: [{ index: 1, propertyName: "<字段类型名>", bizCode: "<源字段code>", bizPropertyType: 0, codeType: 1, serviceMethodParameterCode: "<param code>", displayName: "<显示名>", required: true, bizCodeName: "<源字段名>" }],
+                outputMappings: [],
+            },
+        },
+    },
+    CUSTOM_NODE: {
+        description: "自定义按钮触发：nodeType CUSTOM_NODE + isSystemNode:true（nodeCategory systemNode）；由页面按钮而非数据事件触发。",
+        template: { nodeCode: "Button_1", nodeName: "自定义节点", nodeType: "CUSTOM_NODE", isSystemNode: true, nodeCategory: "systemNode" },
+    },
+    GET_LIST: {
+        description: "获取集合（平台预置 GetList 规则的数据源节点）：dataSourceType:\"GET_LIST\" 走原生列表查询，绑已发布 BizMethod 作自定义数据源时带 methodMapping（DataSourceType.BIZ_SERVICE）；isSystemNode:true。证据 8.6.26 GetListNode.java:14-59 + BizObjectRuleUtils.isOperateDbForQuery:84-96。",
+        template: { nodeCode: "GetList", nodeName: "获取集合数据", nodeType: "GET_LIST", dataSourceType: "GET_LIST", isSystemNode: true },
+    },
+    LOAD: {
+        description: "加载表单详情（表单/流程系统节点）：仅 isSystemNode:true + nodeCategory:\"systemNode\"；平台预置 Load 规则默认图 Start→End，节点按需加入。证据 LoadNode.java:9-35。",
+        template: { nodeCode: "Load", nodeName: "加载表单详情", nodeType: "LOAD", isSystemNode: true, nodeCategory: "systemNode", originHeight: 68, edit: true },
+    },
+    AVAILABLE: {
+        description: "流程生效（流程事件系统节点）：仅 isSystemNode:true + nodeCategory:\"systemNode\"。证据 FlowAvailableNode.java:9-35 + fwb 53 条。",
+        template: { nodeCode: "Available", nodeName: "流程生效时", nodeType: "AVAILABLE", isSystemNode: true, nodeCategory: "systemNode", originHeight: 68, edit: true },
+    },
+    CANCEL: {
+        description: "流程作废（流程事件系统节点）：仅 isSystemNode:true + nodeCategory:\"systemNode\"。证据 CancelNode.java:9-35 + fwb 9 条。",
+        template: { nodeCode: "Cancel", nodeName: "流程作废时", nodeType: "CANCEL", isSystemNode: true, nodeCategory: "systemNode", originHeight: 68, edit: true },
+    },
+    SCHEDULER: {
+        description: "定时作业（规则级 bizRuleType=2）：节点仅 isSystemNode:true；调度参数不在节点上，必须在 nodeGraph.schedulerSetting 传规则级形状。**关键：`dataSourceType` 决定「规则触发数据源」**（SchedulerSetting.dataSourceType + filterConditionGroups，6.26）——`GET_LIST`=**以本模型为数据源**（即「扫描本表」；`filterConditionGroups` 是扫描过滤条件，JSON 二维数组，与 filterCondition 同构），输入数据即被过滤出的行，下游直接以 `inputParam:\"_input\"` 消费其字段；`BIZ_SERVICE`=以业务方法返回集合为源（配 methodMapping）；`NONE`=无触发数据（下游需自建 QUERY 节点取数）。**「定时扫描某表按条件动作」用 `GET_LIST` + filterConditionGroups**（不是 NONE + QUERY）；`NONE` 时整图无输入数据集，下游 MESSAGE 的字段变量解析不到、设计器映射框选不出字段。证据 ScheduleNode.java:9-33 + SchedulerSetting.java:27-52。",
+        template: { nodeCode: "Scheduler_1", nodeName: "定时触发", nodeType: "SCHEDULER", isSystemNode: true, nodeCategory: "systemNode", latestVersion: true, edit: true },
+    },
+    EXCEPTION: {
+        description: "异常中止：errMsg 必填（异常文案，@JSONField jsonDirect 字符串）；可选 dataCondition 执行门与 inputParam:\"_input\"。证据 ExceptionNode.java:13-46 + fwb 2 条（desensitized-config-shapes.md §1.2）。",
+        template: { nodeCode: "ExceptionAbort_1", nodeName: "异常终止", nodeType: "EXCEPTION", nodeCategory: "logicNode", errMsg: "<异常中止提示文案>", dataConditionVisible: false, disabled: false, inputParam: "_input" },
+    },
+    HINT: {
+        description: "提示信息：content 必填，且必须是 **JSON 数组**的字符串（HintNode.content @JSONField(jsonDirect) 按数组反序列化；裸串/对象/JSON 字符串在 businessrule/publish 稳定 50000，2026-09-20 实测）。数组元素 [{type:0=固定文案|1=字段code, value}]，最小 [] 亦可。可选 promptType。",
+        template: { nodeCode: "Hint_1", nodeName: "提示信息", nodeType: "HINT", content: '[{"type":0,"value":"<提示文案>"}]', promptType: "", inputParam: "_input" },
+    },
+});
+// ---------------------------------------------------------------------------
+// Parsing (nodes/routes may arrive as objects or pre-serialized JSON strings)
+// ---------------------------------------------------------------------------
+export function parseMaybeJson(value) {
+    // nodes/routes/schedulerSetting may arrive as objects or pre-serialized JSON
+    // strings; policy: non-strings null-coalesce, unparseable strings pass through.
+    return decodeJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
+}
+// ---------------------------------------------------------------------------
+// Leaf validators — one definition, used by filterCondition/sheetConditions/
+// findMainData/targetConditionGroups/exitConditionGroups and shared with fake
+// ---------------------------------------------------------------------------
+function isLeaf(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value) && ("ruleValueType" in value || "targetSchemaDataItem" in value || "ruleConditionType" in value || BRANCH_EXIT_OPERATOR_KEY in value || "currentSchemaDataItem" in value));
+}
+/** Walk every condition leaf in the evidence-nested group shapes ([[..]]/[[[..]]]). */
+export function walkConditionLeaves(container, visit, where = "conditions") {
+    if (Array.isArray(container)) {
+        for (const entry of container)
+            walkConditionLeaves(entry, visit, where);
+        return;
+    }
+    if (container && typeof container === "object") {
+        const record = container;
+        if (isLeaf(record)) {
+            visit(record, where);
+            return;
+        }
+        // Condition-group containers evidenced across the 8.6.26 node families
+        // (HANDOFF C.2 / evidence/form-conditions-and-rules-truth.md §4):
+        //   filterCondition (UPDATE/DELETE 查找/删除满足条件的主表数据)
+        //   findMainData / targetConditionGroups / exitConditionGroups /
+        //   sourceConditionGroups / execConditionGroups / dataCondition.
+        // Walking them here means every node family gets leaf validation with the
+        // same wire contract (value types + DYNAMIC key placement).
+        for (const key of [
+            "mainConditions",
+            "sheetConditions",
+            "conditionGroup",
+            "findMainData",
+            "targetConditionGroups",
+            "exitConditionGroups",
+            "sourceConditionGroups",
+            "execConditionGroups",
+            "dataCondition",
+        ]) {
+            if (record[key] !== undefined)
+                walkConditionLeaves(record[key], visit, `${where}.${key}`);
+        }
+    }
+}
+/** Count condition leaves nested anywhere in a group container (0 = empty group). */
+export function countConditionLeaves(container) {
+    let count = 0;
+    walkConditionLeaves(container, () => { count += 1; });
+    return count;
+}
+/** Validate one condition leaf; returns blockers (empty = clean). */
+export function validateConditionLeaf(leaf, nodeCode, where) {
+    const blockers = [];
+    const valueType = String(leaf.ruleValueType ?? "");
+    if (!RULE_CONDITION_VALUE_TYPES.includes(valueType))
+        blockers.push({ code: "rule-graph-condition-value-type", nodeCode, key: "ruleValueType", message: `${where}: ruleValueType "${valueType}" 不在 ${RULE_CONDITION_VALUE_TYPES.join("/")}（当前叶：${JSON.stringify(leaf)}）` });
+    // Condition-leaf "VARIABLE" is a runtime NPE: save+publish pass, but the engine
+    // deserializes the leaf into DataFilterCondition, reads the source as a
+    // SingletonDataset with no object, and NPEs at
+    // SingletonDataset.getBizObjectProperty → RelationParameter.getBizObjectProperty
+    // (live 2026-10-08: BRANCH exit leaf {currentSchemaDataItem:"defect_qty",
+    // ruleDataConditionType:"GT", ruleValueType:"VARIABLE",
+    // value:"SearchData_1.threshold_value"} → data.submit 50000). To consume a
+    // QUERY result, set the downstream node's inputParam to "_<QUERYnodeCode>_output"
+    // and compare FIXED/DYNAMIC on that dataset — or fold the comparison into the
+    // QUERY's own targetConditionGroups. Fail closed before the wire.
+    if (valueType === "VARIABLE")
+        blockers.push({ code: "rule-graph-condition-variable-unsupported", nodeCode, key: "ruleValueType", message: `${where}: 条件叶不支持 ruleValueType "VARIABLE"——save/publish 会过，但引擎运行时 NPE（SingletonDataset.getBizObjectProperty）令 data.submit 50000（真机 2026-10-08）。要按"查询到的值"分支：把比较直接写进 QUERY 的 targetConditionGroups，或把下游节点 inputParam 设为 "_<QUERYnodeCode>_output" 后在此叶用 FIXED/DYNAMIC 比较该数据集字段。` });
+    // `SYSTEM` is NOT a condition value type. The frontend condition editor's
+    // value enum is {fixedValue, dynamicValue, today, yesterday, tomorrow,
+    // specifyDate, specifyRange, dynamicRange, VARIABLE, EXPRESSION, EMPTY,
+    // SELF_P, SELF_D, ...} (admin 12404/19497); `SYSTEM` belongs to CREATE/UPDATE
+    // dataActions' TARGET system value. A leaf like
+    // {targetSchemaDataItem:"pay_apply_date", ruleConditionType:"LT",
+    // ruleValueType:"SYSTEM", value:""} (live 2026-10-08 SCM sandbox) saves and
+    // renders in the designer as 「申请日期 小于 (empty)」 — no right-hand value.
+    if (valueType === "SYSTEM")
+        blockers.push({ code: "rule-graph-condition-system-empty", nodeCode, key: "ruleValueType", message: `${where}: 条件叶不能用 ruleValueType "SYSTEM"（SYSTEM 是 CREATE/UPDATE 目标字段的系统值类型，不是条件值；写它设计器渲成「字段 小于 空值」—真机 2026-10-08）。日期比较要用**动态日期值**：ruleValueType "today" + currentSchemaDataItem:"<offset>"（如 "0"=今天、"-7"=7天前、"30"=30天后，可带单位 "-1-week"）；"yesterday"/"tomorrow"（无需 source）；固定日期用 FIXED + "yyyy-MM-dd HH:mm:ss"。` });
+    // `today` reads its day-offset from `currentSchemaDataItem` (Condition.source,
+    // DateFieldFilter.create: Integer.parseInt(source) — null/non-numeric throws
+    // NumberFormatException at query time, the scheduled scan then matches 0 rows
+    // and the rule "never fires" (live 2026-10-08: a today leaf without source
+    // silently killed the GET_LIST scan). Fail closed on the offset shape.
+    if (valueType === "today") {
+        const offset = leaf[DYNAMIC_CONDITION_SOURCE_KEY];
+        if (typeof offset !== "string" || !/^-?\d+(-(hour|day|week|month))?$/.test(offset))
+            blockers.push({ code: "rule-graph-condition-today-offset-missing", nodeCode, key: DYNAMIC_CONDITION_SOURCE_KEY, message: `${where}: ruleValueType "today" 的日期偏移必须放在 ${DYNAMIC_CONDITION_SOURCE_KEY}（运行时 Integer.parseInt(source)）——如 "0"=今天、"-7"=7天前、"30"=30天后、"-1-week"/"2-month" 带单位；缺失或非数字会在查询时抛 NumberFormatException，扫描 0 行、规则「永不触发」（真机 2026-10-08）。` });
+    }
+    if (leaf.ruleConditionType !== undefined && !RULE_CONDITION_TYPES.includes(String(leaf.ruleConditionType)))
+        blockers.push({ code: "rule-graph-condition-type", nodeCode, key: "ruleConditionType", message: `${where}: ruleConditionType "${String(leaf.ruleConditionType)}}" 不在 ${RULE_CONDITION_TYPES.join("/")}` });
+    if (leaf[BRANCH_EXIT_OPERATOR_KEY] !== undefined && !RULE_CONDITION_TYPES.includes(String(leaf[BRANCH_EXIT_OPERATOR_KEY])))
+        blockers.push({ code: "rule-graph-condition-type", nodeCode, key: BRANCH_EXIT_OPERATOR_KEY, message: `${where}: ${BRANCH_EXIT_OPERATOR_KEY} "${String(leaf[BRANCH_EXIT_OPERATOR_KEY])}" 不在 ${RULE_CONDITION_TYPES.join("/")}` });
+    if (valueType === "DYNAMIC") {
+        // Ticket 09 病灶回归保护：过滤来源必须在 currentSchemaDataItem，value 不得承载来源字段。
+        if (typeof leaf[DYNAMIC_CONDITION_SOURCE_KEY] !== "string" || !leaf[DYNAMIC_CONDITION_SOURCE_KEY].trim())
+            blockers.push({ code: "rule-graph-dynamic-condition-source-missing", nodeCode, key: DYNAMIC_CONDITION_SOURCE_KEY, message: `${where}: DYNAMIC 过滤叶必须带 ${DYNAMIC_CONDITION_SOURCE_KEY}（触发模型来源字段 code）；来源字段放 value 是 ticket 09 病灶（引擎按字面量匹配，静默空转）` });
+        if (leaf.value !== undefined && leaf.value !== "")
+            blockers.push({ code: "rule-graph-dynamic-condition-value-present", nodeCode, key: "value", message: `${where}: DYNAMIC 过滤叶不得携带 value（只允许 ${DYNAMIC_CONDITION_SOURCE_KEY}）` });
+    }
+    return blockers;
+}
+/** Validate one dataAction; returns blockers (empty = clean). */
+export function validateDataAction(action, nodeCode, index) {
+    const blockers = [];
+    const where = `dataActions[${index}]`;
+    const valueType = String(action.ruleValueType ?? "");
+    if (!RULE_VALUE_TYPES.includes(valueType))
+        blockers.push({ code: "rule-graph-action-value-type", nodeCode, key: "ruleValueType", message: `${where}: ruleValueType "${valueType}" 不在 ${RULE_VALUE_TYPES.join("/")}` });
+    if (typeof action.targetDataItem !== "string" || !action.targetDataItem.trim())
+        blockers.push({ code: "rule-graph-action-target-missing", nodeCode, key: "targetDataItem", message: `${where}: 缺 targetDataItem（目标字段 code）` });
+    if (valueType === "DYNAMIC") {
+        if (typeof action[DYNAMIC_ACTION_SOURCE_KEY] !== "string" || !action[DYNAMIC_ACTION_SOURCE_KEY].trim())
+            blockers.push({ code: "rule-graph-dynamic-action-source-missing", nodeCode, key: DYNAMIC_ACTION_SOURCE_KEY, message: `${where}: DYNAMIC 赋值必须带 ${DYNAMIC_ACTION_SOURCE_KEY}（来源字段 code）；来源字段放 value 是 ticket 09 病灶` });
+        if (action.value !== undefined && action.value !== "")
+            blockers.push({ code: "rule-graph-dynamic-action-value-present", nodeCode, key: "value", message: `${where}: DYNAMIC 赋值的 value 必须留空串（来源走 ${DYNAMIC_ACTION_SOURCE_KEY}）` });
+    }
+    const expressionValue = action.value && typeof action.value === "object" && !Array.isArray(action.value) ? action.value : undefined;
+    if (valueType === "EXPRESSION" && !(typeof expressionValue?.formula === "string" && expressionValue.formula.trim().length > 0))
+        blockers.push({ code: "rule-graph-expression-value-shape", nodeCode, key: "value", message: `${where}: EXPRESSION 值必须是带非空 formula 的 {formula,...} 对象；字段引用语法是 {字段code}（如 {"formula":"{amount}-{cost}"}）；此门不复用 FORMULA(100) 解析器` });
+    if (valueType === "FIXED" && action.value !== undefined && action.value !== null && typeof action.value === "object")
+        blockers.push({ code: "rule-graph-fixed-value-type", nodeCode, key: "value", message: `${where}: FIXED 值必须是分型标量——下拉=JSON 数组串、数值/布尔=原生、文本=裸字符串（生产形状 §1），对象不合法` });
+    return blockers;
+}
+// ---------------------------------------------------------------------------
+// Graph validator — Start→End connectivity, no dangling nodes/edges,
+// inputParam chaining, nodeType↔dataTriggerType consistency, per-node shapes
+// ---------------------------------------------------------------------------
+/**
+ * Validate the rule-level `schedulerSetting` (object or pre-serialized JSON
+ * string) for a SCHEDULER rule. Shape-only: the DTO defaults most values, so a
+ * partial object is legal; we only pin the enums we can prove and the
+ * DATE_FIELD→triggerDataItem invariant (SchedulerSetting.java:60-64,114).
+ */
+/**
+ * r4-fin 2026-10-09 — masked/placeholder value guard. Exact-match patterns
+ * only (whole trimmed string), so partial business text is never flagged:
+ * a masked corpId (RELEVANCE-<all zeros>), an all-zero id (designer/readback
+ * desensitised display), a whole-value `<...>` recipe placeholder, or an
+ * unresolved `${var}` template variable. All four arrive verbatim on the
+ * wire because neither the server rule API nor anything else validates
+ * values — the designer's interception only guards its own form.
+ */
+const MASKED_CORP_RE = /^RELEVANCE-0{6,}$/i;
+const ALL_ZERO_ID_RE = /^0{16,}$/;
+const WHOLE_PLACEHOLDER_RE = /^<[^<>]{1,80}>$/;
+const TEMPLATE_VAR_RE = /\$\{[A-Za-z_][A-Za-z0-9_.-]*\}/;
+function scanMaskedOrPlaceholderValues(value, path, nodeCode, blockers, seen) {
+    if (typeof value === "string") {
+        const t = value.trim();
+        let why = "";
+        if (MASKED_CORP_RE.test(t))
+            why = "掩码 corpId（RELEVANCE- 后全 0——页面回显/示例脱敏值）";
+        else if (ALL_ZERO_ID_RE.test(t))
+            why = "全 0 id（读回/列表回显的脱敏值，非真实 id）";
+        else if (WHOLE_PLACEHOLDER_RE.test(t))
+            why = "整值 <…> 占位符（未替换的配方/模板参数）";
+        else if (TEMPLATE_VAR_RE.test(t))
+            why = "未替换的 ${var} 模板变量";
+        if (why)
+            blockers.push({
+                code: "rule-graph-masked-or-placeholder-value",
+                nodeCode,
+                key: path,
+                message: `${path}=${JSON.stringify(t)} 是${why}——服务端规则 API 不校验值、前端拦截只管设计器表单，直写会把这种值原样发布并在运行时空转/50000（r4-fin 真机：BIZ_ACTION 常量映射带全 0 corpId 发布成功）。替换为真实值后再写。`,
+            });
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => scanMaskedOrPlaceholderValues(v, `${path}[${i}]`, nodeCode, blockers, seen));
+        return;
+    }
+    if (value && typeof value === "object") {
+        const obj = value;
+        if (seen.has(obj))
+            return;
+        seen.add(obj);
+        for (const [k, v] of Object.entries(value))
+            scanMaskedOrPlaceholderValues(v, `${path}.${k}`, nodeCode, blockers, seen);
+    }
+}
+export function validateSchedulerSetting(value) {
+    const blockers = [];
+    const parsed = parseMaybeJson(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return [{ code: "rule-graph-scheduler-setting-shape", key: "schedulerSetting", message: "schedulerSetting 必须是对象或 JSON 字符串（SchedulerSetting.java；BusinessRuleModel 该列是字符串）" }];
+    }
+    const settings = parsed;
+    const enumChecks = [
+        ["triggerTimeType", RULE_SCHEDULER_TRIGGER_TIME_TYPES],
+        ["executeType", RULE_SCHEDULER_EXECUTE_TYPES],
+        ["cycleType", RULE_SCHEDULER_CYCLE_TYPES],
+        ["endType", RULE_SCHEDULER_END_TYPES],
+        ["dataSourceType", RULE_DATA_SOURCE_TYPES],
+    ];
+    for (const [key, allowed] of enumChecks) {
+        if (settings[key] !== undefined && !allowed.includes(String(settings[key])))
+            blockers.push({ code: "rule-graph-scheduler-setting-enum", key: `schedulerSetting.${key}`, message: `schedulerSetting.${key} "${String(settings[key])}" 不在 ${allowed.join("/")}（8.6.26 枚举）` });
+    }
+    if (settings.triggerTime !== undefined && !Array.isArray(settings.triggerTime))
+        blockers.push({ code: "rule-graph-scheduler-setting-trigger-time", key: "schedulerSetting.triggerTime", message: "schedulerSetting.triggerTime 必须是数组（TriggerTime[]）" });
+    if (String(settings.triggerTimeType ?? "") === "DATE_FIELD" && (typeof settings.triggerDataItem !== "string" || !settings.triggerDataItem.trim()))
+        blockers.push({ code: "rule-graph-scheduler-setting-trigger-data-item", key: "schedulerSetting.triggerDataItem", message: "triggerTimeType=DATE_FIELD 必须带 triggerDataItem（触发日期字段 code）" });
+    if (settings.filterConditionGroups !== undefined && !Array.isArray(settings.filterConditionGroups))
+        blockers.push({ code: "rule-graph-scheduler-setting-filter-groups", key: "schedulerSetting.filterConditionGroups", message: "schedulerSetting.filterConditionGroups 必须是二维数组（TableCondition[][]）" });
+    return blockers;
+}
+/**
+ * Validate a BIZ_ACTION / GET_LIST(BIZ_SERVICE) `methodMapping` against the
+ * 8.6.26 DTO (BizMethodMappingModel + MappingModel). Shape-only: the wire
+ * existence check (service+method must resolve) lives in rule-support, which
+ * runs after this lint on the same nodes.
+ */
+export function validateMethodMapping(mapping, nodeCode) {
+    const blockers = [];
+    if (!mapping || typeof mapping !== "object" || Array.isArray(mapping)) {
+        return [{ code: "rule-graph-bizaction-mapping", nodeCode, key: "methodMapping", message: "BIZ_ACTION 节点缺 methodMapping{schemaCode,serviceCode,serviceMethodCode,methodCode?,inputMappings[],outputMappings[]}" }];
+    }
+    const m = mapping;
+    for (const key of ["schemaCode", "serviceCode", "serviceMethodCode"]) {
+        if (typeof m[key] !== "string" || !m[key].trim())
+            blockers.push({ code: "rule-graph-bizaction-mapping-key", nodeCode, key: `methodMapping.${key}`, message: `methodMapping.${key} 必须是非空字符串（8.6.26 BizMethodMappingModel；serviceCode+serviceMethodCode 是存在性校验对）` });
+    }
+    const mappingArrays = [["inputMappings", m.inputMappings], ["outputMappings", m.outputMappings]];
+    for (const [listKey, list] of mappingArrays) {
+        if (list === undefined)
+            continue;
+        if (!Array.isArray(list)) {
+            blockers.push({ code: "rule-graph-bizaction-list", nodeCode, key: `methodMapping.${listKey}`, message: `methodMapping.${listKey} 必须是数组（MappingModel[]）` });
+            continue;
+        }
+        list.forEach((element, index) => {
+            if (!element || typeof element !== "object" || Array.isArray(element)) {
+                blockers.push({ code: "rule-graph-bizaction-mapping-element", nodeCode, key: `methodMapping.${listKey}[${index}]`, message: `${listKey}[${index}] 必须是对象（8.6.26 MappingModel）` });
+                return;
+            }
+            const row = element;
+            // Ticket 96: only the SEMANTIC keys are policed (codeType /
+            // serviceMethodParameterCode / bizCode below). Every other key is
+            // non-semantic passthrough — forwarded verbatim, never added, dropped,
+            // or reordered by the tool regardless of platform version.
+            if (typeof row.codeType !== "number" || !Number.isInteger(row.codeType) || row.codeType < 0 || row.codeType > RULE_CODE_TYPES.length - 1)
+                blockers.push({ code: "rule-graph-bizaction-mapping-codetype", nodeCode, key: `methodMapping.${listKey}[${index}].codeType`, message: `${listKey}[${index}].codeType 必须是 0-${RULE_CODE_TYPES.length - 1} 的整数（CodeType int 序列化：${RULE_CODE_TYPES.map((t, i) => `${i}=${t}`).join("/")}）` });
+            if (typeof row.serviceMethodParameterCode !== "string" || !row.serviceMethodParameterCode.trim())
+                blockers.push({ code: "rule-graph-bizaction-mapping-param", nodeCode, key: `methodMapping.${listKey}[${index}].serviceMethodParameterCode`, message: `${listKey}[${index}] 缺 serviceMethodParameterCode（集成方法参数 code；quote 以它对账方法参数表）` });
+            if (row.codeType === 1 && (typeof row.bizCode !== "string" || !row.bizCode.trim()))
+                blockers.push({ code: "rule-graph-bizaction-mapping-bizcode", nodeCode, key: `methodMapping.${listKey}[${index}].bizCode`, message: `${listKey}[${index}].codeType=1(PROPERTY) 必须带 bizCode（RuleBizActionQuoteImpl 只消费 PROPERTY 映射的 bizCode+propertyName）` });
+            // CONST(0): the literal value must live in `bizCode` by the time it is
+            // written (MapOps reads getBizCode for CONST; the designer writes
+            // componentValue=bizCode). prepareRuleGraph moves a value found under
+            // `value`/`expressionValue` into bizCode, so accept any of the three here
+            // and only refuse when the element carries no value at all (which would
+            // arrive as literal "null" at runtime).
+            if (row.codeType === 0 && !(typeof row.bizCode === "string" && row.bizCode.trim()) && row.value === undefined && row.expressionValue === undefined)
+                blockers.push({ code: "rule-graph-bizaction-mapping-const-value", nodeCode, key: `methodMapping.${listKey}[${index}].bizCode`, message: `${listKey}[${index}].codeType=0(CONST) 缺常量值——放 bizCode（或 value，工具会移入 bizCode）；平台 CONST 只读 bizCode，缺值运行时会取到字面 null` });
+            // Ticket 113: restore unknown-key POSITIONING without touching the v2
+            // passthrough semantics — keys outside the evidenced union surface as
+            // a warning (never gates the write), so typos like "codeTyp" are seen
+            // instead of silently riding to a dead mapping at runtime.
+            const unknownKeys = Object.keys(row).filter((key) => !MAPPING_ELEMENT_KNOWN_KEYS.has(key));
+            if (unknownKeys.length > 0)
+                blockers.push({
+                    code: "rule-graph-mapping-unknown-key",
+                    nodeCode,
+                    key: `methodMapping.${listKey}[${index}].${unknownKeys.join(",")}`,
+                    message: `${listKey}[${index}] 携带未知键 [${unknownKeys.join(", ")}]——不在 8.6.26 MappingModel 语义键（MappingModel.java:26-40）与已取证 v2 透传键之列；若是拼写错误请修正，平台会静默忽略未知键（透传语义不变，仅提示）`,
+                    severity: "warning",
+                });
+        });
+    }
+    return blockers;
+}
+/**
+ * Ticket 113 — the evidenced mapping-element key union: 8.6.26 MappingModel
+ * semantic/model fields (MappingModel.java:26-40: propertyName/bizCode/
+ * bizPropertyType/externParameterType/codeType/serviceMethodParameterCode/
+ * subParameters) plus the designer v2 passthrough keys evidenced riding real
+ * payloads (index/required/displayName/bizCodeName — tool schema note,
+ * ticket 96; serviceMethodParameterName — the method-param display name, a
+ * natural parallel to bizCodeName that agents emit and the platform ignores;
+ * bizCodeName — the source field display name the designer emits alongside
+ * bizCode; value/expressionValue — accepted input aliases for a codeType:0
+ * CONST literal that prepareRuleGraph moves into bizCode (the key the platform
+ * actually reads for CONST); expressionValue also serves codeType:7 EXPRESSION.
+ * Anything else reports as a warning-positioned unknown key.
+ */
+const MAPPING_ELEMENT_KNOWN_KEYS = new Set([
+    "codeType",
+    "serviceMethodParameterCode",
+    "serviceMethodParameterName",
+    "bizCode",
+    "propertyName",
+    "bizPropertyType",
+    "externParameterType",
+    "subParameters",
+    "index",
+    "required",
+    "displayName",
+    "bizCodeName",
+    "expressionValue",
+    "value",
+]);
+/**
+ * Police the IDENTITY of a preset trigger rule's own system persistence node.
+ *
+ * A structurally valid graph can still carry a semantically wrong node: the
+ * 2026-09-26 incident hand-wrote the Create rule's node as
+ * `nodeCode:"SYSTEM_CREATE"` (the TYPE name) and omitted `nodeName`. Both passed
+ * dry-run, the save overwrote the platform preset node, and the system
+ * persistence node was lost. This is deliberately NOT a normalizer: silently
+ * rewriting nodeCode would dangle the routes that reference the old code. It
+ * fails closed, and only when the caller supplied a node of the preset's own
+ * type — a missing system node is fine (prepareRuleGraph injects the correct
+ * one). Returns [] for non-preset rule codes, which have no such contract.
+ */
+export function validatePresetSystemNodeIdentity(nodesInput, ruleCode) {
+    const spec = ruleCode ? DEFAULT_SYSTEM_NODE_BY_RULE_CODE[ruleCode] : undefined;
+    if (!spec)
+        return [];
+    const nodes = asRecordArray(parseMaybeJson(nodesInput));
+    const blockers = [];
+    for (const node of nodes) {
+        const type = String(node.nodeType ?? "");
+        // Only the preset's OWN system type is policed here; a mismatched SYSTEM_*
+        // type is reported separately by `rule-graph-preset-system-node-mismatch`.
+        if (type !== spec.nodeType)
+            continue;
+        const nodeCode = String(node.nodeCode ?? "");
+        if (nodeCode !== spec.nodeCode)
+            blockers.push({
+                code: "rule-graph-preset-system-node-code-mismatch",
+                nodeCode,
+                key: "nodes",
+                message: `预置触发规则 ${ruleCode} 的系统节点 nodeCode 必须是平台预置编码 "${spec.nodeCode}"，不能是 "${nodeCode}"（常见错误：把 nodeType 名当成 nodeCode）。用 \`omc call rule.get --env <env> --args '{"schemaCode":"<模型>","ruleCode":"${ruleCode}"}'\` 取真实基线，或删掉该系统节点让工具自动注入 "${spec.nodeCode}"（2026-09-26 真机事故：nodeCode 写错覆盖了预置节点、系统节点丢失）`,
+            });
+        if (!String(node.nodeName ?? "").trim())
+            blockers.push({
+                code: "rule-graph-preset-system-node-name-missing",
+                nodeCode,
+                key: "nodeName",
+                message: `预置触发规则 ${ruleCode} 的系统节点（nodeType ${spec.nodeType}）缺 nodeName（平台存原值、不补默认名，设计器会显示空白）。平台预置名是 "${spec.nodeName}"；勿删 nodeName`,
+            });
+    }
+    return blockers;
+}
+export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
+    const blockers = [];
+    const nodes = parseMaybeJson(graph.nodes ?? graph.node);
+    const routes = parseMaybeJson(graph.routes ?? graph.route);
+    if (!Array.isArray(nodes) || nodes.length === 0) {
+        return [{ code: "rule-graph-empty", message: "nodeGraph.nodes 不能为空" }];
+    }
+    const nodeRecords = nodes.filter((node) => Boolean(node && typeof node === "object"));
+    if (nodeRecords.length !== nodes.length)
+        blockers.push({ code: "rule-graph-node-not-object", message: "nodes 中存在非对象元素" });
+    // Cross-model write-back: SUPPORTED (verified live 2026-09-28). An UPDATE whose
+    // `targetObjectCode` is a DIFFERENT model than the rule's own model writes back
+    // correctly once TWO prerequisites hold — a 2026-09-27 probe that reported
+    // "cross-model inert" had missed BOTH:
+    //   1. The rule must actually FIRE. A bare `Update` rule fires only on a
+    //      data.update operation, NOT on create/submit; put the write-back node in
+    //      the model's `Create` rule (fires on submit) or in a rule bound to the
+    //      workflow event (e.g. the flow `end` handler).
+    //   2. The target row must be COMMITTED. The target query does not match a
+    //      DRAFT row, so a write-back aimed at a row still in draft (`data.save`
+    //      without a submit) silently writes nothing — commit it first.
+    // The graph shape (DYNAMIC filter `currentSchemaDataItem` → target `id`;
+    // DYNAMIC action `currentDataItemValue`) is correct as-is. Surface the two
+    // prerequisites as a non-gating note rather than the false "unverified" claim.
+    if (schemaCode !== undefined && schemaCode.length > 0) {
+        const writeTypes = new Set(["UPDATE", "CREATE", "DELETE"]);
+        const crossModel = nodeRecords.filter((node) => {
+            const type = String(node.nodeType ?? "");
+            const target = String(node.targetObjectCode ?? "");
+            return writeTypes.has(type) && target.length > 0 && target !== schemaCode;
+        });
+        if (crossModel.length > 0) {
+            // A cross-model write-back sitting in a preset update-only trigger rule is
+            // the classic silent no-op: it compiles + enables, but create/submit never
+            // runs it. Flag THAT (the real failure) specifically.
+            const updateOnlyTrigger = ruleCode !== undefined && DEFAULT_SYSTEM_NODE_BY_RULE_CODE[ruleCode]?.nodeType === "SYSTEM_UPDATE";
+            blockers.push({
+                code: updateOnlyTrigger ? "rule-graph-cross-model-update-trigger-inert" : "rule-graph-cross-model-prerequisites",
+                nodeCode: String(crossModel[0].nodeCode ?? ""),
+                key: "targetObjectCode",
+                severity: "warning",
+                message: updateOnlyTrigger
+                    ? `跨模型写回节点位于预置 Update 规则中：Update 规则只在 data.update 时触发，create/submit 不会执行它（真机 2026-09-28 复核）。要让回写在订单提交时生效，请把该 UPDATE 节点放进本模型的 Create 规则，或放进绑定到流程事件（如流程 end）的规则。`
+                    : `跨模型写回（目标 "${String(crossModel[0].targetObjectCode)}"）：平台支持，运行时生效的两个前提——① 承载它的规则必须真的触发（Create 在提交时触发，Update 只在 data.update 触发；也可绑定流程事件）；② 目标行必须已提交（COMMITTED），目标查询不匹配 DRAFT 行，data.save 未提交的行不会被回写。`,
+            });
+        }
+    }
+    // Self-triggering CREATE loop: a CREATE action node in the model's own `Create`
+    // rule that writes INTO the same model. Every inserted row re-fires the Create
+    // rule → unbounded recursion → the engine throws BUSINESS_RULE_EXCEPTION
+    // (550009 “业务规则执行异常”) at runtime (live 2026-10-07: the stack is an
+    // infinite `DataActivityBehavior.flushInsert → DomainServiceImpl.create →
+    // RuleExecutorImpl.execute → … → CREATE again`; the platform sometimes refuses
+    // the same graph at publish with 550018). Fail closed. Cross-model CREATE is
+    // fine; this only fires when target == the rule's own schemaCode under a
+    // Create-event trigger.
+    if (schemaCode !== undefined && schemaCode.length > 0 && ruleCode === "Create") {
+        for (const node of nodeRecords) {
+            if (String(node.nodeType ?? "") === "CREATE" && String(node.targetObjectCode ?? "") === schemaCode)
+                blockers.push({ code: "rule-graph-self-trigger-create-loop", nodeCode: String(node.nodeCode ?? ""), key: "targetObjectCode", message: `Create 规则里的 CREATE 节点目标又是本模型 "${schemaCode}"——每新增一行都会再次触发本 Create 规则，形成无界递归，运行时抛 550009「业务规则执行异常」（真机 2026-10-07 栈为 flushInsert→create→execute 无限递归；平台有时在 publish 直接 550018）。改法：CREATE 写别的模型（跨模型允许），或把这步移出 Create 触发规则（定时/按钮/流程事件），或加终止条件。` });
+        }
+    }
+    const presetSystemNode = ruleCode ? DEFAULT_SYSTEM_NODE_BY_RULE_CODE[ruleCode] : undefined;
+    if (presetSystemNode && !nodeRecords.some((node) => node.nodeType === presetSystemNode.nodeType))
+        blockers.push({ code: "rule-graph-preset-system-node-missing", key: "nodes", message: `预置触发规则 ${ruleCode} 的图必须保留平台系统节点 ${presetSystemNode.nodeType}（nodeCode "${presetSystemNode.nodeCode}"）——它是触发行的持久化节点，缺失会静默丢弃状态写入（DefaultBusinessRule；2026-09-12 live 铁证）` });
+    // A preset trigger rule must use ITS system persistence node. A mismatched
+    // SYSTEM_* node (e.g. SYSTEM_UPDATE inside the Create rule) is not a no-op: it
+    // drives the wrong trigger-row write and makes data.submit answer 50000
+    // (live 2026-09-25 sandbox18: Create graph with SYSTEM_UPDATE → submit 50000;
+    // no explicit system node / SYSTEM_CREATE → ok). Fail closed.
+    if (presetSystemNode) {
+        const systemTypes = new Set(["SYSTEM_CREATE", "SYSTEM_UPDATE", "SYSTEM_DELETE"]);
+        for (const node of nodeRecords) {
+            const type = String(node.nodeType ?? "");
+            if (systemTypes.has(type) && type !== presetSystemNode.nodeType)
+                blockers.push({ code: "rule-graph-preset-system-node-mismatch", nodeCode: String(node.nodeCode ?? ""), key: "nodes", message: `${ruleCode} 是预置触发规则，系统持久化节点必须是 ${presetSystemNode.nodeType}，不能是 ${type}——错配会让触发行写错、data.submit 报 50000（真机 2026-09-25）。删掉 ${type}（工具会自动注入 ${presetSystemNode.nodeType} 到 START 之后），或改成 ${presetSystemNode.nodeType}。` });
+        }
+        // The preset's own system node must carry the platform's preset identity
+        // (nodeCode + nodeName). A structurally-legal but semantically-wrong node
+        // passed dry-run and silently overwrote the preset node (2026-09-26).
+        blockers.push(...validatePresetSystemNodeIdentity(nodeRecords, ruleCode));
+    }
+    // Scheduler rules carry the timing config at rule level, never on the node
+    // (ScheduleNode is a bare Node; SchedulerSetting is a rule-row column).
+    const schedulerSetting = parseMaybeJson(graph.schedulerSetting ?? graph.scheduler ?? undefined);
+    if (nodeRecords.some((node) => node.nodeType === "SCHEDULER") && (schedulerSetting === undefined || schedulerSetting === null))
+        blockers.push({ code: "rule-graph-scheduler-setting-missing", key: "schedulerSetting", message: "SCHEDULER 节点必须带规则级 schedulerSetting（调度参数不在节点上；否则规则保存成功但永不触发——ScheduleNode.java 无任何时机字段）" });
+    if (schedulerSetting !== undefined && schedulerSetting !== null)
+        blockers.push(...validateSchedulerSetting(schedulerSetting));
+    // r4-fin 2026-10-09: the server-side rule API does not validate VALUES and
+    // the designer's interception is bypassed by direct writes — a published
+    // BIZ_ACTION carried a masked corpId (`RELEVANCE-00000000000000000000000000000000`)
+    // that would 50000 at every self-call. Refuse masked/placeholder values
+    // anywhere in the graph (nodes + routes + schedulerSetting).
+    const maskedSeen = new Set();
+    for (const node of nodeRecords)
+        scanMaskedOrPlaceholderValues(node, `nodes[${String(node.nodeCode ?? "?")}]`, String(node.nodeCode ?? ""), blockers, maskedSeen);
+    const graphRoutes = parseMaybeJson(graph.routes);
+    if (graphRoutes !== undefined)
+        scanMaskedOrPlaceholderValues(graphRoutes, "routes", "", blockers, maskedSeen);
+    if (schedulerSetting !== undefined && schedulerSetting !== null)
+        scanMaskedOrPlaceholderValues(schedulerSetting, "schedulerSetting", "", blockers, maskedSeen);
+    const byCode = new Map();
+    for (const node of nodeRecords) {
+        const nodeCode = String(node.nodeCode ?? "");
+        if (!nodeCode.trim()) {
+            blockers.push({ code: "rule-graph-node-code-missing", message: `节点缺 nodeCode（nodeType=${String(node.nodeType ?? "?")}）` });
+            continue;
+        }
+        if (byCode.has(nodeCode))
+            blockers.push({ code: "rule-graph-node-code-duplicate", nodeCode, message: `nodeCode "${nodeCode}" 重复` });
+        byCode.set(nodeCode, node);
+        const nodeType = String(node.nodeType ?? "");
+        if (!RULE_NODE_TYPES_SET.has(nodeType))
+            blockers.push({ code: "rule-graph-node-type-unknown", nodeCode, key: "nodeType", message: `nodeType "${nodeType}" 不在已知集 ${[...RULE_NODE_TYPES_SET].join("/")}（有证据才新增，勿猜）` });
+    }
+    const startNodes = nodeRecords.filter((node) => node.nodeType === "START");
+    const endNodes = nodeRecords.filter((node) => node.nodeType === "END");
+    if (startNodes.length !== 1)
+        blockers.push({ code: "rule-graph-start-count", message: `必须恰好 1 个 START 节点（当前 ${startNodes.length}）` });
+    if (endNodes.length < 1)
+        blockers.push({ code: "rule-graph-end-missing", message: "至少需要 1 个 END 节点" });
+    const systemPersistenceTypes = new Set(["SYSTEM_CREATE", "SYSTEM_UPDATE"]);
+    for (const systemNode of nodeRecords.filter((node) => systemPersistenceTypes.has(String(node.nodeType)))) {
+        const systemIndex = nodeRecords.indexOf(systemNode);
+        const actionIndex = nodeRecords.findIndex((node) => String(node.nodeType) === "BIZ_ACTION" && Array.isArray(node.methodMapping?.outputMappings) && node.methodMapping.outputMappings.length > 0);
+        if (actionIndex >= 0 && actionIndex > systemIndex)
+            blockers.push({ code: "rule-graph-bizaction-persistence-order", nodeCode: String(systemNode.nodeCode ?? ""), key: "nodes", message: `BIZ_ACTION outputMappings 必须排在 ${String(systemNode.nodeType)} 之前，否则动作结果不会持久化；将 BIZ_ACTION 放到系统持久化节点前，或移除无输出 mapping` });
+        // ASSIGN(CURRENT) with dataActions merges into the input the system node
+        // persists → it must run BEFORE the system node (live 2026-09-28: an ASSIGN
+        // after SYSTEM_CREATE read back no change; before it, the write landed).
+        if (String(systemNode.nodeType ?? "") === "SYSTEM_CREATE" || String(systemNode.nodeType ?? "") === "SYSTEM_UPDATE") {
+            const assignIndex = nodeRecords.findIndex((node) => String(node.nodeType) === "ASSIGN" && String(node.triggerType ?? "CURRENT") !== "RULE_VARIABLE" && Array.isArray(node.dataActions) && node.dataActions.length > 0);
+            if (assignIndex >= 0 && assignIndex > systemIndex)
+                blockers.push({ code: "rule-graph-assign-persistence-order", nodeCode: String(systemNode.nodeCode ?? ""), key: "nodes", message: `ASSIGN(CURRENT) 的赋值必须排在 ${String(systemNode.nodeType)} 之前（Start→ASSIGN→${String(systemNode.nodeType)}→End），否则赋值合并进 _input 的时机晚于持久化，读回无变化（真机 2026-09-28）。将 ASSIGN 移到系统持久化节点前。` });
+        }
+    }
+    // inputParam chaining: only "_input" or "_<existing nodeCode>_output".
+    for (const node of nodeRecords) {
+        const nodeCode = String(node.nodeCode ?? "");
+        const inputParam = node.inputParam;
+        if (inputParam === undefined)
+            continue;
+        if (typeof inputParam !== "string" || !inputParam.trim()) {
+            blockers.push({ code: "rule-graph-input-param-empty", nodeCode, key: "inputParam", message: "inputParam 不能为空串" });
+            continue;
+        }
+        if (inputParam === RULE_TRIGGER_INPUT_PARAM)
+            continue;
+        const match = /^_(.+)_output$/.exec(inputParam);
+        const source = match?.[1];
+        if (!source || !byCode.has(source))
+            blockers.push({ code: "rule-graph-input-param-chain", nodeCode, key: "inputParam", message: `inputParam 只允许 "${RULE_TRIGGER_INPUT_PARAM}"（触发数据注册名，ticket 02 铁律）或 "_<nodeCode>_output"（本图存在的节点，当前引用 "${inputParam}" 无源节点）` });
+    }
+    // Per-node shape checks.
+    for (const node of nodeRecords) {
+        const nodeCode = String(node.nodeCode ?? "");
+        const nodeType = String(node.nodeType ?? "");
+        // nodeType ↔ dataTriggerType consistency (evidence §7; preset trigger rules).
+        if (node.dataTriggerType !== undefined && NODE_TYPE_TO_DATA_TRIGGER[nodeType] !== undefined && String(node.dataTriggerType) !== NODE_TYPE_TO_DATA_TRIGGER[nodeType])
+            blockers.push({ code: "rule-graph-trigger-type-mismatch", nodeCode, key: "dataTriggerType", message: `nodeType ${nodeType} 的 dataTriggerType 必须是 "${NODE_TYPE_TO_DATA_TRIGGER[nodeType]}"（当前 "${String(node.dataTriggerType)}"）` });
+        if (nodeType === "UPDATE" || nodeType === "DELETE") {
+            if (typeof node.targetObjectCode !== "string" || !node.targetObjectCode.trim())
+                blockers.push({ code: "rule-graph-target-missing", nodeCode, key: "targetObjectCode", message: `${nodeType} 节点缺 targetObjectCode` });
+            const filter = node.filterCondition;
+            if (!filter || typeof filter !== "object")
+                blockers.push({ code: "rule-graph-filter-missing", nodeCode, key: "filterCondition", message: `${nodeType} 节点缺 filterCondition（mainConditions/sheetConditions）` });
+            else {
+                walkConditionLeaves(filter, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+                // Platform label (HANDOFF C.2 / evidence §4): UPDATE.filterCondition =
+                // 「查找满足条件的主表数据」(which row to update), DELETE.filterCondition =
+                // 「删除满足条件的数据」. An EMPTY mainConditions therefore means the node
+                // touches the whole table — the bench23 defect (unconditional update).
+                // Advisory (never gates): the write is legal at the wire but almost
+                // always a modelling error.
+                if (countConditionLeaves(filter) === 0)
+                    blockers.push({
+                        code: "rule-graph-filter-empty-main",
+                        nodeCode,
+                        key: "filterCondition",
+                        severity: "warning",
+                        message: `${nodeType} 节点 filterCondition 为空条件组——平台语义是「查找满足条件的主表数据」，空条件即无条件下操作整表（bench23 的病灶）。请补 mainConditions 定位目标行（如 targetSchemaDataItem:"id" + DYNAMIC currentSchemaDataItem:"id"），或确认确实要操作整表。`,
+                    });
+            }
+        }
+        if (nodeType === "DELETE" && Array.isArray(node.dataActions) && node.dataActions.length > 0)
+            blockers.push({ code: "rule-graph-delete-with-actions", nodeCode, key: "dataActions", message: "DELETE 节点 dataActions 必须为空（生产形状 §7：仅 filterCondition）" });
+        if (nodeType === "UPDATE") {
+            const actions = Array.isArray(node.dataActions) ? node.dataActions : [];
+            if (actions.length === 0)
+                blockers.push({ code: "rule-graph-update-without-actions", nodeCode, key: "dataActions", message: "UPDATE 节点至少需要 1 个 dataAction" });
+            actions.forEach((action, index) => {
+                if (action && typeof action === "object")
+                    blockers.push(...validateDataAction(action, nodeCode, index));
+                else
+                    blockers.push({ code: "rule-graph-action-not-object", nodeCode, key: `dataActions[${index}]`, message: "dataAction 必须是对象" });
+            });
+        }
+        if (nodeType === "QUERY") {
+            if (typeof node.targetSchemaCode !== "string" || !node.targetSchemaCode.trim())
+                blockers.push({ code: "rule-graph-query-target-schema", nodeCode, key: "targetSchemaCode", message: "QUERY 节点缺 targetSchemaCode（可带子表 schemaCode.sheetCode）" });
+            // targetConditionGroups is a TableConditionGroup OBJECT
+            // `{mainConditions:[[…]],sheetConditions:[[…]]}` (TableConditionGroup.java:9-12),
+            // NOT the bare array `[[…]]` that filterCondition/exitConditionGroups use.
+            // A bare array deserializes wrong and the live server 50000s on
+            // businessrule/update (live 2026-10-07). Fail closed before the wire.
+            if (node.targetConditionGroups !== undefined) {
+                if (Array.isArray(node.targetConditionGroups))
+                    blockers.push({ code: "rule-graph-query-condition-group-shape", nodeCode, key: "targetConditionGroups", message: "QUERY 的 targetConditionGroups 必须是对象 {mainConditions:[[叶…]],sheetConditions:[[叶…]]}（TableConditionGroup.java），不能是裸数组 [[…]]（那是 filterCondition/exitConditionGroups 的形状）——裸数组 save 通过但 live businessrule/update 50000（真机 2026-10-07）。" });
+                walkConditionLeaves(node.targetConditionGroups, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+            }
+        }
+        if (nodeType === "BRANCH") {
+            // Source evidence: RuleBranchQuoteImpl.getCurrentBizSchema throws
+            // BUSINESS_RULE_PARAM_ERROR (550018) "缺少[参与判断的数据]配置" when
+            // sourceInputMethod is null — live-confirmed 2026-09-12.
+            if (node.sourceInputMethod === undefined || node.sourceInputMethod === null || String(node.sourceInputMethod) === "")
+                blockers.push({ code: "rule-graph-branch-source-input-method", nodeCode, key: "sourceInputMethod", message: "BRANCH 节点必须带 sourceInputMethod（PRE_OUT=当前/前序数据、OTHER_MODEL=其它模型）——平台 publish 干门 550018「数据判断节点缺少[参与判断的数据]配置」（RuleBranchQuoteImpl.getCurrentBizSchema）" });
+            // inputParam: RuleBranchQuoteImpl.getCurrentBizSchema → getBizSchemaByArg(inputParam)
+            // → getBizSchemaByPath(null) → BIZ_SCHEMA_CODE_EMPTY (300010 「数据模型编码不能为空」)
+            // at publish. The template carries "_input"; a hand-built node that drops it
+            // passed the old dry lint but failed enable (live 2026-09-25 sandbox14).
+            if (typeof node.inputParam !== "string" || !node.inputParam.trim())
+                blockers.push({ code: "rule-graph-branch-input-param", nodeCode, key: "inputParam", message: "BRANCH 节点缺 inputParam——prepareRuleGraph 会自动补 \"_input\"（真机验证）；直连本校验器（未过 prepare）时缺了平台 enable/publish 拒 errcode 300010。" });
+            // judgeMethod: null != DEFAULT, so getTargetSchema() takes the OTHER branch and
+            // builds a target schema from the (also missing) targetSchemaCode → 300010.
+            const judgeMethod = String(node.judgeMethod ?? "");
+            if (!judgeMethod)
+                blockers.push({ code: "rule-graph-branch-judge-method", nodeCode, key: "judgeMethod", message: "BRANCH 节点缺 judgeMethod——prepareRuleGraph 会自动补 \"DEFAULT\"（真机验证）；直连本校验器（未过 prepare）时缺了平台按非 DEFAULT 走 targetSchemaCode 报 300010。" });
+            else if (judgeMethod !== "DEFAULT" && judgeMethod !== "OTHER")
+                blockers.push({ code: "rule-graph-branch-judge-method", nodeCode, key: "judgeMethod", message: `BRANCH judgeMethod "${judgeMethod}" 不在 DEFAULT/OTHER（RuleDataJudgeType.java）` });
+            // Ordering: a BRANCH sitting directly after START (with a preset system
+            // node placed elsewhere, which suppresses auto-injection) evaluates before
+            // the trigger input is staged and silently no-ops at runtime (live
+            // 2026-09-25 sandbox14/17: Start→BRANCH→UPDATE persisted nothing;
+            // Start→SYSTEM_CREATE→BRANCH→UPDATE worked). Silent no-op ⇒ fail closed.
+            // When SYSTEM_* is absent, injectDefaultSystemNode splices it after START
+            // automatically, so this case needs no refusal.
+            if (presetSystemNode && nodeRecords.some((entry) => entry.nodeType === presetSystemNode.nodeType) && Array.isArray(routes)) {
+                const startCode = String(startNodes[0]?.nodeCode ?? "Start");
+                const startsAtBranch = routes.some((route) => String(route?.preNode) === startCode && String(route?.postNode) === nodeCode);
+                if (startsAtBranch)
+                    blockers.push({ code: "rule-graph-branch-before-system-node", nodeCode, message: `BRANCH 直接接在 START 后、且图里已有 ${presetSystemNode.nodeType}——运行时分支静默不生效（输入未就绪，实测提交后动作不回写）。改成 Start→${presetSystemNode.nodeType}→BRANCH→动作→End；或删掉 SYSTEM_* 让工具自动注入到 START 之后。` });
+            }
+            if (!Array.isArray(node.exitConditionGroups) || node.exitConditionGroups.length === 0)
+                blockers.push({ code: "rule-graph-branch-conditions", nodeCode, key: "exitConditionGroups", message: "BRANCH 节点缺 exitConditionGroups（[[叶]] 与或组）" });
+            else {
+                walkConditionLeaves(node.exitConditionGroups, (leaf, where) => {
+                    blockers.push(...validateConditionLeaf(leaf, nodeCode, where));
+                    // 8.6.26: exitConditionGroups deserialize into DataFilterCondition, whose
+                    // left/source key is currentSchemaDataItem and operator key is
+                    // ruleDataConditionType. The UI/line-shaped targetSchemaDataItem +
+                    // ruleConditionType are UNKNOWN properties there: save+publish silently
+                    // accept them, but the engine then reads a null source/operator and
+                    // data.submit 50000s + rolls back (live 2026-09-25 前后对照已证). Fail
+                    // closed before the wire.
+                    if (leaf.targetSchemaDataItem !== undefined || leaf.ruleConditionType !== undefined)
+                        blockers.push({
+                            code: "rule-graph-branch-condition-keys",
+                            nodeCode,
+                            key: "exitConditionGroups",
+                            message: `${where}: BRANCH 出口条件叶用了 UI/连线键 targetSchemaDataItem/ruleConditionType——平台 save+publish 会过，但 exitConditionGroups 反序列化成 DataFilterCondition，运行时读不到来源/操作符，data.submit 稳定 50000 且回滚。改用 currentSchemaDataItem（左值字段）+ ${BRANCH_EXIT_OPERATOR_KEY}（操作符）：{currentSchemaDataItem,${BRANCH_EXIT_OPERATOR_KEY},ruleValueType,value}。`,
+                        });
+                });
+                // Tiered if/else hazard: CloudPivot routes EVERY exit group whose
+                // conditions match (independent groups, matchType ANY) — it does NOT stop
+                // at the first match. Two groups that can both be true (e.g.
+                // amount>=1e8 AND amount>=1e7) BOTH fire, and the later branch's action
+                // overwrites the earlier one (live 2026-10-06 sandbox: risk tiering wrote
+                // 高 then 中). Advisory: for exclusive tiers, nest branches (condition +
+                // else into the next level) instead of sibling condition groups.
+                if (Array.isArray(node.exitConditionGroups)) {
+                    const fieldGroups = new Map();
+                    node.exitConditionGroups.forEach((group, gi) => {
+                        if (!Array.isArray(group))
+                            return;
+                        for (const leaf of group) {
+                            if (!leaf || typeof leaf !== "object")
+                                continue;
+                            const field = leaf.currentSchemaDataItem;
+                            if (typeof field !== "string" || !field)
+                                continue;
+                            const seen = fieldGroups.get(field) ?? [];
+                            if (!seen.includes(gi))
+                                seen.push(gi);
+                            fieldGroups.set(field, seen);
+                        }
+                    });
+                    const overlap = [...fieldGroups.entries()].filter(([, groups]) => groups.length > 1).map(([field]) => field);
+                    if (overlap.length > 0)
+                        blockers.push({
+                            code: "rule-graph-branch-exits-may-overlap",
+                            nodeCode,
+                            key: "exitConditionGroups",
+                            severity: "warning",
+                            message: `BRANCH 多个出口组引用同一字段（${overlap.join("、")}）——平台对每个条件成立的出口都会路由并执行其后动作（不是首个命中即停）；若这些条件可能同时成立，后者分支会覆盖前者（真机 2026-10-06 风险分级：高、中同时命中→最终写成中）。要表达互斥的分级 if/else，请用嵌套 BRANCH（条件出口 + else 兜底进入下一层）。`,
+                        });
+                }
+            }
+        }
+        if (nodeType === "CREATE") {
+            const originatorType = String(node.originatorValueType ?? "");
+            if (originatorType !== "FIXED" && originatorType !== "DYNAMIC")
+                blockers.push({ code: "rule-graph-create-originator", nodeCode, key: "originatorValueType", message: `CREATE 节点 originatorValueType 必须是 FIXED(完整用户对象 JSON 串)/DYNAMIC(字段 code)（当前 "${originatorType}"）` });
+            else if (node.originatorValue === undefined || node.originatorValue === "")
+                blockers.push({ code: "rule-graph-create-originator-value", nodeCode, key: "originatorValue", message: "CREATE 节点缺 originatorValue" });
+            if (node.startWorkflow === true && (typeof node.targetWorkflowCode !== "string" || !node.targetWorkflowCode.trim()))
+                blockers.push({ code: "rule-graph-create-workflow-code", nodeCode, key: "targetWorkflowCode", message: "startWorkflow:true 必须带 targetWorkflowCode" });
+            // Platform labels (HANDOFF C.2): CREATE.findMainData = 「查找满足条件的主表数据」
+            // (its presence only affects *whether* a row is added);
+            // CREATE.filterCondition = 「若存在符合条件的主表数据，则不新增」;
+            // CREATE.aggregation = 主表新增方式 true=分组新增 / false=单条依次新增.
+            if (node.aggregation !== undefined && typeof node.aggregation !== "boolean")
+                blockers.push({ code: "rule-graph-create-aggregation", nodeCode, key: "aggregation", message: "CREATE 节点 aggregation 存在时必须是布尔（true=分组新增 / false=单条依次新增）" });
+            if (node.findMainData !== undefined)
+                walkConditionLeaves(node.findMainData, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+            if (node.filterCondition !== undefined)
+                walkConditionLeaves(node.filterCondition, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+            // The field mapping (UI「主表字段值设置 → 目标字段 / 选择数据项」) is
+            // `dataActions` — one leaf per target field. `execFormMapping` is a DISPLAY
+            // toggle, NOT the mapping source: a CREATE node with `execFormMapping:true`
+            // and no `dataActions` saves + publishes cleanly but the designer shows an
+            // empty mapping and the created row has every business field null
+            // (2026-09-27: bench44 agent inferred the mapping from the template and hit
+            // exactly this). `execFormMapping:true` + empty mapping is the wrong
+            // assumption, so fail closed; a bare empty mapping (system-fields-only
+            // create, as the live-acceptance fixture uses) only warns. Real field-copy
+            // examples (purchase_request / purchase_apply `Create`) carry one DYNAMIC
+            // leaf per field (`currentDataItemValue` = source field).
+            const createActions = Array.isArray(node.dataActions) ? node.dataActions : [];
+            if (createActions.length === 0) {
+                const assumedSwitchMaps = node.execFormMapping === true;
+                blockers.push({
+                    code: assumedSwitchMaps ? "rule-graph-create-mapping-missing" : "rule-graph-create-mapping-empty",
+                    nodeCode,
+                    key: "dataActions",
+                    ...(assumedSwitchMaps ? {} : { severity: "warning" }),
+                    message: assumedSwitchMaps
+                        ? "CREATE 节点 execFormMapping:true 但缺字段映射 dataActions——execFormMapping 只是展示开关，不是映射来源；「主表字段值设置」会为空，新增行业务字段全为 null。补 dataActions:[{targetDataItem:\"<目标字段>\",ruleValueType:\"DYNAMIC\",value:\"\",ruleActionType:\"EQUALS\",currentDataItemValue:\"<来源字段>\"}]（或 FIXED + value）。"
+                        : "CREATE 节点无 dataActions：若需把来源字段带到新增行，必须逐字段声明 dataActions（DYNAMIC + currentDataItemValue / FIXED + value）；若只新增系统字段行可忽略本告警。",
+                });
+            }
+            if (Array.isArray(node.dataActions))
+                node.dataActions.forEach((action, index) => {
+                    if (action && typeof action === "object")
+                        blockers.push(...validateDataAction(action, nodeCode, index));
+                });
+        }
+        if (nodeType === "ASSIGN" && Array.isArray(node.dataActions)) {
+            node.dataActions.forEach((action, index) => {
+                if (action && typeof action === "object")
+                    blockers.push(...validateDataAction(action, nodeCode, index));
+            });
+        }
+        // ASSIGN.filterCondition = 「满足条件时触发赋值」（与 UPDATE 同构的定位/触发条件），
+        // 也是「满足条件触发」的一种——walk 它（不依赖 dataActions 是否存在），避免畸形叶静默上送。
+        if (nodeType === "ASSIGN" && node.filterCondition !== undefined)
+            walkConditionLeaves(node.filterCondition, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+        if (nodeType === "ASSIGN") {
+            // ASSIGN(CURRENT) 写当前单据时，节点必须带 targetObjectCode + aggregation +
+            // nonMatchingAdded，否则 businessrule/publish 稳定 50000 服务异常（实测
+            // 2026-09-23：漏 targetObjectCode/aggregation/nonMatchingAdded → 50000；
+            // 补齐后 publish 成功）。DATA_ASSIGN_NODE(DataAssignNode.java) 的
+            // getTargetObjectCode() 对 CURRENT 回退 getTriggerObjectCode()，publish 期
+            // 该回退可取到空 → getTargetSchema() 为 null。规则变量的 ASSIGN 不需要它。
+            if (String(node.triggerType ?? "") === "CURRENT" && (typeof node.targetObjectCode !== "string" || !node.targetObjectCode.trim()))
+                blockers.push({
+                    code: "rule-graph-assign-current-target",
+                    nodeCode,
+                    key: "targetObjectCode",
+                    severity: "warning",
+                    message: "ASSIGN(数据赋值) triggerType=CURRENT 未带 targetObjectCode：写当前单据/流程回写时平台 publish 可能稳定 50000（实测补齐 targetObjectCode+aggregation+nonMatchingAdded 后可发布）。补 targetObjectCode:\"<当前模型 schemaCode>\"、aggregation:false、nonMatchingAdded:false。",
+                });
+        }
+        if (nodeType === "MESSAGE") {
+            const receiver = node.receiver;
+            if (receiver === undefined || typeof receiver !== "object" || Array.isArray(receiver)) {
+                blockers.push({ code: "rule-graph-message-receiver", nodeCode, key: "receiver", message: "MESSAGE 节点缺 receiver（MessageReceiver 对象：{users,departments,roles,selections}；不要用旧模板的 receiverType/receiverValue——平台 MessageNode 无此字段）" });
+            }
+            else {
+                const hasRecipient = ["users", "departments", "roles", "selections"].some((k) => Array.isArray(receiver[k]) && receiver[k].length > 0);
+                if (!hasRecipient)
+                    blockers.push({ code: "rule-graph-message-receiver-empty", nodeCode, key: "receiver", message: "MESSAGE receiver 未指定任何收件人：在 users/departments/roles/selections 之一给值（users/departments=[{id,type,unitType,name}]，type/unitType 用整数：用户=3、部门=1）" });
+                if (receiver.receiverType !== undefined || receiver.receiverValue !== undefined)
+                    blockers.push({ code: "rule-graph-message-receiver-legacy", nodeCode, key: "receiver", severity: "warning", message: "receiver 携带 receiverType/receiverValue——不是 8.6.26 MessageReceiver 的键，平台会忽略；改用 users/departments/roles/selections" });
+                // type/unitType are UnitType deserialized by Selection$UnitTypeCodec via
+                // Integer.parseInt — a string name ("USER") NumberFormatExceptions the
+                // rule save (50000). Must be the integer index (USER=3, DEPARTMENT=1).
+                for (const key of ["users", "departments"]) {
+                    const list = receiver[key];
+                    if (!Array.isArray(list))
+                        continue;
+                    list.forEach((entry, index) => {
+                        if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                            const row = entry;
+                            for (const field of ["type", "unitType"]) {
+                                if (row[field] === undefined)
+                                    continue;
+                                if (typeof row[field] !== "number" || !Number.isInteger(row[field]))
+                                    blockers.push({ code: "rule-graph-message-unittype", nodeCode, key: `receiver.${key}[${index}].${field}`, message: `MESSAGE receiver.${key}[].${field} 必须是 UnitType 整数索引（用户=3、部门=1），不是枚举名字符串——平台 Selection$UnitTypeCodec 用 Integer.parseInt，传 "USER" 会 NumberFormatException 令规则保存 50000` });
+                            }
+                        }
+                    });
+                }
+            }
+            const station = node.stationSetting;
+            const messageItemCheck = (arr, key) => {
+                if (!Array.isArray(arr))
+                    return;
+                arr.forEach((item, index) => {
+                    if (!item || typeof item !== "object" || Array.isArray(item))
+                        return;
+                    const row = item;
+                    // The node object stores each title/content line as MessageDataItem
+                    // {type, code} — type 0=STRING(fixed text) / 1=DATA_ITEM(field ref).
+                    // The designer's variable editor (77877 parseStringToNode) resolves a
+                    // FIELD token by looking up `variableList.find(code===`${r.code}` &&
+                    // type===`${r.type}`)`; with no numeric `type` the token is dropped and
+                    // the 站内消息通知 panel renders BLANK (live 2026-10-08). A legacy
+                    // `isDataItem` key is the backend `MessageSetting.toJson` STRING form,
+                    // NOT the node-object key — treat it as an error, not an alias.
+                    if (row.type === undefined) {
+                        blockers.push({
+                            code: "rule-graph-message-item-type",
+                            nodeCode,
+                            key: `${key}[${index}]`,
+                            message: `消息条目缺 \`type\`（MessageDataItem 节点键是 {type,code}；type 0=固定文案 / 1=字段引用 ${row.isDataItem !== undefined ? "——不要用 isDataItem，那是运行时字符串形态不是节点键" : ""}；缺 type 设计器「站内消息通知」渲染空白）`,
+                        });
+                    }
+                    else if (typeof row.type !== "number") {
+                        blockers.push({ code: "rule-graph-message-item-type", nodeCode, key: `${key}[${index}].type`, message: `消息条目 type 必须是整数（0=固定文案 / 1=字段引用），收到 ${JSON.stringify(row.type)}` });
+                    }
+                });
+            };
+            if (!station || !Array.isArray(station.content) || station.content.length === 0) {
+                blockers.push({ code: "rule-graph-message-content", nodeCode, key: "stationSetting.content", message: "MESSAGE 节点缺 stationSetting.content（MessageDataItem[]：{type,code}，type 1=字段 code、0=固定文案）" });
+            }
+            else {
+                messageItemCheck(station.content, "stationSetting.content");
+                messageItemCheck(station.title, "stationSetting.title");
+            }
+            // A station message is silently DROPPED unless visible: MessageNode
+            // .getStationSettingVisible() defaults null→FALSE (only top-level
+            // title+content imply TRUE), and StationDispatcherImpl.distributeMessage
+            // skips on !visible (live 2026-10-08: node ran "successful" yet
+            // h_im_message_station gained 0 rows).
+            if (station && node.stationSettingVisible !== true && !(typeof node.title === "string" && node.title.trim() && typeof node.content === "string" && node.content.trim()))
+                blockers.push({ code: "rule-graph-message-station-invisible", nodeCode, key: "stationSettingVisible", message: "MESSAGE 节点带 stationSetting 但未设 `stationSettingVisible:true`——平台默认 FALSE，站内信**静默不发**（MessageNode.getStationSettingVisible null→FALSE；StationDispatcherImpl 跳过；真机 2026-10-08 节点执行成功但收件箱 0 行）。补 `stationSettingVisible:true`。" });
+        }
+        if (nodeType === "BIZ_ACTION") {
+            blockers.push(...validateMethodMapping(node.methodMapping, nodeCode));
+        }
+        if (nodeType === "GET_LIST") {
+            if (node.dataSourceType !== undefined && !RULE_DATA_SOURCE_TYPES.includes(String(node.dataSourceType)))
+                blockers.push({ code: "rule-graph-getlist-datasource-type", nodeCode, key: "dataSourceType", message: `GET_LIST 节点 dataSourceType "${String(node.dataSourceType)}" 不在 ${RULE_DATA_SOURCE_TYPES.join("/")}（DataSourceType.java:13-17；节点存枚举名）` });
+            if (node.methodMapping !== undefined)
+                blockers.push(...validateMethodMapping(node.methodMapping, nodeCode));
+        }
+        if (nodeType === "EXCEPTION" && (typeof node.errMsg !== "string" || !node.errMsg.trim()))
+            blockers.push({ code: "rule-graph-exception-errmsg", nodeCode, key: "errMsg", message: "EXCEPTION 节点必须带非空 errMsg（异常中止文案，ExceptionNode.errMsg @JSONField jsonDirect）" });
+        if (nodeType === "HINT") {
+            // HintNode.content is @JSONField(jsonDirect) and the platform parses it
+            // as a JSON ARRAY; a bare string / object / JSON-string is accepted by
+            // save but 50000s at publish (2026-09-20 live). Refuse it before the wire.
+            const parsedContent = typeof node.content === "string" ? parseMaybeJson(node.content) : node.content;
+            if (!Array.isArray(parsedContent))
+                blockers.push({
+                    code: "rule-graph-hint-content",
+                    nodeCode,
+                    key: "content",
+                    message: 'HINT 节点 content 必须是 JSON 数组（字符串形式），如 [{"type":0,"value":"提示文案"}] 或 []；裸串/对象/JSON 字符串在 publish 稳定 50000（HintNode.content @JSONField jsonDirect）',
+                });
+        }
+        // ── Common trigger-condition keys (HANDOFF C.2/C.3; evidence §4) ──────────
+        // childTriggerConditionType: 子表触发数据范围 ADD/MODIFY/DELETE.
+        if (node.childTriggerConditionType !== undefined) {
+            const value = String(node.childTriggerConditionType);
+            if (!RULE_CHILD_TRIGGER_CONDITION_TYPES.includes(value))
+                blockers.push({ code: "rule-graph-child-trigger-condition-type", nodeCode, key: "childTriggerConditionType", message: `节点 childTriggerConditionType "${value}" 不在 ${RULE_CHILD_TRIGGER_CONDITION_TYPES.join("/")}（子表触发数据范围：新增/修改/删除）` });
+        }
+        // dataCondition: 输入数据满足条件时触发执行动作（通用执行门）。
+        if (node.dataCondition !== undefined)
+            walkConditionLeaves(node.dataCondition, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+        // execConditionGroups: 满足条件时执行业务方法（BIZ_ACTION）。
+        if (node.execConditionGroups !== undefined)
+            walkConditionLeaves(node.execConditionGroups, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
+    }
+    // Routes: reference integrity + reachability.
+    const edgeList = [];
+    if (routes !== undefined && routes !== null) {
+        if (!Array.isArray(routes))
+            blockers.push({ code: "rule-graph-routes-shape", message: "routes 必须是数组（或 JSON 字符串）" });
+        else
+            for (const route of routes) {
+                if (!route || typeof route !== "object") {
+                    blockers.push({ code: "rule-graph-route-not-object", message: "route 必须是对象" });
+                    continue;
+                }
+                const record = route;
+                const pre = String(record.preNode ?? "");
+                const post = String(record.postNode ?? "");
+                const where = `route ${pre || "?"}→${post || "?"}`;
+                if (!byCode.has(pre))
+                    blockers.push({ code: "rule-graph-route-dangling", key: "preNode", message: `路由引用不存在的 preNode "${pre}"` });
+                if (!byCode.has(post))
+                    blockers.push({ code: "rule-graph-route-dangling", key: "postNode", message: `路由引用不存在的 postNode "${post}"` });
+                // CFG-26: missing/empty `points` is BLOCKED — live evidence (P4,
+                // 2026-09-13) is a blank designer canvas caused exactly by routes with
+                // no geometry. `routeCondition`/`matchType`: the adapter
+                // (ensureRouteShape) fills them when absent, so the save path always
+                // persists them; there is no evidence that their absence alone breaks
+                // execution (the live missing-key Create rule ran and wrote back
+                // correctly). This lint therefore only rejects a PRESENT but invalid
+                // value — absence is the adapter's job, not a caller error.
+                const points = record.points;
+                if (!(Array.isArray(points) && points.length > 0 && points.every((point) => typeof point === "string" && RULE_POINT.test(point.trim()))))
+                    blockers.push({ code: "rule-graph-route-points", key: "points", message: `${where}: 必须带非空字符串坐标数组 points（画布连线靠它渲染；平台默认形如 ["406, 76","406, 116"]）` });
+                if (record.routeCondition !== undefined && typeof record.routeCondition !== "boolean")
+                    blockers.push({ code: "rule-graph-route-condition", key: "routeCondition", message: `${where}: routeCondition 存在时必须是布尔（true=满足分支条件执行，false=不满足其他分支时执行的 else 出口）；缺失由适配器补 true` });
+                const matchType = record.matchType;
+                if (matchType !== undefined && matchType !== null && String(matchType).trim() !== "" && !RULE_ROUTE_MATCH_TYPES.includes(String(matchType)))
+                    blockers.push({ code: "rule-graph-route-match-type", key: "matchType", message: `${where}: matchType "${String(matchType)}" 不在 ${RULE_ROUTE_MATCH_TYPES.join("/")}；缺失由适配器补 "ANY"` });
+                if (pre && post && byCode.has(pre) && byCode.has(post))
+                    edgeList.push({ pre, post });
+            }
+    }
+    // Reachability only when the graph carries explicit routes: an empty
+    // routes array is the platform's implied-linear sequence (ticket 09 live
+    // save shipped routes:[] and the engine executed Start→…→End in order);
+    // with edges present, every node must be reachable from START and some
+    // path must reach END.
+    if (startNodes.length === 1 && edgeList.length > 0) {
+        const adjacency = new Map();
+        for (const { pre, post } of edgeList)
+            adjacency.set(pre, [...(adjacency.get(pre) ?? []), post]);
+        const startCode = startNodes.length === 1 ? String(startNodes[0].nodeCode ?? "") : "";
+        if (startCode && byCode.has(startCode)) {
+            const seen = new Set([startCode]);
+            const queue = [startCode];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                for (const next of adjacency.get(current) ?? [])
+                    if (!seen.has(next)) {
+                        seen.add(next);
+                        queue.push(next);
+                    }
+            }
+            for (const [code] of byCode) {
+                if (!seen.has(code))
+                    blockers.push({ code: "rule-graph-node-unreachable", nodeCode: code, message: `节点 "${code}" 从 START 不可达（悬空节点）` });
+            }
+            const reachesEnd = [...seen].some((code) => byCode.get(code)?.nodeType === "END");
+            if (!reachesEnd)
+                blockers.push({ code: "rule-graph-no-path-to-end", message: "START 到 END 不可达（图不连通）" });
+        }
+    }
+    return blockers;
+}
+//# sourceMappingURL=rule-graph.js.map