@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/rule-support.js

@@ -0,0 +1,587 @@
+import { z } from "zod";
+import { wireCall, wireRows, WireError } from "./wire.js";
+import { ENDPOINTS } from "./endpoints.js";
+import { ToolRefusalError } from "./tool-types.js";
+import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "./json-column.js";
+import { RULE_BIZ_RULE_TYPE_DESCRIPTION, RULE_CREATE_BODY, RULE_ROUTES_DESCRIPTION, ruleNodeGraphDescription, schedulerSettingDescription, } from "./lanes/businessrule-contract.js";
+import { validateRuleNodeGraph, prepareRuleGraph, PLATFORM_TRIGGER_RULE_CODES } from "./lanes/rule-graph.js";
+import { compileMethodConfigPlain } from "./bizservice-config.js";
+import { RESERVED_CODES } from "./code-rules.js";
+/** Business-rule node graph. Platform trigger rules are addressed by ruleCode: Create / Update / Delete / Available / Cancel / GetList / Load. */
+export const ruleNodeGraphArg = z
+    .object({
+    nodes: z
+        .union([z.array(z.record(z.string(), z.unknown())), z.string()])
+        .optional()
+        .describe(ruleNodeGraphDescription()),
+    routes: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional().describe(RULE_ROUTES_DESCRIPTION),
+    bizRuleType: z.number().optional().describe(RULE_BIZ_RULE_TYPE_DESCRIPTION),
+    schedulerSetting: z
+        .union([z.record(z.string(), z.unknown()), z.string()])
+        .optional()
+        .describe(schedulerSettingDescription()),
+})
+    .passthrough();
+function declaredParameterCodes(decoded) {
+    if (!Array.isArray(decoded))
+        return [];
+    return decoded
+        .filter((entry) => Boolean(entry && typeof entry === "object"))
+        .map((entry) => (typeof entry.code === "string" ? entry.code.trim() : ""))
+        .filter((code) => code.length > 0);
+}
+/** inputParametersJson/outputParametersJson decode; policy: non-strings null-coalesce, unparseable passes through. */
+function parseJsonColumn(value) {
+    return decodeJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
+}
+/**
+ * Ticket 35: the platform gates only SERVICE existence at rule update/publish
+ * (BusinessRuleFacadeImpl.addBizMethodMapping throws BUSINESS_SERVICE_NOT_EXIST),
+ * and the publish dry gate (550018, checkBizRuleIsEnable → filterProertyVo)
+ * rejects when a mapped serviceMethodParameterCode is missing from the method's
+ * declared parameter face (live-proven 2026-09-12: a parameterless registration
+ * shell + inputMappings → 550018 保存规则失败). This pre-write wire gate mirrors
+ * both checks: resolve every BIZ_ACTION / GET_LIST(BIZ_SERVICE) methodMapping
+ * against get_by_code + list_by_service_code (existence AND parameter face)
+ * before any write, so the caller learns it before burning the rule write.
+ */
+async function resolveBizMethodMappings(session, refs) {
+    const methodsByService = new Map();
+    const adapterByService = new Map();
+    const serviceNameByCode = new Map();
+    const serviceAbsent = new Set();
+    for (const serviceCode of new Set(refs.map((ref) => ref.serviceCode))) {
+        try {
+            const service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode } });
+            if (service.data == null)
+                serviceAbsent.add(serviceCode);
+            else {
+                adapterByService.set(serviceCode, String(service.data.adapterCode ?? ""));
+                serviceNameByCode.set(serviceCode, String(service.data.name ?? ""));
+            }
+        }
+        catch {
+            // get_by_code answers 500001 业务服务不存在 when the service is gone.
+            serviceAbsent.add(serviceCode);
+            continue;
+        }
+        try {
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode, filterFlag: "false" } })).data);
+            const byCode = new Map();
+            for (const row of rows) {
+                const code = String(row.code ?? "").trim();
+                if (!code)
+                    continue;
+                byCode.set(code, { code, name: String(row.name ?? ""), inputParameters: parseJsonColumn(row.inputParametersJson), outputParameters: parseJsonColumn(row.outputParametersJson), configJson: parseJsonColumn(row.configJson) });
+            }
+            methodsByService.set(serviceCode, byCode);
+        }
+        catch {
+            // Service present but the method list failed: keep the empty map so
+            // each ref is reported as method-absent rather than silently skipped.
+            methodsByService.set(serviceCode, new Map());
+        }
+    }
+    const unresolved = [];
+    const resolved = [];
+    for (const ref of refs) {
+        if (serviceAbsent.has(ref.serviceCode)) {
+            unresolved.push({ nodeCode: ref.nodeCode, serviceCode: ref.serviceCode, serviceMethodCode: ref.serviceMethodCode, reason: `service "${ref.serviceCode}" 不存在（get_by_code 500001；平台 update/publish 门只拦服务不拦方法——本预检是唯一 fail-closed 存在性门）` });
+            continue;
+        }
+        const method = methodsByService.get(ref.serviceCode)?.get(ref.serviceMethodCode);
+        if (!method) {
+            unresolved.push({ nodeCode: ref.nodeCode, serviceCode: ref.serviceCode, serviceMethodCode: ref.serviceMethodCode, reason: `method "${ref.serviceMethodCode}" 不在服务 ${ref.serviceCode} 的方法列表（list_by_service_code filterFlag=false；平台设计时不拦、app 包导入时静默 enabled=false——BusinessRuleFacadeImpl 只拦服务缺失）` });
+            continue;
+        }
+        const inputCodes = declaredParameterCodes(method.inputParameters);
+        const outputCodes = declaredParameterCodes(method.outputParameters);
+        const missingInput = ref.inputParameterCodes.filter((code) => !inputCodes.includes(code));
+        const missingOutput = ref.outputParameterCodes.filter((code) => !outputCodes.includes(code));
+        if (missingInput.length > 0 || missingOutput.length > 0) {
+            const parts = [];
+            if (missingInput.length > 0)
+                parts.push(`inputMappings 参数 ${missingInput.join("/")} 不在方法声明的输入参数面（声明：${inputCodes.length ? inputCodes.join("/") : "空"}）`);
+            if (missingOutput.length > 0)
+                parts.push(`outputMappings 参数 ${missingOutput.join("/")} 不在方法声明的输出参数面（声明：${outputCodes.length ? outputCodes.join("/") : "空"}）`);
+            unresolved.push({ nodeCode: ref.nodeCode, serviceCode: ref.serviceCode, serviceMethodCode: ref.serviceMethodCode, reason: `${parts.join("；")}——平台 publish 干门同语义拒绝（550018，live 2026-09-12：无参数面注册壳 + inputMappings → 保存规则失败）；service.register 用 methodInputParameters 声明参数面` });
+            continue;
+        }
+        resolved.push({
+            nodeCode: ref.nodeCode,
+            serviceCode: ref.serviceCode,
+            serviceName: serviceNameByCode.get(ref.serviceCode) ?? "",
+            serviceMethodCode: ref.serviceMethodCode,
+            serviceMethodName: method.name,
+            adapterCode: adapterByService.get(ref.serviceCode) ?? "",
+            inputFace: parameterFaceRecords(method.inputParameters),
+            outputFace: parameterFaceRecords(method.outputParameters),
+            methodConfig: method.configJson,
+        });
+    }
+    return { unresolved, resolved, checked: refs.length };
+}
+/** Parameter face decoded into records (empty when the column is absent/garbage). */
+function parameterFaceRecords(decoded) {
+    return Array.isArray(decoded) ? decoded.filter((entry) => Boolean(entry && typeof entry === "object")) : [];
+}
+/**
+ * Ticket 96 follow-up — designer-parity enrichment for BIZ_ACTION bindings.
+ * The platform rule designer's own save payload carries node-level
+ * `nodeCategory:"actionNode"` / `serviceType:"BIZ_METHOD"` and a
+ * `methodMapping` with `serviceName` / `serviceMethodName`, plus per-element
+ * `index`. The 绑定业务方法 dialog re-hydrates its mapping rows from this
+ * richer shape; a bare name-less binding renders the node as a generic
+ * 业务动作 and (transiently) as empty mapping rows. OMC resolves the
+ * service/method faces anyway for validation, so it fills the designer's
+ * denormalized display fields with what it already fetched. Values the caller
+ * supplied are never overwritten.
+ */
+function enrichBizActionBindings(nodes, resolved) {
+    const byNode = new Map(resolved.map((ref) => [ref.nodeCode, ref]));
+    const fillIndex = (list) => {
+        if (!Array.isArray(list))
+            return;
+        list.forEach((element, position) => {
+            if (!element || typeof element !== "object" || Array.isArray(element))
+                return;
+            const row = element;
+            if (row.index === undefined)
+                row.index = position + 1;
+        });
+    };
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const node = entry;
+        if (String(node.nodeType ?? "") !== "BIZ_ACTION")
+            continue;
+        const ref = byNode.get(String(node.nodeCode ?? ""));
+        if (node.nodeCategory === undefined)
+            node.nodeCategory = "actionNode";
+        if (node.serviceType === undefined)
+            node.serviceType = "BIZ_METHOD";
+        if (!ref)
+            continue;
+        const mapping = node.methodMapping;
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+            continue;
+        const m = mapping;
+        if ((m.serviceName === undefined || m.serviceName === "") && ref.serviceName)
+            m.serviceName = ref.serviceName;
+        if ((m.serviceMethodName === undefined || m.serviceMethodName === "") && ref.serviceMethodName)
+            m.serviceMethodName = ref.serviceMethodName;
+        fillIndex(m.inputMappings);
+        fillIndex(m.outputMappings);
+    }
+}
+/**
+ * Ticket 96 — registration-shell gate: a config-bearing adapter method
+ * (RESTFUL / DATA_SQL) must carry its adapter-required configJson keys to be
+ * bindable. A name-plus-parameter-face-only record is a registration shell
+ * (CONTEXT.md 业务集成注册壳): never bound by a rule. INTERNAL /
+ * extension-package methods carry no adapter config and stay bindable.
+ */
+function assertBindableBizMethodConfig(resolved) {
+    const shells = resolved
+        .filter((ref) => ref.adapterCode === "RESTFUL" || ref.adapterCode === "DATA_SQL")
+        .map((ref) => {
+        if (!ref.methodConfig || typeof ref.methodConfig !== "object" || Array.isArray(ref.methodConfig))
+            return { nodeCode: ref.nodeCode, serviceCode: ref.serviceCode, serviceMethodCode: ref.serviceMethodCode, adapterCode: ref.adapterCode, reason: `方法 configJson 缺失或非对象——只有名字/参数面的注册壳（CONTEXT.md 业务集成注册壳），不是可消费的 BizMethod` };
+        try {
+            compileMethodConfigPlain(ref.adapterCode, ref.methodConfig);
+            return null;
+        }
+        catch (error) {
+            return { nodeCode: ref.nodeCode, serviceCode: ref.serviceCode, serviceMethodCode: ref.serviceMethodCode, adapterCode: ref.adapterCode, reason: `方法 configJson 不含 ${ref.adapterCode} 必需键（${error.message}）` };
+        }
+    })
+        .filter((row) => row !== null);
+    if (shells.length > 0) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-graph-bizmethod-registration-shell",
+            message: "methodMapping 指向注册壳（无适配器配置的业务集成方法）；注册壳不是已发布 BizMethod，绝不可被规则绑定",
+            shells,
+        });
+    }
+}
+/**
+ * Ticket 96 — `required` mirror: the method parameter face is the
+ * authoritative source for a mapping element's `required` (CONTEXT.md 方法
+ * 参数面). Caller-omitted → filled from the face; face key absent → the
+ * mapping stays absent (never coerced to false); caller-explicit value that
+ * contradicts the face → local refusal BEFORE any rule write.
+ */
+function mirrorRequiredFromParameterFace(nodes, resolved) {
+    const byNode = new Map(resolved.map((ref) => [ref.nodeCode, ref]));
+    const mismatches = [];
+    const mirrorList = (list, face, nodeCode, listKey) => {
+        if (!Array.isArray(list))
+            return;
+        list.forEach((element, index) => {
+            if (!element || typeof element !== "object" || Array.isArray(element))
+                return;
+            const row = element;
+            const paramCode = typeof row.serviceMethodParameterCode === "string" ? row.serviceMethodParameterCode.trim() : "";
+            const faceParam = face.find((candidate) => String(candidate.code ?? "").trim() === paramCode);
+            const faceRequired = faceParam?.required;
+            if (row.required === undefined) {
+                // Omitted → mirror the face; a face that does not declare stays absent.
+                if (typeof faceRequired === "boolean")
+                    row.required = faceRequired;
+                return;
+            }
+            if (typeof row.required !== "boolean" || row.required !== faceRequired) {
+                mismatches.push({
+                    nodeCode,
+                    key: `methodMapping.${listKey}[${index}].required`,
+                    message: `required=${JSON.stringify(row.required)} 与方法参数面${typeof faceRequired === "boolean" ? `声明的 required=${faceRequired}` : "（未声明 required）"}矛盾——参数面是权威（调用方省略则自动镜像；面缺席则映射保持缺席）`,
+                });
+            }
+        });
+    };
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const node = entry;
+        const ref = byNode.get(String(node.nodeCode ?? ""));
+        if (!ref)
+            continue;
+        const mapping = node.methodMapping;
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+            continue;
+        const m = mapping;
+        mirrorList(m.inputMappings, ref.inputFace, ref.nodeCode, "inputMappings");
+        mirrorList(m.outputMappings, ref.outputFace, ref.nodeCode, "outputMappings");
+    }
+    if (mismatches.length > 0) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-graph-bizmethod-required-mismatch",
+            message: "methodMapping 的 required 与方法参数面矛盾（参数面是权威）；修正映射或更新参数面后重试",
+            validation: mismatches,
+        });
+    }
+}
+async function assertCreateSelectionCompatibility(session, schemaCode, nodes) {
+    const createNodes = nodes.filter((entry) => Boolean(entry && typeof entry === "object" && String(entry.nodeType ?? "") === "CREATE"));
+    if (createNodes.length === 0)
+        return;
+    const fields = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    const dictionaryFields = fields.filter((field) => {
+        const type = Number(field.type ?? field.propertyType);
+        if (![12, 13, 14, 15].includes(type))
+            return false;
+        const options = decodeJsonColumn(field.options, JSON_COLUMN_NULL_COALESCE);
+        return Boolean(options && typeof options === "object" && !Array.isArray(options) && options.optionsSet && typeof options.optionsSet === "object" && options.optionsSet.optionsType === "dictionary");
+    });
+    if (dictionaryFields.length === 0)
+        return;
+    const targets = new Set(dictionaryFields.map((field) => String(field.code ?? field.propertyCode ?? "")));
+    const touched = createNodes.flatMap((node) => Array.isArray(node.dataActions) ? node.dataActions.filter((action) => Boolean(action && typeof action === "object")) : []).filter((action) => targets.has(String(action.targetDataItem ?? "")));
+    if (touched.length > 0)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-create-dictionary-selection-unsupported",
+            schemaCode,
+            fields: [...targets],
+            message: "已知不兼容组合：CREATE 节点直接写 dictionary-backed selection 字段不会可靠持久化；改用已验证的 UPDATE 节点写入，或先使用普通 selection/custom choices",
+            recovery: [{ code: "use-update-for-selection", action: "保留 CREATE 后接 UPDATE，令 UPDATE 节点写入字典选择字段；先 field.list(published:true) 核对字段" }],
+        });
+}
+function collectBizMethodRefs(nodes) {
+    const refs = [];
+    const mappingParameterCodes = (list) => Array.isArray(list)
+        ? list
+            .filter((entry) => Boolean(entry && typeof entry === "object"))
+            .map((entry) => (typeof entry.serviceMethodParameterCode === "string" ? entry.serviceMethodParameterCode.trim() : ""))
+            .filter((code) => code.length > 0)
+        : [];
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const node = entry;
+        const isBizAction = String(node.nodeType ?? "") === "BIZ_ACTION";
+        const isGetListBizService = String(node.nodeType ?? "") === "GET_LIST" && String(node.dataSourceType ?? "") === "BIZ_SERVICE";
+        if (!isBizAction && !isGetListBizService)
+            continue;
+        const mapping = node.methodMapping;
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+            continue;
+        const m = mapping;
+        const serviceCode = typeof m.serviceCode === "string" ? m.serviceCode.trim() : "";
+        const serviceMethodCode = typeof m.serviceMethodCode === "string" ? m.serviceMethodCode.trim() : "";
+        if (!serviceCode || !serviceMethodCode)
+            continue; // shape lint already blocked these
+        refs.push({
+            nodeCode: String(node.nodeCode ?? ""),
+            serviceCode,
+            serviceMethodCode,
+            inputParameterCodes: mappingParameterCodes(m.inputMappings),
+            outputParameterCodes: mappingParameterCodes(m.outputMappings),
+        });
+    }
+    return refs;
+}
+/**
+ * Round 21 live incident — fail-closed field-existence gate for BIZ_ACTION /
+ * GET_LIST(BIZ_SERVICE) mappings. A PROPERTY mapping (`codeType:1`) whose
+ * `bizCode` names a field that does not exist (or is not published) makes the
+ * platform's rule publish answer a DETAIL-LESS `550018 保存规则失败，规则存在
+ * 异常，请点击检测并修正！` — the real cause only surfaces via the designer's
+ * 检测 (`POST /api/app/businessrule/node_run_map → notExistPropertyObjectList`),
+ * which OMC's local dry-run did not mirror. Reproduced live 2026-10-01: a
+ * BIZ_ACTION mapping `bizCode:"omcprobe_title"` on a model where that field was
+ * never created → 550018; after field.create+field.publish the same rule
+ * published. This gate resolves the schema's PUBLISHED fields first and refuses
+ * on a missing `bizCode` — turning the opaque 550018 into an actionable local
+ * error (the platform requires the field to be PUBLISHED, not merely drafted).
+ */
+const RULE_RESERVED_MAPPING_CODES = RESERVED_CODES;
+async function assertBizActionMappingFieldsExist(session, schemaCode, nodes) {
+    const rows = [];
+    for (const entry of nodes) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const node = entry;
+        const isBizAction = String(node.nodeType ?? "") === "BIZ_ACTION";
+        const isGetListBizService = String(node.nodeType ?? "") === "GET_LIST" && String(node.dataSourceType ?? "") === "BIZ_SERVICE";
+        if (!isBizAction && !isGetListBizService)
+            continue;
+        const mapping = node.methodMapping;
+        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+            continue;
+        const m = mapping;
+        for (const listKey of ["inputMappings", "outputMappings"]) {
+            const list = m[listKey];
+            if (!Array.isArray(list))
+                continue;
+            for (const element of list) {
+                if (!element || typeof element !== "object" || Array.isArray(element))
+                    continue;
+                const row = element;
+                if (Number(row.codeType) !== 1)
+                    continue; // only PROPERTY mappings resolve to a schema field
+                const bizCode = typeof row.bizCode === "string" ? row.bizCode.trim() : "";
+                if (!bizCode)
+                    continue; // missing bizCode is a shape-lint concern
+                rows.push({ nodeCode: String(node.nodeCode ?? ""), listKey, serviceMethodParameterCode: typeof row.serviceMethodParameterCode === "string" ? row.serviceMethodParameterCode : "", bizCode });
+            }
+        }
+    }
+    if (rows.length === 0)
+        return;
+    const fields = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    const known = new Set(fields.map((field) => String(field.code ?? field.propertyCode ?? "").trim()).filter((code) => code.length > 0));
+    for (const code of RULE_RESERVED_MAPPING_CODES)
+        known.add(code);
+    const missing = rows.filter((row) => !known.has(row.bizCode));
+    if (missing.length > 0) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-graph-bizaction-mapping-field-missing",
+            schemaCode,
+            missing,
+            message: "methodMapping 的 PROPERTY(codeType:1) 映射 bizCode 指向该模型上不存在（或未发布）的字段——平台 publish 会只回一个无明细的 550018「规则存在异常」。先 field.create 建字段并 field.publish 发布，或把映射改到已发布的真实字段 code",
+            recovery: [{ code: "create-and-publish-mapped-field", action: "field.create 建该字段 → field.publish 发布 → 重试 rule.save；或先 field.list(published:true) 核对字段 code" }],
+        });
+    }
+}
+/**
+ * Ticket 96 live incident fix — fail-closed schema-existence gate for every
+ * RULE WRITE. The platform's businessrule list/save face auto-creates the 7
+ * preset rules for ANY schemaCode (BusinessRuleFacadeImpl.listViewsBySchemaCode
+ * :179-185 → checkAndFillDefaultBusinessRule, BusinessRuleServiceImpl.java
+ * :315-344 — no model-existence check; publish gates the model only via 601003),
+ * so writing a rule against a phantom schema silently litters preset rows that
+ * the API cannot cleanly delete (each list re-fills them). This gate resolves
+ * the schema against the authoritative model list BEFORE the first rule wire
+ * call and refuses on miss — zero pollution.
+ */
+export async function assertRuleSchemaExists(session, schemaCode) {
+    // Authoritative per-schema probe: GET /bizmodels/get_all (BizSchemaController
+    // .java:615-633) resolves getBizSchemaBySchemaCode and answers
+    // SCHEMA_NOT_FOUNT_ERR (10011 业务模型不存在) on miss — the same facade
+    // primitive the rule faces rely on. The fake answers ok+null for an absent
+    // schema, so BOTH signals decode as a miss.
+    let missing = false;
+    try {
+        const probe = await wireCall(session, { path: ENDPOINTS.modelGet, query: { schemaCode } });
+        missing = probe.data == null;
+    }
+    catch (error) {
+        if (error instanceof WireError && error.kind === "business" && error.errcode === 10011)
+            missing = true;
+        else
+            throw error;
+    }
+    if (missing) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-schema-unresolved",
+            message: `schemaCode "${schemaCode}" 不是已存在的业务模型（bizmodels/get_all 10011/空）——平台的规则面会对任意 schemaCode 自动补建 7 条预置规则（list 即触发重灌，API 删除不可达），幻影 schema 必须在写前拒绝；请先 model.create 建模或改用真实模型编码`,
+            schemaCode,
+        });
+    }
+}
+export async function executeRuleSaveWrite(session, args) {
+    // Pre-flight dry lint (ticket 14): a mis-shaped graph must be refused BEFORE
+    // any wire call, with structured blockers locating the node/key — never
+    // silently forwarded to the platform (ticket 09 lesson).
+    //
+    // Preset trigger rules (Create/Update/Delete) route the trigger-row write
+    // through the platform system node; the adapter injects it when absent
+    // before linting, so the caller only authors their action nodes (ticket 17
+    // live finding: dropping SYSTEM_CREATE pinned the row to DRAFT).
+    //
+    // Ticket 80: a button/flow-triggered rule (explicit customTrigger signal)
+    // gets the platform's CUSTOM_NODE 「自定义按钮/流程触发」 system trigger node
+    // synthesized after START when the caller did not author one, and EVERY
+    // route leaves with explicit string coordinates (empty points break the
+    // designer canvas).
+    const graph = args.nodeGraph;
+    // Ticket 80 + CFG-02/CFG-26: ONE normalization shared with the write
+    // preflight (prepareRuleGraph), so preview and execute validate the same
+    // graph: preset system node → button/flow CUSTOM_NODE trigger → route shape.
+    const prepared = prepareRuleGraph(args.ruleCode, graph, args.customTrigger, args.schemaCode);
+    const preparedGraph = prepared.graph;
+    const blockers = [...prepared.warnings, ...validateRuleNodeGraph(preparedGraph, args.ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined)];
+    // Ticket 113: warning-severity findings (e.g. unknown mapping keys) do not
+    // gate the write; they surface in the readback as lintWarnings.
+    const lintWarnings = blockers.filter((blocker) => blocker.severity === "warning");
+    if (blockers.some((blocker) => blocker.severity !== "warning")) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-graph-validation-failed",
+            message: "nodeGraph 未过出门前校验（dry lint）；按 validation 逐项修正，校验器不猜不改",
+            validation: blockers,
+        });
+    }
+    const nodes = preparedGraph.nodes ?? [];
+    const routes = preparedGraph.routes ?? [];
+    await assertCreateSelectionCompatibility(session, args.schemaCode, Array.isArray(nodes) ? nodes : []);
+    await assertBizActionMappingFieldsExist(session, args.schemaCode, Array.isArray(nodes) ? nodes : []);
+    // Ticket 96: phantom-schema gate — BEFORE the first businessrule wire call
+    // (the rule list itself auto-creates preset rows for unknown schemas).
+    await assertRuleSchemaExists(session, args.schemaCode);
+    // Ticket 35: wire existence gate for BizMethod bindings — runs after the
+    // local lint, before the create/update wire call (fail-closed; the platform
+    // itself only gates the SERVICE, never the METHOD, at design time).
+    const bizMethodRefs = collectBizMethodRefs(Array.isArray(nodes) ? nodes : []);
+    let bizMethodChecks = 0;
+    if (bizMethodRefs.length > 0) {
+        const { unresolved, resolved, checked } = await resolveBizMethodMappings(session, bizMethodRefs);
+        bizMethodChecks = checked;
+        if (unresolved.length > 0) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "rule-graph-bizmethod-unresolved",
+                message: "nodeGraph 的 methodMapping 指向不存在的服务/方法（写前 wire 校验失败）；绝不用注册壳冒充已发布 BizMethod",
+                unresolved,
+            });
+        }
+        // Ticket 96: registration-shell gate (config-bearing adapters must carry
+        // their adapter-required configJson keys) runs BEFORE the required mirror
+        // so a shell is reported as a shell, not as a face contradiction.
+        assertBindableBizMethodConfig(resolved);
+        // Ticket 96: mirror `required` from the authoritative method parameter
+        // face onto the mapping elements (mutating the prepared graph in place),
+        // refusing an explicit value that contradicts the face.
+        mirrorRequiredFromParameterFace(Array.isArray(nodes) ? nodes : [], resolved);
+        // Ticket 96 follow-up: designer-parity enrichment (serviceName /
+        // serviceMethodName / nodeCategory / element index) so the platform rule
+        // designer's 绑定业务方法 dialog re-hydrates the stored binding.
+        enrichBizActionBindings(Array.isArray(nodes) ? nodes : [], resolved);
+    }
+    // Read bizRuleType from the PREPARED graph (not the raw args): prepareRuleGraph
+    // infers bizRuleType=2 for SCHEDULER/TIMING_TASK graphs, and that inferred face
+    // must reach the wire row (see lanes/rule-graph.ts prepareRuleGraph).
+    const bizRuleType = typeof preparedGraph.bizRuleType === "number" ? preparedGraph.bizRuleType : 0;
+    // SCHEDULER rules keep the schedule on the rule row (schedulerSetting), not
+    // on the node: normalize object → JSON string exactly like node/route.
+    const schedulerInput = preparedGraph.schedulerSetting ?? preparedGraph.scheduler;
+    const schedulerSetting = schedulerInput === undefined || schedulerInput === null
+        ? undefined
+        : typeof schedulerInput === "string"
+            ? schedulerInput
+            : JSON.stringify(schedulerInput);
+    const nodeJson = typeof nodes === "string" ? nodes : JSON.stringify(nodes);
+    const routeJson = typeof routes === "string" ? routes : JSON.stringify(routes);
+    const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+    const existing = wireRows(list.data).find((row) => row.code === args.ruleCode);
+    const schedulerField = schedulerSetting === undefined ? {} : { schedulerSetting };
+    // Preset trigger rules (Create/Update/Delete/Load/GetList/Available/Cancel
+    // and 流程 code) are platform-managed: their `name` is a platform default
+    // (数据新增/数据更新/…). A caller's `name` must NEVER rename them — user logic
+    // is authored INTO the preset row, but its identity stays the platform's.
+    // Only CUSTOM rule codes take the caller's name. `existing` already carries
+    // the platform name, so the spread preserves it.
+    const isPresetRule = PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode);
+    const performed = existing?.id
+        ? await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...existing, ...(isPresetRule ? {} : { name: args.name }), node: nodeJson, route: routeJson, bizRuleType, ...schedulerField, enabled: existing.enabled === true, status: existing.status ?? "DISABLED" } })
+        : await wireCall(session, { path: ENDPOINTS.businessRuleCreate, method: "POST", body: { code: args.ruleCode, name: args.name, schemaCode: args.schemaCode, bizRuleType, node: nodeJson, route: routeJson, schedulerSetting: schedulerSetting ?? null, ...RULE_CREATE_BODY } });
+    // Ticket 62: a bare save only writes the DRAFT working row — the designer
+    // and the runtime read the PUBLISHED version, so "saved" ≠ "visible". An
+    // explicit publish:true pushes the new version out in the same call
+    // (businessrule/publish, the same face rule.enable drives); enabling the
+    // DRAFT switch stays a separate rule.enable concern.
+    const enabled = existing?.enabled === true;
+    // Ticket 80/109: updating the same ruleCode mints a NEW record id — the old
+    // id stays readable (rule.get by it shows the HISTORICAL graph). The
+    // readback therefore pins the CURRENT effective row id/version so callers
+    // never have to guess which row the designer now renders.
+    const versionNote = "同一 ruleCode 的更新会产生新规则记录 ID（旧 ID 仍可读、前端持旧 ID 显示旧图）；readback.id 是当前生效行（rule.get 请用它，或以 rule.list 同编码且 latestPublished:true 的新 ID 为准）";
+    const currentRow = async () => wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data).find((item) => item.code === args.ruleCode);
+    if (args.publish === true) {
+        const row = await currentRow();
+        if (row?.id) {
+            // Publish the FULL model, not the list-projection row: `list_by_schemacode`
+            // omits `node`/`route`/`schedulerSetting`, so publishing it drops the
+            // schedule and a TIMING_TASK rule never gets a quartz job (2026-10-06). Use
+            // the authoritative `businessrule/get?id` model (same as rule.get/enable).
+            const full = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+            await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: full ?? row });
+        }
+        const effective = await currentRow();
+        // Live 8.6.26 (2026-09-17): businessrule/publish mints a version but does
+        // NOT flip a publish marker that this readback can see — the working row
+        // keeps templateType DRAFT and the list projection reports
+        // latestPublished:false even for the platform's own ENABLED presets. So
+        // `published` must be DERIVED from the effective row, never assumed; a
+        // hardcoded true made a draft rule look live and a workflow end-event
+        // binding on it was silently dead. Liveness itself is `rule.enable`.
+        const published = effective?.status === "ENABLED" || effective?.latestPublished === true || effective?.templateType === "PUBLISH";
+        return {
+            performed: { errcode: performed.errcode, mode: existing?.id ? "update" : "create", publishRequested: true, ...(bizMethodChecks > 0 ? { bizMethodChecks } : {}) },
+            readback: {
+                rulePresent: true,
+                published,
+                enabled,
+                status: effective?.status,
+                ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+                id: effective?.id ?? undefined,
+                ruleVersion: effective?.ruleVersion,
+                latestPublished: effective?.latestPublished,
+                ...(existing?.id ? { versionNote } : {}),
+                ...(enabled ? {} : { nextAction: "rule.enable（businessrule/publish + businessrule/enable 两步）后规则才会分发并对流程/按钮可见；publish:true 只写入版本" }),
+            },
+        };
+    }
+    const effective = await currentRow();
+    return {
+        performed: { errcode: performed.errcode, mode: existing?.id ? "update" : "create", ...(bizMethodChecks > 0 ? { bizMethodChecks } : {}) },
+        readback: {
+            rulePresent: true,
+            published: false,
+            enabled,
+            ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+            id: effective?.id ?? undefined,
+            ruleVersion: effective?.ruleVersion,
+            latestPublished: effective?.latestPublished,
+            ...(existing?.id ? { versionNote } : {}),
+            nextAction: "rule.enable 发布后设计器才可见（businessrule/publish 出新版本 + 翻 DRAFT 启用开关）；或 rule.save 传 publish:true 只发布",
+        },
+    };
+}
+//# sourceMappingURL=rule-support.js.map