@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/lanes/datarule-contract.js

@@ -0,0 +1,155 @@
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION, describeTool, emitterBinding } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+/**
+ * G1 field-level data-rule wire facts (8.6.26 `BizDataRuleController` /
+ * `BizDataRuleModel` / `DataRuleType`, decompiled launcher source). These are
+ * the single source for the handler descriptions and the coverage declaration.
+ *
+ * This is a distinct engine from the form's per-control options: the
+ * `attributes[].historyOpt` snapshot and this `bizdatarule` table are the
+ * same field-level rule source, while the field-control "visible/readonly/
+ * required per form" flags are a separate engine (CONTEXT: 两套引擎).
+ */
+export const DATARULE_WIRE = Object.freeze({
+    list: "GET bizdatarule/list?schemaCode=<schemaCode>[&dataRuleType=<1..5>] -> BizDataRuleModel[]",
+    create: "POST bizdatarule/create body BizDataRuleModel {schemaCode,propertyCodes (array; real designer binding),propertyCode (legacy single),dataRuleType,options (JSON string),checkType?,childRule?,name?,sortKey?}; create requires schemaCode + dataRuleType + a target field; options.propertyCodes mirrors the binding (real 2026-09-23 rows bind via the ARRAY, not the singular column)",
+    update: "POST bizdatarule/update body BizDataRuleModel; requires id + schemaCode + dataRuleType; the full-row overwrite preserves the existing propertyCodes when the caller omits a target",
+    delete: "bizdatarule/delete?id=<ruleId> (@RequestParam String id) with list exact-absence readback",
+    dataRuleTypes: "DataRuleType: 1 CHECK_RULE (校验), 2 CALCULATE_RULE (计算/拼接), 3 DISPLAY_RULE (显示), 4 OTHER_RULE (必填), 5 READ_ONLY_RULE (只读); 8 EXTENSION_RULE is out of scope",
+    dataRuleCheckTypes: "dataRuleType 1 (CHECK_RULE 提交校验规则) 的 checkType 判别（cloudpivot-shared DataRuleCheckType.java）——**校验类需求走这里，不要写在线 JS**：1 REGEX_CHECK 正则校验 / 2 SUBMIT_CHECK 提交校验（含跨字段比较）/ 3 EMPTY_ROW_CHECK 空行校验 / 4 MAX_LENGTH_CHECK 最大长度校验 / 5 REPEAT_CHECK 重复校验；checkType 只配 dataRuleType 1，缺省或非法值由工具拒绝",
+    optionsByCheckType: "各 checkType 的 options（engine/bo/datarule/impl/checkType/*）：1 REGEX_CHECK{regexp:'/…/',regexpText:{zh,en}}（regexp 必须斜杠包裹，RegexCheckValidator 会去掉首尾字符）；2 SUBMIT_CHECK{conditions:'<字段code> 操作符 <值> [&&| || 连接]', verifyType:'submitDenied'?（满足条件即拒绝提交，缺省为满足才允许）, prompt:'<提示，**纯文本**，勿 URL 编码——这种顶层 options.prompt 门户原样显示，编码过会显示成 %E5..乱码>' }（操作符 等于/不等于/大于/小于/大于等于/小于等于/为空/不为空…；**字段 vs 字面量**直接写值如 {qty} 大于 100；**跨字段**右值必须写实为值对象 {\"valueType\":\"currentModel\",\"value\":\"<字段code>\"}，如「结束日期不早于开始日期」= {end_date} 小于 {\"valueType\":\"currentModel\",\"value\":\"start_date\"}——裸 {字段code} 右值会原样落库但前端/服务端都不解析成字段值，规则静默不生效，工具拒绝）；3 EMPTY_ROW_CHECK{isEmptyRow,isEmptyRowTips}；4 MAX_LENGTH_CHECK{maxLength}；5 REPEAT_CHECK{properties:[<字段code>],isSubTableValidationAllData?,prompt:[{isDataItem,code}]}（重复提示逐项/数组解析，RepeatCheckValidator:258-272：**isDataItem=0 → code 是字面文案**，如 [{\"isDataItem\":0,\"code\":\"单号重复\"}]；**isDataItem=1 → code 是字段 code**，提示取该字段（值/名）。写成 isDataItem:1 + 字段code 会把提示显示成字段值而不是你要的文案；`promptText` 等未识别键平台会忽略，勿用）",
+    optionsByType: "options is a JSON string read per type: 1 check keys (verifyFormula/regexp/maxLength/isEmptyRow/noRepeat/conditions), 2 FormulaConfig — `shortTextStitch` (falling back to `value`) MUST be a JSON OBJECT STRING whose `formula` key holds the expression, e.g. {\"shortTextStitch\":\"{\\\"formula\\\":\\\"{field}\\\",\\\"editorText\\\":\\\"{字段名}\\\"}\"}; a bare \"{field}\" string fails JSONUtil.isJson → getCalRuleExpression returns null → false 305003 dead-cycle; `formulaType:\"AGGREGATION\"` instead reads `aggregation`; a top-level `expression` is NEVER read (it is only a key INSIDE that nested JSON), 3 displayFormula, 4 requiredFormula, 5 readonlyCondition",
+    formulaReference: "类型2 公式引用按位置解析：裸 {字段}=**主记录**字段；带点 {子表code.字段}=**子表**字段（FormulaProcessor.constructSubExprParamsValueMap 要求点前等于子表 schema）。所以**主表公式**用裸 {字段}（带 {主表code.字段} 会按子表解析 → 值空/静默 null），**子表公式**（childRule:true）引用同级子字段必须带点 {子表code.字段}（裸引用被当主记录字段 → 值缺失 → 提交 50000）。工具在写前按子表已发布字段判定并拒绝裸引用（blocker datarule-formula-child-bare-reference），读回对存量子表公式加 formulaHint 提示复核。",
+    optionsEncoding: "the engine JSON-parses the `options` column and reads requiredFormula / readonlyCondition / displayFormula / verifyFormula / shortTextStitch (whose VALUE is itself a JSON string carrying `formula`); send options as a stringified object",
+    expressionSyntax: "field references are `{fieldCode}` (e.g. {amount}>5000). This CLI does NOT publish or validate an expression grammar: operators, functions, escaping, and coercion are unspecified here, and rule-action EXPRESSION must NOT be assumed to share FORMULA(100)'s parser without live evidence. A constant `\\\"true\\\"` is the known always-on form. Treat a saved expression as unverified until the portal form proves it.",
+    acceptanceBoundary: "types 3/4/5 are form-interaction rules; `data.*` does NOT run the form validation layer, so the CLI cannot prove a required/readonly/display rule true or false. Acceptance is a portal-form manual check — never report a saved rule as verified from `data.*` readback alone.",
+    formHistoryOpt: "same field-level rule engine as form attributes[].historyOpt; distinct from the per-form field-control rule engine (dataRuleType 3/4/5 must not be confused with form-control visible/readonly/required)",
+});
+const DATARULE_SCOPE = "create update delete readback";
+export const DATARULE_LANE_CONTRACT = Object.freeze({
+    lane: LANES.dataRule,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        list: "dataRuleList",
+        create: "dataRuleCreate",
+        update: "dataRuleUpdate",
+        delete: "dataRuleDelete",
+    }),
+    wire: Object.freeze({
+        list: DATARULE_WIRE.list,
+        create: DATARULE_WIRE.create,
+        update: DATARULE_WIRE.update,
+        delete: DATARULE_WIRE.delete,
+        dataRuleTypes: DATARULE_WIRE.dataRuleTypes,
+        dataRuleCheckTypes: DATARULE_WIRE.dataRuleCheckTypes,
+        optionsByType: DATARULE_WIRE.optionsByType,
+        formulaReference: DATARULE_WIRE.formulaReference,
+        optionsByCheckType: DATARULE_WIRE.optionsByCheckType,
+        optionsEncoding: DATARULE_WIRE.optionsEncoding,
+        formHistoryOpt: DATARULE_WIRE.formHistoryOpt,
+    }),
+    wireBindings: Object.freeze({
+        list: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule type4", assertDataRuleContract)]),
+        create: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule.create refuses before the wire", assertDataRuleContract)]),
+        update: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule.update preserves full current row", assertDataRuleContract)]),
+        delete: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule type5", assertDataRuleContract)]),
+        dataRuleTypes: Object.freeze([emitterBinding("lanes/datarule-contract.DATARULE_TYPE_OPTION_KEYS", assertDataRuleContract)]),
+        dataRuleCheckTypes: Object.freeze([emitterBinding("lanes/datarule.DATARULE_CHECK_TYPES", assertDataRuleContract)]),
+        optionsByType: Object.freeze([emitterBinding("lanes/datarule-contract.DATARULE_TYPE_OPTION_KEYS", assertDataRuleContract)]),
+        formulaReference: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule refuses a child-table formula that bare-references a sibling child field", assertDataRuleContract)]),
+        optionsByCheckType: Object.freeze([emitterBinding("lanes/datarule.DATARULE_CHECK_TYPES", assertDataRuleContract)]),
+        optionsEncoding: Object.freeze([emitterBinding("lanes/datarule-contract.DATARULE_TYPE_OPTION_KEYS", assertDataRuleContract)]),
+        formHistoryOpt: Object.freeze([behaviorBinding("test/datarule.test.ts#datarule type5", assertDataRuleContract)]),
+    }),
+    evidence: Object.freeze([
+        "cp-sources/backend/decompiled-full/launcher-8.6.26/cloudpivot-engine-8.6.26/.../controller/app/BizDataRuleController.java:156-364",
+        "cp-sources/backend/decompiled-models/com/authine/cloudpivot/metadata/bizmodel/BizDataRuleModel.java",
+        "cp-sources/backend/decompiled-models/com/authine/cloudpivot/metadata/bizmodel/DataRuleType.java (CHECK=1,CALCULATE=2,DISPLAY=3,OTHER=4,READ_ONLY=5,EXTENSION=8)",
+        "cp-sources/backend/.../engine/bo/datarule/impl/ruleType/RequiredDataRuleValidator.java reads options.requiredFormula",
+        "cp-sources/backend/.../engine/bo/datarule/impl/ruleType/ReadOnlyValidator.java reads options.readonlyCondition",
+        "cp-sources/backend/.../engine/bo/calculate/impl/CalculateRuleProcessor.java reads options.shortTextStitch",
+        ".scratch/omc-app-management/research/desensitized-config-shapes.md §4",
+        ".scratch/omc-app-management/research/configuration-gap-report.md §3 P0/G1, §5.1 Spec A",
+    ]),
+    tools: Object.freeze({
+        "datarule.list": Object.freeze({
+            scope: DATARULE_SCOPE,
+            description: describeTool("List field-level data rules of a model (bizdatarule/list), optionally filtered by `dataRuleType` 1–5.", [
+                "`schemaCode` is required; `dataRuleType` omits every type when absent.",
+                "Each row decodes to {id, schemaCode, propertyCode, dataRuleType, checkType, childRule, name, sortKey, options}.",
+                "**子表规则用主表 schemaCode 查**：平台对 `schemaCode=<子表>` 只返回部分行——公式字段(FORMULA t100)的 type2 镜像行不返回（真机 8.6.26：bench40_order_item 按子表查 2 行、缺 subtotal；按主表 bench40_order 查 16 行、含该 type2 行）。公式字段的公式读 `field.list` 的 `options.formulaConfig`（字段属性，不是独立规则）。普通数值字段的子表 type2 规则按子表查是有的。",
+            ]),
+        }),
+        "datarule.create": Object.freeze({
+            scope: DATARULE_SCOPE,
+            description: describeTool("Create a field-level data rule (bizdatarule/create) and read it back from the authoritative list.", [
+                "`dataRuleType`: 1 校验 / 2 计算拼接 / 3 显示 / 4 必填 / 5 只读 (8 EXTENSION is out of scope).",
+                "**⚠️ type3/4/5 行的两个读面**：门户**运行时**读**字段 options**（`requiredFormula`/`readonlyCondition`/`readonlyFormula`/`displayFormula`，`field.create/update` 写）；表单设计器**设计态** Set/Unset 读 **bizdatarule/list**（本行，network capture 2026-09-23）。**实测：type3/4/5 规则单独不会让门户表单控件变必填/只读**（中文或符号操作符都一样），符号式经 `historyOpt` 镜像还会让表单渲染崩溃——运行时条件请用中文操作符。表单条件优先走 `field.update`：它会**自动配对**本行（readback.formConditionSync）。本工具用于字段级引擎规则或独立增删改。",
+                "**类型3/4/5 条件串协议（平台 create 不校验，坏形状落库即雷，工具按此协议拒绝）**：`{字段code} 操作符 [值]`。操作符取 **bizdatarule 词表**（与字段 options 的表单交互引擎不同——那是符号式）：**中文** 等于/不等于/大于/小于/大于等于/小于等于/包含/不包含/包含全部/不包含全部/包含任意一个/不包含任意一个/等于任意一个/属于/不属于/介于/为空/不为空（实测 146 条真实规则以此为主），也接受符号 `==` `!=` `>` `<` `>=` `<=` `Contains` `IsEmpty` 等。为空/不为空**不带值**（`{field} 不为空`）；其余带值（JSON 对象或标量）。多条件 ` && `、多组 ` || `。示例 type4：`options:{requiredFormula:\"{amount} 等于 {\\\"valueType\\\":\\\"specifyOption\\\",\\\"value\\\":\\\"A\\\"}\"}`；无条件必填用字面量 \"true\"。**字段绑定用 `propertyCodes`（数组）**，工具自动把 `options.propertyCodes` 也补上；存量的坏规则由 datarule.list 以 shapeWarning 标出。",
+                "`options` is a JSON object sent to the wire as a JSON string; the engine reads `requiredFormula` (4), `readonlyCondition` (5), `displayFormula` (3), `verifyFormula` (1) and `shortTextStitch` (2).",
+                "类型2（计算/拼接）：`options.shortTextStitch`（或 `value`）的值**必须是含 `formula` 的 JSON 对象字符串**（如 `{\"formula\":\"{字段}\"}`）；裸串会被工具拒绝（否则引擎返回 null → 误报 305003 死循环）。顶层没有 `expression` 键——它只是该嵌套 JSON 内部的字段名。",
+                "Missing type or schemaCode is refused before any write.",
+                "根因提示（ticket 78）：类型2 CALCULATE 在未发布应用上会报假死循环 305003（checkCalculateRulesDeadCycle 在 getAppFunctionByCode 为 null 时按 schemaCode.propertyCode 拼接、口径不一致）——工具反推后拒 app-not-published；类型 3/4/5 不受影响。",
+            ]),
+        }),
+        "datarule.update": Object.freeze({
+            scope: DATARULE_SCOPE,
+            description: describeTool("Update an existing field-level data rule (bizdatarule/update) by `id`; requires `schemaCode` + `dataRuleType`.", [
+                "The rule is located by its `id` from datarule.list; duplicate property/type and absent ids refuse before POST. Because the platform update is full-row overwrite, the body is an explicit persisted-column whitelist plus the patch; readback returns before/after, changedFields, and unexpectedChanges.",
+            ]),
+        }),
+        "datarule.delete": Object.freeze({
+            scope: DATARULE_SCOPE,
+            description: describeTool("Delete a field-level data rule (bizdatarule/delete) by `id` with exact-absence readback from the authoritative list.", [
+                "Absence is proven by a post-delete datarule/list that no longer carries the id.",
+            ]),
+        }),
+    }),
+});
+/** Per-type required option keys the engine actually reads (fail-closed gate). */
+export const DATARULE_TYPE_OPTION_KEYS = Object.freeze({
+    1: Object.freeze(["verifyFormula", "regexp", "regexpText", "maxLength", "isEmptyRow", "isEmptyRowTips", "noRepeat", "properties", "conditions"]),
+    2: Object.freeze(["shortTextStitch", "expression", "aggregation"]),
+    3: Object.freeze(["displayFormula"]),
+    4: Object.freeze(["requiredFormula"]),
+    5: Object.freeze(["readonlyCondition"]),
+});
+export function assertDataRuleContract() {
+    assertLaneContract(DATARULE_LANE_CONTRACT);
+    if (DATARULE_TYPE_OPTION_KEYS[4][0] !== "requiredFormula")
+        throw new Error("datarule contract pins type 4 to requiredFormula");
+    if (DATARULE_TYPE_OPTION_KEYS[5][0] !== "readonlyCondition")
+        throw new Error("datarule contract pins type 5 to readonlyCondition");
+    assertDescriptionCarries(DATARULE_LANE_CONTRACT, "datarule.list", ["bizdatarule/list", "schemaCode", "dataRuleType"]);
+    assertDescriptionCarries(DATARULE_LANE_CONTRACT, "datarule.create", ["bizdatarule/create", "requiredFormula", "readonlyCondition", "displayFormula", "JSON string"]);
+    assertDescriptionCarries(DATARULE_LANE_CONTRACT, "datarule.update", ["bizdatarule/update", "id", "full-row", "changedFields"]);
+    assertDescriptionCarries(DATARULE_LANE_CONTRACT, "datarule.delete", ["bizdatarule/delete", "absence"]);
+    if (!DATARULE_WIRE.list.includes("bizdatarule/list"))
+        throw new Error("datarule contract must pin the list endpoint");
+    if (!DATARULE_WIRE.create.includes("BizDataRuleModel"))
+        throw new Error("datarule contract must pin the create body DTO");
+    if (!DATARULE_WIRE.update.includes("id + schemaCode + dataRuleType"))
+        throw new Error("datarule contract must pin the update required keys");
+    if (!DATARULE_WIRE.delete.includes("id=<ruleId>"))
+        throw new Error("datarule contract must pin the delete query param");
+    if (!DATARULE_WIRE.dataRuleTypes.includes("CHECK_RULE") || !DATARULE_WIRE.dataRuleTypes.includes("EXTENSION_RULE"))
+        throw new Error("datarule contract must pin the DataRuleType enum (1..5 in scope, 8 out)");
+    if (!DATARULE_WIRE.optionsByType.includes("shortTextStitch"))
+        throw new Error("datarule contract must pin the type-2 shortTextStitch option");
+    if (!DATARULE_WIRE.formulaReference.includes("裸 {字段}") || !DATARULE_WIRE.formulaReference.includes("datarule-formula-child-bare-reference"))
+        throw new Error("datarule contract must pin the type-2 formula reference semantics (bare=main / dotted=child)");
+    if (!DATARULE_WIRE.dataRuleCheckTypes.includes("SUBMIT_CHECK") || !DATARULE_WIRE.dataRuleCheckTypes.includes("REPEAT_CHECK") || !DATARULE_WIRE.dataRuleCheckTypes.includes("REGEX_CHECK"))
+        throw new Error("datarule contract must pin the DataRuleCheckType enum (regex/submit/repeat)");
+    if (!DATARULE_WIRE.optionsByCheckType.includes("submitDenied") || !DATARULE_WIRE.optionsByCheckType.includes("regexp"))
+        throw new Error("datarule contract must pin the per-checkType option shapes");
+    if (!DATARULE_WIRE.optionsByCheckType.includes("纯文本"))
+        throw new Error("datarule contract must pin the checkType-2 prompt as plain text (the portal renders options.prompt raw)");
+    if (!DATARULE_WIRE.optionsByCheckType.includes("isDataItem=0 → code 是字面文案"))
+        throw new Error("datarule contract must pin the checkType-5 repeat prompt isDataItem semantics (RepeatCheckValidator)");
+    if (!DATARULE_WIRE.optionsEncoding.includes("requiredFormula"))
+        throw new Error("datarule contract must pin the stringified options encoding");
+    if (!DATARULE_WIRE.formHistoryOpt.includes("historyOpt"))
+        throw new Error("datarule contract must pin the field-level vs form-control engine distinction");
+}
+//# sourceMappingURL=datarule-contract.js.map

