@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/lanes/datarule.js

@@ -0,0 +1,818 @@
+import { z } from "zod";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { ToolRefusalError } from "../tool-types.js";
+import { writeTool } from "../write.js";
+import { decodeJsonColumn, JSON_COLUMN_PASSTHROUGH } from "../json-column.js";
+import { defineTool } from "../tool-types.js";
+import { resolveDataRuleRow } from "../identity.js";
+import { wireCall, wireRows, WireError } from "../wire.js";
+import { runtimeWriteWithAppMapping } from "../runtime-support.js";
+import { DATARULE_LANE_CONTRACT, DATARULE_TYPE_OPTION_KEYS } from "./datarule-contract.js";
+import { CONDITION_PROTOCOL_EXAMPLES, dataRuleOptionsShapeError } from "./datarule-protocol.js";
+const DATARULE_LANE = DATARULE_LANE_CONTRACT.lane;
+const DATARULE_TOOLS = DATARULE_LANE_CONTRACT.tools;
+const dataRuleTypeArg = z
+    .number()
+    .int()
+    .min(1)
+    .max(5)
+    .describe("field-level rule type: 1 校验 / 2 计算拼接 / 3 显示 / 4 必填 / 5 只读 (8 EXTENSION is out of scope)");
+const dataRuleOptionsArg = z
+    .record(z.unknown())
+    .describe("rule options object, sent to the wire as a JSON string; type4 requires requiredFormula, type5 readonlyCondition, type3 displayFormula, type2 shortTextStitch|expression, type1 a check key keyed by checkType");
+/**
+ * DataRuleCheckType (8.6.26 cloudpivot-shared DataRuleCheckType.java) — the
+ * `checkType` discriminator for a `dataRuleType:1` (CHECK_RULE / 提交校验规则) row.
+ * Each id maps to a validator under `engine/bo/datarule/impl/checkType/` and reads
+ * a distinct options key. `checkType` is ONLY meaningful with dataRuleType 1.
+ *
+ *  - 1 REGEX_CHECK    正则校验   options {regexp:"/…/", regexpText:{zh,en}} (regexp is slash-wrapped; RegexCheckValidator strips the outer chars)
+ *  - 2 SUBMIT_CHECK   提交校验   options {conditions:"<cond>[ &&| || <cond>]", verifyType:"submitDenied"? , prompt:"<plain text — the portal shows options.prompt verbatim, so do NOT URL-encode it>"}  ← cross-field rules use a currentModel value object on the right (e.g. {end} 小于 {"valueType":"currentModel","value":"start"})
+ *  - 3 EMPTY_ROW_CHECK 空行校验  options {isEmptyRow:true, isEmptyRowTips?}
+ *  - 4 MAX_LENGTH_CHECK 最大长度  options {maxLength:<int>}
+ *  - 5 REPEAT_CHECK   重复校验   options {properties:[<fieldCodes>], isSubTableValidationAllData?, prompt:[{code,isDataItem}]}
+ */
+export const DATARULE_CHECK_TYPES = Object.freeze({
+    1: "REGEX_CHECK 正则校验（options.regexp 需 /…/ 包裹 + regexpText）",
+    2: "SUBMIT_CHECK 提交校验（options.conditions 条件串 + verifyType:submitDenied 表示满足即拒绝 + prompt）",
+    3: "EMPTY_ROW_CHECK 空行校验（options.isEmptyRow + isEmptyRowTips）",
+    4: "MAX_LENGTH_CHECK 最大长度校验（options.maxLength）",
+    5: "REPEAT_CHECK 重复校验（options.properties 数组 + isSubTableValidationAllData + prompt）",
+});
+const checkTypeArg = z
+    .number()
+    .int()
+    .min(1)
+    .max(5)
+    .optional()
+    .describe(`dataRuleType:1 的校验类别（DataRuleCheckType）：${Object.entries(DATARULE_CHECK_TYPES).map(([id, text]) => `${id}=${text.split(" ")[0]}`).join(" / ")}。仅在 dataRuleType=1 时使用`);
+/** `checkType` discriminates a dataRuleType 1 row; it is meaningless on any other type. */
+export function assertDataRuleCheckType(dataRuleType, checkType) {
+    if (checkType === undefined)
+        return;
+    if (dataRuleType !== 1)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-check-type-invalid",
+            dataRuleType,
+            checkType,
+            message: `checkType=${checkType} 只用于 dataRuleType=1（提交校验规则）；dataRuleType=${dataRuleType} 不接受 checkType`,
+        });
+    if (!(checkType in DATARULE_CHECK_TYPES))
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-check-type-invalid",
+            checkType,
+            message: `checkType=${checkType} 不是已知 DataRuleCheckType（${Object.keys(DATARULE_CHECK_TYPES).join("/")}）`,
+        });
+}
+const propertyCodeArg = z.string().min(1).optional().describe("目标字段 code（单字段简写）；与 propertyCodes 二选一，至少给一个");
+const propertyCodesArg = z.array(z.string().min(1)).min(1).optional().describe("目标字段 code 数组（真实设计器形态，多字段用；此时 propertyCode 置空）");
+/**
+ * The target field(s) a rule binds.
+ *
+ * Real designer rows (2026-09-23 observation) bind via `propertyCodes` (ARRAY;
+ * top-level `propertyCode` is null) and mirror them inside `options.propertyCodes`
+ * (comma-joined). The legacy single `propertyCode` column is kept for the
+ * one-field case, but the array is what the engine reads — writing only the
+ * singular column is the suspected root cause of a type-4 rule having no portal
+ * effect.
+ */
+function dataRuleTargetCodes(args) {
+    const codes = (args.propertyCodes && args.propertyCodes.length > 0 ? args.propertyCodes : [args.propertyCode]).map((code) => String(code ?? "")).filter((code) => code.length > 0);
+    return [...new Set(codes)];
+}
+/** Parse the stored options JSON string for readback; policy: non-strings and unparseable strings pass through verbatim. */
+function parseOptions(value) {
+    return decodeJsonColumn(value, JSON_COLUMN_PASSTHROUGH);
+}
+/** Target field codes from a stored row (propertyCodes array preferred; legacy singular fallback). */
+function storedTargetCodes(row) {
+    const raw = row.propertyCodes;
+    if (Array.isArray(raw))
+        return raw.map((code) => String(code)).filter((code) => code.length > 0);
+    const single = row.propertyCode;
+    return single !== undefined && single !== null && String(single).length > 0 ? [String(single)] : [];
+}
+function decodeDataRule(row) {
+    const options = parseOptions(row.options);
+    const codes = storedTargetCodes(row);
+    const decoded = {
+        id: row.id ?? null,
+        schemaCode: row.schemaCode ?? null,
+        propertyCode: row.propertyCode ?? (codes.length === 1 ? codes[0] : null),
+        propertyCodes: codes,
+        dataRuleType: row.dataRuleType ?? null,
+        checkType: row.checkType ?? null,
+        childRule: row.childRule === true,
+        name: row.name ?? null,
+        sortKey: row.sortKey ?? null,
+        options,
+    };
+    // Round 4 (ADR 0005): read-side annotation. The platform accepted and stored
+    // malformed option shapes for years; the same protocol validator that gates
+    // writes marks stored landmines here. Report-only — stored data is never
+    // auto-modified.
+    const type = Number(row.dataRuleType);
+    if ([3, 4, 5].includes(type) && options !== null && typeof options === "object" && !Array.isArray(options)) {
+        const error = dataRuleOptionsShapeError(type, options);
+        if (error !== null)
+            decoded.shapeWarning = `stored options fail the platform protocol (${error}); the portal form renderer may crash on this rule — fix with datarule.update using e.g. requiredFormula: "${CONDITION_PROTOCOL_EXAMPLES.conditional}"`;
+    }
+    else if (type === 1 && Number(row.checkType) === 2 && options !== null && typeof options === "object" && !Array.isArray(options)) {
+        // Live 2026-09-24: a bare {fieldCode} right-hand value in a cross-field submit
+        // condition stores fine but is never resolved to the peer field's value, so
+        // the rule silently does nothing. Mark it (fix with a currentModel value).
+        const conditions = options.conditions;
+        if (typeof conditions === "string" && SUBMIT_CROSS_FIELD_BARE_TOKEN.test(conditions))
+            decoded.shapeWarning = 'checkType 2 跨字段条件用了裸 {字段code} 右值，平台不会解析成字段值——该规则静默不生效；改用 {"valueType":"currentModel","value":"<字段code>"}';
+        else {
+            const prompt = options.prompt;
+            if (typeof prompt === "string" && isUrlEncoded(prompt))
+                decoded.shapeWarning = 'checkType 2 的 prompt 是 URL 编码的——门户对这个顶层 options.prompt 原样显示，验证弹窗会显示 %E5..乱码；用 datarule.update 改成纯文本';
+        }
+    }
+    else if (type === 2 && row.childRule === true && options !== null && typeof options === "object" && !Array.isArray(options)) {
+        // Round 7: a child-table formula with bare tokens. Without field context we
+        // cannot say whether each bare token is a child field (the 50000 landmine)
+        // or a legitimate main-record field, so this is an advisory, not a warning —
+        // it surfaces every bare token for review (the write gate is field-aware).
+        const formula = type2FormulaText(options);
+        if (formula !== null) {
+            const bare = [...formula.matchAll(/\{([^{}]+)\}/g)]
+                .map((match) => match[1].trim())
+                .filter((token) => /^[A-Za-z][A-Za-z0-9_]*$/.test(token));
+            if (bare.length > 0)
+                decoded.formulaHint = `子表公式含裸引用 ${[...new Set(bare)].map((token) => `{${token}}`).join("、")}：裸 {字段}=主记录字段，带点 {子表code.字段}=子表字段；若本意是同级子字段请带点，否则提交会因主记录字段缺失报 50000`;
+        }
+    }
+    return decoded;
+}
+/**
+ * Fail closed when the options object cannot carry the key the engine reads
+ * for this type (RequiredDataRuleValidator / ReadOnlyValidator /
+ * CalculateRuleProcessor / list controller `parseFormula`).
+ */
+/**
+ * T-04 (round 2) — value-shape probe for the type-2 CALCULATE expression
+ * carriers. The 8.6.26 engine (`BizObjectSchemaManagerImpl.getCalRuleExpression`
+ * :842-875) reads `shortTextStitch` (falling back to `value`), JSON-parses it
+ * and then reads ITS `formula` key; `formulaType:"AGGREGATION"` instead reads
+ * `aggregation` (a JSON string) → `AggregationFormula.formula`. A bare
+ * non-JSON string makes `getCalRuleExpression` return null, which the
+ * dead-cycle check (`checkCalculateRulesDeadCycle`) then misreports as
+ * `305003 死循环`.
+ */
+function calcExpressionShapeError(carrier, value) {
+    if (value === undefined)
+        return `${carrier} is required`;
+    if (typeof value !== "string")
+        return `${carrier} must be a JSON *string* (received ${typeof value})`;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return `${carrier} is not valid JSON (a bare "{field}" string fails JSONUtil.isJson → engine returns null → false 305003 死循环)`;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return `${carrier} must parse to a JSON object`;
+    const formula = parsed.formula;
+    if (typeof formula !== "string" || formula.trim().length === 0)
+        return `${carrier} JSON object is missing a non-empty "formula"`;
+    return null;
+}
+/**
+ * Mirror the frontend formula editor's `parseFormulaFromEditorText`
+ * (admin bundle 45843…): every `<editorMark…>content</editorMark>` token is
+ * replaced by `{content}` — **the editor adds the braces itself**. `editorText`
+ * is the rich display the designer stores alongside the canonical `formula`;
+ * the UI re-derives the formula from it on load. A caller must therefore put the
+ * BARE token inside the tag (no braces); wrapping the brace-including token
+ * yields `<mark>{code}</mark>` → rebuilds `{{code}}` ≠ `formula` → the rule
+ * renders 已失效 (live 2026-10-08, SCM sandbox: `{inq_quotes.quote_price_incl}`
+ * inside the tag).
+ */
+export function formulaFromEditorText(editorText, editorMark) {
+    const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`<${escape(editorMark)}[^>]*>(.*?)</${escape(editorMark)}>`, "g");
+    const flat = editorText.replace(/[\r]?\n/g, "");
+    let cursor = 0;
+    let out = "";
+    let match;
+    while ((match = re.exec(flat)) !== null) {
+        out += `${flat.slice(cursor, match.index)}{${match[1]}}`;
+        cursor = match.index + match[0].length;
+    }
+    if (cursor !== flat.length)
+        out += flat.slice(cursor, flat.length);
+    return out;
+}
+/** The `{formula,editorText,editorMark}` object of a type-2 rule, or null. */
+function parseStitchObject(options) {
+    const raw = typeof options.shortTextStitch === "string" ? options.shortTextStitch : typeof options.value === "string" ? options.value : undefined;
+    if (raw === undefined)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fail closed when the rich `editorText` does not rebuild the canonical
+ * `formula`. The designer shows 已失效 otherwise; the platform `create` does not
+ * check this, so it settles as a broken rule. Skipped when editorText/editorMark
+ * are absent (the engine only reads `formula`).
+ */
+export function assertStitchEditorTextRoundTrips(options) {
+    const parsed = parseStitchObject(options);
+    if (!parsed)
+        return;
+    const formula = typeof parsed.formula === "string" ? parsed.formula : null;
+    const editorText = typeof parsed.editorText === "string" ? parsed.editorText : undefined;
+    const editorMark = typeof parsed.editorMark === "string" && parsed.editorMark.trim() ? parsed.editorMark : undefined;
+    if (!formula || !editorText || !editorMark)
+        return;
+    // Only enforce when editorText actually carries tagged references; a plain
+    // display string without tags is left as-is (it does not round-trip to a
+    // formula by construction, and the platform tolerates it).
+    const tag = new RegExp(`<${editorMark.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^>]*>`);
+    if (!tag.test(editorText))
+        return;
+    const rebuilt = formulaFromEditorText(editorText, editorMark);
+    if (rebuilt === formula)
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "datarule-stitch-editor-mismatch",
+        dataRuleType: 2,
+        message: `shortTextStitch 的 editorText 与 formula 不一致：用 editorMark「${editorMark}」把 editorText 反解为 "${rebuilt}"，但 formula 是 "${formula}"。` +
+            `门户公式编辑器按 editorText 重新生成 formula（见 parseFormulaFromEditorText），不一致时该计算规则显示「已失效」。` +
+            `最常见错误：把带花括号的 token 包进标签（<${editorMark}>{字段code}</${editorMark}>）——编辑器会再加一层括号变成 {{字段code}}。` +
+            `正确写法：标签内只放**裸 token**（无花括号），如 formula「{a}+{b}」对应 editorText「<${editorMark}>a</${editorMark}>+<${editorMark}>b</${editorMark}>」。`,
+    });
+}
+/** Require a target field binding (singular `propertyCode` or `propertyCodes`). */
+export function assertDataRuleTarget(args) {
+    if (dataRuleTargetCodes(args).length === 0)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-target-missing",
+            message: "必须提供目标字段：propertyCode（单字段）或 propertyCodes（数组）；真实设计器按字段数组绑定",
+        });
+}
+/**
+ * A cross-field submit condition (dataRuleType 1 / checkType 2) must reference
+ * the peer field with `{"valueType":"currentModel","value":"<fieldCode>"}`. A
+ * bare `{fieldCode}` on the right of an operator is accepted and stored, but
+ * neither the portal form's `formSubmitValidate` nor the server
+ * `SubmitCheckValidator.getConditionValue` resolves it to the field value — only
+ * `currentModel` is mapped (backend SubmitCheckValidator:424-441). The rule is
+ * therefore a silent no-op. Live 2026-09-24: `{end} 小于 {start}` did not block
+ * while the same rule with a `currentModel` right-hand value did.
+ */
+const SUBMIT_CROSS_FIELD_BARE_TOKEN = /\}\s*(?:等于|不等于|大于等于|小于等于|大于|小于|包含|不包含|属于|不属于|介于|不介于|==|!=|>=|<=|>|<)\s*\{\s*[A-Za-z_][A-Za-z0-9_.]*\s*\}/;
+/** True when a string is exactly a URL-encoded form of some other text (the designer's storage quirk). */
+function isUrlEncoded(value) {
+    if (!/%[0-9A-Fa-f]{2}/.test(value))
+        return false;
+    try {
+        const decoded = decodeURIComponent(value);
+        return decoded !== value && encodeURIComponent(decoded) === value;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fail closed on the silent no-op cross-field submit-condition form.
+ *
+ * Also rejects a URL-ENCODED `prompt`. The form designer stores a custom prompt
+ * as `encodeURIComponent(text)` and decodes it, but it only does so for its own
+ * nested `options.verifyFormula.prompt` shape. This lane writes the top-level
+ * `options.prompt` shape, and the portal uses that value RAW (`return
+ * t.options`; portal-app 34987.2913aa1b.js) — an encoded prompt renders as
+ * `%E5%AE%8C…` in the validation popup (live equipmaint_workorder). Store plain
+ * text; `decodeURIComponent` leaves plain text unchanged, so the designer still
+ * reads it.
+ */
+export function assertDataRuleSubmitConditions(dataRuleType, checkType, options) {
+    if (dataRuleType !== 1 || checkType !== 2)
+        return;
+    const prompt = options.prompt;
+    if (typeof prompt === "string" && isUrlEncoded(prompt)) {
+        let decoded = prompt;
+        try {
+            decoded = decodeURIComponent(prompt);
+        }
+        catch {
+            /* unreachable: isUrlEncoded proved decodability */
+        }
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-submit-prompt-encoded",
+            checkType,
+            message: `checkType=2 的 prompt 被 URL 编码了（"${prompt.slice(0, 40)}…"）——这种顶层 options.prompt 门户**原样显示**，会把乱码弹给用户。` +
+                `请存纯文本：prompt:"${decoded}"。（编码是设计器内部 verifyFormula 形态的约定，本工具不写那种形态。）`,
+        });
+    }
+    const conditions = options.conditions;
+    if (typeof conditions !== "string" || !SUBMIT_CROSS_FIELD_BARE_TOKEN.test(conditions))
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "datarule-submit-cross-field-bare",
+        dataRuleType,
+        checkType,
+        message: "checkType=2 提交校验跨字段比较的右值不能用裸 {字段code}——平台只把 " +
+            '{"valueType":"currentModel","value":"<字段code>"} 解析成字段值，裸 token 会原样落库但规则静默不生效。' +
+            '正确写法：conditions:"{end} 小于 {\\"valueType\\":\\"currentModel\\",\\"value\\":\\"start\\"}"（字段 vs 字面量仍可直接写值，如 {qty} 大于 100）。',
+    });
+}
+export function assertDataRuleOptions(dataRuleType, options, checkType) {
+    assertDataRuleSubmitConditions(dataRuleType, checkType, options);
+    const required = DATARULE_TYPE_OPTION_KEYS[dataRuleType] ?? [];
+    if (Object.keys(options).length === 0 || !required.some((key) => options[key] !== undefined)) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-options-invalid",
+            dataRuleType,
+            message: `dataRuleType ${dataRuleType} requires at least one of ${required.join(", ")} in options (those are the keys the 8.6.26 engine reads)`,
+        });
+    }
+    // Round 4 (ADR 0005): types 3/4/5 gate on the reproduced condition protocol.
+    // The platform itself does not validate these shapes at create time, so an
+    // unguarded write stores a portal-renderer landmine that only fires when a
+    // user opens the form. Verified shapes only — see datarule-protocol.ts.
+    const protocolError = dataRuleOptionsShapeError(dataRuleType, options);
+    if (protocolError !== null) {
+        const example = dataRuleType === 5 ? CONDITION_PROTOCOL_EXAMPLES.conditional : dataRuleType === 4 ? `${CONDITION_PROTOCOL_EXAMPLES.conditional}（恒必填用字面量 "true"）` : CONDITION_PROTOCOL_EXAMPLES.conditional;
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-options-invalid",
+            dataRuleType,
+            message: `${protocolError}。平台 create 不校验该形状（checkDataRuleFormat 只查计算规则/部门条件），坏形状会原样落库并在门户表单渲染时崩溃（compareType 未定义族）。` +
+                `条件串协议：{字段code} 操作符 {"valueType":...,"value":...}，三段单空格；多条件用 " && "，多组用 " || "（操作符：== != > < >= <= Contains NotContains IsEmpty IsNotEmpty）。` +
+                `正确形状示例：options:{${dataRuleType === 4 ? "requiredFormula" : dataRuleType === 5 ? "readonlyCondition" : "displayFormula"}:"${example}"}`,
+        });
+    }
+    if (dataRuleType === 2) {
+        // T-04: a top-level `expression` is NEVER read by the engine — the carrier is
+        // the nested {formula,editorText,editorMark} JSON. Refuse it only when it is
+        // the SOLE carrier (a caller who thinks it holds the expression). The platform
+        // itself stores a harmless top-level `expression` mirror on some rules (e.g.
+        // formula-field type-2 rows), so a legit round-trip that also carries
+        // shortTextStitch/value/aggregation must be accepted (live bench40_order_item).
+        const hasCarrier = options.shortTextStitch !== undefined || options.value !== undefined || options.aggregation !== undefined;
+        if (options.expression !== undefined && !hasCarrier) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "datarule-options-invalid",
+                dataRuleType,
+                message: 'dataRuleType 2 顶层没有 `expression` 键——引擎读的是 `shortTextStitch`（或 `value`），其值必须是含 `formula` 的 JSON 对象字符串；`expression` 只是该嵌套 JSON 内部的字段名。正确形状：options:{shortTextStitch:"{\\"formula\\":\\"{字段}\\",\\"editorText\\":\\"{字段名}\\",\\"editorMark\\":\\"{字段名}\\"}"}',
+            });
+        }
+        const formulaType = typeof options.formulaType === "string" ? options.formulaType : "";
+        const error = formulaType === "AGGREGATION"
+            ? calcExpressionShapeError("aggregation", options.aggregation)
+            : calcExpressionShapeError(options.shortTextStitch !== undefined ? "shortTextStitch" : "value", options.shortTextStitch ?? options.value);
+        if (error) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "datarule-options-invalid",
+                dataRuleType,
+                message: `dataRuleType 2 options 形状无效：${error}。裸串不是合法 JSON → 引擎 getCalRuleExpression 返回 null → 死循环校验误报 305003。` +
+                    '正确形状：options:{shortTextStitch:"{\\"formula\\":\\"{字段code}\\",\\"editorText\\":\\"{字段名}\\",\\"editorMark\\":\\"{字段名}\\"}"}（editorText/editorMark 仅展示用；formula 是表达式）',
+            });
+        }
+        // editorText ↔ formula round-trip (display correctness). Skipped for the
+        // AGGREGATION carrier (its display object differs).
+        if (formulaType !== "AGGREGATION")
+            assertStitchEditorTextRoundTrips(options);
+    }
+}
+/** Extract the expression of a type-2 CALCULATE rule (mirrors calcExpressionShapeError's carrier choice). */
+function type2FormulaText(options) {
+    const raw = typeof options.shortTextStitch === "string" ? options.shortTextStitch : typeof options.value === "string" ? options.value : undefined;
+    if (raw === undefined)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.formula === "string" ? parsed.formula : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Bare references to sibling child fields in a CHILD-table formula.
+ *
+ * Evidence (round 3, HANDOFF-round5 §3): a formula token's meaning is
+ * positional — bare `{field}` resolves against the MAIN record, dotted
+ * `{childSchema.field}` against the child. So a CHILD-table formula
+ * (dataRuleType 2, childRule=true) that references a sibling child field with a
+ * BARE token reads a missing main field and the submit answers errcode 50000
+ * (bench40: `{partPrice}*{partQty}` on the child table; the corrected
+ * `{partUsages.partPrice}` lands). Field-aware, so only a bare token that
+ * actually exists on the (child) schema is flagged — a legitimate bare main
+ * field reference is left alone.
+ */
+function childFormulaBareReferences(formula, childFieldCodes) {
+    const hits = new Set();
+    for (const match of formula.matchAll(/\{([^{}]+)\}/g)) {
+        const token = match[1].trim();
+        if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(token))
+            continue; // bare only; the dotted form is the correct one
+        if (childFieldCodes.has(token))
+            hits.add(token);
+    }
+    return [...hits];
+}
+/**
+ * Fail closed on a child-table formula that bare-references a sibling child
+ * field (→ platform 50000 on submit). Field-aware via the child schema's
+ * published fields; a caller-provided set avoids a duplicate fieldList read.
+ */
+async function assertChildFormulaRefs(session, args, knownChildFields) {
+    if (args.dataRuleType !== 2 || args.childRule !== true)
+        return;
+    const formula = type2FormulaText(args.options);
+    if (formula === null)
+        return;
+    const codes = knownChildFields ??
+        new Set(wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } })).data).map((row) => String(row.code ?? row.propertyCode ?? "")));
+    const bare = childFormulaBareReferences(formula, codes);
+    if (bare.length === 0)
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "datarule-formula-child-bare-reference",
+        schemaCode: args.schemaCode,
+        propertyCodes: bare,
+        message: `子表公式里 ${bare.map((token) => `{${token}}`).join("、")} 是子表字段的**裸引用**——平台按主记录字段解析（值缺失 → 提交 50000）。` +
+            `子表公式引用同级子字段必须带点：${bare.map((token) => `{${args.schemaCode}.${token}}`).join("、")}` +
+            `（裸 {字段}=主记录字段，带点 {子表code.字段}=子表字段）。`,
+    });
+}
+/** Ensure the wire `options` carries `propertyCodes` (comma-joined), as the designer writes it. */
+function withOptionsPropertyCodes(options, codes) {
+    if (codes.length === 0)
+        return options;
+    if (options.propertyCodes !== undefined)
+        return options;
+    return { propertyCodes: codes.join(","), ...options };
+}
+/**
+ * Auto-fill the type-2 `editorText`/`editorMark` from `formula` when the caller
+ * supplied only a formula in `shortTextStitch`. The designer needs the rich
+ * `editorText` (else 标红); since the frontend derives the formula back from it
+ * (`parseFormulaFromEditorText`: tag content → `{content}`), OMC builds it the
+ * one correct way — each `{token}` wrapped as `<field-omc0001>token</field-omc0001>`
+ * (bare token, NO braces). A caller-supplied editorText is left untouched and
+ * then checked by `assertStitchEditorTextRoundTrips`.
+ */
+export function withStitchEditorText(options) {
+    const key = options.shortTextStitch !== undefined ? "shortTextStitch" : options.value !== undefined ? "value" : undefined;
+    if (key === undefined)
+        return options;
+    const raw = options[key];
+    if (typeof raw !== "string")
+        return options;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return options;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return options;
+    const obj = parsed;
+    if (typeof obj.formula !== "string" || !obj.formula.trim())
+        return options;
+    const hasEditorText = typeof obj.editorText === "string" && obj.editorText.trim().length > 0;
+    const hasMark = typeof obj.editorMark === "string" && obj.editorMark.trim().length > 0;
+    if (hasEditorText && hasMark)
+        return options;
+    const mark = hasMark ? String(obj.editorMark) : "field-omc0001";
+    const editorText = obj.formula.replace(/\{([^{}]+)\}/g, (_full, token) => `<${mark}>${token}</${mark}>`);
+    return { ...options, [key]: JSON.stringify({ ...obj, editorText, editorMark: mark }) };
+}
+/**
+ * Live 2026-09-23: bizdatarule type 3/4/5 do NOT drive the portal form
+ * interaction layer. Reproduced on bench22 + a fresh probe: a type-4 required
+ * rule (Chinese OR symbol formula) never made the control required in the real
+ * portal, while the SAME condition in the field's `options.requiredFormula`
+ * (via field.update) did — and a SYMBOL type-4 rule additionally crashed the
+ * renderer through its `historyOpt` mirror. So form-interaction
+ * required/readonly/display belongs in field options; this lane is the
+ * field-level engine read elsewhere. The advisory makes the write-time
+ * consequence explicit so the caller stops reaching for datarule for form UI.
+ *
+ * Corrected 2026-09-23 (see evidence/datarule-designer-visibility-20260923.md):
+ * the row written here IS what the FORM DESIGNER's design-time Set/Unset reads
+ * — `20156.9cbebcd2.js:51036/111025` `isRequire` matches `(propertyCodes||
+ * [propertyCode]).includes(<field>)` over the `bizdatarule` list. A clean
+ * isolation (CLI `datarule.create` type-4 on an otherwise-untouched field, then
+ * a HARD page reload) shows the designer attribute panel flips to "Set". The
+ * earlier "设计器看不到" symptom was a stale SPA hash-route session: navigating
+ * `page.goto` to the SAME `#/...form-design/...` URL does not reload the SPA, so
+ * the Vuex rule list keeps the previous in-memory state. So:
+ *   - design-time visibility  → this row (hard-reload to observe);
+ *   - portal runtime required → field `options.*` (field.update + configure_form).
+ * Two engines, two storage locations; neither substitutes for the other.
+ */
+const DATARULE_FORM_INTERACTION_ADVISORY = "bizdatarule type3/4/5 行是**表单设计器设计态** Set/Unset 的读面（设计器加载 bizdatarule/list）；门户**运行时**则读**字段 options**。所以表单条件优先走 `field.update`：写 requiredFormula/readonlyCondition/displayFormula 时它会**自动配对**本行，readback.formConditionSync 报 created/updated/deleted/skipped，清空条件传空串会同时删行。本工具用于字段级引擎规则，或独立增删改既有行。设计器是 SPA——写入后须整页硬重载才观察得到（`goto` 同一 hash URL 不会重载）。符号式经 historyOpt 镜像在门户渲染会崩，运行时条件请用中文操作符。";
+function dataRuleBody(args, options) {
+    const codes = dataRuleTargetCodes(args);
+    return {
+        schemaCode: args.schemaCode,
+        // Single field also fills the legacy column; multiple fields leave it null,
+        // matching the designer (propertyCodes is the authoritative binding).
+        propertyCode: codes.length === 1 ? codes[0] : null,
+        propertyCodes: codes,
+        ...(args.name !== undefined ? { name: args.name } : {}),
+        dataRuleType: args.dataRuleType,
+        options,
+        ...(args.checkType !== undefined ? { checkType: args.checkType } : {}),
+        ...(args.childRule !== undefined ? { childRule: args.childRule } : {}),
+        ...(args.sortKey !== undefined ? { sortKey: args.sortKey } : {}),
+    };
+}
+const DATA_RULE_ROW_FIELDS = ["id", "schemaCode", "propertyCode", "propertyCodes", "dataRuleType", "options", "checkType", "childRule", "name", "sortKey"];
+function fullDataRuleBody(current, args, options) {
+    const patch = dataRuleBody(args, options);
+    return Object.fromEntries(DATA_RULE_ROW_FIELDS.map((field) => [field, field === "options" ? options : field in patch ? patch[field] : current[field] ?? null]));
+}
+function dataRuleChanges(before, after) {
+    const changedFields = [];
+    for (const field of DATA_RULE_ROW_FIELDS)
+        if (JSON.stringify(before[field] ?? null) !== JSON.stringify(after[field] ?? null))
+            changedFields.push(field);
+    return { changedFields, unexpectedChanges: changedFields.filter((field) => !["options", "checkType", "childRule", "name", "sortKey", "propertyCode", "propertyCodes", "dataRuleType"].includes(field)) };
+}
+async function listDataRules(session, schemaCode, dataRuleType) {
+    const query = { schemaCode };
+    if (dataRuleType !== undefined)
+        query.dataRuleType = String(dataRuleType);
+    return wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query })).data);
+}
+/**
+ * Identity seam: resolve a data-rule row from either its physical `id` or the
+ * business locator `(propertyCode, dataRuleType)`. The latter removes the forced
+ * `datarule.list → id → datarule.update/delete` dance for the common "change this
+ * field's required/readonly rule" case.
+ */
+async function locateDataRuleId(session, locator, verb) {
+    if (locator.id)
+        return locator.id;
+    const result = await resolveDataRuleRow(session, locator.schemaCode, locator);
+    if (!result.ok) {
+        const where = [locator.propertyCode, ...(locator.propertyCodes ?? [])].filter(Boolean).join(",") || "(未给字段)";
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: result.reason === "ambiguous" ? "datarule-locator-ambiguous" : "datarule-absent",
+            message: result.reason === "ambiguous"
+                ? `字段 ${locator.schemaCode}.${where} 有 ${result.count} 条数据规则，业务键不唯一；请补 dataRuleType 或直接传 id，拒绝 ${verb}`
+                : `按业务键在 ${locator.schemaCode} 找不到数据规则（propertyCode=${where}, dataRuleType=${locator.dataRuleType ?? "任意"}）；可用 datarule.list 核对，拒绝 ${verb}`,
+        });
+    }
+    return String(result.row.id);
+}
+/**
+ * Form-interaction option key → the `bizdatarule` dataRuleType that carries the
+ * SAME condition for the form DESIGNER. `readonlyFormula` (boolean, 恒只读) has
+ * no rule-row counterpart, so it is deliberately absent.
+ */
+const FORM_CONDITION_RULE_TYPES = Object.freeze({
+    displayFormula: 3,
+    requiredFormula: 4,
+    readonlyCondition: 5,
+});
+/**
+ * Pair a field's form-interaction condition into the `bizdatarule` projection.
+ *
+ * Evidence (2026-09-23, ADR 0005):
+ *  - the form DESIGNER's design-time Set/Unset reads `bizdatarule/list` rows
+ *    for dataRuleType 3/4/5 — network capture shows the designer loads
+ *    `bizdatarule/list?schemaCode=`, while `bizproperty/list` carries NO
+ *    model-level rule rows (see evidence/datarule-designer-visibility-20260923.md
+ *    §4b). Frontend `isRequire` matches `(propertyCodes||[propertyCode])`.
+ *  - the portal RUNTIME reads the field's `options.{requiredFormula|
+ *    readonlyCondition|displayFormula}`.
+ * A condition is correct only when BOTH faces exist; `field.update` previously
+ * wrote only the options face, so CLI-authored conditions showed "Unset" in the
+ * designer. This helper mirrors the designer's own row shape exactly:
+ * `propertyCodes:[field]`, `options:{propertyCodes, functionType:"true", <key>}`.
+ *
+ * Only keys whose string value changed are touched; clearing a key deletes the
+ * matching row. Writes are full-row so no persisted column is dropped.
+ */
+export async function syncFormConditionDataRules(session, schemaCode, fieldCode, prevOptions, nextOptions) {
+    const result = { created: [], updated: [], deleted: [], skipped: [] };
+    const text = (options, key) => (typeof options[key] === "string" ? options[key].trim() : "");
+    const changedKeys = Object.keys(FORM_CONDITION_RULE_TYPES).filter((key) => text(prevOptions, key) !== text(nextOptions, key));
+    if (changedKeys.length === 0)
+        return result;
+    const existing = await listDataRules(session, schemaCode);
+    // The designer's rule rows live on the PUBLISHED face (like datarule.create's
+    // own guard); a draft-only field cannot carry a designer-visible row yet.
+    const published = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data)
+        .some((row) => String(row.code ?? row.propertyCode ?? "") === fieldCode);
+    for (const key of changedKeys) {
+        const dataRuleType = FORM_CONDITION_RULE_TYPES[key];
+        const next = text(nextOptions, key);
+        const current = existing.find((row) => Number(row.dataRuleType) === dataRuleType && storedTargetCodes(row).includes(fieldCode));
+        if (next.length === 0) {
+            if (current && typeof current.id === "string" && current.id.length > 0) {
+                await wireCall(session, { path: ENDPOINTS.dataRuleDelete, method: "POST", query: { id: current.id } });
+                result.deleted.push({ fieldCode, dataRuleType, key, id: current.id });
+            }
+            continue;
+        }
+        if (!published) {
+            result.skipped.push({ key, dataRuleType, reason: `字段 ${fieldCode} 未发布，无法在其上建设计器可见规则行；先 field.publish 再改条件` });
+            continue;
+        }
+        const options = JSON.stringify({ propertyCodes: fieldCode, functionType: "true", [key]: next });
+        if (current && typeof current.id === "string" && current.id.length > 0) {
+            const body = Object.fromEntries(DATA_RULE_ROW_FIELDS.map((field) => [field, field === "options" ? options : field === "schemaCode" ? schemaCode : field === "propertyCode" ? fieldCode : field === "propertyCodes" ? [fieldCode] : field === "dataRuleType" ? dataRuleType : current[field] ?? null]));
+            await wireCall(session, { path: ENDPOINTS.dataRuleUpdate, method: "POST", body });
+            result.updated.push({ fieldCode, dataRuleType, key, id: current.id });
+        }
+        else {
+            await wireCall(session, { path: ENDPOINTS.dataRuleCreate, method: "POST", body: { schemaCode, propertyCode: fieldCode, propertyCodes: [fieldCode], dataRuleType, options } });
+            result.created.push({ fieldCode, dataRuleType, key, id: null });
+        }
+    }
+    return result;
+}
+export function registerDataRuleLane(tools) {
+    tools.push(defineTool({
+        name: "datarule.list",
+        layer: "low",
+        kind: "read",
+        lane: DATARULE_LANE,
+        scope: DATARULE_TOOLS["datarule.list"].scope,
+        description: DATARULE_TOOLS["datarule.list"].description,
+        inputSchema: {
+            environment: environmentArg,
+            schemaCode: z.string().min(1),
+            dataRuleType: dataRuleTypeArg.optional(),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const rows = await listDataRules(session, args.schemaCode, args.dataRuleType);
+            return {
+                schemaCode: args.schemaCode,
+                dataRuleType: args.dataRuleType ?? null,
+                rules: rows.map(decodeDataRule),
+            };
+        }),
+    }));
+    writeTool(tools, "datarule.create", DATARULE_LANE, DATARULE_TOOLS["datarule.create"].scope, DATARULE_TOOLS["datarule.create"].description, {
+        schemaCode: z.string().min(1),
+        propertyCode: propertyCodeArg,
+        propertyCodes: propertyCodesArg,
+        dataRuleType: dataRuleTypeArg,
+        options: dataRuleOptionsArg,
+        checkType: checkTypeArg,
+        childRule: z.boolean().optional(),
+        name: z.string().optional(),
+        sortKey: z.number().int().optional(),
+    }, async (session, args) => {
+        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+        assertDataRuleCheckType(args.dataRuleType, args.checkType);
+        assertDataRuleTarget(args);
+        const codes = dataRuleTargetCodes(args);
+        const fields = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } })).data);
+        const published = new Set(fields.map((row) => String(row.code ?? row.propertyCode ?? "")));
+        await assertChildFormulaRefs(session, args, published);
+        const missing = codes.filter((code) => !published.has(code));
+        if (missing.length > 0)
+            throw new ToolRefusalError({ status: "refused", blocker: "datarule-property-not-published", schemaCode: args.schemaCode, propertyCodes: codes, missing, message: `字段 ${args.schemaCode}.${missing.join(",")} 不在发布面上；拒绝 datarule.create POST` });
+        const existingRules = await listDataRules(session, args.schemaCode);
+        // dataRuleType 1 (CHECK_RULE) fans out into 5 checkTypes that COEXIST on one
+        // field (the platform auto-creates a checkType 4 maxLength row per text
+        // field), so the clash key there is field + `checkType`, not field + type.
+        if (existingRules.some((row) => {
+            if (Number(row.dataRuleType) !== args.dataRuleType)
+                return false;
+            if (!storedTargetCodes(row).some((code) => codes.includes(code)))
+                return false;
+            return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
+        }))
+            throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", schemaCode: args.schemaCode, propertyCodes: codes, dataRuleType: args.dataRuleType, ...(args.dataRuleType === 1 ? { checkType: args.checkType } : {}), message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝重复 POST` });
+        const createRule = () => wireCall(session, {
+            path: ENDPOINTS.dataRuleCreate,
+            method: "POST",
+            body: dataRuleBody(args, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
+        });
+        // Ticket 78: ONLY type2 CALCULATE has the corroborated unpublished-app
+        // FALSE dead-cycle 305003 (checkCalculateRulesDeadCycle mis-concatenates
+        // schemaCode.propertyCode when getAppFunctionByCode is null); types
+        // 3/4/5 keep the plain wire failure.
+        const performed = args.dataRuleType === 2
+            ? await runtimeWriteWithAppMapping(session, args.schemaCode, 305003, "datarule.create 类型2 CALCULATE 报死循环（305003，误判）", createRule)
+            : await createRule();
+        const rules = (await listDataRules(session, args.schemaCode, args.dataRuleType)).filter((row) => storedTargetCodes(row).some((code) => codes.includes(code)));
+        return {
+            performed: { errcode: performed.errcode },
+            readback: {
+                schemaCode: args.schemaCode,
+                propertyCodes: codes,
+                dataRuleType: args.dataRuleType,
+                matchedCount: rules.length,
+                rules: rules.map(decodeDataRule),
+                ...(args.dataRuleType >= 3 ? { advisory: DATARULE_FORM_INTERACTION_ADVISORY } : {}),
+            },
+        };
+    }, 
+    // T-04: the type-2 shape gate is static — refuse BEFORE the write permission gate.
+    (args) => {
+        assertDataRuleTarget(args);
+        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+        assertDataRuleCheckType(args.dataRuleType, args.checkType);
+    });
+    writeTool(tools, "datarule.update", DATARULE_LANE, DATARULE_TOOLS["datarule.update"].scope, DATARULE_TOOLS["datarule.update"].description, {
+        id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
+        schemaCode: z.string().min(1),
+        propertyCode: propertyCodeArg,
+        propertyCodes: propertyCodesArg,
+        dataRuleType: dataRuleTypeArg,
+        options: dataRuleOptionsArg,
+        checkType: checkTypeArg,
+        childRule: z.boolean().optional(),
+        name: z.string().optional(),
+        sortKey: z.number().int().optional(),
+    }, async (session, args) => {
+        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+        assertDataRuleCheckType(args.dataRuleType, args.checkType);
+        const id = await locateDataRuleId(session, args, "update POST");
+        const before = await listDataRules(session, args.schemaCode);
+        const current = before.find((row) => row.id === id);
+        if (!current)
+            throw new ToolRefusalError({ status: "refused", blocker: "datarule-absent", message: `数据规则 ${id} 不存在于 ${args.schemaCode}；拒绝 update POST` });
+        // The stored childRule governs when the caller omits it (full-row update).
+        const patchArgs = { ...args, id };
+        await assertChildFormulaRefs(session, { ...patchArgs, childRule: args.childRule ?? current.childRule === true });
+        // Keep the existing binding when the caller omits a target (the platform
+        // update is a full-row overwrite — an empty patch would clear propertyCodes).
+        const requested = dataRuleTargetCodes(patchArgs);
+        const codes = requested.length > 0 ? requested : storedTargetCodes(current);
+        const boundArgs = { ...patchArgs, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes };
+        if (before.some((row) => {
+            if (row.id === id)
+                return false;
+            if (Number(row.dataRuleType) !== args.dataRuleType)
+                return false;
+            if (!storedTargetCodes(row).some((code) => codes.includes(code)))
+                return false;
+            return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
+        }))
+            throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝 update POST` });
+        const beforeDecoded = decodeDataRule(current);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.dataRuleUpdate,
+            method: "POST",
+            body: fullDataRuleBody(current, boundArgs, JSON.stringify(withOptionsPropertyCodes(withStitchEditorText(args.options), codes))),
+        });
+        const record = (await listDataRules(session, args.schemaCode, args.dataRuleType)).find((row) => row.id === id);
+        if (!record)
+            throw new WireError("business", `data rule ${id} disappeared after update`, 304001);
+        const afterDecoded = decodeDataRule(record);
+        const proof = dataRuleChanges(beforeDecoded, afterDecoded);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { id, present: true, before: beforeDecoded, after: afterDecoded, changedFields: proof.changedFields, unexpectedChanges: proof.unexpectedChanges, rule: afterDecoded },
+        };
+    }, (args) => {
+        assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+    });
+    writeTool(tools, "datarule.delete", DATARULE_LANE, DATARULE_TOOLS["datarule.delete"].scope, DATARULE_TOOLS["datarule.delete"].description, {
+        id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
+        schemaCode: z.string().min(1),
+        propertyCode: propertyCodeArg,
+        propertyCodes: propertyCodesArg,
+        dataRuleType: z.number().int().min(1).max(5).optional().describe("业务键定位去歧义：同一字段可能有多条规则（如必填+只读），用它指定要删的类型"),
+    }, async (session, args) => {
+        const id = await locateDataRuleId(session, args, "delete POST");
+        const before = (await listDataRules(session, args.schemaCode)).find((row) => row.id === id);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.dataRuleDelete,
+            method: "POST",
+            query: { id },
+        });
+        const after = await listDataRules(session, args.schemaCode);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { id, existedBefore: before !== undefined, absent: !after.some((row) => row.id === id) },
+        };
+    });
+}
+//# sourceMappingURL=datarule.js.map