@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/intent/capabilities/businessrule.js

@@ -0,0 +1,493 @@
+import { ENDPOINTS } from "../../endpoints.js";
+import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "../../json-column.js";
+import { wireCall, wireRows } from "../../wire.js";
+import { countConditionLeaves, prepareRuleGraph, RULE_IDENTITY_FILTER, validateRuleNodeGraph } from "../../lanes/rule-graph.js";
+import { canonicalJson } from "../dsl.js";
+import { isScalarString, pushError } from "../validation.js";
+import { toPlain } from "../yaml.js";
+/** Keys a rule item accepts. */
+const RULE_KEYS = new Set(["code", "name", "enabled", "bizRuleType", "customTrigger", "actions", "nodeGraph"]);
+/** Keys a compact action accepts. */
+const ACTION_KEYS = new Set(["type", "target", "filter", "when", "set"]);
+/** Keys a compact filter/assignment item accepts. */
+const LEAF_KEYS = new Set(["field", "from", "equals", "notEquals", "gt", "gte", "lt", "lte", "value"]);
+/**
+ * Compact-condition operator keys → the platform's `ruleConditionType`. `equals`
+ * existed alone before round 14 (FIXED EQ); the comparison operators were added
+ * because a threshold rule (`amount > 5000`) is otherwise INEXPRESSIBLE on the
+ * compact face and forced callers into a hand-built `nodeGraph` (bench37: ~46 KB
+ * of validate/retry churn from exactly that). `from` stays the DYNAMIC (EQ) form.
+ */
+const CONDITION_OPERATORS = Object.freeze({
+    equals: "EQ",
+    notEquals: "NEQ",
+    gt: "GT",
+    gte: "GTEQ",
+    lt: "LT",
+    lte: "LTEQ",
+});
+/** Geometry/display keys ignored when comparing a synthesized graph to the live one. */
+const GEOMETRY_KEYS = new Set(["x", "y", "width", "height", "points", "originHeight", "originWidth", "edit"]);
+function stripGeometry(value) {
+    if (Array.isArray(value))
+        return value.map(stripGeometry);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value))
+            if (!GEOMETRY_KEYS.has(key))
+                out[key] = stripGeometry(entry);
+        return out;
+    }
+    return value;
+}
+/**
+ * Canonicalize a route for digesting: strip geometry and apply the same
+ * defaults `ensureRouteShape` applies to the wire (`routeCondition` absent ->
+ * true, `matchType` absent/empty -> "ANY"), so an equivalent live route that
+ * omits those keys is not reported as drift. An explicit `false`/custom value
+ * is preserved.
+ */
+function canonicalRoute(route) {
+    const stripped = stripGeometry(route);
+    if (!stripped || typeof stripped !== "object" || Array.isArray(stripped))
+        return stripped;
+    const out = { ...stripped };
+    if (out.routeCondition === undefined || out.routeCondition === null)
+        out.routeCondition = true;
+    if (out.matchType === undefined || out.matchType === null || String(out.matchType).trim() === "")
+        out.matchType = "ANY";
+    return out;
+}
+/**
+ * Semantic digest of a rule graph: geometry/display-only keys removed, nodes
+ * sorted by nodeCode, routes defaulted and sorted by their canonical form.
+ * Stable across the platform's cosmetic normalization (layout, route ordering,
+ * omitted route defaults), so readback compares intent, not canvas pixels.
+ */
+export function ruleGraphDigest(nodes, routes) {
+    const nodeList = Array.isArray(nodes)
+        ? [...nodes].sort((a, b) => String(a?.nodeCode ?? "").localeCompare(String(b?.nodeCode ?? "")))
+        : [];
+    const routeList = (Array.isArray(routes) ? routes : []).map(canonicalRoute).sort((a, b) => canonicalJson(a).localeCompare(canonicalJson(b)));
+    return canonicalJson({ nodes: stripGeometry(nodeList) ?? [], routes: routeList });
+}
+function conditionLeaf(condition) {
+    const raw = condition;
+    if (condition.from !== undefined)
+        return { targetSchemaDataItem: condition.field, ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: condition.from };
+    const operator = Object.keys(CONDITION_OPERATORS).find((key) => raw[key] !== undefined) ?? "equals";
+    return { targetSchemaDataItem: condition.field, ruleConditionType: CONDITION_OPERATORS[operator], ruleValueType: "FIXED", value: raw[operator] ?? null };
+}
+/**
+ * A `when` leaf compiles to the node's EXECUTION GATE (`dataCondition`), whose
+ * leaves use the platform's `Condition`/`DataFilterCondition` shape: the left
+ * value is `currentSchemaDataItem` (the input/current-data field) and the
+ * operator is `ruleDataConditionType` — NOT `filterCondition`'s
+ * `targetSchemaDataItem` + `ruleConditionType`. Verified against 8.6.26
+ * `DataCondition.java` (conditionGroup: List<List<DataFilterCondition>>),
+ * `DataFilterCondition.java` (ruleDataConditionType) and `Condition.java`
+ * (currentSchemaDataItem / ruleValueType / value).
+ */
+function gateConditionLeaf(condition) {
+    const raw = condition;
+    const operator = Object.keys(CONDITION_OPERATORS).find((key) => raw[key] !== undefined) ?? "equals";
+    return { currentSchemaDataItem: condition.field, ruleDataConditionType: CONDITION_OPERATORS[operator], ruleValueType: "FIXED", value: raw[operator] ?? null };
+}
+function assignment(action) {
+    if (action.from !== undefined)
+        return { targetDataItem: action.field, ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: action.from };
+    return { targetDataItem: action.field, ruleValueType: "FIXED", value: action.value ?? null, ruleActionType: "EQUALS" };
+}
+/**
+ * Synthesize the raw node graph from compact actions: a linear
+ * Start → UPDATE_1..N → End chain. The platform's own normalization
+ * (prepareRuleGraph: preset system node / custom trigger / layout / route
+ * geometry) is applied on top, exactly as `rule.save` will apply it again.
+ */
+function graphFromActions(actions, modelCode) {
+    const nodes = [{ nodeCode: "Start", nodeName: "开始", nodeType: "START" }];
+    actions.forEach((action, index) => {
+        const filter = action.filter ?? [];
+        const when = action.when ?? [];
+        // `filter` is the row LOCATOR (filterCondition). An omitted filter on a
+        // SAME-MODEL action defaults to the self-identity match (`id = id`) — the
+        // "update the current record" intent. A cross-model action must name its
+        // locator explicitly; an empty one is refused fail-closed by lintRuleGraph
+        // (empty filterCondition = unconditional whole-target-table update).
+        const filterCondition = filter.length > 0
+            ? { mainConditions: [filter.map(conditionLeaf)], sheetConditions: [] }
+            : action.target === modelCode
+                ? RULE_IDENTITY_FILTER
+                : { mainConditions: [], sheetConditions: [] };
+        nodes.push({
+            nodeCode: `Update_${index + 1}`,
+            nodeName: "数据更新",
+            nodeType: "UPDATE",
+            targetObjectCode: action.target,
+            inputParam: "_input",
+            updateNodeType: "UPDATE_MODEL",
+            execFormMapping: false,
+            // `when` is the node EXECUTION GATE (`dataCondition`): the node runs only
+            // when the input data satisfies it. Distinct from `filter` (which rows).
+            ...(when.length > 0 ? { dataCondition: { conditionGroup: [when.map(gateConditionLeaf)] } } : {}),
+            filterCondition,
+            dataActions: action.set.map(assignment),
+        });
+    });
+    nodes.push({ nodeCode: "End", nodeName: "结束", nodeType: "END" });
+    const routes = nodes.slice(0, -1).map((node, index) => ({ preNode: String(node.nodeCode), postNode: String(nodes[index + 1].nodeCode) }));
+    return { nodes, routes };
+}
+/**
+ * The graph the compiler expects on the platform for a declared rule.
+ * `modelCode` (the declaring model) lets a compact same-model action default its
+ * locator to self-identity; it is optional because a raw `nodeGraph` needs no
+ * synthesis (and callers that only compare digests still pass it).
+ */
+export function expectedRuleGraph(rule, modelCode = "") {
+    const raw = rule.nodeGraph ?? graphFromActions(rule.actions ?? [], modelCode);
+    return prepareRuleGraph(rule.code, { ...raw, ...(rule.bizRuleType !== undefined ? { bizRuleType: rule.bizRuleType } : {}) }, rule.customTrigger, modelCode || undefined).graph;
+}
+/**
+ * Offline dry-lint of a declared rule's PREPARED graph. Runs the exact validator
+ * `rule.save` runs at apply time, so `intent validate`/`plan` fail with the same
+ * blockers before any approval or wire (2026-09-27: a CREATE node missing
+ * `originatorValueType` passed plan and only failed at apply). Pure — no
+ * environment contact. Shape errors are already reported by the readers, so a
+ * prepare throw is swallowed rather than double-reported.
+ */
+function lintRuleGraph(rule, ctx, base, schemaCode) {
+    try {
+        const graph = expectedRuleGraph(rule, schemaCode);
+        for (const blocker of validateRuleNodeGraph(graph, rule.code, schemaCode)) {
+            // Warning-severity findings (e.g. cross-model-unverified, defaulted keys)
+            // ride the payload but never gate — same rule the tool preflight applies.
+            if (blocker.severity === "warning")
+                continue;
+            pushError(ctx, blocker.code, blocker.message, `${base}.${rule.nodeGraph ? "nodeGraph" : "actions"}`, "value");
+        }
+        // Cross-model UPDATE with an empty filter is fail-closed on the declarative
+        // face: the platform semantic is "find the target rows matching these
+        // conditions" (empty ⇒ update the WHOLE target table). The tool's own lint
+        // rates this a warning (legal at the wire), but for a target model OTHER than
+        // the rule's own, an unconditional update is almost certainly the "write back
+        // to the related row" intent with the locate-filter forgotten — bench52/53
+        // saved+publish passed and the runtime silently wrote nothing, costing a full
+        // end-to-end cycle each. Make the declarative face require the filter.
+        for (const raw of graph.nodes ?? []) {
+            if (String(raw.nodeType ?? "") !== "UPDATE")
+                continue;
+            const target = typeof raw.targetObjectCode === "string" ? raw.targetObjectCode : "";
+            const crossModel = target.length > 0 && target !== schemaCode && !target.startsWith(`${schemaCode}.`);
+            if (crossModel && countConditionLeaves(raw.filterCondition) === 0)
+                pushError(ctx, "intent-rule-cross-model-filter-required", `跨模型 UPDATE 节点 ${String(raw.nodeCode ?? "")}（目标 ${target}）的 filterCondition 为空——空条件=无条件下更新目标模型整表。回写关联行的规则必须给出定位条件，例如 filter: [{field: id, from: <本模型保存目标 id 的字段>}]`, `${base}.${rule.nodeGraph ? "nodeGraph" : "actions"}`, "value");
+        }
+    }
+    catch {
+        /* shape errors already reported */
+    }
+}
+/** The exact `rule.save` args for a declared rule (nodeGraph is the prepared graph). */
+function ruleSaveArgs(schemaCode, rule) {
+    return {
+        schemaCode,
+        ruleCode: rule.code,
+        name: rule.name,
+        nodeGraph: expectedRuleGraph(rule, schemaCode),
+        ...(rule.customTrigger !== undefined ? { customTrigger: rule.customTrigger } : {}),
+    };
+}
+/**
+ * Read a compact condition/assignment leaf off a YAML map.
+ *
+ * Fail-closed (round 14): before, a leaf with `field` but no `from`/`equals`
+ * silently became `{..., value: null}` and the platform normalized it to
+ * "field EQ null" — a rule that saves + publishes fine but never matches
+ * (bench37: an agent wrote a threshold intent, got `EQ null`, and burned ~46 KB
+ * of validate/apply retries chasing it). A condition now needs EXACTLY ONE of
+ * `from` (DYNAMIC EQ) or an operator key; an assignment needs `from` XOR `value`.
+ * Zero or ambiguous sources are a semantic error, never a silent null.
+ */
+function readLeaf(leaf, base, ctx, kind) {
+    for (const entry of leaf.entries)
+        if (!LEAF_KEYS.has(entry.key))
+            pushError(ctx, "intent-key-unknown", `${kind} 不支持键 "${entry.key}"（条件接受 field / from / equals / notEquals / gt / gte / lt / lte；赋值接受 field / from / value）`, `${base}.${entry.key}`);
+    const fieldNode = leaf.entries.find((entry) => entry.key === "field")?.value;
+    const fromNode = leaf.entries.find((entry) => entry.key === "from")?.value;
+    if (!isScalarString(fieldNode))
+        pushError(ctx, "intent-rule-leaf-field-invalid", `${kind} 缺 field（非空字符串）`, `${base}.field`, "value");
+    if (fromNode !== undefined && !isScalarString(fromNode))
+        pushError(ctx, "intent-rule-leaf-from-invalid", `${kind}.from 必须是非空字符串（触发字段 code）`, `${base}.from`, "value");
+    const literalKeys = kind === "condition" ? Object.keys(CONDITION_OPERATORS) : ["value"];
+    const present = literalKeys.filter((key) => leaf.entries.some((entry) => entry.key === key));
+    for (const key of present) {
+        const node = leaf.entries.find((entry) => entry.key === key).value;
+        const value = node.kind === "scalar" ? node.value : undefined;
+        if (value !== undefined && value !== null && typeof value === "object")
+            pushError(ctx, "intent-rule-leaf-literal-invalid", `${kind}.${key} 必须是标量`, `${base}.${key}`, "value");
+    }
+    const sources = present.length + (fromNode !== undefined ? 1 : 0);
+    if (sources === 0)
+        pushError(ctx, "intent-rule-leaf-source-missing", kind === "condition"
+            ? `filter 项缺条件来源：给 from: <字段>（DYNAMIC）或一个比较键（equals/notEquals/gt/gte/lt/lte: <值>）。空来源会被平台归一化成 "EQ null"，规则永不命中`
+            : `set 项缺赋值来源：给 value: <值>（FIXED）或 from: <字段>（DYNAMIC）`, base, "value");
+    else if (sources > 1)
+        pushError(ctx, "intent-rule-leaf-source-ambiguous", `${kind} 只能有一个来源（from 或 ${literalKeys.join("/")} 之一），得到 ${sources} 个`, base, "value");
+    if (!isScalarString(fieldNode))
+        return null;
+    if (sources !== 1)
+        return { field: fieldNode.value.trim() };
+    if (fromNode !== undefined)
+        return { field: fieldNode.value.trim(), from: fromNode.value.trim() };
+    const operator = present[0];
+    const literalNode = leaf.entries.find((entry) => entry.key === operator).value;
+    const literal = literalNode.kind === "scalar" ? literalNode.value : null;
+    return { field: fieldNode.value.trim(), [operator]: literal };
+}
+function readActions(actionsNode, base, ctx, modelCode) {
+    if (actionsNode.kind !== "seq") {
+        pushError(ctx, "intent-rule-actions-not-a-list", `actions 必须是列表（得到 ${actionsNode.kind}）`, `${base}.actions`, "value");
+        return [];
+    }
+    const actions = [];
+    actionsNode.items.forEach((actionNode, index) => {
+        const actionBase = `${base}.actions[${index}]`;
+        if (actionNode.kind !== "map") {
+            pushError(ctx, "intent-rule-action-not-a-map", "action 必须是映射", actionBase, "value");
+            return;
+        }
+        for (const entry of actionNode.entries)
+            if (!ACTION_KEYS.has(entry.key))
+                pushError(ctx, "intent-key-unknown", `action 不支持键 "${entry.key}"（只接受 type / target / filter / when / set）`, `${actionBase}.${entry.key}`);
+        const typeNode = actionNode.entries.find((entry) => entry.key === "type")?.value;
+        const targetNode = actionNode.entries.find((entry) => entry.key === "target")?.value;
+        const filterNode = actionNode.entries.find((entry) => entry.key === "filter")?.value;
+        const whenNode = actionNode.entries.find((entry) => entry.key === "when")?.value;
+        const setNode = actionNode.entries.find((entry) => entry.key === "set")?.value;
+        const type = isScalarString(typeNode) ? typeNode.value.trim() : "";
+        if (type !== "UPDATE")
+            pushError(ctx, "intent-rule-action-type-unsupported", `action.type 目前只支持 "UPDATE"（得到 "${type}"）。action.filter 是「定位要操作哪些数据」（filterCondition，改哪条），action.when 是「输入数据满足条件才执行」（dataCondition，要不要执行）——两者是两码事。非 UPDATE 节点（CREATE/DELETE/BIZ_ACTION/MESSAGE…）用 nodeGraph 透传。`, `${actionBase}.type`, "value");
+        if (!isScalarString(targetNode) && targetNode !== undefined && !(targetNode.kind === "scalar" && targetNode.value === null))
+            pushError(ctx, "intent-rule-action-target-invalid", `第 ${index + 1} 个动作的 target 必须是字符串（目标模型 code）；同模型动作可省略 target，默认当前模型 ${modelCode}`, `${actionBase}.target`, "value");
+        // `target` defaults to the rule's OWN model: the common case is a same-model
+        // update, and forcing the code to be repeated is redundant friction (bench61
+        // feedback). Cross-model writes still name the other model explicitly.
+        const targetCode = isScalarString(targetNode) ? targetNode.value.trim() : modelCode;
+        const readList = (listNode, listKey) => {
+            if (listNode === undefined || (listNode.kind === "scalar" && listNode.value === null))
+                return [];
+            if (listNode.kind !== "seq") {
+                pushError(ctx, "intent-rule-action-list-invalid", `action.${listKey} 必须是列表`, `${actionBase}.${listKey}`, "value");
+                return [];
+            }
+            const rows = [];
+            listNode.items.forEach((item, itemIndex) => {
+                if (item.kind !== "map") {
+                    pushError(ctx, "intent-rule-action-item-invalid", `action.${listKey} 项必须是映射`, `${actionBase}.${listKey}[${itemIndex}]`, "value");
+                    return;
+                }
+                const row = readLeaf(item, `${actionBase}.${listKey}[${itemIndex}]`, ctx, listKey === "set" ? "assignment" : "condition");
+                if (row)
+                    rows.push(row);
+            });
+            return rows;
+        };
+        const filter = readList(filterNode, "filter");
+        const when = readList(whenNode, "when");
+        const set = readList(setNode, "set");
+        // The gate (`when`) compiles to `dataCondition`, whose leaf has no DYNAMIC
+        // "compare against another field" form in this compact face (the platform's
+        // DataFilterCondition DYNAMIC value shape is not the same as filter's). Fail
+        // closed rather than emit a leaf the engine misreads; nodeGraph can carry it.
+        when.forEach((row, whenIndex) => {
+            if (row.from !== undefined)
+                pushError(ctx, "intent-rule-when-from-unsupported", `action.when 不支持 from（执行门只支持与字面量比较：equals/notEquals/gt/gte/lt/lte）；需要与另一字段比较时用 nodeGraph 传 dataCondition`, `${actionBase}.when[${whenIndex}].from`, "value");
+        });
+        if (type === "UPDATE") {
+            // Never DROP a declared action. Before round 15, an action with an empty
+            // filter or set was silently discarded, so the rule compiled with no
+            // UPDATE node and validate/plan passed — bench52/53 lost a whole end-to-end
+            // cycle to a cross-model writeback whose filter was omitted and whose
+            // action therefore never existed. An empty `set` is always an error; an
+            // empty `filter` compiles and is gated by lintRuleGraph (cross-model).
+            if (set.length === 0)
+                pushError(ctx, "intent-rule-action-set-required", "action.set 不能为空（UPDATE 至少要有一个赋值；平台 UPDATE 节点必须有 dataActions）", `${actionBase}.set`, "value");
+            actions.push({
+                type: "UPDATE",
+                target: targetCode,
+                filter: filter,
+                ...(whenNode !== undefined && !(whenNode.kind === "scalar" && whenNode.value === null) ? { when: when } : {}),
+                set: set,
+            });
+        }
+    });
+    return actions;
+}
+/**
+ * The business-rule capability. Rules are model-scoped and declared as either
+ * compact `actions` (the compiler synthesizes the nodeGraph) or a raw
+ * `nodeGraph` escape hatch. It requires the field capability because a rule
+ * binds declared fields. Liveness is `rule.enable` (publish + enable), never
+ * `rule.save` alone.
+ */
+export const businessruleCapability = {
+    id: "businessrule",
+    title: "业务规则",
+    requires: ["field"],
+    operations: ["save", "enable", "disable"],
+    validate(node, draft, ctx) {
+        const rulesNode = node.entries.find((entry) => entry.key === "rules")?.value;
+        if (rulesNode === undefined || (rulesNode.kind === "scalar" && rulesNode.value === null))
+            return;
+        if (rulesNode.kind !== "seq") {
+            pushError(ctx, "intent-rules-not-a-list", `rules 必须是列表（得到 ${rulesNode.kind}）`, `${ctx.base}.rules`, "value");
+            return;
+        }
+        const seen = new Set();
+        rulesNode.items.forEach((ruleNode, index) => {
+            const base = `${ctx.base}.rules[${index}]`;
+            if (ruleNode.kind !== "map") {
+                pushError(ctx, "intent-rule-not-a-map", "规则项必须是映射", base, "value");
+                return;
+            }
+            for (const entry of ruleNode.entries)
+                if (!RULE_KEYS.has(entry.key))
+                    pushError(ctx, "intent-key-unknown", `规则不支持键 "${entry.key}"（只接受 code / name / enabled / actions / nodeGraph / bizRuleType / customTrigger）`, `${base}.${entry.key}`);
+            const codeNode = ruleNode.entries.find((entry) => entry.key === "code")?.value;
+            const nameNode = ruleNode.entries.find((entry) => entry.key === "name")?.value;
+            const enabledNode = ruleNode.entries.find((entry) => entry.key === "enabled")?.value;
+            const bizRuleTypeNode = ruleNode.entries.find((entry) => entry.key === "bizRuleType")?.value;
+            const customTriggerNode = ruleNode.entries.find((entry) => entry.key === "customTrigger")?.value;
+            const actionsNode = ruleNode.entries.find((entry) => entry.key === "actions")?.value;
+            const nodeGraphNode = ruleNode.entries.find((entry) => entry.key === "nodeGraph")?.value;
+            let code = "";
+            if (!isScalarString(codeNode))
+                pushError(ctx, "intent-rule-code-invalid", "规则 code 必须是非空字符串", `${base}.code`, "value");
+            else {
+                code = codeNode.value.trim();
+                if (seen.has(code))
+                    pushError(ctx, "intent-rule-code-duplicate", `规则 code 在模型内重复：${code}`, `${base}.code`, "value");
+                seen.add(code);
+            }
+            if (!isScalarString(nameNode))
+                pushError(ctx, "intent-rule-name-invalid", "规则 name 必须是非空字符串", `${base}.name`, "value");
+            let enabled = false;
+            if (enabledNode !== undefined) {
+                if (enabledNode.kind !== "scalar" || typeof enabledNode.value !== "boolean")
+                    pushError(ctx, "intent-rule-enabled-invalid", "rule.enabled 必须是布尔", `${base}.enabled`, "value");
+                else
+                    enabled = enabledNode.value;
+            }
+            let bizRuleType;
+            if (bizRuleTypeNode !== undefined) {
+                if (bizRuleTypeNode.kind !== "scalar" || typeof bizRuleTypeNode.value !== "number")
+                    pushError(ctx, "intent-rule-bizruletype-invalid", "rule.bizRuleType 必须是数字", `${base}.bizRuleType`, "value");
+                else
+                    bizRuleType = bizRuleTypeNode.value;
+            }
+            let customTrigger;
+            if (customTriggerNode !== undefined) {
+                if (customTriggerNode.kind !== "scalar" || typeof customTriggerNode.value !== "boolean")
+                    pushError(ctx, "intent-rule-customtrigger-invalid", "rule.customTrigger 必须是布尔", `${base}.customTrigger`, "value");
+                else
+                    customTrigger = customTriggerNode.value;
+            }
+            const hasActions = actionsNode !== undefined && !(actionsNode.kind === "scalar" && actionsNode.value === null);
+            const hasNodeGraph = nodeGraphNode !== undefined && !(nodeGraphNode.kind === "scalar" && nodeGraphNode.value === null);
+            if (hasActions && hasNodeGraph)
+                pushError(ctx, "intent-rule-actions-and-nodegraph", "规则不能同时声明 actions 与 nodeGraph（二选一）", base, "value");
+            if (!hasActions && !hasNodeGraph)
+                pushError(ctx, "intent-rule-body-missing", "规则必须声明 actions（紧凑）或 nodeGraph（透传）之一", base, "value");
+            const actions = hasActions && actionsNode ? readActions(actionsNode, base, ctx, draft.code) : undefined;
+            let nodeGraph;
+            if (hasNodeGraph && nodeGraphNode) {
+                if (nodeGraphNode.kind !== "map")
+                    pushError(ctx, "intent-rule-nodegraph-invalid", "rule.nodeGraph 必须是映射", `${base}.nodeGraph`, "value");
+                else
+                    nodeGraph = toPlain(nodeGraphNode);
+            }
+            if (code.length === 0 || !isScalarString(nameNode))
+                return;
+            const rule = {
+                code,
+                name: nameNode.value,
+                enabled,
+                ...(bizRuleType !== undefined ? { bizRuleType } : {}),
+                ...(customTrigger !== undefined ? { customTrigger } : {}),
+                ...(actions ? { actions } : {}),
+                ...(nodeGraph ? { nodeGraph } : {}),
+            };
+            lintRuleGraph(rule, ctx, base, draft.code);
+            draft.rules.push(rule);
+        });
+    },
+    async read(session, intent, draft) {
+        if (!intent.rules?.length)
+            return;
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: draft.code } })).data);
+        for (const row of rows) {
+            const code = String(row.code ?? "");
+            if (!code)
+                continue;
+            const declared = intent.rules.find((rule) => rule.code === code);
+            if (!declared) {
+                draft.rules.push({ code, present: true, enabled: row.enabled === true, nodes: undefined, routes: undefined });
+                continue;
+            }
+            const record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+            draft.rules.push({
+                code,
+                present: true,
+                enabled: row.enabled === true,
+                nodes: record ? decodeJsonColumn(record.node, JSON_COLUMN_NULL_COALESCE) : undefined,
+                routes: record ? decodeJsonColumn(record.route, JSON_COLUMN_NULL_COALESCE) : undefined,
+            });
+        }
+    },
+    plan(intent, baseline, emit) {
+        for (const rule of intent.rules ?? []) {
+            const live = (baseline.rules ?? []).find((entry) => entry.code === rule.code);
+            const expected = expectedRuleGraph(rule, intent.code);
+            const resource = `rule:${intent.code}.${rule.code}`;
+            const graphChanged = live === undefined || live.nodes === undefined || ruleGraphDigest(live.nodes, live.routes) !== ruleGraphDigest(expected.nodes, expected.routes);
+            if (live === undefined)
+                emit.change("rule.save", ruleSaveArgs(intent.code, rule), resource, "rule-absent");
+            else if (graphChanged)
+                emit.change("rule.save", ruleSaveArgs(intent.code, rule), resource, "rule-graph-drift");
+            else
+                emit.skip(resource, "rule-present");
+            if (rule.enabled) {
+                if (graphChanged || live?.enabled !== true)
+                    emit.change("rule.enable", { schemaCode: intent.code, ruleCode: rule.code }, resource, live === undefined ? "rule-created-disabled" : "rule-not-enabled");
+            }
+            else if (live?.enabled === true) {
+                emit.change("rule.disable", { schemaCode: intent.code, ruleCode: rule.code }, resource, "rule-enabled-unexpected");
+            }
+        }
+    },
+    decode(baseline, draft) {
+        draft.rules = (baseline.rules ?? []).map((rule) => ({ code: rule.code, present: rule.present, enabled: rule.enabled, nodes: rule.nodes, routes: rule.routes }));
+    },
+    compare(intent, live, emit) {
+        const declared = new Set((intent.rules ?? []).map((rule) => rule.code));
+        for (const rule of intent.rules ?? []) {
+            const current = (live.rules ?? []).find((entry) => entry.code === rule.code);
+            const resource = `rule:${intent.code}.${rule.code}`;
+            if (current?.present !== true) {
+                emit.difference("rule-missing", resource, `规则 ${intent.code}.${rule.code} 不存在`);
+                continue;
+            }
+            if (rule.enabled && !current.enabled)
+                emit.difference("rule-not-enabled", resource, `规则 ${intent.code}.${rule.code} 未启用（enabled 应为 true）`);
+            if (!rule.enabled && current.enabled)
+                emit.difference("rule-enabled-unexpected", resource, `规则 ${intent.code}.${rule.code} 已启用但意图声明为未启用`);
+            const expected = expectedRuleGraph(rule, intent.code);
+            if (ruleGraphDigest(current.nodes, current.routes) !== ruleGraphDigest(expected.nodes, expected.routes))
+                emit.difference("rule-graph-mismatch", resource, `规则 ${intent.code}.${rule.code} 的节点图与意图不等价`);
+        }
+        for (const current of live.rules ?? [])
+            if (!declared.has(current.code))
+                emit.ignored(`rule:${intent.code}.${current.code}`);
+    },
+};
+//# sourceMappingURL=businessrule.js.map