package/dist/lanes/datarule-coverage.js

@@ -0,0 +1,19 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { DATARULE_LANE_CONTRACT } from "./datarule-contract.js";
+const T = DATARULE_LANE_CONTRACT.tools;
+export const DATARULE_COVERAGE = declareLaneCoverage(DATARULE_LANE_CONTRACT.lane, [
+    {
+        capability: "G1 field-level data rules (bizdatarule) lifecycle",
+        evidence: [
+            "packages/omc-cli/src/lanes/datarule.ts",
+            ".scratch/omc-app-management/research/configuration-gap-report.md",
+        ],
+        tools: [
+            claim("datarule.list", T["datarule.list"].scope),
+            claim("datarule.create", T["datarule.create"].scope),
+            claim("datarule.update", T["datarule.update"].scope),
+            claim("datarule.delete", T["datarule.delete"].scope),
+        ],
+    },
+]);
+//# sourceMappingURL=datarule-coverage.js.map

package/dist/lanes/datarule-protocol.js

@@ -0,0 +1,308 @@
+/**
+ * Datarule condition-string protocol (round 4).
+ *
+ * Evidence (ADR 0005): the 8.6.26 platform does NOT validate data-rule
+ * option shapes at create time (`BizDataRuleRuntimeFacadeImpl.checkDataRuleFormat`
+ * checks only calculate-rule compilation and org conditions), so malformed
+ * conditions store verbatim and break the portal form renderer
+ * (`conditionGroup.compareType.undefined` family — reproduced live on the
+ * dogfood environment 2026-09-22: `readonlyCondition:"true"` crashed the
+ * renderer and the target control never rendered; the protocol-correct
+ * condition restored it).
+ *
+ * The protocol itself is reproduced from three independent sources:
+ *  1. backend readback parser `BizDataRuleController.parseFormula`
+ *     (decompiled-engine .../app/BizDataRuleController.java:156-176): splits
+ *     on " || " then " && "; a condition carrying `valueType` must split
+ *     `(" ", 3)` into `{field}` / operator / JSON.
+ *  2. frontend designer `initModel` (frontend-dist/admin/js/11993.a661fd05.js):
+ *     `requiredType = e && "true" !== e ? 2 : 1` — literal "true" is the
+ *     unconditional-required marker; fields serialize as `"{"+code+"}"`.
+ *  3. frontend renderer mapping (frontend-dist/admin/js/19407.d285b567.js
+ *     compareTypeMapping): operators == != > < >= <= Contains NotContains
+ *     IsEmpty IsNotEmpty.
+ *  4. runtime validators RequiredDataRuleValidator.java:526-627 /
+ *     ReadOnlyValidator.java:497-597 / SubmitCheckValidator.java:390-490
+ *     (three independent implementations of the same value-type set).
+ *
+ * Per ADR 0005 this gate enforces only reproduced behavior: unconditional
+ * readonly (`readonlyFormula` / `functionType:"true"`) is NOT accepted until
+ * a live experiment reproduces it — the reproduced unconditional form for
+ * readonly is a tautological condition.
+ */
+/**
+ * Operators — the SERIALIZED symbol vocabulary the runtime actually executes.
+ *
+ * Live correction 2026-09-23: the earlier `eq/ne/gt/…` set was the condition
+ * BUILDER's internal enum, not what is stored. The filled-form runtime compiles
+ * the stored string with `new Function` after `parseConditionExp` rewrites the
+ * symbols (`==`→this.equal, `>`→this.greaterThan, …), so a stored `eq` throws
+ * `SyntaxError: Unexpected identifier 'eq'`, aborts the form render, and the
+ * control never appears (reproduced live on bench20: the whole form went blank).
+ *
+ * Evidence:
+ *  1. a designer-authored row in the same environment stores a SYMBOL:
+ *     `r4_auto_purchase_apply6.apply_description.requiredFormula =
+ *      {apply_amount} > {"valueType":"specifyOption","value":5000}`.
+ *  2. runtime operator→label map (frontend chunk 19497):
+ *     `{"==":"等于","!=":"不等于",">":"大于","<":"小于",">=":"大于等于",
+ *       "<=":"小于等于",Contains:"包含",NotContains:"不包含",
+ *       IsEmpty:"为空",IsNotEmpty:"不为空"}`
+ *  3. the condition builder's serialized `value` set (same chunk):
+ *     `== != > < >= <= Contains NotContains BETWEEN NOTBETWEEN IsEmpty
+ *      IsNotEmpty CT_ALL NCT_ALL CT_ANY NCT_ANY EQ_ANY NEQ_ANY`.
+ */
+const CONDITION_OPERATORS = new Set([
+    // CHINESE operators — the CANONICAL serialized vocabulary. Production
+    // observation 2026-09-23: a real designer condition in a form control's
+    // `options` is `{caseNo} 不为空`; the form-options scan found 等于 11,
+    // 等于任意一个 3, 不等于任意一个 2, 不等于 2, 不为空 4, 为空 4. The condition
+    // builder serializes to these words and the runtime parses them.
+    "等于", "不等于", "大于", "小于", "大于等于", "小于等于",
+    "包含", "不包含", "包含全部", "不包含全部", "包含任意一个", "不包含任意一个",
+    "等于任意一个", "不等于任意一个", "属于", "不属于", "介于", "不介于",
+    "为空", "不为空",
+    // SYMBOLS — also accepted by the runtime (parseConditionExp rewrites them);
+    // kept so symbol-authored conditions (bench20/21, verified working) stay valid.
+    "==", "!=", ">", "<", ">=", "<=",
+    "Contains", "NotContains", "IsEmpty", "IsNotEmpty",
+    "BETWEEN", "NOTBETWEEN",
+    "CT_ALL", "NCT_ALL", "CT_ANY", "NCT_ANY", "EQ_ANY", "NEQ_ANY",
+]);
+/** Null-check operators take no value: `{field} 不为空` / `{field} IsEmpty`. */
+const CONDITION_UNARY_OPERATORS = new Set(["为空", "不为空", "IsEmpty", "IsNotEmpty"]);
+/** valueJson.valueType strings evidenced by the three runtime validators. */
+const CONDITION_VALUE_TYPES = new Set([
+    "custom", "specifyDate", "specifyUser", "specifyDepartment", "EXPRESSION", "currentModel",
+    "specifyOption", "specifyRange", "yesterday", "tomorrow", "today", "true", "false", "dynamicRange",
+]);
+/**
+ * A single condition: `{fieldCode} operator {"valueType":...}`. The operator is
+ * a serialized symbol; the value is JSON (which itself may contain spaces), so
+ * parse with a regex rather than a plain split.
+ */
+function conditionShapeError(condition) {
+    const match = /^(\{[A-Za-z0-9_.]+\})\s+(\S+)(?:\s+([\s\S]+))?$/.exec(condition.trim());
+    if (match === null)
+        return `条件「${condition}」必须是「{字段} 操作符 [值]」（如 {amount} 不为空 / {amount} 等于 {"valueType":"specifyOption","value":500}）`;
+    const [, , operator, value] = match;
+    if (!CONDITION_OPERATORS.has(operator)) {
+        return `操作符「${operator}」不在平台条件词表内（合法：中文 等于/不等于/大于/大于等于/包含/包含全部/等于任意一个/为空/不为空…，也接受符号 == != > >= Contains IsEmpty…）；**不是** eq/gt/isnull 那套内部枚举（会让门户表单渲染 SyntaxError、整表空白）`;
+    }
+    if (CONDITION_UNARY_OPERATORS.has(operator)) {
+        return value === undefined ? null : `「${operator}」是不带值的操作符，不应带值（收到：${value.slice(0, 30)}）`;
+    }
+    if (value === undefined)
+        return `「${operator}」需要值（JSON 对象）`;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return `值段必须是 JSON 对象（如 {"valueType":"specifyOption","value":500}），收到：${value.slice(0, 40)}`;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return "值段必须解析为 JSON 对象";
+    const valueType = parsed.valueType;
+    if (typeof valueType !== "string" || !CONDITION_VALUE_TYPES.has(valueType)) {
+        return `值段 JSON 的 valueType「${String(valueType)}」不被平台校验器接受（合法：${[...CONDITION_VALUE_TYPES].join("/")})`;
+    }
+    // `specifyOption` means the value is one of the TARGET FIELD's own option
+    // codes — always a STRING. A number/boolean here is a literal the author meant
+    // to compare (`custom`); worse, the designer's rule formatter maps the target
+    // field's options and crashes (`t.map is not a function`) when a non-option
+    // field carries specifyOption, taking the WHOLE form blank (live 2026-09-24
+    // bench33/bench36). Refuse the mistaken valueType at write time.
+    if (valueType === "specifyOption") {
+        const value = parsed.value;
+        if (typeof value !== "string")
+            return `specifyOption 的 value 必须是字符串（选项 code）；收到 ${JSON.stringify(value)}。字面量（数值/布尔/文本）比较请用 {\"valueType\":\"custom\",\"value\":${JSON.stringify(value)}}——specifyOption 用在无选项字段会让设计器规则格式化器崩溃、整个表单空白`;
+    }
+    return null;
+}
+/**
+ * Validate a condition string: groups joined by " || ", conditions within a
+ * group by " && ", each condition the three-part shape above. `allowTrue`
+ * admits the literal `"true"` marker (unconditional REQUIRED, per the
+ * designer's `requiredType` check; only reproduced for type 4).
+ */
+export function conditionProtocolError(formula, options = {}) {
+    if (typeof formula !== "string" || formula.trim().length === 0)
+        return "必须是非空字符串";
+    if (options.allowTrue === true && formula.trim() === "true")
+        return null;
+    for (const group of formula.split(/\s*\|\|\s*/)) {
+        for (const condition of group.split(/\s*&&\s*/)) {
+            const error = conditionShapeError(condition);
+            if (error !== null)
+                return error;
+        }
+    }
+    return null;
+}
+/**
+ * The protocol-correct shapes, embedded in refusal messages and describes.
+ *
+ * `valueType` follows the COMPARED VALUE, not the field kind:
+ *  - `custom`        — a literal typed by the author (数/日期/文本字面量). Use
+ *    this for a numeric/date/text comparison, e.g. 金额 大于等于 10000.
+ *  - `specifyOption` — the value must be one of the TARGET FIELD's own options
+ *    (单选/复选/下拉). Only valid when that field actually has an options list.
+ *
+ * Live 2026-09-24 (bench33): putting `specifyOption` on a field with NO options
+ * (金额 is a number) makes the FORM DESIGNER's rule formatter throw
+ * `TypeError: t.map is not a function` while listing the rule, so the rule row
+ * SILENTLY DISAPPEARS from the Required/Read-only Condition dialog — even though
+ * the runtime honors the condition. Switching the literal to `custom` renders
+ * the row again. So the examples below use `custom` for literals.
+ */
+export const CONDITION_PROTOCOL_EXAMPLES = Object.freeze({
+    conditional: '{leave_amount} 大于等于 {"valueType":"custom","value":500}',
+    unary: "{leave_reason} 不为空",
+    and: '{leave_amount} 大于等于 {"valueType":"custom","value":500} && {leave_reason} 为空',
+    or: '{a} 等于 {"valueType":"specifyOption","value":"选项A"} || {b} 等于 {"valueType":"specifyOption","value":"选项B"}',
+    unconditionalRequired: "true",
+    alwaysTrueReadonly: '{leave_amount} 大于 {"valueType":"custom","value":-999999999}',
+});
+/**
+ * Form-interaction conditions live in the FIELD's `options`, not in a
+ * bizdatarule row. Reproduced live (2026-09-22, Playwright, dogfood `local`):
+ * a `datarule.create` type-4 rule did NOT block the portal form, while
+ * `field.update` with `options.requiredFormula` set the red required marker and
+ * blocked submit. Keys, from the form designer schema
+ * (frontend-dist/admin/js/12404.1675d362.js):
+ *   displayFormula   String  — 显示条件
+ *   requiredFormula  String  — 是否必填（"true" = 恒必填）
+ *   readonlyCondition String — 只读条件
+ *   readonlyFormula  Boolean — 是否只读（true = 恒只读）
+ */
+export const FORM_CONDITION_OPTION_KEYS = Object.freeze({
+    requiredFormula: "required",
+    readonlyCondition: "readonly",
+    displayFormula: "display",
+    readonlyFormula: "readonly-bool",
+});
+/**
+ * Validate the form-interaction condition keys when they appear in field options.
+ *
+ * An EMPTY STRING is the platform's "no condition" value (real designer rows
+ * store `requiredFormula:""`), so it is accepted as a CLEAR — field.update
+ * passes it through and the paired bizdatarule row is deleted.
+ */
+export function formConditionOptionsError(options) {
+    if ("requiredFormula" in options) {
+        if (typeof options.requiredFormula !== "string")
+            return "options.requiredFormula 必须是字符串（恒必填用字面量 \"true\"；清除用空串）";
+        if (options.requiredFormula.trim() !== "") {
+            const error = conditionProtocolError(options.requiredFormula, { allowTrue: true });
+            if (error !== null)
+                return `options.requiredFormula ${error}；示例：${CONDITION_PROTOCOL_EXAMPLES.conditional}`;
+        }
+    }
+    if ("readonlyCondition" in options) {
+        if (typeof options.readonlyCondition !== "string")
+            return "options.readonlyCondition 必须是字符串；恒只读请用 options.readonlyFormula:true，清除用空串";
+        if (options.readonlyCondition.trim() !== "") {
+            const error = conditionProtocolError(options.readonlyCondition);
+            if (error !== null)
+                return `options.readonlyCondition ${error}；示例：${CONDITION_PROTOCOL_EXAMPLES.conditional}`;
+        }
+    }
+    if ("displayFormula" in options) {
+        if (typeof options.displayFormula !== "string")
+            return "options.displayFormula 必须是字符串；清除用空串";
+        if (options.displayFormula.trim() !== "") {
+            const error = conditionProtocolError(options.displayFormula);
+            if (error !== null)
+                return `options.displayFormula ${error}；示例：${CONDITION_PROTOCOL_EXAMPLES.conditional}`;
+        }
+    }
+    if ("readonlyFormula" in options && typeof options.readonlyFormula !== "boolean")
+        return "options.readonlyFormula 必须是布尔（true = 恒只读）";
+    return null;
+}
+/**
+ * `bizdatarule` condition operators — a DIFFERENT vocabulary from the
+ * form-interaction (field options) engine.
+ *
+ * Live correction 2026-09-23, from 146 real production type-3/4/5 rows:
+ * `bizdatarule` conditions are authored with CHINESE operator words —
+ * 等于(76), 包含全部(30), 包含(30), 为空(20), 不为空(19), 等于任意一个(15),
+ * 不等于(11), 大于(1) — e.g. `{supplementFile} 不为空`. The form runtime's
+ * symbol set (`==`, `>`, `Contains`, …) is the field-options engine, not this
+ * one. Accept BOTH here (symbols were already in tests and are harmless) so a
+ * valid production rule is never falsely refused.
+ */
+const DATARULE_CONDITION_OPERATORS = new Set([
+    // Chinese (real production vocabulary)
+    "等于", "不等于", "大于", "小于", "大于等于", "小于等于",
+    "包含", "不包含", "包含全部", "不包含全部", "包含任意一个", "不包含任意一个",
+    "等于任意一个", "不等于任意一个", "属于", "不属于", "介于", "不介于",
+    "为空", "不为空",
+    // Symbols (form-engine vocabulary; kept for back-compat)
+    "==", "!=", ">", "<", ">=", "<=",
+    "Contains", "NotContains", "IsEmpty", "IsNotEmpty",
+    "BETWEEN", "NOTBETWEEN", "CT_ALL", "NCT_ALL", "CT_ANY", "NCT_ANY", "EQ_ANY", "NEQ_ANY",
+]);
+/** Null-check operators take no value: `{field} 不为空`. */
+const DATARULE_UNARY_OPERATORS = new Set(["为空", "不为空", "IsEmpty", "IsNotEmpty"]);
+/**
+ * A single `bizdatarule` condition. Grammar: `{field} 操作符 [值]`.
+ * - unary operators (为空/不为空/IsEmpty/IsNotEmpty) carry no value;
+ * - others carry a value: a JSON object (`{"valueType":…,"value":…}` or `{...}`)
+ *   OR a bare scalar (real rows also use plain values).
+ */
+function dataRuleConditionError(condition) {
+    const trimmed = condition.trim();
+    if (trimmed.length === 0)
+        return "条件为空";
+    const match = /^(\{[A-Za-z0-9_.]+\})\s+(\S+)(?:\s+([\s\S]+))?$/.exec(trimmed);
+    if (match === null)
+        return `条件「${condition}」必须是「{字段} 操作符 [值]」（如 {字段} 不为空 / {字段} 等于 {"valueType":"specifyOption","value":"A"}）`;
+    const [, , operator, value] = match;
+    if (!DATARULE_CONDITION_OPERATORS.has(operator))
+        return `操作符「${operator}」不在 bizdatarule 词表内（中文：等于/不等于/大于/小于/大于等于/小于等于/包含/包含全部/包含任意一个/等于任意一个/属于/为空/不为空…；也接受符号 == != > < >= <= Contains IsEmpty 等）`;
+    const unary = DATARULE_UNARY_OPERATORS.has(operator);
+    if (unary)
+        return value === undefined ? null : `「${operator}」是不带值的操作符，不应带值（收到：${value.slice(0, 30)}）`;
+    if (value === undefined)
+        return `「${operator}」需要值（JSON 对象或标量）`;
+    return null;
+}
+/** Validate a full bizdatarule condition string (multi via && / ||). */
+export function dataRuleConditionProtocolError(formula, options = {}) {
+    if (typeof formula !== "string" || formula.trim().length === 0)
+        return "必须是非空字符串";
+    if (options.allowTrue === true && formula.trim() === "true")
+        return null;
+    for (const group of formula.split(/\s*\|\|\s*/)) {
+        for (const condition of group.split(/\s*&&\s*/)) {
+            const error = dataRuleConditionError(condition);
+            if (error !== null)
+                return error;
+        }
+    }
+    return null;
+}
+/** Per-type option-shape validation for datarule.create/update. Returns a refusal message or null. */
+export function dataRuleOptionsShapeError(dataRuleType, options) {
+    if (dataRuleType === 4) {
+        if (typeof options.requiredFormula !== "string")
+            return "type4 必填规则必须有 options.requiredFormula";
+        return dataRuleConditionProtocolError(options.requiredFormula, { allowTrue: true });
+    }
+    if (dataRuleType === 5) {
+        if (typeof options.readonlyCondition !== "string")
+            return "type5 只读规则必须有 options.readonlyCondition";
+        // Unconditional readonly ("true"/functionType) is NOT reproduced yet — see
+        // the module comment; a tautological condition is the verified form.
+        return dataRuleConditionProtocolError(options.readonlyCondition);
+    }
+    if (dataRuleType === 3) {
+        if (typeof options.displayFormula !== "string")
+            return "type3 显示规则必须有 options.displayFormula";
+        return dataRuleConditionProtocolError(options.displayFormula);
+    }
+    return null;
+}
+//# sourceMappingURL=datarule-protocol.js.map