weaver-work-cli 0.1.5 → 0.1.7

package/dist/shortcuts/workflow/operations/form.js

@@ -0,0 +1,4159 @@
+/**
+ * workflow/form.ts - 发起流程（create）与修改流程表单（edit）的 7 个 operation。
+ *
+ * 移植自 Python skill e10_workflow_create.py（4,963 行），行为须与该脚本逐条对齐。
+ * 认证由 CLI 托管（host 注入会话），本文件不实现登录/缓存（verify_login_auth /
+ * atrust_cookie_diagnosis / get_runtime / state/create_contexts 一律丢弃）。
+ *
+ * 原 Python 用磁盘文件保存「上下文（context）」，本 TS 模块改用 continuation 令牌承载上下文：
+ *   createForm   -> 发出 continuation(operation=workflow.createForm) 内嵌表单上下文
+ *   createPrepare -> 校验该 continuation，产出预览 + 发出 continuation(operation=workflow.createPrepare)
+ *   createApply   -> 校验该 continuation，复核只读字段后 save+create
+ *   editLoad / editPrepare / editSave 同理（operation 分别为 workflow.editLoad / workflow.editPrepare）。
+ */
+import { randomUUID } from 'node:crypto';
+import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CONTINUATION, SCHEMA_CONFIRM, } from './types.js';
+import { responseData, toArray, withLeadingMeta, stdoutBytesOf, STDOUT_SAFE_BYTES, } from './shared.js';
+import { workflowValidationError, workflowApiError, workflowPartialError, workflowPolicyError, WorkflowCliError, } from '../errors.js';
+import { FORM_ENDPOINTS, AJAX_QUERY, formApiUrl } from '../endpoints.js';
+import { continuationReplayError } from '../continuation.js';
+import { writeStateFileBestEffort } from '../state.js';
+// ---------------------------------------------------------------------------
+// 常量（与 Python 源逐条对齐）
+// ---------------------------------------------------------------------------
+const TEXTAREA_COMPONENTS = new Set(['textarea', 'richtext', 'editor', 'html', 'htmltext']);
+const SELECT_COMPONENTS = new Set(['select', 'selectmultiple', 'radiobox', 'checkbox', 'radio', 'multiselect']);
+const BROWSER_COMPONENTS = new Set([
+    'employee', 'department', 'subcompany', 'jobtitle', 'job', 'relatebrowser',
+    'browser', 'workflow', 'ebuilder', 'customer', 'project',
+]);
+const NON_INPUT_COMPONENTS = new Set([
+    'paragraph', 'label', 'divider', 'option', 'detailtable', 'group', 'layout', 'internaltitle', 'multilingualtag',
+]);
+const READONLY_COMPONENTS = new Set([
+    'dividingline', 'paragraph', 'slidercomponent', 'button', 'subtablecontrol', 'mobileinteraction',
+]);
+/** 系统字段键：流程标题/紧急程度/密级；流程编号 REQUESTMARK 忽略不校验。 */
+const SYSTEM_FIELD_KEYS = {
+    REQUEST_NAMEL: '流程标题',
+    REQUEST_LEVEL: '紧急程度',
+    SECLEVEL: '密级',
+};
+/** 附件大小档位 0-5 对应 1/5/10/20/50/100MB；6/9 取同层 customAttmentSize（已修复 bug）。 */
+const ATTACH_SIZE_LIMIT_STEPS_MB = [1, 5, 10, 20, 50, 100];
+const CONTINUATION_TTL_MS = 10 * 60 * 1000;
+/**
+ * `fields` 的紧凑编码（通用）。
+ *
+ * 字段多的表单里，`fields` 的键名要重复 N 次；pretty 输出下每个字段还会占掉 4~6 行缩进
+ * —— 实测某 278 字段的表单 `fields` 占 35.8KB，其中键名 + 缩进比真实数据还多。这里改成
+ * "一行一个字段、列用 `|` 分隔"的字符串数组：省掉重复键名，也只占一行缩进。
+ *
+ *   "columns": ["id","name","subFormId","componentKey"],
+ *   "rows": ["856266610411798602|Cost Bearer||MultiContent", …],
+ *   "extra": { "<字段id>": { "required": true, "isBrowser": true, "options": [ … ] } }
+ *
+ * 非列信息（required / readOnly / isBrowser / options / fileUploadParams…）条目少，
+ * 仍按字段 id 登记在 `extra`。信息不丢：完整结构写在 resultFile，这里只是换一种编码。
+ */
+function encodeFieldsCompact(fields) {
+    const columns = ['id', 'name', 'subFormId', 'componentKey'];
+    const cell = (value) => String(value === undefined || value === null ? '' : value).replace(/[|\r\n]/g, ' ');
+    const rows = fields.map((field) => columns.map((col) => cell(field?.[col])).join('|'));
+    const extra = {};
+    for (const field of fields) {
+        if (!field || typeof field !== 'object')
+            continue;
+        const rest = {};
+        for (const [key, value] of Object.entries(field)) {
+            if (!columns.includes(key))
+                rest[key] = value;
+        }
+        if (Object.keys(rest).length)
+            extra[String(field.id ?? '')] = rest;
+    }
+    return { columns, rows, rowCount: rows.length, extra };
+}
+/**
+ * `fields` 被整体移出 stdout 时的补偿索引（V12.1.34）。
+ *
+ * 极端档（`fieldsOmitted`）此前只留 `requiredFields` / `subFormRequired` / `editableFields`
+ * 三个**纯 id 数组**，模型拿不到「字段名 ↔ 字段 id」的对应关系，只能自己写脚本去 resultFile 里挖
+ * （实测某次会话为此多写 3 个脚本、3 次被 head 截断，白花 6 次工具往返）。
+ * 这里补一份**只含可写字段**的紧凑索引（行 = `id|name|subFormId|componentKey|flags`），
+ * 体积很小（某 278 字段表单实测 3.7KB，其余字段 17.5KB，合计 21.2KB < 安全线），
+ * 足以让模型直接构造 `data` 的键；更细的元数据（browserModule / fileUploadParams / 完整 options）
+ * 仍按字段 id 去 resultFile 取。纯结构裁剪，不做任何语义判断。
+ *
+ * @param writableIds   可写字段 id（含系统字段），顺序即输出顺序的同构子集
+ * @param sourceFields  字段来源（createForm 传可见字段原对象；editLoad 传 slimFields）
+ * @param systemNames   系统字段 id → 中文名（不在 sourceFields 里的兜底）
+ */
+function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
+    const byId = new Map();
+    for (const f of sourceFields)
+        byId.set(String(f?.id ?? ''), f);
+    const cell = (value) => String(value === undefined || value === null ? '' : value).replace(/[|\r\n]/g, ' ');
+    const flagsOf = (f) => {
+        const component = String(f.componentKey ?? '').toLowerCase();
+        let flags = '';
+        if (f.required)
+            flags += 'R';
+        if (f.isBrowser)
+            flags += 'B';
+        if (f.isSelect)
+            flags += 'S';
+        if (f.isMultiple)
+            flags += 'M';
+        if (component === 'employeescope')
+            flags += 'E';
+        if (component === 'einvoicecomponent')
+            flags += 'V';
+        if (f.folderDependsOnOption)
+            flags += 'D';
+        if (f.fileUploadParams)
+            flags += 'F';
+        if (Array.isArray(f.options) && f.options.length)
+            flags += 'O';
+        if (String(f.format ?? '').trim())
+            flags += 'T';
+        return flags;
+    };
+    const rows = [];
+    const optionIndex = {};
+    const emitted = new Set();
+    const push = (id) => {
+        if (emitted.has(id))
+            return;
+        emitted.add(id);
+        const f = byId.get(id);
+        if (!f) {
+            rows.push([id, systemNames[id] || '', '', '', ''].map(cell).join('|'));
+            return;
+        }
+        rows.push([id, f.name, f.subFormId, f.componentKey, flagsOf(f)].map(cell).join('|'));
+        const options = Array.isArray(f.options) ? f.options : [];
+        if (options.length) {
+            optionIndex[id] = options.slice(0, 30).map((o) => (o && typeof o === 'object' ? String(o.name ?? o.content ?? '') : String(o)));
+        }
+    };
+    const wanted = new Set(writableIds);
+    for (const f of sourceFields) {
+        const id = String(f?.id ?? '');
+        if (wanted.has(id))
+            push(id);
+    }
+    for (const id of writableIds)
+        push(id);
+    const out = {
+        columns: ['id', 'name', 'subFormId', 'componentKey', 'flags'],
+        rows,
+        rowCount: rows.length,
+        flagLegend: 'R=必填 B=浏览按钮 S=选项 M=多选 E=人员范围 V=发票 D=附件目录随选项 '
+            + 'F=有上传参数(见 resultFile) O=有选项(见 optionIndex) T=有日期/时间格式要求',
+    };
+    if (Object.keys(optionIndex).length)
+        out.optionIndex = optionIndex;
+    return out;
+}
+/**
+ * 大表单输出保护（通用，不针对任何具体工作流/表单）。
+ *
+ * 字段多的表单，`createForm` / `editLoad` 的输出能轻松超过 60KB，会被宿主截断成 2KB 预览；
+ * 模型于是写脚本读回、读回又被截断，白花好几轮工具往返（实测某次会话为此多花 5 次）。这里
+ * 对齐 `todoStat` 的做法：超安全线时把**完整结果**写入 resultFile，stdout 只回精简版并前置
+ * `resultFile`（放最前，被截断也看得见），同时把 `fields` 换成列式编码。
+ *
+ * 落盘不可用时保持全量输出（宁大不丢数据），只补一句说明。
+ *
+ * V12.1.34：入口可传 `fieldsOmittedCompensation`（可写字段紧凑索引）。它**只在 `fields` 真的被
+ * 整体移出 stdout 时**才随摘要一起产出 —— 紧凑编码那一档 `fields` 仍在，模型本来就能读到字段名，
+ * 不需要重复体积；小表单（未超线）完全不产出，避免无谓地把输出顶到安全线上。
+ */
+/** 读取本输出的统一叮嘱（紧凑版与兜底版共用）。 */
+const READ_WHOLE_OUTPUT_HINT = '读取本输出请一次读完：不要用 head/tail 等管道截断'
+    + '（截断会破坏 JSON，并导致重复执行同一条命令）；本输出被截断读不全时直接读 resultFile，不要重跑本命令。';
+async function compactFormOutput(result, env, resultFileName, fieldsOmittedCompensation) {
+    const bytes = stdoutBytesOf(result);
+    if (bytes <= STDOUT_SAFE_BYTES)
+        return result;
+    const fields = toArray(result.fields);
+    const resultFile = await writeStateFileBestEffort(resultFileName, JSON.stringify(result, null, 2), env.ctx);
+    if (!resultFile) {
+        return {
+            ...result,
+            outputBytes: bytes,
+            largeOutputNotice: `表单字段较多（${fields.length} 个）且本地落盘不可用，已按原样返回全量 fields。`
+                + READ_WHOLE_OUTPUT_HINT,
+        };
+    }
+    const compact = withLeadingMeta({
+        resultFile,
+        persistedResult: true,
+        outputBytes: bytes,
+        largeOutputNotice: `表单字段较多（${fields.length} 个），完整结果已写入 resultFile。`
+            + 'stdout 里的 fields 是紧凑编码：columns 为列名，rows 每行一个字段、各列用 "|" 分隔'
+            + '（顺序与 columns 一致），extra 按字段 id 存放非列信息'
+            + '（required / readOnly / disableEdit / isBrowser / isSelect / isMultiple / browserModule /'
+            + ' browserType / options / fileUploadParams 等；未出现在 extra 里的字段即为默认值）。'
+            + '需要某字段的完整原始元数据时，从 resultFile 里按该字段 id 取。'
+            + 'resultFile 是完整 pretty JSON、体积很大，请用脚本按需提取，不要整份读入上下文。'
+            + READ_WHOLE_OUTPUT_HINT,
+    }, {
+        ...result,
+        fields: encodeFieldsCompact(fields),
+    });
+    if (stdoutBytesOf(compact) <= STDOUT_SAFE_BYTES)
+        return compact;
+    // 极端兜底（字段极多的表单，紧凑编码也压不进安全线）：stdout 只留指针 + 摘要，
+    // 字段清单去 resultFile 按需提取 —— 否则整段输出会被宿主截成 2KB 预览，等于什么都没拿到。
+    // V12.1.34：随摘要附上**可写字段补偿索引**，模型不必再自己写脚本挖 resultFile。
+    // V12.1.35（实测 278 字段表单：美化 37,887 B → ≈17 KB，落进宿主 28 KB 内联区）：
+    //  ① 安全线改用**美化口径** `stdoutBytesOf()`（与实际 stdout 一致）。此前量压缩 JSON，**低估 1.79 倍**
+    //     ⇒ 这一档从未触发，且 `writableFields` 被追加在末尾（起始偏移 31,093），宿主只给 2048 B 预览
+    //     ⇒ 模型永远看不到它，只能自写脚本挖 resultFile（实测白烧 4 轮工具往返、约 54 s）。
+    //  ② `conditionalRequired`（278 字段表单实测压缩 10.9 KB / 美化 ≈19.5 KB）与 `editableFields`
+    //     （与 writableFields 冗余）移出 stdout，只留条数 —— 二者合起来才够把体积压进宿主内联区。
+    //  ③ `writableFields` 前置到载荷最前，任何截断场景下都先被看到。
+    const condCount = Array.isArray(result.conditionalRequired) ? result.conditionalRequired.length : 0;
+    const summary = { ...result };
+    delete summary.fields;
+    delete summary.conditionalRequired;
+    delete summary.editableFields;
+    const ordered = {};
+    if (fieldsOmittedCompensation)
+        ordered.writableFields = fieldsOmittedCompensation;
+    for (const [key, value] of Object.entries(summary)) {
+        if (value !== undefined)
+            ordered[key] = value;
+    }
+    const fieldsOmittedNotice = `表单字段过多（${fields.length} 个），字段清单已整体移出 stdout，`
+        + '完整结果（含全部 fields 原始元数据）已写入 resultFile。'
+        + (fieldsOmittedCompensation
+            ? 'stdout **最前面**已给出全部可写字段的紧凑索引 writableFields：columns 为列名、rows 每行一个字段'
+                + '（`id|name|subFormId|componentKey|flags`，flags 含义见 flagLegend；带选项的字段，'
+                + '其选项名见 optionIndex）。**直接用 writableFields 里的字段 id 构造 data 的键**，'
+                + '不要为了拿字段清单再写脚本解析 resultFile；只有需要某字段更细的元数据'
+                + '（browserModule / fileUploadParams / 完整 options 结构）时，才按该字段 id 从 resultFile 取。'
+            : '构造表单数据前，请按字段 id 从 resultFile 里提取所需键，按需只取几个键、'
+                + '不要把整份 resultFile 读入上下文。')
+        + (condCount
+            ? `为压进体积安全线，条件必填规则（conditionalRequired，${condCount} 条）与可写白名单`
+                + '（editableFields）也已移出 stdout（条数见 conditionalRequiredCount）；'
+                + '需要时按同一个 resultFile 取。'
+            : '')
+        + READ_WHOLE_OUTPUT_HINT;
+    const leadingMeta = {
+        resultFile,
+        persistedResult: true,
+        outputBytes: bytes,
+        fieldsOmitted: true,
+        fieldCount: fields.length,
+        ...(condCount ? { conditionalRequiredCount: condCount } : {}),
+        largeOutputNotice: fieldsOmittedNotice,
+    };
+    const withIndex = withLeadingMeta(leadingMeta, ordered);
+    if (stdoutBytesOf(withIndex) <= STDOUT_SAFE_BYTES)
+        return withIndex;
+    // 索引也放不进安全线（字段数量极端）：退回只留指针，并显式标注已省略。
+    delete ordered.writableFields;
+    return withLeadingMeta({
+        ...leadingMeta,
+        ...(fieldsOmittedCompensation ? { writableFieldsOmitted: true } : {}),
+    }, ordered);
+}
+async function requestJson(env, method, path, query, body) {
+    const response = await env.host.workflowRequest({ method, path, query, body, operation: path });
+    return responseData(response);
+}
+async function getSessionContext(env) {
+    const session = await env.host.getSession();
+    return { baseUrl: session.baseUrl, profile: session.profile, userId: session.userId };
+}
+/** 校验 continuation 的上下文绑定与当前会话一致（baseUrl/profile/userId）。 */
+async function verifyContextLease(env, token, expectedOperation, consumeOnVerify = false) {
+    const lease = await env.continuation.verify(token, expectedOperation);
+    const session = await getSessionContext(env);
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw workflowValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 createForm/editLoad');
+    }
+    // apply 阶段才消费（一次性防重放）；prepare 阶段可重试、不写业务数据，不消费。
+    if (consumeOnVerify) {
+        const claim = await env.continuation.consume(token, expectedOperation);
+        // 抢不到说明已有（并发的）执行占用该句柄：**不得再写入**，并按占用状态给出可执行的处置说明。
+        if (!claim.claimed)
+            throw continuationReplayError(claim.previous ?? { state: 'unknown' }, expectedOperation);
+        // 登记本次执行的句柄：写请求发出前据此推进阶段，避免"死在写入途中"被误判成可安全重占。
+        env.activeContinuation = token;
+    }
+    return lease;
+}
+function isNetworkError(error) {
+    return error instanceof WorkflowCliError && error.type === 'network';
+}
+// ---------------------------------------------------------------------------
+// 原始布局 walk（收集 {fieldId: raw} 供附件限制解析，独立于 extractFields）
+// ---------------------------------------------------------------------------
+function walkLayoutRawFields(layoutRoot) {
+    const result = {};
+    const walk = (value) => {
+        if (Array.isArray(value)) {
+            for (const child of value)
+                walk(child);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        const fieldId = String(value.fieldId ?? '').trim();
+        const component = String(value.componentKey ?? value.type ?? '').trim();
+        if (fieldId && component) {
+            const previous = result[fieldId];
+            if (previous === undefined || Object.keys(value).length > Object.keys(previous).length) {
+                result[fieldId] = value;
+            }
+        }
+        for (const child of Object.values(value))
+            walk(child);
+    };
+    walk(layoutRoot);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// runtime / frame / minor 解析
+// ---------------------------------------------------------------------------
+function parseRuntime(data, workflowId) {
+    if (!data || typeof data !== 'object')
+        throw workflowApiError('format_error', 'loadBaseParam 未返回 data');
+    const common = data.commonParam;
+    if (!common || typeof common !== 'object')
+        throw workflowApiError('format_error', 'loadBaseParam 未返回 commonParam');
+    const currentUser = (common.currentUser && typeof common.currentUser === 'object') ? common.currentUser : {};
+    const employeeId = String(currentUser.userId ?? '');
+    if (!employeeId)
+        throw workflowApiError('format_error', '缺少 commonParam.currentUser.userId');
+    const requestInfo = (data.requestInfo && typeof data.requestInfo === 'object') ? data.requestInfo : {};
+    const requestName = String(requestInfo.requestName ?? '').trim();
+    const requestLevel = requestInfo.requestLevel === null || requestInfo.requestLevel === undefined ? '' : String(requestInfo.requestLevel).trim();
+    const secLevel = requestInfo.secLevel === null || requestInfo.secLevel === undefined ? '' : String(requestInfo.secLevel).trim();
+    return {
+        request_id: String(common.requestId ?? ''),
+        node_id: String(common.userCurrentNodeId ?? common.fixedNodeId ?? ''),
+        employee_id: employeeId,
+        identity_id: String(common.identityId ?? employeeId),
+        identity_type: Number(common.identityType ?? 0),
+        current_user_name: String(currentUser.userName ?? ''),
+        auth_str: String(common.authStr ?? ''),
+        auth_signature: String(common.authSignatureStr ?? ''),
+        workflow_id: workflowId,
+        workflow_name: String(requestInfo.workflowName ?? ''),
+        workflow_description: String(requestInfo.workflowDesc ?? ''),
+        workflow_type_name: String(requestInfo.workflowTypeName ?? ''),
+        default_request_name: requestName,
+        default_request_level: requestLevel,
+        default_sec_level: secLevel,
+    };
+}
+function parseFrame(data, nodeId) {
+    if (!data || typeof data !== 'object')
+        throw workflowApiError('format_error', 'loadFrameParam 未返回 data');
+    const configs = data.formConfig;
+    if (!Array.isArray(configs) || configs.length !== 1 || !configs[0] || typeof configs[0] !== 'object') {
+        throw workflowApiError('format_error', 'loadFrameParam 返回的表单配置不是唯一项');
+    }
+    const config = configs[0];
+    const formInfo = (config.formInfo && typeof config.formInfo === 'object') ? config.formInfo : {};
+    const formId = String(formInfo.relateKey ?? '');
+    if (!formId)
+        throw workflowApiError('format_error', '缺少 formConfig.formInfo.relateKey');
+    const relateType = String(formInfo.relateType ?? '').trim() || 'WEA_FORM';
+    const viewNodeId = String(config.viewFormNodeId ?? nodeId);
+    if (!viewNodeId)
+        throw workflowApiError('format_error', '缺少 formConfig.viewFormNodeId');
+    if (viewNodeId !== nodeId)
+        throw workflowApiError('format_error', 'loadBaseParam 与 loadFrameParam 返回了不同节点');
+    const ts = String(config.timestamp ?? '').match(/^\d+$/) ? Number(config.timestamp) : Date.now();
+    return {
+        form_id: formId,
+        relate_type: relateType,
+        permission_id: String(config.permissionId ?? '').trim(),
+        permission_type: Number(config.permissionType ?? 1),
+        layout_multi_id: String(config.layoutMultiId ?? config.defaultLayoutId ?? ''),
+        new_layout: config.newLayout !== false,
+        sys_field_new_mode: config.sysFieldNewMode !== false,
+        view_form_node_id: viewNodeId,
+        timestamp: ts,
+        // enableNodePermission=false ⇒ 该表单未启用节点权限：字段属性只由表单设计决定，
+        // 不带顶层 permissionId 才能拿到 viewRelateConfig（静态必填/只读/禁止编辑）。
+        // 缺省（服务端未返回该字段）视为启用，保持既有行为。
+        enable_node_permission: config.enableNodePermission !== false,
+    };
+}
+function parseMinorInfo(data) {
+    if (!data || typeof data !== 'object') {
+        return { permissions: {}, level_options: [], sec_level_options: [], sec_default_id: '' };
+    }
+    const permissions = {};
+    const sysPermission = (data.sysFieldPermission && typeof data.sysFieldPermission === 'object') ? data.sysFieldPermission : {};
+    for (const key of Object.keys(SYSTEM_FIELD_KEYS)) {
+        const item = sysPermission[key];
+        if (item && typeof item === 'object') {
+            permissions[key] = {
+                isview: Boolean(item.isview),
+                isedit: Boolean(item.isedit),
+                ismandatory: Boolean(item.ismandatory),
+            };
+        }
+    }
+    const levelOptions = [];
+    for (const item of data.customLevelList || []) {
+        if (!item || typeof item !== 'object')
+            continue;
+        if (item.closed === true)
+            continue;
+        const customName = String(item.customName ?? '').trim();
+        const defaultName = String(item.defaultName ?? '').trim();
+        const display = customName || defaultName;
+        if (display)
+            levelOptions.push({ code: item.code, name: display });
+    }
+    const secLevelOptions = [];
+    let defaultSecLevelId = '';
+    const params = (data.params && typeof data.params === 'object') ? data.params : {};
+    for (const item of params.secLevelOption || []) {
+        if (!item || typeof item === 'object')
+            continue;
+        const id = String(item.id ?? '').trim();
+        if (!id)
+            continue;
+        secLevelOptions.push({ id, name: String(item.name ?? '').trim() });
+        if (!defaultSecLevelId) {
+            const isDefault = item.isDefault === true || String(item.isDefault ?? '').trim().toLowerCase() === '1' || String(item.isDefault ?? '').trim().toLowerCase() === 'true';
+            if (isDefault)
+                defaultSecLevelId = id;
+        }
+    }
+    return { permissions, level_options: levelOptions, sec_level_options: secLevelOptions, sec_default_id: defaultSecLevelId };
+}
+function parseTenantSetting(data) {
+    if (!data || typeof data !== 'object')
+        return {};
+    const maxSizeText = String(data.sysMaxSingleUploadSize ?? '').trim();
+    let maxSizeMb = 0;
+    try {
+        maxSizeMb = parseInt(maxSizeText, 10);
+        if (Number.isNaN(maxSizeMb))
+            maxSizeMb = 0;
+    }
+    catch {
+        maxSizeMb = 0;
+    }
+    const whitesEnable = data.sysFormatWhitesEnable === true;
+    const formatText = String(data[whitesEnable ? 'sysFormatWhites' : 'sysFormatBlacks'] ?? '');
+    const formats = formatText.split(',').map((p) => p.trim().toLowerCase()).filter((p) => p);
+    if (maxSizeMb <= 0 && formats.length === 0)
+        return {};
+    return { max_size_mb: maxSizeMb, format_mode: whitesEnable ? 'white' : 'black', formats };
+}
+/**
+ * build_layout_request：customParam 逐字段对齐。
+ *
+ * 顶层 permissionId 的带与不带，由 `loadFrameParam.formConfig[0].enableNodePermission` 决定
+ * （2026-09-17 实测定案，同一租户 OA 10.0.2607.01）：
+ * - 该表单**启用了节点权限**（`true`/缺省）→ 带上 `permissionId`，拿到的是该节点的真实字段权限；
+ *   不带时业务字段会被返回成 `readOnly=true`（mulinquan 公文zc 实测：5 字段全只读、`editableFields: []`）。
+ * - 该表单**未启用节点权限**（`false`）→ 不带。此时带上（服务端给的哨兵值 `-1`）会让服务端把
+ *   `viewRelateConfig` 返回成空数组、布局里只剩 1 个 `required=true`（流程标题），
+ *   静态必填/只读/禁止编辑信息全丢（实测：`requiredFields` 由 11 个业务字段掉到 `["REQUEST_NAMEL"]`，
+ *   只读字段 35→0）；不带时拿到的才是表单设计级的真实属性。
+ */
+function buildLayoutRequest(workflowId, runtime, frame) {
+    const custom = {
+        permissionType: frame.permission_type,
+        requestId: runtime.request_id,
+        workflowId,
+        nodeId: runtime.node_id,
+        authSignatureStr: runtime.auth_signature,
+        authStr: runtime.auth_str,
+        readOnly: false,
+        identityId: runtime.identity_id,
+        identityType: runtime.identity_type,
+        isTest: false,
+        create: true,
+        mobile: false,
+        formId: frame.form_id,
+        source: 'view',
+        isAgent: false,
+        beAgentId: '0',
+        hideSysFieldArea: true,
+        viewFormNodeId: frame.view_form_node_id,
+        timestamp: frame.timestamp,
+        turnTodoUser: [],
+        sysFieldNewMode: frame.sys_field_new_mode,
+    };
+    const permissionId = String(frame.permission_id ?? '').trim();
+    // 未启用节点权限的表单（enableNodePermission=false）不带 permissionId：带了会丢静态必填/只读属性。
+    const nodePermissionEnabled = frame.enable_node_permission !== false;
+    return {
+        terminalType: 'PC',
+        formId: frame.form_id,
+        ...(nodePermissionEnabled && permissionId ? { permissionId } : {}),
+        module: 'workflow',
+        customParam: custom,
+        cacheUid: randomUUID(),
+        newLayout: frame.new_layout,
+        layoutMultiId: frame.layout_multi_id,
+        dataCrossLayout: false,
+        employeeId: runtime.employee_id,
+        refId: workflowId,
+        initialDatas: [
+            { keyType: null, key: 'isCreate', value: 1 },
+            { keyType: null, key: 'isMobile', value: 0 },
+        ],
+        cost: false,
+        effectValues: [workflowId, runtime.node_id],
+        orgAsyncPageQuery: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// 字段提取（extractFields）
+// ---------------------------------------------------------------------------
+function extractFields(layoutData, requiredMap, disableEditMap, displayMap) {
+    const candidates = {};
+    const walk = (value) => {
+        if (Array.isArray(value)) {
+            for (const child of value)
+                walk(child);
+            return;
+        }
+        if (!value || typeof value !== 'object')
+            return;
+        const fieldId = String(value.fieldId ?? '').trim();
+        const component = String(value.componentKey ?? value.type ?? '').trim();
+        if (fieldId && component) {
+            const previous = candidates[fieldId];
+            if (previous === undefined || Object.keys(value).length > Object.keys(previous).length) {
+                candidates[fieldId] = value;
+            }
+        }
+        for (const child of Object.values(value))
+            walk(child);
+    };
+    walk(layoutData.formLayout);
+    const result = [];
+    for (const fieldId of Object.keys(candidates)) {
+        const raw = candidates[fieldId];
+        const component = String(raw.componentKey ?? raw.type ?? '');
+        const normalized = component.toLowerCase();
+        if (NON_INPUT_COMPONENTS.has(normalized) || normalized.startsWith('flowpagesysfield'))
+            continue;
+        const browserType = (raw.browserType && typeof raw.browserType === 'object') ? raw.browserType : {};
+        const options = [];
+        for (const option of raw.options || []) {
+            if (!option || typeof option !== 'object')
+                continue;
+            const optionId = String(option.valueKey ?? option.selectionId ?? option.id ?? '').trim();
+            const name = String(option.name ?? option.content ?? '').trim();
+            if (optionId && name)
+                options.push({ id: optionId, name });
+        }
+        // 注意：browserType 上面已归一化成对象（缺省 `{}`），而 **JS 的 `Boolean({})` 恒为 true**
+        // （Python 的 `bool({})` 为 False）——直接照抄 Python 的 `bool(browser_type)` 会让**每个字段**
+        // 都被判成浏览按钮字段，文本/富文本字段随之走 name→ID 解析并报 BROWSER NOT_FOUND，
+        // 内容永远写不进去（2026-09-16「内部留言」留言内容字段实证）。必须判"非空对象"。
+        const isBrowser = Object.keys(browserType).length > 0 || BROWSER_COMPONENTS.has(normalized);
+        const isSelect = SELECT_COMPONENTS.has(normalized) || options.length > 0;
+        result.push({
+            id: fieldId,
+            name: String(raw.title ?? raw.name ?? raw.dataKey ?? fieldId),
+            componentKey: component,
+            required: (requiredMap[fieldId] !== undefined) ? requiredMap[fieldId] : Boolean(raw.required || raw.mustInput),
+            disableEdit: (disableEditMap[fieldId] !== undefined) ? disableEditMap[fieldId] : Boolean(raw.disableEdit),
+            readOnly: Boolean(READONLY_COMPONENTS.has(normalized) || raw.readOnly),
+            display: (displayMap[fieldId] !== undefined) ? displayMap[fieldId] : (raw.display !== undefined ? raw.display : true),
+            formId: String(raw.formId ?? (layoutData.form && layoutData.form.id) ?? ''),
+            subFormId: String(raw.subFormId ?? ''),
+            isBrowser,
+            isSelect,
+            isMultiple: Boolean(SELECT_COMPONENTS.has(normalized) && (normalized === 'selectmultiple' || normalized === 'checkbox' || normalized === 'multiselect'))
+                || (isBrowser && raw.isSingle === false),
+            browserModule: String(browserType.module ?? raw.browserModule ?? ''),
+            browserType: String(browserType.type ?? browserType.id ?? raw.browserTypeCode ?? ''),
+            options,
+            maxLength: raw.maxLen !== undefined ? raw.maxLen : raw.maxlen,
+            richEditor: Boolean(raw.richEditor),
+            showOrder: raw.showOrder !== undefined ? raw.showOrder : 0,
+            format: String(raw.format ?? raw.formatPattern ?? ''),
+            placeholder: String(raw.placeholder ?? ''),
+            defaultExtend: (raw.defaultExtend && typeof raw.defaultExtend === 'object') ? raw.defaultExtend : null,
+            typeLen: raw.typeLen !== undefined ? raw.typeLen : raw.typeLength,
+            columnType: String(raw.columnType ?? ''),
+        });
+    }
+    result.sort((a, b) => {
+        if (Boolean(a.subFormId) !== Boolean(b.subFormId))
+            return a.subFormId ? 1 : -1;
+        if (a.subFormId !== b.subFormId)
+            return a.subFormId < b.subFormId ? -1 : 1;
+        const sa = Number(a.showOrder || 0);
+        const sb = Number(b.showOrder || 0);
+        if (sa !== sb)
+            return sa - sb;
+        if (a.name !== b.name)
+            return a.name < b.name ? -1 : 1;
+        return a.id < b.id ? -1 : 1;
+    });
+    return result;
+}
+function normalizeDetail(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const formField = (raw.formField && typeof raw.formField === 'object') ? raw.formField : {};
+    const fieldId = String(formField.id ?? raw.fieldId ?? '').trim();
+    if (!fieldId)
+        return {};
+    const detail = { formField: { id: fieldId } };
+    if (raw.content !== undefined && raw.content !== null)
+        detail.content = String(raw.content);
+    const dataText = raw.dataText;
+    if (dataText && typeof dataText === 'object' && dataText.content !== undefined && dataText.content !== null) {
+        detail.dataText = { content: String(dataText.content) };
+    }
+    const options = raw.dataOptions;
+    if (Array.isArray(options)) {
+        const normalizedOptions = [];
+        for (const item of options) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const option = {
+                optionId: String(item.optionId ?? item.id ?? ''),
+                content: String(item.content ?? item.name ?? ''),
+            };
+            const scopeType = String(item.type ?? '').trim();
+            if (scopeType)
+                option.type = scopeType;
+            if (item.optionObj && typeof item.optionObj === 'object')
+                option.optionObj = item.optionObj;
+            normalizedOptions.push(option);
+        }
+        detail.dataOptions = normalizedOptions;
+    }
+    for (const key of ['dataIndex', 'rowId']) {
+        if (raw[key] !== undefined && raw[key] !== null)
+            detail[key] = raw[key];
+    }
+    const subForm = (raw.subForm && typeof raw.subForm === 'object') ? raw.subForm : null;
+    const subFormId = String(raw.subFormId ?? (subForm && subForm.id) ?? '').trim();
+    if (subFormId)
+        detail.subForm = { id: subFormId };
+    return detail;
+}
+function hasDetailValue(detail) {
+    if (String(detail.content ?? '').trim())
+        return true;
+    if (String((detail.dataText && detail.dataText.content) ?? '').trim())
+        return true;
+    return (detail.dataOptions || []).some((item) => String(item.optionId ?? '').trim());
+}
+function normalizeDefaults(value) {
+    if (!Array.isArray(value))
+        return [];
+    const result = [];
+    for (const raw of value) {
+        const detail = normalizeDetail(raw);
+        if (detail && hasDetailValue(detail))
+            result.push(detail);
+    }
+    return result;
+}
+function slimFieldInfo(field) {
+    let options = field.options || [];
+    let truncated = false;
+    if (options.length > 30) {
+        options = options.slice(0, 30);
+        truncated = true;
+    }
+    const slim = {
+        id: field.id,
+        name: field.name,
+        componentKey: field.componentKey,
+        required: field.required,
+        isBrowser: field.isBrowser,
+        isSelect: field.isSelect,
+        isMultiple: field.isMultiple,
+        browserType: field.browserType || '',
+        browserModule: field.browserModule || '',
+        options,
+        format: field.format || '',
+        placeholder: field.placeholder || '',
+        typeLen: field.typeLen,
+    };
+    if (slim.format && ['datecomponent', 'datetimecomponent', 'timecomponent', 'dateinterval'].includes(String(field.componentKey ?? '').toLowerCase())) {
+        slim.formatHint = `格式: ${slim.format}，必须按此格式传值`;
+    }
+    if (truncated)
+        slim.optionsTruncated = true;
+    return slim;
+}
+function requiredFieldsWithSystem(formRequired, runtime, sysPermissions) {
+    const ids = formRequired.map((f) => String(f.id ?? ''));
+    for (const sysKey of Object.keys(SYSTEM_FIELD_KEYS)) {
+        const perm = sysPermissions[sysKey] || {};
+        if (perm.isview && perm.ismandatory)
+            ids.push(sysKey);
+    }
+    return ids;
+}
+// ---------------------------------------------------------------------------
+// 附件上传限制解析
+// ---------------------------------------------------------------------------
+function _attachDirLayer(rawFileField, attachConfig) {
+    if (rawFileField && typeof rawFileField === 'object' && String(rawFileField.folderType ?? '').trim() === '1') {
+        return [rawFileField, true];
+    }
+    return [(attachConfig && typeof attachConfig === 'object') ? attachConfig : {}, false];
+}
+function _rawUploadFieldsMap(rawFieldsById, attachConfigs) {
+    const result = {};
+    if (!rawFieldsById || typeof rawFieldsById !== 'object')
+        return result;
+    attachConfigs = (attachConfigs && typeof attachConfigs === 'object') ? attachConfigs : {};
+    for (const fid of Object.keys(rawFieldsById)) {
+        const raw = rawFieldsById[fid];
+        if (!raw || typeof raw !== 'object')
+            continue;
+        if (String(raw.componentKey ?? '').toLowerCase() !== 'filecomponent')
+            continue;
+        const [layer] = _attachDirLayer(raw, attachConfigs[fid]);
+        const optionFid = String(layer.optionId ?? '').trim();
+        if (String(layer.folderSelectType ?? '').trim() !== '1' || !optionFid)
+            continue;
+        result[fid] = raw;
+        if (optionFid in rawFieldsById)
+            result[optionFid] = rawFieldsById[optionFid];
+    }
+    return result;
+}
+function _valueTokens(value) {
+    const tokens = [];
+    const add = (raw) => {
+        if (raw === undefined || raw === null)
+            return;
+        const text = String(raw).trim();
+        if (text && !tokens.includes(text))
+            tokens.push(text);
+    };
+    if (value && typeof value === 'object') {
+        for (const item of value.dataOptions || []) {
+            if (!item || typeof item !== 'object')
+                continue;
+            for (const key of ['optionId', 'id', 'valueKey', 'selectionId'])
+                add(item[key]);
+            for (const key of ['content', 'name'])
+                add(item[key]);
+        }
+        for (const key of ['content', 'name', 'value', 'optionId', 'id', 'valueKey', 'selectionId'])
+            add(value[key]);
+    }
+    else {
+        add(value);
+    }
+    return tokens;
+}
+function resolveOptionFolderId(optionFieldRaw, selectedValue) {
+    if (!optionFieldRaw || typeof optionFieldRaw !== 'object')
+        return null;
+    const rawOptions = optionFieldRaw.options;
+    if (!Array.isArray(rawOptions))
+        return null;
+    const tokens = _valueTokens(selectedValue);
+    if (!tokens.length)
+        return null;
+    const flat = [];
+    const collect = (items) => {
+        if (!Array.isArray(items))
+            return;
+        for (const item of items) {
+            if (item && typeof item === 'object') {
+                flat.push(item);
+                collect(item.children);
+            }
+        }
+    };
+    collect(rawOptions);
+    const catalogueId = (option) => {
+        const catalogue = option.catalogue;
+        if (catalogue && typeof catalogue === 'object') {
+            const id = String(catalogue.catalogueId ?? '').trim();
+            if (id)
+                return id;
+        }
+        return null;
+    };
+    const idKeys = (option) => {
+        const keys = [];
+        for (const key of ['valueKey', 'selectionId', 'optionId', 'id']) {
+            if (option[key] !== undefined && option[key] !== null && String(option[key]).trim())
+                keys.push(String(option[key]).trim());
+        }
+        return keys;
+    };
+    const idMatches = [];
+    const nameMatches = [];
+    for (const option of flat) {
+        const iks = idKeys(option);
+        const names = [];
+        for (const key of ['content', 'name']) {
+            if (option[key] !== undefined && option[key] !== null && String(option[key]).trim())
+                names.push(String(option[key]).trim());
+        }
+        if (iks.some((k) => tokens.includes(k)))
+            idMatches.push(option);
+        else if (names.some((n) => tokens.includes(n)))
+            nameMatches.push(option);
+    }
+    if (idMatches.length === 1)
+        return catalogueId(idMatches[0]);
+    if (!idMatches.length && nameMatches.length === 1)
+        return catalogueId(nameMatches[0]);
+    return null;
+}
+function _attachmentFolderIds(rawUploadFields, attachConfigs, fields, valueByFid) {
+    const result = {};
+    if (!rawUploadFields || typeof rawUploadFields !== 'object' || !Array.isArray(fields))
+        return result;
+    attachConfigs = (attachConfigs && typeof attachConfigs === 'object') ? attachConfigs : {};
+    for (const field of fields) {
+        if (!field || typeof field !== 'object')
+            continue;
+        if (String(field.subFormId ?? '').trim())
+            continue;
+        if (String(field.componentKey ?? '').toLowerCase() !== 'filecomponent')
+            continue;
+        const fid = String(field.id ?? '').trim();
+        const raw = rawUploadFields[fid];
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const [layer] = _attachDirLayer(raw, attachConfigs[fid]);
+        const optionFieldId = String(layer.optionId ?? '').trim();
+        if (String(layer.folderSelectType ?? '').trim() !== '1' || !optionFieldId)
+            continue;
+        const optionRaw = rawUploadFields[optionFieldId];
+        const selected = valueByFid[optionFieldId];
+        result[fid] = resolveOptionFolderId(optionRaw, selected);
+    }
+    return result;
+}
+function resolveFileUploadConstraints(rawField, tenantSetting, attachConfig, optionFieldRaw, selectedOptionValue) {
+    const txt = (key) => {
+        const v = rawField[key];
+        return v !== undefined && v !== null ? String(v).trim() : '';
+    };
+    const txtIn = (d, key) => {
+        const v = d && typeof d === 'object' ? d[key] : undefined;
+        return v !== undefined && v !== null ? String(v).trim() : '';
+    };
+    const [dirLayer] = _attachDirLayer(rawField, attachConfig);
+    let resolvedFolderId = null;
+    if (txtIn(dirLayer, 'folderSelectType') === '1') {
+        resolvedFolderId = resolveOptionFolderId(optionFieldRaw, selectedOptionValue);
+    }
+    else {
+        const folderIdText = txtIn(dirLayer, 'folderId');
+        if (folderIdText)
+            resolvedFolderId = folderIdText;
+    }
+    const sizeLayers = [];
+    if (txt('sizeType') === '1')
+        sizeLayers.push(rawField);
+    if (attachConfig && typeof attachConfig === 'object')
+        sizeLayers.push(attachConfig);
+    let sizeLimitMb = null;
+    for (const layer of sizeLayers) {
+        const idx = txtIn(layer, 'attmentSizeLimit');
+        if (['0', '1', '2', '3', '4', '5'].includes(idx)) {
+            sizeLimitMb = ATTACH_SIZE_LIMIT_STEPS_MB[Number(idx)];
+            break;
+        }
+        if (idx === '6' || idx === '9') {
+            const customText = txtIn(layer, 'customAttmentSize');
+            let customMb = 0;
+            try {
+                customMb = parseInt(customText, 10);
+            }
+            catch {
+                customMb = 0;
+            }
+            if (customMb > 0) {
+                sizeLimitMb = customMb;
+                break;
+            }
+        }
+    }
+    if (sizeLimitMb === null) {
+        const maxSize = tenantSetting && tenantSetting.max_size_mb;
+        if (typeof maxSize === 'number' && maxSize > 0)
+            sizeLimitMb = maxSize;
+    }
+    let formatLimit = null;
+    const customLayers = [];
+    if (txt('limitType') === '1')
+        customLayers.push(rawField);
+    else if (attachConfig && typeof attachConfig === 'object')
+        customLayers.push(attachConfig);
+    for (const layer of customLayers) {
+        const customFormatText = txtIn(layer, 'customLimitFormat');
+        const customFormats = customFormatText ? customFormatText.split(',').map((p) => p.trim().toLowerCase()).filter((p) => p) : [];
+        if (customFormats.length) {
+            formatLimit = { mode: 'white', formats: customFormats };
+            break;
+        }
+    }
+    if (formatLimit === null && tenantSetting && typeof tenantSetting === 'object') {
+        const mode = tenantSetting.format_mode;
+        const formats = tenantSetting.formats;
+        if ((mode === 'white' || mode === 'black') && Array.isArray(formats) && formats.length) {
+            formatLimit = { mode, formats };
+        }
+    }
+    let maxNum = null;
+    const maxNumText = txt('maxNum');
+    if (maxNumText) {
+        let n = 0;
+        try {
+            n = parseInt(maxNumText, 10);
+        }
+        catch {
+            n = 0;
+        }
+        if (n > 0)
+            maxNum = n;
+    }
+    return [resolvedFolderId, sizeLimitMb, formatLimit, maxNum];
+}
+function buildFileUploadParams(runtime, frame, fieldId, isCreate, secretLevelId, folderId, sizeLimitMb, formatLimit, maxNum, readOnly) {
+    const moduleValue = String(frame.relate_type ?? '').trim() === 'WEA_EBUILDER' ? 'ebuildercard' : 'workflow';
+    const params = {
+        customParam: {
+            requestId: runtime.request_id,
+            workflowId: runtime.workflow_id,
+            nodeId: runtime.node_id,
+            readOnly: Boolean(readOnly),
+            identityId: runtime.identity_id,
+            identityType: runtime.identity_type,
+            isTest: false,
+            create: isCreate,
+            mobile: false,
+            formId: frame.form_id,
+            authSignatureStr: runtime.auth_signature,
+            authStr: runtime.auth_str,
+            fieldId,
+        },
+        source: 'form',
+        module: moduleValue,
+        authModule: moduleValue,
+        sourceRefId: runtime.request_id,
+        refId: runtime.request_id,
+    };
+    if (secretLevelId)
+        params.secretLevel = String(secretLevelId);
+    if (folderId)
+        params.folderId = String(folderId);
+    if (typeof sizeLimitMb === 'number' && sizeLimitMb > 0)
+        params.sizeLimit = sizeLimitMb;
+    if (formatLimit && typeof formatLimit === 'object' && (formatLimit.mode === 'white' || formatLimit.mode === 'black')) {
+        const formats = formatLimit.formats;
+        if (Array.isArray(formats) && formats.length)
+            params.formatLimit = { mode: formatLimit.mode, formats: [...formats] };
+    }
+    if (typeof maxNum === 'number' && maxNum > 0)
+        params.maxNum = maxNum;
+    return params;
+}
+function parseLayoutMeta(layoutData) {
+    const hiddenCellIds = new Set();
+    const compsFieldIds = new Set();
+    const layoutSubformIds = new Set();
+    let page0 = null;
+    const pageLayouts = layoutData && layoutData.formLayout ? layoutData.formLayout.pageLayouts : undefined;
+    if (Array.isArray(pageLayouts) && pageLayouts.length)
+        page0 = pageLayouts[0];
+    if (page0 && typeof page0 === 'object') {
+        const wb = page0.config && page0.config.workbook ? page0.config.workbook : {};
+        const sheet1 = wb.Sheet1;
+        const cells = sheet1 ? sheet1.cells : null;
+        const hidePositions = new Set();
+        if (Array.isArray(cells)) {
+            for (const cell of cells) {
+                if (!cell || typeof cell !== 'object')
+                    continue;
+                const attrs = cell.tag && cell.tag.attrs ? cell.tag.attrs : {};
+                if (attrs.hide) {
+                    try {
+                        hidePositions.add(`${cell.col}:${cell.row}`);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        if (hidePositions.size) {
+            for (const comp of page0.comps || []) {
+                if (!comp || typeof comp !== 'object')
+                    continue;
+                const cfg = comp.config || {};
+                const fid = String(cfg.fieldId ?? '').trim();
+                if (!fid)
+                    continue;
+                const excel = cfg.excel || {};
+                try {
+                    const pos = `${excel.col}:${excel.row}`;
+                    if (hidePositions.has(pos))
+                        hiddenCellIds.add(fid);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        for (const comp of page0.comps || []) {
+            if (!comp || typeof comp !== 'object')
+                continue;
+            const cfg = comp.config || {};
+            const fid = String(cfg.fieldId ?? '').trim();
+            if (fid)
+                compsFieldIds.add(fid);
+            if (String(cfg.type ?? '').toLowerCase() === 'detailtable' || String(cfg.type ?? '').toLowerCase() === 'datatable') {
+                const sid = String(cfg.subFormId ?? '').trim();
+                if (sid)
+                    layoutSubformIds.add(sid);
+            }
+        }
+    }
+    return { hiddenCellIds, compsFieldIds, layoutSubformIds };
+}
+function applyViewRelateHidden(layoutSubformIds, viewRelateConfig) {
+    if (Array.isArray(viewRelateConfig)) {
+        for (const item of viewRelateConfig) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const fid = String(item.fieldId ?? '').trim();
+            if (layoutSubformIds.has(fid) && item.display === false)
+                layoutSubformIds.delete(fid);
+        }
+    }
+}
+/**
+ * 「OA 未下发静态必填标记」的显式告警（V12.1.22 引入，V12.1.27 纠正措辞）。
+ *
+ * 静态必填的权威来源是 `getFormLayout` 的 `viewRelateConfig[]`（fieldId → required/disableEdit/display），
+ * 回退来源是布局节点自身的 `required`/`mustInput`。**2026-09-17 更正**：此前观测到的"三个表单
+ * `viewRelateConfig` 长度为 0"并非服务端没配置，而是 `getFormLayout` 请求多带了顶层 `permissionId`
+ * （未启用节点权限的表单会因此拿不到字段级属性；见 `buildLayoutRequest`）。该请求口径修正后，
+ * 本告警只在服务端**确实**不下发字段属性时才出现（如启用节点权限的表单）。
+ * 真正未下发时：`requiredFields` 只剩系统字段、`subFormRequired` 恒为 `{}`，**不代表表单没有必填项**。
+ *
+ * V12.1.27 纠正（此前措辞有硬伤）：原文案把 `missingFields` 也写成"为空不代表没有必填/无法据此校验业务必填"，
+ * 与事实相反——本租户的业务必填是**条件必填**，由 `viewLinkages` 的 `required` 规则承载，
+ * prepare 阶段按实际所填数据**实时求值**，`missingFields` 完全可信（2026-09-17 真机验证：总部费用报销
+ * `报销方式=银行（付公司）` → `missingFields=[账户名称,账号,开户机构名称]`）。原文案会诱导模型对用户说
+ * "系统不会校验必填项"，属错误陈述。现改为：静态标记未下发 + 条件必填清单（`conditionalRequired`）+
+ * **missingFields 可信、照常 prepare**。
+ *
+ * 返回 null 表示静态必填信息可用，无需告警。
+ */
+function requiredInfoWarningText(context) {
+    const ctx = context || {};
+    const vrc = Array.isArray(ctx.viewRelateConfig) ? ctx.viewRelateConfig : [];
+    if (vrc.length)
+        return null; // OA 下发了字段级权限配置 → 静态必填信息可信
+    const fields = Array.isArray(ctx.fields) ? ctx.fields : [];
+    const business = fields.filter((f) => f && f.id
+        && !String(f.id).startsWith('REQUEST_') && !String(f.id).startsWith('SECLEVEL')
+        && f.display !== false && !f.readOnly && !f.disableEdit);
+    // 没有业务字段（纯系统字段表单）→ 空清单是正常结果
+    if (!business.length)
+        return null;
+    // 有任何字段带必填标记 → 至少拿到了部分真实信息，不必告警
+    if (business.some((f) => f.required))
+        return null;
+    return 'OA 未下发该表单的**静态**必填标记，本次 requiredFields / subFormRequired 只含系统字段（流程标题等），'
+        + '但这**不代表该表单没有业务必填项**：业务必填见 conditionalRequired。'
+        + 'missingFields 由 prepare 按实际所填数据实时计算、**可信**——照常 prepare，'
+        + '并把 missingFields 与 conditionalRequired 一次性向用户问齐。'
+        + '不要对用户说"系统不会校验必填项"。';
+}
+// ---------------------------------------------------------------------------
+// createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
+// ---------------------------------------------------------------------------
+async function commandCreateForm(args, env) {
+    const workflowId = String(args.workflowId ?? '').trim();
+    if (!workflowId)
+        throw workflowValidationError('workflow_id_required', 'workflowId 必填');
+    const query = { workflowId, isCreate: 1, ...AJAX_QUERY };
+    const body = { workflowId, isCreate: 1, isMobile: 0 };
+    const baseResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body);
+    const frameResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadFrame, query, body);
+    let minorInfo = {};
+    let minorWarning = null;
+    try {
+        const minorResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, query, { workflowId, isCreate: 1, isMobile: 0 });
+        minorInfo = parseMinorInfo(minorResp);
+    }
+    catch {
+        minorInfo = {};
+        minorWarning = 'loadMinorInfo 获取系统字段权限失败，跳过系统字段（流程标题/紧急程度/密级）必填校验';
+    }
+    const base = baseResp;
+    const frameData = frameResp;
+    const runtime = parseRuntime(base, workflowId);
+    const frame = parseFrame(frameData, runtime.node_id);
+    let tenantSetting = {};
+    try {
+        const settingResp = await requestJson(env, 'POST', FORM_ENDPOINTS.tenantSetting, undefined, { setType: [] });
+        tenantSetting = parseTenantSetting(settingResp);
+    }
+    catch {
+        tenantSetting = {};
+    }
+    const layoutResp = await requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formLayout, frame.relate_type), { formId: frame.form_id, ...AJAX_QUERY }, buildLayoutRequest(workflowId, runtime, frame));
+    const layoutData = layoutResp;
+    if (!layoutData || typeof layoutData !== 'object')
+        throw workflowApiError('format_error', 'getFormLayout 未返回有效 data');
+    const returnedFormId = String((layoutData.form && layoutData.form.id) ?? '');
+    if (returnedFormId && returnedFormId !== frame.form_id)
+        throw workflowApiError('format_error', 'getFormLayout 返回了不同的 formId');
+    const layoutId = String((layoutData.formLayout && layoutData.formLayout.id) ?? '');
+    if (!layoutId)
+        throw workflowApiError('format_error', '缺少 formLayout.id');
+    const requiredMap = {};
+    const disableEditMap = {};
+    const displayMap = {};
+    const viewRelateConfig = Array.isArray(layoutData.viewRelateConfig) ? layoutData.viewRelateConfig : [];
+    for (const item of viewRelateConfig) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const fid = String(item.fieldId ?? '').trim();
+        if (!fid)
+            continue;
+        requiredMap[fid] = Boolean(item.required);
+        disableEditMap[fid] = Boolean(item.disableEdit);
+        displayMap[fid] = item.display !== undefined ? Boolean(item.display) : true;
+    }
+    const fields = extractFields(layoutData, requiredMap, disableEditMap, displayMap);
+    const rawFieldsById = walkLayoutRawFields(layoutData.formLayout);
+    const attachConfigs = (layoutData.attachConfigs && typeof layoutData.attachConfigs === 'object') ? layoutData.attachConfigs : {};
+    const rawUploadFields = _rawUploadFieldsMap(rawFieldsById, attachConfigs);
+    const meta = parseLayoutMeta(layoutData);
+    const hiddenCellIds = meta.hiddenCellIds;
+    let compsFieldIds = meta.compsFieldIds;
+    const layoutSubformIds = meta.layoutSubformIds;
+    applyViewRelateHidden(layoutSubformIds, viewRelateConfig);
+    const visibleFields = [];
+    for (const f of fields) {
+        const fid = String(f.id ?? '');
+        if (hiddenCellIds.has(fid))
+            continue;
+        if (compsFieldIds.size && !String(f.subFormId ?? '').trim() && !compsFieldIds.has(fid))
+            continue;
+        visibleFields.push(f);
+    }
+    const defaults = normalizeDefaults(layoutData.defaultDetails);
+    // 计算必填/可编辑/明细必填（按默认值 + onLoadForm 联动）
+    const systemFieldValues = _normalizeSystemFieldValues(layoutData.businessOperatorObj);
+    let linkageActions = Array.isArray(layoutData.linkageActions) ? layoutData.linkageActions : [];
+    let onLoadLinkage = [];
+    if (linkageActions.length) {
+        const loadEntries = _entriesFromDefaults(defaults);
+        try {
+            onLoadLinkage = await runFieldLinkage(env, buildLinkageContext({ runtime, frame, layout: { form_id: frame.form_id }, linkageActions }), loadEntries, new Set(['onLoadForm']), defaults);
+        }
+        catch {
+            onLoadLinkage = [];
+        }
+        if (onLoadLinkage.length) {
+            const merged = mergeLinkageDetails(defaults, onLoadLinkage);
+            defaults.length = 0;
+            for (const d of merged)
+                defaults.push(d);
+        }
+    }
+    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = computeLinkageVisibility(layoutData.viewLinkages, [], defaults, onLoadLinkage, systemFieldValues);
+    const mainHidden = new Set(rowHidden.main || []);
+    const initialHidden = new Set(fields.filter((f) => f.display === false).map((f) => String(f.id ?? '')));
+    if (initialHidden.size) {
+        for (const id of initialHidden)
+            mainHidden.add(id);
+        rowHidden.main = mainHidden;
+    }
+    const vrcFieldIds = new Set(viewRelateConfig.filter((i) => i && typeof i === 'object' && String(i.fieldId ?? '').trim()).map((i) => String(i.fieldId)));
+    const mainDisabled = new Set(rowDisabled.main || []);
+    const mainExtraRequired = new Set(rowExtraRequired.main || []);
+    const requiredFieldsList = [];
+    const editableFieldsList = [];
+    const subFormRequired = {};
+    const subFormLinkageRequired = {};
+    for (const key of Object.keys(rowExtraRequired)) {
+        if (key === 'main' || !key.includes(':'))
+            continue;
+        const subFormId = key.split(':', 1)[0];
+        for (const fid of rowExtraRequired[key]) {
+            const target = visibleFields.find((f) => String(f.id ?? '') === fid);
+            if (target)
+                subFormLinkageRequired[subFormId] = subFormLinkageRequired[subFormId] || [];
+            if (target)
+                subFormLinkageRequired[subFormId].push(slimFieldInfo(target));
+        }
+    }
+    const folderOptionValues = _mainValueMap(defaults);
+    for (const field of visibleFields) {
+        const fieldId = String(field.id ?? '');
+        const subFormId = String(field.subFormId ?? '');
+        if (field.readOnly || field.disableEdit || mainDisabled.has(fieldId))
+            continue;
+        if (mainHidden.has(fieldId) || (subFormId && hiddenSubforms.has(subFormId)))
+            continue;
+        if (fieldId && vrcFieldIds.size && !vrcFieldIds.has(fieldId))
+            continue;
+        if (field.required || mainExtraRequired.has(fieldId)) {
+            const slim = slimFieldInfo(field);
+            if (subFormId) {
+                subFormRequired[subFormId] = subFormRequired[subFormId] || [];
+                subFormRequired[subFormId].push(slim);
+                continue;
+            }
+            requiredFieldsList.push(slim);
+            continue;
+        }
+        editableFieldsList.push(slimFieldInfo(field));
+    }
+    for (const subFormId of Object.keys(subFormLinkageRequired)) {
+        const existing = new Set((subFormRequired[subFormId] || []).map((f) => String(f.id ?? '')));
+        for (const slim of subFormLinkageRequired[subFormId]) {
+            if (!existing.has(String(slim.id ?? ''))) {
+                subFormRequired[subFormId] = subFormRequired[subFormId] || [];
+                subFormRequired[subFormId].push(slim);
+                existing.add(String(slim.id ?? ''));
+            }
+        }
+    }
+    const slimFields = [];
+    for (const field of visibleFields) {
+        const item = {
+            id: field.id,
+            name: field.name,
+            subFormId: field.subFormId,
+            componentKey: field.componentKey,
+        };
+        if (field.required)
+            item.required = true;
+        if (field.readOnly || field.disableEdit) {
+            item.readOnly = Boolean(field.readOnly);
+            item.disableEdit = Boolean(field.disableEdit);
+        }
+        for (const key of ['isBrowser', 'isSelect', 'isMultiple', 'browserType', 'browserModule']) {
+            if (field[key])
+                item[key] = field[key];
+        }
+        if (String(field.componentKey ?? '').toLowerCase() === 'employeescope')
+            item.isEmployeeScope = true;
+        if (String(field.componentKey ?? '').toLowerCase() === 'einvoicecomponent')
+            item.isEinvoice = true;
+        if (String(field.componentKey ?? '').toLowerCase() === 'filecomponent') {
+            const fileFieldId = String(field.id ?? '');
+            if (fileFieldId && !(field.readOnly || field.disableEdit)) {
+                const rawFileField = rawFieldsById[fileFieldId] || {};
+                const attachCfg = attachConfigs[fileFieldId];
+                const [dirLayer] = _attachDirLayer(rawFileField, attachCfg);
+                let optionFieldRaw = null;
+                let optionValue = null;
+                if (String(dirLayer.folderSelectType ?? '').trim() === '1') {
+                    item.folderDependsOnOption = true;
+                    const optionFieldId = String(dirLayer.optionId ?? '').trim();
+                    if (optionFieldId) {
+                        optionFieldRaw = rawFieldsById[optionFieldId];
+                        optionValue = folderOptionValues[optionFieldId];
+                    }
+                }
+                const [folderId, sizeLimitMb, formatLimit, maxNum] = resolveFileUploadConstraints(rawFileField, tenantSetting, attachCfg || null, optionFieldRaw, optionValue);
+                item.fileUploadParams = buildFileUploadParams(runtime, frame, fileFieldId, true, minorInfo.sec_default_id || null, folderId, sizeLimitMb, formatLimit, maxNum, Boolean(field.readOnly || field.disableEdit));
+            }
+        }
+        if (String(field.componentKey ?? '').toLowerCase() === 'textarea' && field.richEditor)
+            item.componentKey = 'RichText';
+        if (String(field.format ?? '').trim())
+            item.format = String(field.format).trim();
+        const options = field.options || [];
+        if (options.length)
+            item.options = options;
+        slimFields.push(item);
+    }
+    const fieldsById = new Map();
+    for (const f of fields)
+        fieldsById.set(String(f.id ?? ''), f);
+    const initValues = [];
+    for (const d of defaults) {
+        const fid = String((d.formField && d.formField.id) ?? '').trim();
+        if (!fid || hiddenCellIds.has(fid))
+            continue;
+        const sf = String((d.subForm && d.subForm.id) ?? '').trim();
+        if (sf) {
+            if (layoutSubformIds.size && !layoutSubformIds.has(sf))
+                continue;
+        }
+        else if (compsFieldIds.size && !compsFieldIds.has(fid)) {
+            continue;
+        }
+        const disp = _detailDisplayText(d);
+        if (!disp)
+            continue;
+        const f = fieldsById.get(fid) || {};
+        const iv = { fieldId: fid, name: f.name ?? fid, value: disp };
+        if (sf)
+            iv.subFormId = sf;
+        initValues.push(iv);
+    }
+    const session = await getSessionContext(env);
+    const context = {
+        kind: 'CREATE',
+        version: 1,
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        oaBaseUrl: session.baseUrl,
+        workflow: {
+            id: workflowId,
+            name: runtime.workflow_name,
+            description: runtime.workflow_description,
+            type_name: runtime.workflow_type_name,
+        },
+        runtime,
+        frame,
+        layout: { form_id: frame.form_id, layout_id: layoutId },
+        fields,
+        defaults,
+        rawUploadFields,
+        attachConfigs,
+        viewLinkages: Array.isArray(layoutData.viewLinkages) ? layoutData.viewLinkages : null,
+        systemFieldValues,
+        linkageActions,
+        viewRelateConfig,
+        hiddenCellFieldIds: [...hiddenCellIds],
+        compsFieldIds: [...compsFieldIds],
+        layoutSubformIds: [...layoutSubformIds],
+        systemFields: {
+            permissions: minorInfo.permissions || {},
+            level_options: minorInfo.level_options || [],
+            sec_level_options: minorInfo.sec_level_options || [],
+            defaults: {
+                requestName: runtime.default_request_name || '',
+                requestLevel: runtime.default_request_level || '',
+                secLevel: runtime.default_sec_level || '',
+            },
+        },
+        minorInfo,
+        tenantSetting,
+        onLoadLinkage,
+    };
+    const token = await env.continuation.issue({ operation: 'workflow.createForm', baseUrl: session.baseUrl, profile: session.profile, userId: session.userId, payload: context }, CONTINUATION_TTL_MS);
+    // 条件必填清单（V12.1.27）：viewLinkages 里的 required 规则原样结构化，form 阶段即可主动问齐必填项。
+    const conditionalRequired = conditionalRequiredFields(layoutData.viewLinkages, rawFieldsById);
+    const requiredFieldIds = requiredFieldsWithSystem(requiredFieldsList, runtime, minorInfo.permissions || {});
+    // 可写字段 = 必填（主表 + 明细，含系统字段）+ 其余可编辑字段。
+    // 只在 `fields` 真被整体移出 stdout 时才会随输出（由 compactFormOutput 决定）。
+    const writableFieldIds = [];
+    for (const id of requiredFieldIds)
+        writableFieldIds.push(id);
+    for (const list of Object.values(subFormRequired)) {
+        for (const f of list)
+            writableFieldIds.push(String(f?.id ?? ''));
+    }
+    for (const f of editableFieldsList)
+        writableFieldIds.push(String(f?.id ?? ''));
+    const writableFieldsCompact = encodeWritableFieldsCompact([...new Set(writableFieldIds)], visibleFields, SYSTEM_FIELD_KEYS);
+    return workflowSuccess('workflow.createForm', await compactFormOutput({
+        status: 'FORM_READY',
+        contextId: token,
+        requestId: runtime.request_id,
+        requestName: runtime.default_request_name || '',
+        workflow: context.workflow,
+        form: { id: frame.form_id, layout_id: layoutId },
+        requiredFields: requiredFieldIds,
+        subFormRequired: Object.fromEntries(Object.entries(subFormRequired).map(([k, v]) => [k, v.map((f) => String(f.id ?? ''))])),
+        editableFields: editableFieldsList.map((f) => String(f.id ?? '')),
+        fields: slimFields,
+        initialValues: initValues,
+        systemFields: {
+            permissions: minorInfo.permissions || {},
+            defaults: context.systemFields.defaults,
+            levelOptions: minorInfo.level_options || [],
+            secLevelOptions: minorInfo.sec_level_options || [],
+        },
+        systemFieldWarning: minorWarning,
+        requiredInfoWarning: requiredInfoWarningText(context),
+        ...(conditionalRequired.length ? { conditionalRequired } : {}),
+        // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
+        continuation: token,
+    }, env, 'last_create_form.json', writableFieldsCompact));
+}
+// ---------------------------------------------------------------------------
+// 输入拆分 / 字段绑定 / 只读校验
+// ---------------------------------------------------------------------------
+function splitInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw workflowValidationError('input_invalid', '表单数据必须是 JSON 对象');
+    let main;
+    let details;
+    if ('main' in value || 'details' in value) {
+        main = value.main || {};
+        details = value.details || {};
+    }
+    else {
+        main = value;
+        details = {};
+    }
+    if (!main || typeof main !== 'object' || !details || typeof details !== 'object')
+        throw workflowValidationError('input_invalid', 'main 和 details 必须是 JSON 对象');
+    const normalizedDetails = {};
+    for (const subFormId of Object.keys(details)) {
+        const rows = details[subFormId];
+        if (!Array.isArray(rows) || !rows.every((r) => r && typeof r === 'object')) {
+            throw workflowValidationError('input_invalid', `明细表 ${subFormId} 必须是对象数组`);
+        }
+        normalizedDetails[String(subFormId)] = rows;
+    }
+    return [main, normalizedDetails];
+}
+function bindInputFields(main, details, fields) {
+    const entries = [];
+    const ambiguities = [];
+    const resolve = (key, subFormId) => {
+        const scope = fields.filter((f) => String(f.subFormId ?? '') === subFormId);
+        const idMatches = scope.filter((f) => String(f.id) === key);
+        const nameMatches = scope.filter((f) => String(f.name ?? '').toLowerCase() === key.toLowerCase());
+        const matches = idMatches.length ? idMatches : nameMatches;
+        if (matches.length === 1)
+            return matches[0];
+        ambiguities.push({
+            kind: 'FIELD',
+            input: key,
+            subFormId,
+            candidates: matches.map((m) => ({ id: m.id, name: m.name })),
+            reason: matches.length ? 'DUPLICATE_NAME' : 'NOT_FOUND',
+        });
+        return null;
+    };
+    for (const key of Object.keys(main)) {
+        const field = resolve(String(key), '');
+        if (field)
+            entries.push({ field, value: main[key] });
+    }
+    const rowSeed = Date.now() * 100000 + Math.floor(Math.random() * 70000) + 10000;
+    let rowOffset = 0;
+    for (const subFormId of Object.keys(details)) {
+        const rows = details[subFormId];
+        rows.forEach((row, index) => {
+            const rowId = String(rowSeed + rowOffset);
+            rowOffset += 1;
+            const rowMeta = { dataIndex: index + 1, rowId, subForm: { id: subFormId } };
+            for (const key of Object.keys(row)) {
+                const field = resolve(String(key), subFormId);
+                if (field)
+                    entries.push({ field, value: row[key], row: rowMeta });
+            }
+        });
+    }
+    return [entries, ambiguities];
+}
+function readonlyEntryViolations(entries) {
+    const hits = [];
+    for (const entry of entries) {
+        const field = entry.field || {};
+        if (field.readOnly || field.disableEdit) {
+            hits.push({ fieldId: String(field.id ?? ''), name: String(field.name ?? ''), subFormId: String(field.subFormId ?? '') });
+        }
+    }
+    return hits;
+}
+// ---------------------------------------------------------------------------
+// 人员范围字段（componentKey=EmployeeScope）名称→ID
+// 来源：V11.3 `e10_workflow.py` 的 `EMPLOYEE_SCOPE_BROWSER_TYPES` /
+// `employee_scope_browser_candidates` / `_employee_scope_strip_suffix`。
+// 人员范围同一字段内可混合 8 类对象，各类走各自 /api/hrm/common/browser/complete/{type}；
+// all / allExternal 是特殊类，不调接口（optionId 固定 "0"）。
+// ---------------------------------------------------------------------------
+const EMPLOYEE_SCOPE_MODULE = 'hrm';
+const EMPLOYEE_SCOPE_BROWSER_TYPES = {
+    user: 'resource',
+    dept: 'department',
+    subcompany: 'subcompany',
+    group: 'channel',
+    role: 'role',
+    position: 'position',
+    external: 'external',
+};
+const EMPLOYEE_SCOPE_SPECIAL_TYPES = { all: '所有人', allExternal: '所有外部联系人' };
+/** 人员范围名称常见口语后缀（出现在名称末尾时剥离后重试搜索）。 */
+const EMPLOYEE_SCOPE_NAME_SUFFIXES = ['部门', '分部', '岗位', '群组', '群', '角色', '人员'];
+function isEmployeeScopeField(field) {
+    return Boolean(field?.isEmployeeScope)
+        || String(field?.componentKey ?? '').toLowerCase() === 'employeescope';
+}
+/** 认证/网络错误必须原样抛出，不得降级成"未匹配到候选"（读路径红线）。 */
+function rethrowAuthOrNetwork(error) {
+    const type = error?.type;
+    if (type === 'authentication' || type === 'network')
+        throw error;
+}
+function stripEmployeeScopeSuffix(keyword) {
+    for (const suffix of EMPLOYEE_SCOPE_NAME_SUFFIXES) {
+        if (keyword.endsWith(suffix) && keyword.length > suffix.length)
+            return keyword.slice(0, -suffix.length);
+    }
+    return keyword;
+}
+/** all / allExternal 的固定结构（optionId 恒为 "0"，optionObj 为固定字段）。 */
+function employeeScopeSpecialCandidate(scopeType) {
+    const name = EMPLOYEE_SCOPE_SPECIAL_TYPES[scopeType];
+    if (!name)
+        return null;
+    const raw = scopeType === 'all'
+        ? {
+            content: name,
+            type: 'all',
+            icon: 'Icon-all02',
+            _entityContent: '所有人',
+            _secretLevel: '0-100',
+            secretLevel: '0-100',
+        }
+        : { content: name, type: 'allExternal', icon: 'Icon-all02', _entityContent: '所有外部联系人' };
+    return { id: '0', name, raw };
+}
+/**
+ * 人员范围字段单类对象名称转 ID：`POST /api/hrm/common/browser/complete/{browserType}`，
+ * 入参统一 `{browserMultiple:true, newly:1, searchValue:keyword}`，返回 `[{id,name,raw}]`
+ * （raw 为接口原始对象，保存时作为 optionObj）。0 命中时按 V11.3 剥离口语后缀重试一次。
+ */
+async function employeeScopeCandidates(env, scopeType, keyword) {
+    const special = employeeScopeSpecialCandidate(scopeType);
+    if (special)
+        return [special];
+    const browserType = EMPLOYEE_SCOPE_BROWSER_TYPES[scopeType];
+    const kw = String(keyword ?? '').trim();
+    if (!browserType || !kw)
+        return [];
+    const fetchOnce = async (searchValue) => {
+        let response;
+        try {
+            response = await env.host.workflowRequest({
+                method: 'POST',
+                path: `/api/${EMPLOYEE_SCOPE_MODULE}/common/browser/complete/${browserType}`,
+                operation: 'name.resolve',
+                body: { browserMultiple: true, newly: 1, searchValue },
+            });
+        }
+        catch (error) {
+            // V11.3 把请求失败一律当 0 命中；本项目红线要求认证/网络错误原样抛出，其余按 0 命中。
+            rethrowAuthOrNetwork(error);
+            return [];
+        }
+        const data = responseData(response);
+        const list = data?.data?.data ?? data?.data;
+        if (!Array.isArray(list))
+            return [];
+        const out = [];
+        const seen = new Set();
+        for (const item of list) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const id = String(item.id ?? '').trim();
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, name: String(item.name ?? item.content ?? '').trim(), raw: item });
+        }
+        return out;
+    };
+    let candidates = await fetchOnce(kw);
+    if (!candidates.length) {
+        const stripped = stripEmployeeScopeSuffix(kw);
+        if (stripped && stripped !== kw)
+            candidates = await fetchOnce(stripped);
+    }
+    return candidates;
+}
+// ---------------------------------------------------------------------------
+// 值序列化（serializeValue：文本/选项/浏览按钮/附件/发票/人员范围）
+// ---------------------------------------------------------------------------
+class ValueAmbiguity extends Error {
+    details;
+    constructor(details) {
+        super(details.reason || 'AMBIGUOUS');
+        this.details = details;
+    }
+}
+function listValues(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function assertMultiplicity(field, options) {
+    if (!field.isMultiple && options.length > 1) {
+        throw new ValueAmbiguity({ kind: 'MULTIPLICITY', fieldId: field.id, fieldName: field.name, reason: '该字段是单选，但输入了多个值', candidates: options });
+    }
+}
+function normalizeRelateCandidate(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const id = String(value.relateId ?? '').trim();
+    const name = String(value.name ?? '').trim();
+    return id && name ? { id, name } : null;
+}
+function serializeValue(field, value, mappings, row, browserHints = {}) {
+    const detail = { ...(row || {}), formField: { id: field.id } };
+    const isEmployeeScope = field.isEmployeeScope || String(field.componentKey ?? '').toLowerCase() === 'employeescope';
+    if (isEmployeeScope) {
+        const options = [];
+        for (const item of listValues(value)) {
+            if (!item || typeof item !== 'object') {
+                throw new ValueAmbiguity({ kind: 'EMPLOYEE_SCOPE', fieldId: field.id, fieldName: field.name, reason: '人员范围字段的值必须是对象数组，每项含 name 和 type', resolution: '格式如 [{"name":"袁湘云","type":"user"}]' });
+            }
+            const optionId = String(item.optionId ?? item.id ?? '').trim();
+            const content = String(item.content ?? item.name ?? '').trim();
+            const scopeType = String(item.type ?? '').trim();
+            if (optionId && content && scopeType) {
+                const option = { optionId, content, type: scopeType };
+                if (item.optionObj && typeof item.optionObj === 'object')
+                    option.optionObj = item.optionObj;
+                options.push(option);
+                continue;
+            }
+            if (!content || !scopeType) {
+                throw new ValueAmbiguity({ kind: 'EMPLOYEE_SCOPE', fieldId: field.id, fieldName: field.name, input: item, reason: '缺少名称或类型', resolution: '每项必须含 name/content 与 type（user/dept/subcompany/group/role/position/external/all/allExternal）' });
+            }
+            // 名称/类型齐了却没拿到 ID：说明名称→ID 解析没成功（预解析失败或未走预解析）。
+            // **绝不静默丢弃**——空 optionId 会让 hasDetailValue 判为无值，整条值从保存体里消失，
+            // 用户看到"已准备"、实际收件人为空（2026-09-16「内部留言」被留言人字段的实测现象）。
+            throw new ValueAmbiguity({
+                kind: 'EMPLOYEE_SCOPE',
+                fieldId: field.id,
+                fieldName: field.name,
+                scopeType,
+                input: content,
+                reason: 'NOT_RESOLVED',
+                resolution: `名称「${content}（${scopeType}）」未能解析为 ID，请核对名称，或改用 {"optionId":"候选id","content":"候选名称","type":"${scopeType}"} 后重新 prepare。`,
+            });
+        }
+        detail.dataOptions = options;
+        return [detail, options.map((o) => ({ id: o.optionId, name: o.content, type: o.type }))];
+    }
+    if (String(field.componentKey ?? '').toLowerCase() === 'einvoicecomponent') {
+        const options = [];
+        for (const item of listValues(value)) {
+            if (!item || typeof item !== 'object') {
+                throw new ValueAmbiguity({ kind: 'EINVOICE', fieldId: field.id, fieldName: field.name, input: item, reason: '发票字段的值必须是发票对象数组', resolution: '每项传发票对象（含 id/fid）' });
+            }
+            let optionObj;
+            let optionId;
+            if (item.optionObj && typeof item.optionObj === 'object') {
+                optionObj = item.optionObj;
+                optionId = String(item.optionId ?? optionObj.optionId ?? optionObj.id ?? optionObj.fid ?? '').trim();
+            }
+            else {
+                optionObj = item;
+                optionId = String(item.optionId ?? item.id ?? item.fid ?? '').trim();
+            }
+            if (!optionId) {
+                throw new ValueAmbiguity({ kind: 'EINVOICE', fieldId: field.id, fieldName: field.name, input: item, reason: '发票对象缺少 optionId/id/fid', resolution: '传入完整发票对象（含 id 或 fid）' });
+            }
+            options.push({ optionId, type: 'einvoice', optionObj });
+        }
+        assertMultiplicity(field, options);
+        detail.dataOptions = options;
+        return [detail, options.map((o) => ({ id: o.optionId, name: String((o.optionObj && (o.optionObj.name || o.optionObj.content)) || o.optionId) }))];
+    }
+    if (String(field.componentKey ?? '').toLowerCase() === 'filecomponent') {
+        const options = [];
+        for (const item of listValues(value)) {
+            if (!item || typeof item !== 'object') {
+                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件字段的值必须是附件项数组', resolution: '每项固定格式 {"optionId":"上传返回的file_id","content":"文件名","type":"file"}' });
+            }
+            const optionId = String(item.optionId ?? '').trim();
+            const content = String(item.content ?? '').trim();
+            const ftype = String(item.type ?? '').trim();
+            if (!optionId || !content || ftype !== 'file') {
+                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件项缺少 optionId/content，或 type 不是 file', resolution: '固定格式 {"optionId":"上传返回的file_id","content":"文件名","type":"file"}' });
+            }
+            options.push({ optionId, content, type: 'file' });
+        }
+        assertMultiplicity(field, options);
+        detail.dataOptions = options;
+        return [detail, options.map((o) => ({ id: o.optionId, name: o.content }))];
+    }
+    if (field.isBrowser) {
+        const options = [];
+        for (const item of listValues(value)) {
+            if (item && typeof item === 'object' && item.id) {
+                options.push({ optionId: String(item.id), content: String(item.name ?? item.content ?? item.id) });
+                continue;
+            }
+            const keyword = String(item).trim();
+            const rowIndex = String((row && row.dataIndex) ?? '0');
+            const lookupKey = `${field.id}_${rowIndex}_${keyword}`;
+            const candidates = mappings[lookupKey] || [];
+            const exact = candidates.filter((c) => c.name.toLowerCase() === keyword.toLowerCase());
+            const selected = exact.length === 1 ? exact : candidates;
+            if (selected.length !== 1) {
+                // 未命中时带上候选澄清清单（该浏览控件首页合法取值）；一个候选都没有时如实给空数组，
+                // 由文档要求模型"一次明确告知用户并请其给出准确名称"，禁止换相近词反复 prepare。
+                const hints = selected.length ? selected : (browserHints[lookupKey] || []);
+                throw new ValueAmbiguity({
+                    kind: 'BROWSER',
+                    fieldId: field.id,
+                    fieldName: field.name,
+                    input: keyword,
+                    reason: selected.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
+                    candidates: hints,
+                    candidatesAvailable: hints.length > 0,
+                    resolution: hints.length
+                        ? '从 candidates 里挑出用户确认的那个，按 {"id":"候选id","name":"候选名称"} 重新 prepare。'
+                        : '将该值改为 {"id":"候选id","name":"候选名称"} 后重新 prepare。',
+                });
+            }
+            options.push({ optionId: selected[0].id, content: selected[0].name });
+        }
+        assertMultiplicity(field, options);
+        detail.dataOptions = options;
+        return [detail, options.map((o) => ({ id: o.optionId, name: o.content }))];
+    }
+    if (field.isSelect) {
+        const selectedOptions = [];
+        const choices = field.options || [];
+        for (const item of listValues(value)) {
+            if (item && typeof item === 'object' && item.id) {
+                selectedOptions.push({ optionId: String(item.id), content: String(item.name ?? item.content ?? item.id) });
+                continue;
+            }
+            const keyword = String(item).trim();
+            const matches = choices.filter((c) => String(c.id) === keyword || String(c.name ?? '').toLowerCase() === keyword.toLowerCase());
+            if (matches.length !== 1) {
+                throw new ValueAmbiguity({ kind: 'OPTION', fieldId: field.id, fieldName: field.name, input: keyword, reason: matches.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND', candidates: matches || choices, resolution: '将该值改为 {"id":"选项id","name":"选项名称"} 后重新 prepare。' });
+            }
+            selectedOptions.push({ optionId: matches[0].id, content: matches[0].name });
+        }
+        assertMultiplicity(field, selectedOptions);
+        detail.dataOptions = selectedOptions;
+        return [detail, selectedOptions.map((o) => ({ id: o.optionId, name: o.content }))];
+    }
+    const component = String(field.componentKey ?? '').toLowerCase();
+    if (value && typeof value === 'object') {
+        throw new ValueAmbiguity({ kind: 'VALUE_FORMAT', fieldId: field.id, fieldName: field.name, reason: '文本字段只接受字符串、数字或布尔值', candidates: [] });
+    }
+    const content = value === null || value === undefined ? '' : String(value);
+    const dateFormat = String(field.format ?? '');
+    const needsTime = dateFormat && /(HH|hh)[:：.]?mm|H:mm|h:mm/i.test(dateFormat);
+    if (needsTime && /^\d{4}-\d{1,2}-\d{1,2}$/.test(content)) {
+        throw new ValueAmbiguity({ kind: 'DATETIME_FORMAT', fieldId: field.id, fieldName: field.name, input: content, reason: `该字段是日期+时间控件（format=${dateFormat}），只传日期不完整；请按 format 传完整值（如 2026-08-21 09:00）后重新 prepare，不要省略时间。`, candidates: [] });
+    }
+    const maxLength = field.maxLength;
+    const richUnlimited = component === 'textarea' && Boolean(field.richEditor);
+    if (!richUnlimited && maxLength !== undefined && maxLength !== null && String(maxLength).match(/^\d+$/) && content.length > Number(maxLength)) {
+        throw new ValueAmbiguity({ kind: 'VALUE_TOO_LONG', fieldId: field.id, fieldName: field.name, reason: `长度超过 ${maxLength}`, candidates: [] });
+    }
+    if (TEXTAREA_COMPONENTS.has(component))
+        detail.dataText = { content };
+    else
+        detail.content = content;
+    return [detail, content];
+}
+/**
+ * 人员范围字段的名称→ID 预解析：把 `{"name":"刘艳","type":"user"}` 就地换成
+ * `{"optionId":"<解析出的ID>","content":"刘艳","type":"user","optionObj":<接口原始对象>}`，
+ * 交给 `serializeValue` 的"已解析"分支直接透传。解析不到（0 命中/多命中）时把歧义挂到该条目上，
+ * 由主循环原样报给模型（带候选），**不允许退化成一个空 optionId 被静默丢掉**。
+ */
+async function preResolveEmployeeScopeEntries(env, entries) {
+    const failures = new Map();
+    for (const entry of entries) {
+        const field = entry.field;
+        if (!isEmployeeScopeField(field))
+            continue;
+        const items = listValues(entry.value);
+        const resolved = [];
+        let failure = null;
+        for (const item of items) {
+            if (!item || typeof item !== 'object') {
+                resolved.push(item); // 非对象由 serializeValue 报"必须是对象数组"
+                continue;
+            }
+            const optionId = String(item.optionId ?? item.id ?? '').trim();
+            const content = String(item.content ?? item.name ?? '').trim();
+            const scopeType = String(item.type ?? '').trim();
+            // 已解析 / 缺名称或类型：原样回填，交回 serializeValue 处理（保持单一报错出口）
+            if (optionId || !content || !scopeType) {
+                resolved.push(item);
+                continue;
+            }
+            const candidates = await employeeScopeCandidates(env, scopeType, content);
+            const exact = candidates.filter((c) => String(c.name).toLowerCase() === content.toLowerCase());
+            const selected = exact.length === 1 ? exact : candidates;
+            if (selected.length !== 1) {
+                failure = {
+                    kind: 'EMPLOYEE_SCOPE',
+                    fieldId: field.id,
+                    fieldName: field.name,
+                    ...(entry.row ? { dataIndex: entry.row.dataIndex } : {}),
+                    scopeType,
+                    input: content,
+                    reason: selected.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
+                    candidates: selected.map((c) => ({ id: c.id, name: c.name })),
+                    resolution: `将该值改为 {"optionId":"候选id","content":"候选名称","type":"${scopeType}"} 后重新 prepare。`,
+                };
+                break;
+            }
+            const chosen = selected[0];
+            resolved.push({
+                optionId: String(chosen.id),
+                content: String(chosen.name),
+                type: scopeType,
+                ...(chosen.raw && typeof chosen.raw === 'object' ? { optionObj: chosen.raw } : {}),
+            });
+        }
+        if (failure) {
+            failures.set(entry, failure);
+            continue;
+        }
+        entry.value = Array.isArray(entry.value) ? resolved : resolved[0];
+    }
+    return failures;
+}
+/**
+ * 浏览按钮字段「名称→ID 未命中」时的候选澄清（V12.1.22 定稿）。
+ *
+ * 名称→ID 走的是 `nameToId`（`/api/ai/chat/fieldMapping/getRelateData`），它**一个关键词只回一个
+ * "最佳匹配"**，未命中时给不出任何候选 —— 于是 `ambiguities[].candidates` 只能是空数组，模型只能
+ * 自己换相近词瞎猜（2026-09-16「费用类型=手机话费」实证：模型猜了"手机费"，最后干脆把字段删了）。
+ * 同文件里 **select 分支** `candidates: matches || choices` 是会回退给出**该字段全部可选项**的，
+ * 浏览按钮这一支缺了这个兜底。
+ *
+ * 这里改用字段自带的浏览接口（与人员范围同一套协议）
+ * `POST /api/{browserModule}/common/browser/complete/{browserType}`：
+ *   ① 先按关键词查一次（该接口与 nameToId 不是同一实现，可能命中 nameToId 命不中的值）；
+ *   ② 仍为空 → **再用空关键词**查一次，把该浏览控件首页的合法取值当候选返回，让模型/用户有据可依。
+ * 只对**真的没命中**的关键词发请求，命中路径零额外开销。
+ */
+async function browserFieldCandidates(env, field, keyword) {
+    const module = String(field?.browserModule ?? '').trim();
+    const btype = String(field?.browserType ?? '').trim();
+    if (!module || !btype)
+        return [];
+    const fetchOnce = async (searchValue) => {
+        let response;
+        try {
+            response = await env.host.workflowRequest({
+                method: 'POST',
+                path: `/api/${module}/common/browser/complete/${btype}`,
+                operation: 'name.resolve',
+                body: { browserMultiple: true, newly: 1, searchValue },
+            });
+        }
+        catch (error) {
+            // 与人员范围同口径：认证/网络错误原样抛出，其余（含接口不支持空关键词）按 0 命中处理。
+            rethrowAuthOrNetwork(error);
+            return [];
+        }
+        const data = responseData(response);
+        const list = data?.data?.data ?? data?.data;
+        if (!Array.isArray(list))
+            return [];
+        const out = [];
+        const seen = new Set();
+        for (const item of list) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const id = String(item.id ?? '').trim();
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            const name = String(item.name ?? item.content ?? '').trim();
+            if (!name)
+                continue;
+            out.push({ id, name });
+            if (out.length >= 20)
+                break; // 候选只用于澄清，截断防输出膨胀
+        }
+        return out;
+    };
+    const kw = String(keyword ?? '').trim();
+    const byKeyword = kw ? await fetchOnce(kw) : [];
+    if (byKeyword.length)
+        return byKeyword;
+    // 关键词查不到 → 取该浏览控件的合法取值清单（空关键词枚举首页）
+    const all = await fetchOnce('');
+    return all.filter((c) => c.name.toLowerCase() !== kw.toLowerCase());
+}
+async function resolveEntryValues(env, entries, formId) {
+    // 人员范围先做名称→ID（它不走 nameToId，也不该被当成普通浏览按钮字段）
+    const employeeScopeFailures = await preResolveEmployeeScopeEntries(env, entries);
+    const fieldDatas = [];
+    const seenLookups = new Set();
+    // 待查关键词 → {字段, 原始关键词}：名称→ID 未命中时据此补一次候选澄清（见 browserFieldCandidates）
+    const lookupSpecs = new Map();
+    for (const entry of entries) {
+        const field = entry.field;
+        if (!field.isBrowser)
+            continue;
+        // 人员范围已在上一步解析完，不能再塞进 nameToId 的 fieldDatas（否则会把对象字面量当关键词送出去）
+        if (isEmployeeScopeField(field))
+            continue;
+        const row = (entry.row && typeof entry.row === 'object') ? entry.row : null;
+        const rowIndex = String((row && row.dataIndex) ?? '0');
+        const isDetail = Boolean(row);
+        for (const item of listValues(entry.value)) {
+            if (item && typeof item === 'object' && (item.id || item.optionId))
+                continue;
+            const keyword = String(item).trim();
+            if (!keyword)
+                continue;
+            const lookupKey = `${field.id}_${rowIndex}_${keyword}`;
+            if (seenLookups.has(lookupKey))
+                continue;
+            seenLookups.add(lookupKey);
+            lookupSpecs.set(lookupKey, { field, keyword });
+            fieldDatas.push({
+                fieldId: String(field.id),
+                componentKey: field.componentKey || '',
+                fieldValue: keyword,
+                rowIndex,
+                operateType: 'add',
+                isDetail,
+                subFormId: String(field.subFormId || '0'),
+                browserModule: field.browserModule || '',
+                browserType: field.browserType || '',
+            });
+        }
+    }
+    const mappings = {};
+    if (fieldDatas.length) {
+        const response = await requestJson(env, 'POST', FORM_ENDPOINTS.nameToId, AJAX_QUERY, { formId: String(formId), fieldDatas });
+        const relateData = (response && typeof response === 'object') ? response.relateData : null;
+        if (!relateData || typeof relateData !== 'object')
+            throw workflowApiError('format_error', 'getRelateData 未返回 data.relateData 对象');
+        for (const resultKey of Object.keys(relateData)) {
+            if (!resultKey.includes('_'))
+                continue;
+            const keywordMapping = relateData[resultKey];
+            if (!keywordMapping || typeof keywordMapping !== 'object')
+                continue;
+            const idx = resultKey.lastIndexOf('_');
+            const fieldId = resultKey.slice(0, idx);
+            const rowIndex = resultKey.slice(idx + 1);
+            for (const keyword of Object.keys(keywordMapping)) {
+                const normalized = normalizeRelateCandidate(keywordMapping[keyword]);
+                mappings[`${fieldId}_${rowIndex}_${keyword}`] = normalized ? [normalized] : [];
+            }
+        }
+    }
+    // 名称→ID 未命中的浏览按钮：补一次候选澄清（只对真的没命中的关键词发请求）。
+    // 有了候选清单，模型的 `ambiguities[].resolution` 才有据可依（把合法取值列给用户选），
+    // 而不是拿到空数组后自己换相近词硬猜（见 browserFieldCandidates 的说明）。
+    const browserHints = {};
+    for (const [key, spec] of lookupSpecs) {
+        if (mappings[key] && mappings[key].length)
+            continue;
+        if (!spec.field.browserModule || !spec.field.browserType)
+            continue;
+        browserHints[key] = await browserFieldCandidates(env, spec.field, spec.keyword);
+    }
+    const details = [];
+    const ambiguities = [];
+    const preview = [];
+    for (const entry of entries) {
+        const field = entry.field;
+        const scopeFailure = employeeScopeFailures.get(entry);
+        if (scopeFailure) {
+            ambiguities.push(scopeFailure);
+            continue;
+        }
+        let detail;
+        let display;
+        try {
+            [detail, display] = serializeValue(field, entry.value, mappings, entry.row, browserHints);
+        }
+        catch (err) {
+            if (err instanceof ValueAmbiguity) {
+                ambiguities.push(err.details);
+                continue;
+            }
+            throw err;
+        }
+        if (detail && hasDetailValue(detail)) {
+            details.push(detail);
+            const pv = {
+                fieldId: field.id,
+                fieldName: field.name,
+                subFormId: field.subFormId || '',
+                value: display,
+            };
+            if (entry.row)
+                pv.dataIndex = entry.row.dataIndex;
+            preview.push(pv);
+            if (detail && display !== entry.value)
+                entry.value = display;
+        }
+    }
+    return [details, ambiguities, preview];
+}
+// ---------------------------------------------------------------------------
+// 字段联动 / 显示属性联动 / 必填校验
+// ---------------------------------------------------------------------------
+function linkageContextFromPayload(payload) {
+    return {
+        layout: payload.layout,
+        runtime: payload.runtime,
+        frame: payload.frame,
+        linkageActions: payload.linkageActions,
+    };
+}
+function buildLinkageContext(base) {
+    return {
+        layout: base.layout,
+        runtime: base.runtime,
+        frame: base.frame,
+        linkageActions: base.linkageActions,
+    };
+}
+function _buildLinkageRunData(linkageActions, changedFieldIds, actionTypes) {
+    const changed = new Set([...changedFieldIds].map((f) => String(f).trim()).filter(Boolean));
+    const actionTypeSet = actionTypes ? new Set([...actionTypes].map((s) => String(s))) : null;
+    const runData = [];
+    if (!Array.isArray(linkageActions))
+        return runData;
+    for (const action of linkageActions) {
+        if (!action || typeof action !== 'object')
+            continue;
+        const actionType = String(action.actionType ?? 'changeField');
+        const targetField = String(action.targetField ?? '').trim();
+        if (actionType === 'onblur')
+            continue;
+        if (actionType === 'changeField') {
+            if (actionTypeSet !== null && !actionTypeSet.has('changeField'))
+                continue;
+            if (!targetField || !changed.has(targetField))
+                continue;
+        }
+        else {
+            if (actionTypeSet === null || !actionTypeSet.has(actionType))
+                continue;
+        }
+        const ids = action.idList;
+        if (!Array.isArray(ids) || !ids.length)
+            continue;
+        runData.push({ linkageIds: ids.map(String), actionType, targetField });
+    }
+    return runData;
+}
+function _entriesFromDefaults(defaults) {
+    const entries = [];
+    for (const detail of defaults || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const formField = (detail.formField && typeof detail.formField === 'object') ? detail.formField : {};
+        const fieldId = String(formField.id ?? '').trim();
+        if (!fieldId)
+            continue;
+        const options = detail.dataOptions;
+        let value = null;
+        if (Array.isArray(options) && options.length) {
+            value = options.filter((o) => o && typeof o === 'object' && String(o.optionId ?? '').trim()).map((o) => ({ id: String(o.optionId ?? ''), name: String(o.content ?? o.optionId ?? '') }));
+        }
+        else if (detail.dataText && typeof detail.dataText === 'object') {
+            const t = String(detail.dataText.content ?? '').trim();
+            if (t)
+                value = t;
+        }
+        else {
+            const t = String(detail.content ?? '').trim();
+            if (t)
+                value = t;
+        }
+        if (value === null || (Array.isArray(value) && !value.length))
+            continue;
+        const entry = { field: { id: fieldId, componentKey: String(formField.componentKey ?? ''), isBrowser: Array.isArray(options) && Boolean(options.length) }, value };
+        const subForm = (detail.subForm && typeof detail.subForm === 'object') ? detail.subForm : null;
+        const subFormId = String(detail.subFormId ?? (subForm && subForm.id) ?? '').trim();
+        if (subFormId || detail.dataIndex !== undefined || detail.rowId) {
+            const row = { subForm: { id: subFormId || '' } };
+            if (detail.dataIndex !== undefined)
+                row.dataIndex = Number(detail.dataIndex);
+            if (detail.rowId)
+                row.rowId = String(detail.rowId);
+            entry.row = row;
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+function _neededLinkageFieldIds(linkageActions, runDataList) {
+    const needed = new Set();
+    if (!Array.isArray(linkageActions) || !runDataList.length)
+        return needed;
+    for (const run of runDataList) {
+        if (!run || typeof run !== 'object')
+            continue;
+        const runActionType = String(run.actionType ?? '');
+        const runIds = new Set((run.linkageIds || []).map(String));
+        const runTarget = String(run.targetField ?? '').trim();
+        for (const action of linkageActions) {
+            if (!action || typeof action !== 'object')
+                continue;
+            if (String(action.actionType ?? '') !== runActionType)
+                continue;
+            if (runTarget !== String(action.targetField ?? '').trim())
+                continue;
+            const actionIds = new Set((action.idList || []).map(String));
+            if (runIds.size && [...runIds].every((x) => actionIds.has(x))) {
+                const tf = String(action.targetField ?? '').trim();
+                if (tf)
+                    needed.add(tf);
+                for (const cf of action.conditionFieldList || []) {
+                    const c = String(cf ?? '').trim();
+                    if (c)
+                        needed.add(c);
+                }
+            }
+        }
+    }
+    return needed;
+}
+function _entryValueText(value) {
+    for (const item of listValues(value)) {
+        if (item && typeof item === 'object') {
+            for (const key of ['id', 'optionId']) {
+                if (item[key] !== undefined && item[key] !== null && String(item[key]).trim())
+                    return String(item[key]).trim();
+            }
+            for (const key of ['name', 'content']) {
+                if (item[key] !== undefined && item[key] !== null && String(item[key]).trim())
+                    return String(item[key]).trim();
+            }
+        }
+        else {
+            const t = String(item).trim();
+            if (t)
+                return t;
+        }
+    }
+    return '';
+}
+function _entryValueIds(value) {
+    const ids = [];
+    for (const item of listValues(value)) {
+        if (item && typeof item === 'object') {
+            for (const key of ['id', 'optionId', 'value']) {
+                if (item[key] !== undefined && item[key] !== null && String(item[key]).trim()) {
+                    ids.push(String(item[key]).trim());
+                    break;
+                }
+            }
+        }
+        else {
+            const t = String(item).trim();
+            if (t)
+                ids.push(t);
+        }
+    }
+    return ids;
+}
+function _detailValueIds(detail) {
+    const ids = [];
+    if (detail.content !== undefined && detail.content !== null) {
+        const t = String(detail.content).trim();
+        if (t)
+            ids.push(t);
+    }
+    if (detail.dataText && typeof detail.dataText === 'object' && detail.dataText.content !== undefined && detail.dataText.content !== null) {
+        const t = String(detail.dataText.content).trim();
+        if (t)
+            ids.push(t);
+    }
+    for (const option of detail.dataOptions || []) {
+        if (option && typeof option === 'object' && option.optionId !== undefined && option.optionId !== null) {
+            const t = String(option.optionId).trim();
+            if (t)
+                ids.push(t);
+        }
+    }
+    return ids;
+}
+function _linkageOptions(sourceContent) {
+    if (!sourceContent || typeof sourceContent !== 'string' || !sourceContent.trim())
+        return [];
+    let data;
+    try {
+        data = JSON.parse(sourceContent);
+    }
+    catch {
+        return [];
+    }
+    if (!data || typeof data !== 'object')
+        return [];
+    const result = [];
+    for (const item of data.dataOptions || []) {
+        if (item && typeof item === 'object') {
+            const id = String(item.optionId ?? '').trim();
+            const content = String(item.content ?? '').trim();
+            if (id)
+                result.push([id, content]);
+        }
+    }
+    for (const item of data.optionValues || []) {
+        if (item && typeof item === 'object') {
+            const tv = String(item.textValue ?? '').trim();
+            const name = String(item.name ?? '').trim();
+            if (tv)
+                result.push([tv, name]);
+        }
+    }
+    return result;
+}
+/**
+ * 联动条件里的"期望取值"（`sourceContent` 是 JSON 字符串）。
+ *
+ * 与 `_linkageOptions`（只服务条件命中判定，取 id/name 两元组）分开：本函数保留 **id + content**，
+ * 并在没有任何选项列表时回退到 `dataOptions`/`content` 标量（如 `{"formField":{"id":"…"},"content":"1"}`），
+ * 供 `conditionalRequired` 原样展示条件取值用。
+ */
+function _linkageConditionValues(sourceContent) {
+    if (!sourceContent || typeof sourceContent !== 'string' || !sourceContent.trim())
+        return [];
+    let data;
+    try {
+        data = JSON.parse(sourceContent);
+    }
+    catch {
+        return [];
+    }
+    if (!data || typeof data !== 'object')
+        return [];
+    const result = [];
+    for (const item of data.dataOptions || []) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = String(item.optionId ?? '').trim();
+        const content = String(item.content ?? '').trim();
+        if (id)
+            result.push(content ? { id, content } : { id });
+        else if (content)
+            result.push({ content });
+    }
+    for (const item of data.optionValues || []) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = String(item.textValue ?? '').trim();
+        const content = String(item.name ?? '').trim();
+        if (id)
+            result.push(content ? { id, content } : { id });
+        else if (content)
+            result.push({ content });
+    }
+    if (!result.length && data.content !== undefined && data.content !== null) {
+        const content = String(data.content).trim();
+        if (content)
+            result.push({ content });
+    }
+    return result;
+}
+/**
+ * 「条件必填」清单（V12.1.27 新增能力）。
+ *
+ * 背景：本租户 OA 的 `getFormLayout` 不下发静态必填标记（`viewRelateConfig` 为空、布局组件 `required`
+ * 全为 false），业务必填**只以「显示属性联动」形式存在**——`viewLinkages[]` 中 `linkageProp='required'`
+ * 的规则：条件命中时该字段才变必填。
+ *
+ * 这些规则原先只在 prepare 阶段按"实际所填数据"参与必填计算（命中才出现在 `missingFields`），
+ * form 阶段模型完全看不到 ⇒ 模型无法在发起前主动向用户问齐必填项，只能等用户恰巧填对触发字段
+ * （2026-09-17 分享会话实证：模型只能说"拿不到必填信息"，用户此前也反复反馈"没有必填字段"）。
+ *
+ * 本函数把规则**按 OA 原样结构化输出**（不评价、不做语义改写、不做条件求值）：`match` 取
+ * `condition.detailType`（AND/OR，缺省 AND），`term` 取 `detailSymbol` 原值
+ * （EQUAL/UN_EQUAL/IN/NOT_IN/NULL/NOT_NULL），`values` 为该条件的期望取值。
+ * **条件是否命中仍以 prepare 的 `missing_fields` 为准**。
+ * 无 required 规则时返回空数组（调用方按需省略该键）。
+ */
+function conditionalRequiredFields(linkages, rawFieldsById) {
+    if (!Array.isArray(linkages) || !linkages.length)
+        return [];
+    const fieldMeta = (fieldId) => {
+        const raw = rawFieldsById[fieldId];
+        if (!raw || typeof raw !== 'object')
+            return { name: '', subFormId: '' };
+        return {
+            name: String(raw.title ?? raw.name ?? raw.dataKey ?? '').trim(),
+            subFormId: String(raw.subFormId ?? '').trim(),
+        };
+    };
+    const result = [];
+    const seen = new Set();
+    for (const linkage of linkages) {
+        if (!linkage || typeof linkage !== 'object')
+            continue;
+        const condition = (linkage.condition && typeof linkage.condition === 'object') ? linkage.condition : null;
+        if (!condition)
+            continue;
+        const conditionDetails = Array.isArray(condition.conditionDetails) ? condition.conditionDetails : [];
+        const when = [];
+        for (const cd of conditionDetails) {
+            if (!cd || typeof cd !== 'object')
+                continue;
+            const conditionFieldId = String(cd.targetId ?? '').trim();
+            if (!conditionFieldId)
+                continue;
+            const item = { fieldId: conditionFieldId };
+            const meta = fieldMeta(conditionFieldId);
+            if (meta.name)
+                item.fieldName = meta.name;
+            item.term = String(cd.detailSymbol ?? 'EQUAL').trim().toUpperCase();
+            const sourceType = String(cd.sourceType ?? 'CONSTANT').trim().toUpperCase();
+            if (sourceType !== 'CONSTANT') {
+                item.sourceType = sourceType;
+                const sourceFieldId = String(cd.sourceId ?? '').trim();
+                if (sourceFieldId)
+                    item.sourceFieldId = sourceFieldId;
+            }
+            const values = _linkageConditionValues(cd.sourceContent);
+            if (values.length)
+                item.values = values;
+            when.push(item);
+        }
+        if (!when.length)
+            continue;
+        const match = String(condition.detailType ?? 'AND').trim().toUpperCase() || 'AND';
+        const details = Array.isArray(linkage.linkageDetails) ? linkage.linkageDetails : [];
+        for (const ld of details) {
+            if (!ld || typeof ld !== 'object')
+                continue;
+            if (String(ld.linkageProp ?? '').trim().toLowerCase() !== 'required')
+                continue;
+            for (const target of String(ld.linkageValue ?? '').split(',')) {
+                const fieldId = target.trim();
+                if (!fieldId)
+                    continue;
+                const dedupeKey = [fieldId, match, JSON.stringify(when)].join('\u0000');
+                if (seen.has(dedupeKey))
+                    continue;
+                seen.add(dedupeKey);
+                const meta = fieldMeta(fieldId);
+                const item = { fieldId };
+                if (meta.name)
+                    item.fieldName = meta.name;
+                if (meta.subFormId)
+                    item.subFormId = meta.subFormId;
+                item.match = match;
+                item.when = when;
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+function _normalizeSystemFieldValues(businessOperatorObj) {
+    const result = {};
+    if (!businessOperatorObj || typeof businessOperatorObj !== 'object')
+        return result;
+    for (const key of Object.keys(businessOperatorObj)) {
+        const value = businessOperatorObj[key];
+        const ids = systemFieldValueIds(value);
+        if (ids.length)
+            result[String(key).trim()] = ids;
+    }
+    return result;
+}
+function systemFieldValueIds(value) {
+    const ids = [];
+    if (value && typeof value === 'object') {
+        const optionValues = value.optionValues;
+        if (Array.isArray(optionValues)) {
+            for (const item of optionValues) {
+                if (item && typeof item === 'object') {
+                    for (const raw of [item.textValue, item.name]) {
+                        if (raw !== undefined && raw !== null && String(raw).trim())
+                            ids.push(String(raw).trim());
+                    }
+                }
+                else {
+                    const t = String(item).trim();
+                    if (t)
+                        ids.push(t);
+                }
+            }
+        }
+        else {
+            for (const key of ['textValue', 'content', 'value']) {
+                if (value[key] !== undefined && value[key] !== null && String(value[key]).trim())
+                    ids.push(String(value[key]).trim());
+            }
+        }
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value)
+            ids.push(...systemFieldValueIds(item));
+    }
+    else {
+        const t = String(value).trim();
+        if (t)
+            ids.push(t);
+    }
+    return ids;
+}
+function rowKeyFor(subFormId, dataIndex) {
+    const sub = String(subFormId ?? '').trim();
+    if (!sub)
+        return 'main';
+    return `${sub}:${dataIndex ?? 1}`;
+}
+function _detailDisplayText(detail) {
+    if (detail.content !== undefined && detail.content !== null && String(detail.content).trim())
+        return String(detail.content).trim();
+    if (detail.dataText && typeof detail.dataText === 'object' && detail.dataText.content !== undefined && detail.dataText.content !== null && String(detail.dataText.content).trim()) {
+        return String(detail.dataText.content).trim();
+    }
+    const options = detail.dataOptions;
+    if (Array.isArray(options) && options.length) {
+        return options.map((o) => String(o.content ?? o.optionId ?? '')).filter(Boolean).join('、');
+    }
+    return '';
+}
+function _mainValueMap(details) {
+    const result = {};
+    for (const detail of details || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const subForm = (detail.subForm && typeof detail.subForm === 'object') ? detail.subForm : null;
+        if (subForm && String(subForm.id ?? '').trim())
+            continue;
+        if (String(detail.subFormId ?? '').trim())
+            continue;
+        const fid = String((detail.formField && detail.formField.id) ?? '').trim();
+        if (fid)
+            result[fid] = detail;
+    }
+    return result;
+}
+async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false) {
+    const changedIds = entries.filter((e) => e.field && typeof e.field === 'object' && String(e.field.id ?? '').trim())
+        .map((e) => String(e.field.id));
+    const runDataList = _buildLinkageRunData(ctx.linkageActions, changedIds, actionTypes);
+    const neededIds = _neededLinkageFieldIds(ctx.linkageActions, runDataList);
+    const dataList = [];
+    const collectedIds = new Set();
+    const pushItem = (field, value, row) => {
+        const fieldId = String(field.id ?? '').trim();
+        if (!fieldId || !neededIds.has(fieldId))
+            return;
+        const valueText = _entryValueText(value);
+        const item = { fieldId, componentKey: String(field.componentKey ?? ''), content: valueText };
+        if (row && typeof row === 'object') {
+            const subFormId = String((row.subForm && row.subForm.id) ?? '').trim();
+            if (subFormId)
+                item.subFormId = subFormId;
+            if (row.dataIndex !== undefined)
+                item.dataIndex = Number(row.dataIndex);
+            if (row.rowId)
+                item.rowId = String(row.rowId);
+        }
+        const options = [];
+        for (const vi of listValues(value)) {
+            if (vi && typeof vi === 'object' && vi.id)
+                options.push({ id: String(vi.id), name: String(vi.name ?? vi.content ?? vi.id) });
+        }
+        if (options.length)
+            item.optionList = options;
+        dataList.push(item);
+        collectedIds.add(fieldId);
+    };
+    for (const entry of entries) {
+        if (!entry.field || typeof entry.field !== 'object')
+            continue;
+        pushItem(entry.field, entry.value, entry.row);
+    }
+    if (allDetails) {
+        for (const extra of _entriesFromDefaults(allDetails)) {
+            const fld = extra.field;
+            if (!fld || typeof fld !== 'object')
+                continue;
+            const eid = String(fld.id ?? '').trim();
+            if (!eid || !neededIds.has(eid) || collectedIds.has(eid))
+                continue;
+            pushItem(fld, extra.value, extra.row);
+        }
+    }
+    if (!dataList.length && !runDataList.length)
+        return [];
+    const executeParam = {
+        formId: ctx.layout.form_id,
+        module: 'workflow',
+        dataList,
+        runDataList,
+        moduleDataList: [],
+    };
+    if (isEdit) {
+        const runtime = ctx.runtime || {};
+        const frame = ctx.frame || {};
+        executeParam.customParam = {
+            permissionType: Number(frame.permission_type ?? 1),
+            requestId: ctx.requestId ?? runtime.request_id,
+            workflowId: (ctx.workflow && ctx.workflow.id) ?? runtime.workflow_id,
+            nodeId: runtime.node_id ?? '',
+            dataSrc: 'NEW',
+            authSignatureStr: runtime.auth_signature ?? '',
+            authStr: runtime.auth_str ?? '',
+            readOnly: false,
+            identityId: runtime.identity_id ?? '',
+            identityType: Number(runtime.identity_type ?? 0),
+            isTest: false,
+            create: false,
+            mobile: false,
+            formId: ctx.formId ?? ctx.layout.form_id,
+            dataId: ctx.dataId ?? runtime.request_id,
+            source: 'view',
+            isAgent: false,
+            beAgentId: '0',
+            hideSysFieldArea: true,
+            viewFormNodeId: frame.view_form_node_id ?? runtime.node_id ?? '',
+            timestamp: Date.now(),
+            turnTodoUser: [],
+            sysFieldNewMode: true,
+            isOverrideViewConfig: true,
+        };
+        executeParam.businessFields = ctx.businessFields || [];
+    }
+    else {
+        const runtime = ctx.runtime || {};
+        if (runtime.request_id)
+            executeParam.refId = runtime.request_id;
+        const frame = ctx.frame || {};
+        if (frame.layout_multi_id)
+            executeParam.layoutId = frame.layout_multi_id;
+    }
+    const payload = { formId: ctx.layout.form_id, module: 'workflow', executeParam };
+    const relateType = (ctx.frame && ctx.frame.relate_type) || '';
+    const endpoint = formApiUrl(FORM_ENDPOINTS.fdLinkage, relateType);
+    const response = await requestJson(env, 'POST', endpoint, AJAX_QUERY, payload);
+    // requestJson 内部已解包一层（responseData），此处不可再取 .data
+    const data = (response && typeof response === 'object') ? response : null;
+    const linkageList = (data && typeof data === 'object') ? data.linkageDataList : null;
+    if (!Array.isArray(linkageList))
+        return [];
+    return linkageList.filter((i) => i && typeof i === 'object').map((i) => normalizeDetail(i));
+}
+function mergeLinkageDetails(merged, linkageDetails) {
+    const keyOf = (detail) => {
+        const formField = (detail.formField && typeof detail.formField === 'object') ? detail.formField : {};
+        const subForm = (detail.subForm && typeof detail.subForm === 'object') ? detail.subForm : {};
+        return [String(subForm.id ?? '').trim(), String(detail.dataIndex ?? '').trim(), String(formField.id ?? '').trim()];
+    };
+    if (!linkageDetails || !linkageDetails.length)
+        return [...merged];
+    const result = [...merged];
+    const indexByKey = new Map();
+    result.forEach((d, i) => indexByKey.set(keyOf(d).join('\u0000'), i));
+    for (const linkageDetail of linkageDetails) {
+        const key = keyOf(linkageDetail);
+        if (!key[2])
+            continue;
+        const joined = key.join('\u0000');
+        if (indexByKey.has(joined)) {
+            result[indexByKey.get(joined)] = linkageDetail;
+        }
+        else {
+            result.push(linkageDetail);
+            indexByKey.set(joined, result.length - 1);
+        }
+    }
+    return result;
+}
+function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues) {
+    const hiddenSubforms = new Set();
+    const rowHidden = {};
+    const rowExtraRequired = {};
+    const rowDisabled = {};
+    if (!Array.isArray(linkages))
+        return [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled];
+    const rowAdd = (target, rowKey, fieldId) => {
+        (target[rowKey] || (target[rowKey] = new Set())).add(fieldId);
+    };
+    const rowDiscard = (target, rowKey, fieldId) => {
+        if (target[rowKey])
+            target[rowKey].delete(fieldId);
+    };
+    const fieldValues = {};
+    for (const detail of defaults || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const formField = (detail.formField && typeof detail.formField === 'object') ? detail.formField : {};
+        const fieldId = String(formField.id ?? '').trim();
+        if (!fieldId)
+            continue;
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        const dataIndex = detail.dataIndex;
+        const rowKey = rowKeyFor(subFormId, dataIndex);
+        (fieldValues[rowKey] || (fieldValues[rowKey] = {}))[fieldId] = (fieldValues[rowKey][fieldId] || []).concat(_detailValueIds(detail));
+    }
+    for (const detail of linkageDetails || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const formField = (detail.formField && typeof detail.formField === 'object') ? detail.formField : {};
+        const fieldId = String(formField.id ?? '').trim();
+        if (!fieldId)
+            continue;
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        const dataIndex = detail.dataIndex;
+        const rowKey = rowKeyFor(subFormId, dataIndex);
+        (fieldValues[rowKey] || (fieldValues[rowKey] = {}))[fieldId] = _detailValueIds(detail);
+    }
+    for (const entry of entries) {
+        const field = entry.field;
+        if (!field || typeof field !== 'object')
+            continue;
+        const fieldId = String(field.id ?? '').trim();
+        if (!fieldId)
+            continue;
+        const row = (entry.row && typeof entry.row === 'object') ? entry.row : null;
+        const subFormId = row ? String((row.subForm && row.subForm.id) ?? '').trim() : String(field.subFormId ?? '').trim();
+        const dataIndex = row ? row.dataIndex : null;
+        const rowKey = rowKeyFor(subFormId, dataIndex);
+        (fieldValues[rowKey] || (fieldValues[rowKey] = {}))[fieldId] = _entryValueIds(entry.value);
+    }
+    if (systemFieldValues) {
+        const mainValues = (fieldValues.main || (fieldValues.main = {}));
+        for (const sysKey of Object.keys(systemFieldValues)) {
+            if (systemFieldValues[sysKey].length)
+                (mainValues[sysKey] || (mainValues[sysKey] = [])).push(...systemFieldValues[sysKey]);
+        }
+    }
+    if (!fieldValues.main)
+        fieldValues.main = {};
+    for (const linkage of linkages) {
+        if (!linkage || typeof linkage !== 'object')
+            continue;
+        const condition = linkage.condition;
+        if (!condition || typeof condition !== 'object')
+            continue;
+        const conditionDetails = condition.conditionDetails;
+        if (!Array.isArray(conditionDetails) || !conditionDetails.length)
+            continue;
+        const detailType = String(condition.detailType ?? 'AND').trim().toUpperCase();
+        const cdHitSets = [];
+        for (const cd of conditionDetails) {
+            if (!cd || typeof cd !== 'object')
+                continue;
+            const triggerId = String(cd.targetId ?? '').trim();
+            if (!triggerId)
+                continue;
+            const detailSymbol = String(cd.detailSymbol ?? 'EQUAL').trim().toUpperCase();
+            const sourceType = String(cd.sourceType ?? 'CONSTANT').trim().toUpperCase();
+            const sourceIsVariable = sourceType === 'VARIABLE';
+            let condValues;
+            if (sourceIsVariable) {
+                const sourceId = String(cd.sourceId ?? '').trim();
+                if (!sourceId)
+                    continue;
+                condValues = [];
+            }
+            else {
+                condValues = _linkageOptions(cd.sourceContent).flatMap((p) => [p[0], p[1]]);
+            }
+            if (detailSymbol !== 'NULL' && detailSymbol !== 'NOT_NULL' && !sourceIsVariable && !condValues.length)
+                continue;
+            const matchedRows = new Set();
+            for (const rowKey of Object.keys(fieldValues)) {
+                const values = fieldValues[rowKey][triggerId] || [];
+                let condVals = condValues;
+                if (sourceIsVariable) {
+                    condVals = fieldValues[rowKey][String(cd.sourceId ?? '').trim()] || [];
+                    if (detailSymbol !== 'NULL' && detailSymbol !== 'NOT_NULL' && !condVals.length)
+                        continue;
+                }
+                if (detailSymbol === 'NULL') {
+                    if (!values.length)
+                        matchedRows.add(rowKey);
+                }
+                else if (detailSymbol === 'NOT_NULL') {
+                    if (values.length)
+                        matchedRows.add(rowKey);
+                }
+                else if (detailSymbol === 'UN_EQUAL' || detailSymbol === 'NOT_IN') {
+                    if (values.length && !values.some((v) => condVals.includes(v)))
+                        matchedRows.add(rowKey);
+                }
+                else {
+                    if (values.some((v) => condVals.includes(v)))
+                        matchedRows.add(rowKey);
+                }
+            }
+            cdHitSets.push(matchedRows);
+        }
+        if (!cdHitSets.length)
+            continue;
+        let hitRows;
+        if (detailType === 'AND') {
+            hitRows = new Set(cdHitSets[0]);
+            for (const rows of cdHitSets.slice(1))
+                hitRows = new Set([...hitRows].filter((r) => rows.has(r)));
+        }
+        else {
+            hitRows = new Set();
+            for (const rows of cdHitSets)
+                for (const r of rows)
+                    hitRows.add(r);
+        }
+        if (!hitRows.size)
+            continue;
+        for (const ld of linkage.linkageDetails || []) {
+            if (!ld || typeof ld !== 'object')
+                continue;
+            const linkageObj = String(ld.linkageObj ?? '').trim().toLowerCase();
+            const linkageProp = String(ld.linkageProp ?? '').trim().toLowerCase();
+            for (const target of String(ld.linkageValue ?? '').split(',')) {
+                const t = target.trim();
+                if (!t)
+                    continue;
+                if (linkageObj === 'detail' && (linkageProp === 'hide' || linkageProp === 'hideline')) {
+                    hiddenSubforms.add(t);
+                    continue;
+                }
+                if (linkageProp === 'show' && linkageObj === 'detail') {
+                    hiddenSubforms.delete(t);
+                    continue;
+                }
+                for (const rowKey of hitRows) {
+                    if (linkageProp === 'hide' || linkageProp === 'hideline')
+                        rowAdd(rowHidden, rowKey, t);
+                    else if (linkageProp === 'show')
+                        rowDiscard(rowHidden, rowKey, t);
+                    else if (linkageProp === 'required')
+                        rowAdd(rowExtraRequired, rowKey, t);
+                    else if (linkageProp === 'disabled')
+                        rowAdd(rowDisabled, rowKey, t);
+                }
+            }
+        }
+    }
+    return [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled];
+}
+function mergeDetails(defaults, supplied) {
+    const result = new Map();
+    const keyOf = (detail) => {
+        const formField = (detail.formField && typeof detail.formField === 'object') ? detail.formField : {};
+        const subForm = (detail.subForm && typeof detail.subForm === 'object') ? detail.subForm : {};
+        return [String(subForm.id ?? '').trim(), String(detail.dataIndex ?? '').trim(), String(formField.id ?? '').trim()].join('\u0000');
+    };
+    for (const detail of [...(defaults || []), ...(supplied || [])]) {
+        const normalized = normalizeDetail(detail);
+        if (!normalized)
+            continue;
+        const key = keyOf(normalized);
+        if (hasDetailValue(normalized))
+            result.set(key, normalized);
+        else
+            result.delete(key);
+    }
+    return [...result.values()];
+}
+/** 用户本轮**已建的明细行**：subFormId → `[{dataIndex, rowId}]`（取自入参 entries 的明细行）。 */
+function userDetailRows(entries) {
+    const rows = {};
+    for (const entry of entries || []) {
+        if (!entry || !entry.row)
+            continue;
+        const sub = String((entry.row.subForm && entry.row.subForm.id) ?? '').trim();
+        if (!sub)
+            continue;
+        const list = rows[sub] || (rows[sub] = []);
+        const di = entry.row.dataIndex;
+        if (list.some((r) => String(r.dataIndex) === String(di)))
+            continue;
+        list.push({ dataIndex: di, rowId: entry.row.rowId });
+    }
+    return rows;
+}
+/**
+ * 把「**没有行号的明细默认值**」补到用户已建的行上（V12.1.35）。
+ *
+ * OA `defaultDetails` 里的明细类默认值**不带 `dataIndex`**（实测 6/6，形如
+ * `{formField:{id}, dataOptions:[{optionId,content}], subForm:{id}}`），而明细字段的
+ * **判缺失**与**写载荷**都按 `subFormId + dataIndex + fieldId` 索引 ⇒ 不补就会两处踩：
+ *  ① 判缺失查的是 `sub\0行号\0field`（行号来自用户入参），默认值的键却是 `sub\0空\0field`
+ *     ⇒ **永远比不中** ⇒ 「明细里已有默认值的必填字段」被**误报缺失**
+ *     （实例：`币种` 默认「人民币」、明在 `initialValues` 里，仍进 `missingFields`）；主表键固定为
+ *     `\0\0field`、与默认值同键，所以主表 18 个默认值都没问题，**只有明细会踩**；
+ *  ② 载荷里的默认值因没有行号而落不到行上。
+ *
+ * **只补缺口、不做任何语义判断**：某个 `(subFormId, dataIndex, fieldId)` 已经有值（用户填的、或联动
+ * 带出的）就原样留着不覆盖；**有行号的默认值原样保留**；该明细没有用户行时也原样保留。
+ */
+function fillDetailDefaultsByRow(details, detailDefaults, rowsBySubform) {
+    const out = [...(details || [])];
+    const present = new Set(out.map((d) => [
+        String((d && d.subForm && d.subForm.id) ?? '').trim(),
+        String(d && d.dataIndex !== undefined && d.dataIndex !== null ? d.dataIndex : '').trim(),
+        String((d && d.formField && d.formField.id) ?? '').trim(),
+    ].join('\u0000')));
+    for (const def of detailDefaults || []) {
+        if (!def)
+            continue;
+        const sub = String((def.subForm && def.subForm.id) ?? '').trim();
+        const fid = String((def.formField && def.formField.id) ?? '').trim();
+        const hasRow = def.dataIndex !== undefined && def.dataIndex !== null
+            && String(def.dataIndex).trim() !== '';
+        const rows = sub ? rowsBySubform[sub] : undefined;
+        if (!sub || !fid || hasRow || !rows || !rows.length)
+            continue;
+        for (const row of rows) {
+            const key = [sub, String(row.dataIndex).trim(), fid].join('\u0000');
+            if (present.has(key))
+                continue;
+            const copy = { ...def, dataIndex: row.dataIndex };
+            if (row.rowId !== undefined && row.rowId !== null)
+                copy.rowId = row.rowId;
+            out.push(copy);
+            present.add(key);
+        }
+    }
+    return out;
+}
+function missingRequiredFields(fields, entries, details, hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled, hiddenFieldIds, compsFieldIds, layoutSubformIds) {
+    const present = new Set((details || []).filter((d) => hasDetailValue(d)).map((d) => {
+        const formField = (d.formField && typeof d.formField === 'object') ? d.formField : {};
+        const subForm = (d.subForm && typeof d.subForm === 'object') ? d.subForm : {};
+        return [String(subForm.id ?? '').trim(), String(d.dataIndex ?? '').trim(), String(formField.id ?? '').trim()].join('\u0000');
+    }));
+    const rowsBySubform = {};
+    for (const entry of entries) {
+        if (entry.row) {
+            const sub = String(entry.row.subForm.id);
+            (rowsBySubform[sub] || (rowsBySubform[sub] = new Set())).add(String(entry.row.dataIndex));
+        }
+    }
+    const missing = [];
+    for (const field of fields) {
+        if (field.readOnly || field.disableEdit)
+            continue;
+        const fieldId = String(field.id ?? '');
+        if (hiddenFieldIds.has(fieldId))
+            continue;
+        const subFormId = String(field.subFormId ?? '');
+        if (subFormId && hiddenSubforms.has(subFormId))
+            continue;
+        if (subFormId && layoutSubformIds.size && !layoutSubformIds.has(subFormId))
+            continue;
+        if (!subFormId) {
+            if (compsFieldIds.size && !compsFieldIds.has(fieldId))
+                continue;
+            const rowKey = rowKeyFor('');
+            if ((rowHidden[rowKey] || new Set()).has(fieldId) || (rowDisabled[rowKey] || new Set()).has(fieldId))
+                continue;
+            if (!(field.required || (rowExtraRequired[rowKey] || new Set()).has(fieldId)))
+                continue;
+            if (!present.has(['', '', fieldId].join('\u0000')))
+                missing.push({ id: fieldId, name: field.name, subFormId: '' });
+            continue;
+        }
+        for (const dataIndex of [...(rowsBySubform[subFormId] || new Set())].sort()) {
+            const rowKey = rowKeyFor(subFormId, dataIndex);
+            if ((rowHidden[rowKey] || new Set()).has(fieldId) || (rowDisabled[rowKey] || new Set()).has(fieldId))
+                continue;
+            if (!(field.required || (rowExtraRequired[rowKey] || new Set()).has(fieldId)))
+                continue;
+            if (!present.has([subFormId, dataIndex, fieldId].join('\u0000'))) {
+                missing.push({ id: fieldId, name: field.name, subFormId, dataIndex: Number(dataIndex) });
+            }
+        }
+    }
+    return missing;
+}
+function buildPreviewDetails(preview) {
+    const groups = {};
+    for (const item of preview || []) {
+        const subFormId = String(item.subFormId ?? '').trim();
+        if (!subFormId)
+            continue;
+        const fieldId = String(item.fieldId ?? '').trim();
+        const fieldName = String(item.fieldName ?? '').trim();
+        if (!fieldId || !fieldName)
+            continue;
+        const group = groups[subFormId] || (groups[subFormId] = { subFormId, name: '', columns: [], row_map: {} });
+        if (!group.columns.some((c) => c.fieldName === fieldName))
+            group.columns.push({ fieldId, fieldName });
+        const dataIndex = item.dataIndex;
+        const rowKey = String(dataIndex !== undefined && dataIndex !== null ? dataIndex : '0');
+        const row = group.row_map[rowKey] || (group.row_map[rowKey] = { dataIndex, values: {} });
+        row.values[fieldId] = previewValueText(item.value);
+    }
+    const result = [];
+    for (const subFormId of Object.keys(groups).sort()) {
+        const group = groups[subFormId];
+        const rows = Object.keys(group.row_map).sort().map((rk) => ({
+            dataIndex: group.row_map[rk].dataIndex,
+            values: group.columns.map((c) => group.row_map[rk].values[c.fieldId] ?? ''),
+        }));
+        result.push({ subFormId, name: group.name, columns: group.columns, rows });
+    }
+    return result;
+}
+function previewValueText(value) {
+    if (Array.isArray(value) && value.length && value.every((i) => i && typeof i === 'object')) {
+        const names = value.map((i) => String(i.name ?? i.content ?? '').trim()).filter(Boolean);
+        if (names.length)
+            return names.join('、');
+    }
+    return value;
+}
+function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, hiddenFieldIds, compsFieldIds, entries, layoutSubformIds) {
+    if (!linkageDetails || !linkageDetails.length)
+        return '';
+    const nameById = new Map();
+    for (const f of fields)
+        nameById.set(String(f.id ?? ''), f.name || '');
+    const entryFieldIds = new Set(entries.filter((e) => e.field && typeof e.field === 'object').map((e) => String(e.field.id)));
+    const brought = [];
+    const cleared = [];
+    for (const detail of linkageDetails) {
+        const fieldId = String((detail.formField && detail.formField.id) ?? '').trim();
+        if (!fieldId)
+            continue;
+        if (hiddenFieldIds.has(fieldId))
+            continue;
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        if (!subFormId && compsFieldIds.size && !compsFieldIds.has(fieldId))
+            continue;
+        if (subFormId && layoutSubformIds.size && !layoutSubformIds.has(subFormId))
+            continue;
+        const dataIndex = detail.dataIndex;
+        const rowKey = rowKeyFor(subFormId, dataIndex);
+        if ((rowHidden[rowKey] || new Set()).has(fieldId))
+            continue;
+        const field = fields.find((f) => String(f.id ?? '') === fieldId);
+        if (field && hiddenSubforms.has(String(field.subFormId ?? '')))
+            continue;
+        const name = nameById.get(fieldId) || fieldId;
+        const display = _detailDisplayText(detail);
+        if (!display) {
+            if (entryFieldIds.has(fieldId))
+                cleared.push(name);
+            continue;
+        }
+        brought.push(`${name}=${display}`);
+    }
+    let result = '';
+    if (brought.length)
+        result += '字段联动带出：' + brought.join('、') + '。';
+    if (cleared.length)
+        result += '字段联动清空：' + cleared.join('、') + '。';
+    return result;
+}
+// ---------------------------------------------------------------------------
+// createPrepare / createApply
+// ---------------------------------------------------------------------------
+async function commandCreatePrepare(args, env) {
+    const token = String(args.context ?? '');
+    if (!token)
+        throw workflowValidationError('context_required', '需要 createForm 返回的 continuation（context）');
+    const lease = await verifyContextLease(env, token, 'workflow.createForm');
+    const context = lease.payload;
+    const [main, detailValues] = splitInput(args.data);
+    const fields = Array.isArray(context.fields) ? context.fields : [];
+    const [entries, fieldAmbiguities] = bindInputFields(main, detailValues, fields);
+    if (fieldAmbiguities.length) {
+        return workflowSuccess('workflow.createPrepare', {
+            status: 'NEEDS_CONFIRMATION',
+            contextId: token,
+            message: '存在重名或无法识别的表单字段，请改用字段 id。',
+            ambiguities: fieldAmbiguities,
+        });
+    }
+    const readonlyHits = readonlyEntryViolations(entries);
+    if (readonlyHits.length) {
+        return workflowSuccess('workflow.createPrepare', {
+            status: 'NEEDS_CONFIRMATION',
+            contextId: token,
+            message: '以下字段是只读/禁止手工编辑字段，不能填写：' + readonlyHits.map((h) => h.name || h.fieldId).join('、'),
+            notEditable: readonlyHits,
+        });
+    }
+    const [details, valueAmbiguities, preview] = await resolveEntryValues(env, entries, context.layout.form_id);
+    const merged = mergeDetails(context.defaults || [], details);
+    const linkageDetails = await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false);
+    // 明细默认值无行号，而判缺失/写载荷都按行号索引 ⇒ 按用户已建行补齐缺口（V12.1.35，
+    // 详见 fillDetailDefaultsByRow 注释）。放在联动之后合并，联动带出的值仍然优先。
+    const merged2 = fillDetailDefaultsByRow(mergeLinkageDetails(merged, linkageDetails), context.defaults || [], userDetailRows(entries));
+    const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
+    const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
+    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], linkageDetails, context.systemFieldValues);
+    const initialHidden = new Set(fields.filter((f) => f.display === false).map((f) => String(f.id ?? '')));
+    if (initialHidden.size) {
+        const mh = new Set(rowHidden.main || []);
+        for (const id of initialHidden)
+            mh.add(id);
+        rowHidden.main = mh;
+    }
+    const missing = missingRequiredFields(fields, entries, merged2, hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), new Set(context.layoutSubformIds || []));
+    const sysPermissions = (context.systemFields && context.systemFields.permissions) || {};
+    const sysDefaults = (context.systemFields && context.systemFields.defaults) || {};
+    const requestLevelArg = String(args.requestLevel ?? '').trim();
+    const secLevelArg = String(args.secLevel ?? '').trim();
+    const requestNameValue = String(args.requestName ?? sysDefaults.requestName ?? '').trim();
+    const requestLevelValue = requestLevelArg || String(sysDefaults.requestLevel ?? '').trim();
+    const secLevelValue = secLevelArg || String(sysDefaults.secLevel ?? '').trim();
+    const systemMissing = [];
+    for (const sysKey of Object.keys(SYSTEM_FIELD_KEYS)) {
+        const perm = sysPermissions[sysKey] || {};
+        if (!perm.isview)
+            continue;
+        const value = { REQUEST_NAMEL: requestNameValue, REQUEST_LEVEL: requestLevelValue, SECLEVEL: secLevelValue }[sysKey];
+        if (perm.ismandatory && !value)
+            systemMissing.push({ key: sysKey, name: SYSTEM_FIELD_KEYS[sysKey], subFormId: '', systemField: true });
+    }
+    const intent = String(args.intent ?? 'submit');
+    if (valueAmbiguities.length || ((missing.length || systemMissing.length) && intent !== 'draft')) {
+        return workflowSuccess('workflow.createPrepare', {
+            status: valueAmbiguities.length ? 'NEEDS_CONFIRMATION' : 'NEEDS_INPUT',
+            contextId: token,
+            message: valueAmbiguities.length ? '存在无法唯一解析的选项，或无法匹配的浏览按钮值，请让用户确认。' : '缺少必填字段。',
+            // 已解析成功的字段回显（V12.1.34）：入参给的是名称时，这里给出**服务端最终解析结果**
+            // （选项给名称、浏览/人员/部门给 {id,name} 数组），模型据此自查"我传的值到底变成了什么对象"，
+            // 不必把不确定性转嫁给用户确认。READY 时同一内容在 `fields`（确认预览），此处不再重复。
+            // 之前这条短路返回完全没有回显，模型因此抱怨"prepare 输出里看不到字段预览"。
+            resolvedValues: preview,
+            ambiguities: valueAmbiguities,
+            missingFields: [...missing, ...systemMissing],
+            linkageResult: linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), entries, new Set(context.layoutSubformIds || [])),
+            ...folderPayload,
+        });
+    }
+    const requestName = String(args.requestName ?? sysDefaults.requestName ?? context.runtime.default_request_name ?? context.workflow.name ?? '新建流程').trim();
+    if (!requestName)
+        throw workflowValidationError('input_invalid', 'request_name 不能为空');
+    const inputFieldIds = [...new Set(entries.map((e) => String((e.field && e.field.id) ?? '')).filter(Boolean))];
+    const prepared = {
+        dataDetails: merged2,
+        requestName,
+        requestLevel: requestLevelValue,
+        secLevel: secLevelValue,
+        remark: String(args.remark ?? ''),
+        preview,
+        previewDetails: buildPreviewDetails(preview),
+        intent,
+        missingFields: (intent === 'draft') ? [...missing, ...systemMissing] : [],
+        inputFieldIds,
+    };
+    const session = await getSessionContext(env);
+    const outToken = await env.continuation.issue({
+        operation: 'workflow.createPrepare',
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        payload: { context, prepared },
+    }, CONTINUATION_TTL_MS);
+    return workflowSuccess('workflow.createPrepare', {
+        status: 'READY',
+        contextId: outToken,
+        requestId: context.runtime.request_id,
+        workflow: context.workflow,
+        requestName,
+        requestLevel: requestLevelValue,
+        secLevel: secLevelValue,
+        fields: preview,
+        previewDetails: buildPreviewDetails(preview),
+        confirmationRequired: true,
+        linkageResult: linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), entries, new Set(context.layoutSubformIds || [])),
+        missingFields: (intent === 'draft') ? [...missing, ...systemMissing] : [],
+        ...folderPayload,
+        message: (!missing.length && !systemMissing.length)
+            ? '尚未调用 saveFormData 和 flow/create。请向用户展示预览并获得明确确认。'
+            : `仅发起保存（draft）模式：以下必填字段未填写：${[...missing, ...systemMissing].map((m) => m.name).join('、')}。可继续 create 保存草稿，或补全字段后重新 prepare。`,
+        continuation: outToken,
+    });
+}
+function formatRemark(value) {
+    const text = String(value ?? '').trim();
+    if (!text)
+        return '_weaverMte_';
+    if (text.startsWith('_weaverMte_'))
+        return text;
+    return `_weaverMte_<p>${text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>`;
+}
+function buildSaveBody(context, prepared) {
+    const runtime = context.runtime;
+    return {
+        module: 'workflow',
+        customParam: {
+            isCreate: true,
+            requestId: runtime.request_id,
+            isTest: false,
+            secretLevel: '0',
+            secretLevelValidity: '',
+            nodeId: runtime.node_id,
+            workflowId: context.workflow.id,
+            type: 23,
+            authSignatureStr: runtime.auth_signature,
+            authStr: runtime.auth_str,
+            identityId: runtime.identity_id,
+            identityType: runtime.identity_type,
+            monitorEditFormData: false,
+        },
+        employeeId: runtime.employee_id,
+        formData: {
+            module: 'workflow',
+            presetDataId: runtime.request_id,
+            dataDetails: prepared.dataDetails,
+            client: 'pc',
+            dataStatus: 'temporary',
+            form: { id: context.layout.form_id },
+            formLayout: { id: context.layout.layout_id },
+        },
+    };
+}
+/**
+ * 取出 prepare 阶段算好的载荷。
+ *
+ * `createPrepare`/`editPrepare` 签发的结构是 **`payload: {context, prepared}`** —— `prepared` 与
+ * `context` **平级**，并不在 `context` 里面。历史上这里直接读 `context.prepared`，于是：
+ *  - 发起（createApply）：`flow/create` 之前构造请求体时 `context.prepared` 为 undefined，
+ *    读 `requestLevel` 直接抛 TypeError（internal/unexpected）⇒ **流程根本创建不出来**；
+ *  - 修改（editApply）：退化成 `{}` ⇒ `dataDetails` 恒为空数组 ⇒ **改了半天一个字段都没存进去**。
+ * 现在统一走这一个出口：优先用调用方传下来的平级 `prepared`，同时兼容旧的嵌套形态。
+ */
+function resolvePrepared(context, prepared) {
+    if (prepared && typeof prepared === 'object' && Object.keys(prepared).length)
+        return prepared;
+    const nested = context?.prepared;
+    return (nested && typeof nested === 'object') ? nested : {};
+}
+function buildCreateBody(context, prepared, saved, src) {
+    const runtime = context.runtime;
+    return {
+        workflowId: context.workflow.id,
+        isCreate: true,
+        apiModule: 'workflow',
+        identityId: runtime.identity_id,
+        identityType: runtime.identity_type,
+        requestId: runtime.request_id,
+        userCurrentNodeId: runtime.node_id,
+        fixedNodeId: runtime.node_id,
+        isAgent: false,
+        beAgentId: '0',
+        authStr: runtime.auth_str,
+        authSignatureStr: runtime.auth_signature,
+        isTest: false,
+        pageKey: `create_${context.workflow.id}_${Date.now()}`,
+        requestLevel: String(prepared.requestLevel ?? '0').trim(),
+        secLevel: String(prepared.secLevel ?? '0').trim(),
+        secValidity: '',
+        needWfBack: true,
+        sameOperateId: null,
+        customBtnId: null,
+        confirmSecondSubmit: false,
+        selectFlowParam: null,
+        freeChoiceNodeIds: null,
+        nodeAddOperators: null,
+        requestName: prepared.requestName,
+        dataId: saved.data_id,
+        recordId: saved.record_id,
+        saveFormTime: saved.save_form_time,
+        voteSubmit: false,
+        sealId: null,
+        unNeedVerifyPrivacyAgreement: 1,
+        remark: formatRemark(prepared.remark),
+        attachments: [],
+        fileData: [],
+        locationData: {},
+        comment: {
+            relevanceList: [],
+            imAtContent: formatRemark(prepared.remark) !== '_weaverMte_' ? formatRemark(prepared.remark) : '',
+            originContent: formatRemark(prepared.remark) !== '_weaverMte_' ? formatRemark(prepared.remark) : '',
+            atLinkList: [],
+            content: formatRemark(prepared.remark),
+        },
+        quoteData: [],
+        fullTextAnnotationData: [],
+        signatureData: { signatureImgId: '' },
+        userSignatureData: { signatureImgId: '' },
+        src,
+        clientType: 0,
+    };
+}
+function parseSaveResponse(response) {
+    const data = responseData(response);
+    if (!data || typeof data !== 'object')
+        throw workflowPartialError('saveFormData 成功但返回恢复标识不完整，禁止自动重试', { stage: 'saveFormData' });
+    const values = {
+        data_id: String(data.id ?? '').trim(),
+        record_id: String(data.recordId ?? '').trim(),
+        save_form_time: String(data.logDate ?? '').trim(),
+    };
+    if (!values.data_id || !values.record_id || !values.save_form_time) {
+        throw workflowPartialError('saveFormData 成功但返回恢复标识不完整，禁止自动重试', { stage: 'saveFormData', ...values });
+    }
+    return values;
+}
+function parseCreateResponse(response, expectedRequestId) {
+    if (!response || typeof response !== 'object')
+        throw workflowPartialError('flow/create 返回格式错误，禁止自动重试', { stage: 'flow/create' });
+    const success = response.status === true || [0, 200, '0', '200'].includes(response.code) || [0, 200, '0', '200'].includes(response.status);
+    if (!success || response.flowIsCreateSuccess === false || response.fail === true) {
+        throw workflowPartialError(String(response.resultMessage ?? response.msg ?? 'flow/create 未确认成功'), { stage: 'flow/create' });
+    }
+    const sources = [response];
+    let cursor = 0;
+    while (cursor < sources.length) {
+        const source = sources[cursor++];
+        for (const key of ['data', 'result', 'workflowBaseInfo', 'requestInfo']) {
+            const nested = source[key];
+            if (nested && typeof nested === 'object' && !sources.includes(nested))
+                sources.push(nested);
+        }
+    }
+    const firstText = (...keys) => {
+        for (const source of sources) {
+            for (const key of keys) {
+                const v = String(source[key] ?? '').trim();
+                if (v)
+                    return v;
+            }
+        }
+        return '';
+    };
+    const returnedId = firstText('requestId', 'requestid');
+    if (returnedId && returnedId !== expectedRequestId) {
+        throw workflowPartialError('flow/create 返回了不同的 requestId，禁止自动重试', { stage: 'flow/create' });
+    }
+    return {
+        requestId: returnedId || expectedRequestId,
+        requestMark: firstText('requestMark', 'requestmark', 'requestCode'),
+        requestName: firstText('requestName', 'requestname'),
+    };
+}
+async function runCreateNodeFieldVerification(env, context) {
+    const runtime = context.runtime;
+    const requestId = String(runtime.request_id ?? '').trim();
+    const nodeId = String(runtime.node_id ?? '').trim();
+    const result = { enabled: false, results: [], blocked: false, passed: true, reminders: [], error: '' };
+    if (!requestId || !nodeId) {
+        result.error = '缺少 requestId 或 nodeId，跳过节点字段校验';
+        return result;
+    }
+    const baseUrl = (await getSessionContext(env)).baseUrl;
+    const referer = `${baseUrl}/sp/workflow/flowpage/create/${context.workflow.id}?workflowId=${context.workflow.id}&isCreate=1`;
+    const conf = await requestJson(env, 'GET', FORM_ENDPOINTS.conformanceSet, {
+        requestId, nodeId, entryMode: 2, triggerOperation: '0', delete: 'false',
+    }, undefined);
+    // requestJson 内部已解包一层（responseData），此处不可再取 .data
+    const confData = (conf && typeof conf === 'object') ? conf : null;
+    const cptBase = (confData && confData.cptBase) ? confData.cptBase : null;
+    const cptSetList = (confData && confData.cptSetList) ? confData.cptSetList : null;
+    if (!cptBase || typeof cptBase !== 'object' || !Array.isArray(cptSetList) || !cptSetList.length)
+        return result;
+    if (Number(cptBase.openNodeCheck ?? 0) !== 1)
+        return result;
+    result.enabled = true;
+    const ruleSet = [];
+    for (const rule of cptSetList) {
+        if (!rule || typeof rule !== 'object')
+            continue;
+        ruleSet.push({
+            ruleName: String(rule.ruleName ?? ''),
+            verificationResult: '检测中…',
+            rowId: randomUUID().replace(/-/g, ''),
+            conditionKey: String(rule.conditionKey ?? ''),
+            rulePassTip: String(rule.rulePassTip ?? ''),
+            ruleNoPassTip: String(rule.ruleNoPassTip ?? ''),
+            verificationStatus: 0,
+            processType: Number(rule.processType ?? 1),
+            cptSetId: String(rule.id ?? ''),
+            ruleType: Number(rule.ruleType ?? 0),
+        });
+    }
+    const dataResult = await requestJson(env, 'POST', FORM_ENDPOINTS.verificationRequestData, undefined, {
+        requestId, nodeId, ruleSet, isCooperate: 0, isTest: 0, testUserId: String(runtime.employee_id ?? ''),
+    });
+    // requestJson 内部已解包一层（responseData），此处不可再取 .data
+    const dataPayload = (dataResult && typeof dataResult === 'object') ? dataResult : null;
+    if (!dataPayload || typeof dataPayload !== 'object') {
+        result.error = 'getRequestDataByRequestId 未返回有效数据';
+        return result;
+    }
+    const requestData = dataPayload.requestData || [];
+    const systemContents = dataPayload.systemContents || [];
+    for (const rule of ruleSet) {
+        const verdict = await requestJson(env, 'POST', FORM_ENDPOINTS.verificationConditionRule, undefined, {
+            requestId, nodeId, identityId: '', cptSetId: rule.cptSetId, conditionKey: rule.conditionKey, requestData, systemContents,
+        });
+        // requestJson 内部已解包一层（responseData），此处不可再取 .data
+        const vdata = (verdict && typeof verdict === 'object') ? verdict : null;
+        const status = Number((vdata && vdata.status) ?? 0);
+        const ruleType = Number(rule.ruleType ?? 0);
+        const reason = String((vdata && vdata.reason) ?? '').trim();
+        const ruleResult = String((vdata && vdata.result) ?? '').trim();
+        const tip = ruleType === 2 ? reason : ruleResult;
+        const item = { ruleName: rule.ruleName, status, result: tip, reason, ruleType };
+        result.results.push(item);
+        if (status === 3)
+            result.reminders.push(item);
+    }
+    const ruleRelation = Number(cptBase.ruleRelation ?? 0);
+    const statuses = result.results.map((r) => r.status);
+    result.blocked = ruleRelation === 1 ? !statuses.some((s) => s === 1) : statuses.some((s) => s === 2);
+    result.ruleRelation = ruleRelation;
+    result.passPopUpPrompt = Number(cptBase.passPopUpPrompt ?? 0);
+    result.noPassPrompt = Number(cptBase.noPassPrompt ?? 0);
+    result.passed = !result.blocked;
+    return result;
+}
+async function commandCreateApply(args, env) {
+    if (args.confirm !== true)
+        throw workflowValidationError('confirm_required', '必须在用户明确确认后传入 confirm=true');
+    const token = String(args.context ?? '');
+    if (!token)
+        throw workflowValidationError('context_required', '需要 createPrepare 返回的 continuation（context）');
+    const lease = await verifyContextLease(env, token, 'workflow.createPrepare', true);
+    const { context, prepared } = lease.payload;
+    // 只读硬拦截兜底：复核 prepare 记录的输入字段此刻是否仍可写
+    const inputIds = prepared.inputFieldIds || [];
+    if (inputIds.length) {
+        const fieldsById = new Map((context.fields || []).map((f) => [String(f.id ?? ''), f]));
+        const readonlyHits = inputIds.filter((fid) => {
+            const f = fieldsById.get(fid);
+            return f && (f.readOnly || f.disableEdit);
+        }).map((fid) => ({ fieldId: fid, name: (fieldsById.get(fid) || {}).name ?? fid }));
+        if (readonlyHits.length) {
+            throw workflowPolicyError('field_readonly', '提交数据包含只读/禁止手工编辑字段，已停止保存：' + readonlyHits.map((h) => h.name || h.fieldId).join('、'), { notEditable: readonlyHits });
+        }
+    }
+    // 保存时字段联动（EVENT_SAVE_DATA）
+    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
+        const saveDetails = prepared.dataDetails || [];
+        const saveEntries = _entriesFromDefaults(saveDetails);
+        if (saveEntries.length) {
+            try {
+                const saveLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), saveEntries, new Set(['EVENT_SAVE_DATA']), saveDetails, false);
+                if (saveLinkage.length)
+                    prepared.dataDetails = mergeLinkageDetails(saveDetails, saveLinkage);
+            }
+            catch {
+                /* 写操作红线：不确定不重试，仅跳过 */
+            }
+        }
+    }
+    // 阶段推进到"要发写入请求了"：此后再被中止/杀掉，重放只能按**结果不确定**处理（先只读核对），
+    // 而在此之前被中止则允许安全重试同一句柄。写不进阶段就中止（宁可不发，也不留无法判定的一次性写入）。
+    await env.continuation.markStage(token, 'saving');
+    let saveData;
+    try {
+        const saveResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: formApiUrl(FORM_ENDPOINTS.save, context.frame.relate_type),
+            query: { formId: context.layout.form_id, ...AJAX_QUERY },
+            body: buildSaveBody(context, prepared),
+            operation: 'workflow.createApply',
+        });
+        saveData = parseSaveResponse(saveResponse);
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw workflowPartialError('saveFormData 请求发送后连接中断，是否已创建不确定，禁止自动重试，请通过 workflow.list 复核', { attempted: { requestId: context.runtime.request_id } }, { stage: 'saveFormData' });
+        }
+        throw error;
+    }
+    const submitIntent = String(args.intent ?? 'submit') === 'submit';
+    let verification = {};
+    let needConfirm = false;
+    if (submitIntent) {
+        verification = await runCreateNodeFieldVerification(env, context);
+        const reminders = verification.reminders || [];
+        needConfirm = verification.enabled
+            ? (Boolean(reminders.length && verification.noPassPrompt === 1) || (!reminders.length && verification.passPopUpPrompt === 1))
+            : false;
+    }
+    const createSrc = (submitIntent && !verification.blocked && !(needConfirm && args.verificationConfirmed !== true)) ? 'submit' : 'save';
+    // 提交时字段联动（EVENT_SUBMIT_OR_AGREE）
+    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
+        const submitDetails = prepared.dataDetails || [];
+        const submitEntries = _entriesFromDefaults(submitDetails);
+        if (submitEntries.length) {
+            try {
+                const submitLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), submitEntries, new Set(['EVENT_SUBMIT_OR_AGREE']), submitDetails, false);
+                if (submitLinkage.length)
+                    prepared.dataDetails = mergeLinkageDetails(submitDetails, submitLinkage);
+            }
+            catch {
+                /* 跳过 */
+            }
+        }
+    }
+    let created;
+    try {
+        const createResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: FORM_ENDPOINTS.create,
+            query: AJAX_QUERY,
+            body: buildCreateBody(context, resolvePrepared(context, prepared), saveData, createSrc),
+            operation: 'workflow.createApply',
+        });
+        // parseCreateResponse 需读外层 status/code 并向下遍历 data/result，必须传原始响应
+        created = parseCreateResponse(createResponse, context.runtime.request_id);
+        // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
+        // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
+        await env.continuation
+            .markStage(token, 'committed', { requestId: context.runtime.request_id })
+            .catch(() => undefined);
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw workflowPartialError('saveFormData 已成功，但 flow/create 结果失败或不确定；禁止自动重试。', { stage: 'flow/create', ...saveData }, { stage: 'flow/create' });
+        }
+        throw error;
+    }
+    const requestId = context.runtime.request_id;
+    const requestName = prepared.requestName;
+    const baseUrl = (await getSessionContext(env)).baseUrl;
+    const result = {
+        status: 'CREATED',
+        message: '流程已创建并保存为草稿。',
+        contextId: token,
+        requestId,
+        requestName,
+        requestId_alt: requestId,
+        requestMark: created.requestMark || null,
+        requestName_alt: created.requestName || requestName,
+        workflow: context.workflow,
+        url: `${baseUrl}/sp/workflow/flowpage/view/${requestId}?operResultType=SUCCESS_RELOAD_CURRENT_PAGE&userSpecifiedNodeId=0&autoMaxDisplay=0`,
+    };
+    if (submitIntent) {
+        if (verification.blocked) {
+            result.status = 'CREATED';
+            result.message = '流程已创建，但因节点字段校验未通过未提交审批，请调整后重新提交。';
+            result.verification = verification;
+        }
+        else if (needConfirm && args.verificationConfirmed !== true) {
+            result.status = 'CREATED';
+            result.message = '流程已创建，节点字段校验通过。是否继续提交审批？（确认后请告知，将用 submit 命令提交）';
+            result.needVerificationConfirm = true;
+            result.verification = verification;
+            result.nodeId = context.runtime.node_id;
+        }
+        else {
+            result.status = 'CREATED_SUBMITTED';
+            result.message = '流程已发起并提交审批。';
+            result.verification = verification;
+        }
+    }
+    return workflowSuccess('workflow.createApply', result);
+}
+// ---------------------------------------------------------------------------
+// editLoad / editPrepare / editSave
+// ---------------------------------------------------------------------------
+function buildEditDataLayoutRequest(requestId, workflowId, nodeId, formId, dataId, layoutMultiId, viewFormNodeId, permissionType, runtime) {
+    return {
+        terminalType: 'PC',
+        dataId,
+        formId,
+        module: 'workflow',
+        newLayout: true,
+        cacheUid: null,
+        layoutMultiId,
+        dataCrossLayout: false,
+        employeeId: runtime.employee_id,
+        refId: workflowId,
+        effectValues: [workflowId, nodeId],
+        allReadOnly: false,
+        initialDatas: [],
+        dynamicData: false,
+        cost: false,
+        customParam: {
+            permissionType,
+            requestId,
+            workflowId,
+            nodeId,
+            dataSrc: 'NEW',
+            authSignatureStr: runtime.auth_signature,
+            authStr: runtime.auth_str,
+            readOnly: false,
+            identityId: runtime.identity_id,
+            identityType: Number(runtime.identity_type ?? 0),
+            isTest: false,
+            create: false,
+            mobile: false,
+            formId,
+            dataId,
+            source: 'view',
+            isAgent: false,
+            beAgentId: '0',
+            hideSysFieldArea: true,
+            viewFormNodeId,
+            timestamp: Date.now(),
+            turnTodoUser: [],
+            sysFieldNewMode: true,
+            isOverrideViewConfig: true,
+        },
+        orgAsyncPageQuery: true,
+    };
+}
+async function commandEditLoad(args, env) {
+    const requestId = String(args.requestId ?? '').trim();
+    if (!requestId)
+        throw workflowValidationError('request_id_required', 'requestId 必填');
+    const query = { operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE', userSpecifiedNodeId: '0', autoMaxDisplay: '0', isCreate: 0, requestId, ...AJAX_QUERY };
+    const body = { operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE', userSpecifiedNodeId: '0', autoMaxDisplay: '0', isCreate: 0, requestId };
+    const baseResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body);
+    const frameResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadFrame, query, body);
+    const base = baseResp;
+    const frameData = frameResp;
+    const requestInfo = (base.requestInfo && typeof base.requestInfo === 'object') ? base.requestInfo : {};
+    const runtime = parseRuntime(base, requestId);
+    if (String(requestInfo.workflowId ?? '').trim())
+        runtime.workflow_id = String(requestInfo.workflowId).trim();
+    const frame = parseFrame(frameData, runtime.node_id);
+    const workflowId = runtime.workflow_id;
+    let minorInfo = {};
+    try {
+        const minorResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, { workflowId, isCreate: 1, ...AJAX_QUERY }, { workflowId, isCreate: 1, isMobile: 0 });
+        minorInfo = parseMinorInfo(minorResp);
+    }
+    catch {
+        minorInfo = {};
+    }
+    let tenantSetting = {};
+    try {
+        const settingResp = await requestJson(env, 'POST', FORM_ENDPOINTS.tenantSetting, undefined, { setType: [] });
+        tenantSetting = parseTenantSetting(settingResp);
+    }
+    catch {
+        tenantSetting = {};
+    }
+    const dataId = requestId;
+    const dlResp = await requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formDataAndLayout, frame.relate_type), { formId: frame.form_id, dataId, ...AJAX_QUERY }, buildEditDataLayoutRequest(requestId, workflowId, runtime.node_id, frame.form_id, dataId, frame.layout_multi_id, frame.view_form_node_id, frame.permission_type, runtime));
+    const dlData = dlResp;
+    if (!dlData || typeof dlData !== 'object')
+        throw workflowApiError('format_error', 'getFormDataAndLayout 未返回有效 data');
+    const vrc = Array.isArray(dlData.viewRelateConfig) ? dlData.viewRelateConfig : [];
+    const requiredMap = {};
+    const disableEditMap = {};
+    const displayMap = {};
+    for (const item of vrc) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const fid = String(item.fieldId ?? '').trim();
+        if (!fid)
+            continue;
+        requiredMap[fid] = Boolean(item.required);
+        disableEditMap[fid] = Boolean(item.disableEdit);
+        displayMap[fid] = item.display !== undefined ? Boolean(item.display) : true;
+    }
+    const fields = extractFields(dlData, requiredMap, disableEditMap, displayMap);
+    const rawFieldsById = walkLayoutRawFields(dlData.formLayout);
+    const attachConfigs = (dlData.attachConfigs && typeof dlData.attachConfigs === 'object') ? dlData.attachConfigs : {};
+    const rawUploadFields = _rawUploadFieldsMap(rawFieldsById, attachConfigs);
+    const formLayout = (dlData.formLayout && typeof dlData.formLayout === 'object') ? dlData.formLayout : {};
+    const compReadonlyIds = new Set();
+    const compDisableIds = new Set();
+    const compsFieldIds = new Set();
+    for (const page of formLayout.pageLayouts || []) {
+        if (!page || typeof page !== 'object')
+            continue;
+        for (const comp of page.comps || []) {
+            if (!comp || typeof comp !== 'object')
+                continue;
+            const cfg = comp.config || {};
+            const fid = String(cfg.fieldId ?? '').trim();
+            if (!fid)
+                continue;
+            compsFieldIds.add(fid);
+            if (comp.readOnly)
+                compReadonlyIds.add(fid);
+            if (comp.disableEdit || cfg.disableEdit)
+                compDisableIds.add(fid);
+        }
+    }
+    const currentDetails = (dlData.formData && dlData.formData.dataDetails ? dlData.formData.dataDetails : [])
+        .filter((i) => i && typeof i === 'object').map((i) => normalizeDetail(i)).filter(Boolean);
+    const fd = (dlData.formData && typeof dlData.formData === 'object') ? dlData.formData : {};
+    const newDataId = String(fd.id ?? dataId).trim();
+    const updateTimeStamp = String(fd.updateTimeStamp ?? '').trim();
+    const formObj = (dlData.form && typeof dlData.form === 'object') ? dlData.form : {};
+    const layoutId = String(formLayout.id ?? '').trim();
+    const editableIds = [];
+    for (const field of fields) {
+        const fid = String(field.id ?? '');
+        const subFid = String(field.subFormId ?? '');
+        if (subFid) {
+            if (!compReadonlyIds.has(fid) && !compDisableIds.has(fid))
+                editableIds.push(fid);
+            continue;
+        }
+        if (field.readOnly || field.disableEdit)
+            continue;
+        if (field.display === false)
+            continue;
+        if (compsFieldIds.size && !compsFieldIds.has(fid))
+            continue;
+        editableIds.push(fid);
+    }
+    const session = await getSessionContext(env);
+    const context = {
+        kind: 'EDIT',
+        version: 2,
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        oaBaseUrl: session.baseUrl,
+        requestId,
+        workflow: {
+            id: workflowId,
+            name: runtime.workflow_name,
+            description: runtime.workflow_description,
+            type_name: runtime.workflow_type_name,
+        },
+        runtime,
+        frame,
+        form_id: String(formObj.id ?? frame.form_id),
+        data_id: newDataId,
+        layout_id: layoutId,
+        update_time_stamp: updateTimeStamp,
+        employee_id: runtime.employee_id,
+        fields,
+        currentDetails,
+        rawUploadFields,
+        attachConfigs,
+        viewRelateConfig: vrc,
+        viewLinkages: Array.isArray(dlData.viewLinkages) ? dlData.viewLinkages : [],
+        linkageActions: Array.isArray(dlData.linkageActions) ? dlData.linkageActions : [],
+        businessFields: Array.isArray(dlData.businessFields) ? dlData.businessFields : [],
+        defaultDetails: (dlData.defaultDetails || []).filter((i) => i && typeof i === 'object').map((i) => normalizeDetail(i)).filter(Boolean),
+        editableIds: [...new Set(editableIds)],
+        requestInfo: {
+            requestName: runtime.default_request_name || '',
+            requestLevel: runtime.default_request_level || '',
+            secLevel: runtime.default_sec_level || '',
+            currentNodeName: String((base.requestInfo || {}).currentNodeName ?? ''),
+        },
+        minorInfo,
+        tenantSetting,
+    };
+    const token = await env.continuation.issue({ operation: 'workflow.editLoad', baseUrl: session.baseUrl, profile: session.profile, userId: session.userId, payload: context }, CONTINUATION_TTL_MS);
+    const fieldsById = new Map();
+    for (const f of fields)
+        fieldsById.set(String(f.id ?? ''), f);
+    const slimFields = [];
+    const folderOptionValues = _mainValueMap(currentDetails);
+    for (const field of fields) {
+        const item = { id: field.id, name: field.name, subFormId: field.subFormId, componentKey: field.componentKey };
+        if (field.required)
+            item.required = true;
+        for (const key of ['isBrowser', 'isSelect', 'isMultiple', 'browserType', 'browserModule']) {
+            if (field[key])
+                item[key] = field[key];
+        }
+        if (field.readOnly || field.disableEdit) {
+            item.readOnly = Boolean(field.readOnly);
+            item.disableEdit = Boolean(field.disableEdit);
+        }
+        if (String(field.componentKey ?? '').toLowerCase() === 'filecomponent') {
+            const fileFieldId = String(field.id ?? '');
+            if (fileFieldId && !(field.readOnly || field.disableEdit)) {
+                const rawFileField = rawFieldsById[fileFieldId] || {};
+                const attachCfg = attachConfigs[fileFieldId];
+                const [dirLayer] = _attachDirLayer(rawFileField, attachCfg);
+                let optionFieldRaw = null;
+                let optionValue = null;
+                if (String(dirLayer.folderSelectType ?? '').trim() === '1') {
+                    item.folderDependsOnOption = true;
+                    const optionFieldId = String(dirLayer.optionId ?? '').trim();
+                    if (optionFieldId) {
+                        optionFieldRaw = rawFieldsById[optionFieldId];
+                        optionValue = folderOptionValues[optionFieldId];
+                    }
+                }
+                const [folderId, sizeLimitMb, formatLimit, maxNum] = resolveFileUploadConstraints(rawFileField, tenantSetting, attachCfg || null, optionFieldRaw, optionValue);
+                item.fileUploadParams = buildFileUploadParams(runtime, frame, fileFieldId, false, minorInfo.sec_default_id || null, folderId, sizeLimitMb, formatLimit, maxNum, Boolean(field.readOnly || field.disableEdit));
+            }
+        }
+        if (String(field.format ?? '').trim())
+            item.format = String(field.format).trim();
+        const options = field.options || [];
+        if (options.length)
+            item.options = options;
+        slimFields.push(item);
+    }
+    const currentValues = [];
+    for (const detail of currentDetails) {
+        const fid = String((detail.formField && detail.formField.id) ?? '').trim();
+        const field = fieldsById.get(fid);
+        const row = {
+            fieldId: fid,
+            name: (field || {}).name ?? fid,
+            subFormId: (field || {}).subFormId || (detail.subForm && detail.subForm.id) || '',
+            value: _detailDisplayText(detail),
+        };
+        if (detail.dataIndex !== undefined)
+            row.dataIndex = detail.dataIndex;
+        if (detail.rowId)
+            row.rowId = detail.rowId;
+        currentValues.push(row);
+    }
+    // 可写字段补偿索引（同 createForm，见 encodeWritableFieldsCompact）：只在 `fields`
+    // 被整体移出 stdout 时随输出。只保留确实在本次字段清单里的 id，保证每行都有真实字段名。
+    const slimFieldIdSet = new Set(slimFields.map((f) => String(f.id ?? '')));
+    const editWritableIds = [...new Set((context.editableIds || []).map((x) => String(x)))]
+        .filter((id) => slimFieldIdSet.has(id));
+    const writableFieldsCompact = encodeWritableFieldsCompact(editWritableIds, slimFields, SYSTEM_FIELD_KEYS);
+    return workflowSuccess('workflow.editLoad', await compactFormOutput({
+        status: 'EDIT_READY',
+        contextId: token,
+        requestId,
+        workflow: context.workflow,
+        requestInfo: context.requestInfo,
+        form: { id: context.form_id, layout_id: layoutId, data_id: newDataId },
+        editableFields: context.editableIds,
+        currentValues,
+        fields: slimFields,
+        continuation: token,
+    }, env, 'last_edit_load.json', writableFieldsCompact));
+}
+function buildEditLinkageParam(context, dataList, runDataList) {
+    const runtime = context.runtime || {};
+    const frame = context.frame || {};
+    return {
+        formId: context.form_id,
+        module: 'workflow',
+        dataId: context.data_id,
+        employeeId: context.employee_id || runtime.employee_id || '',
+        customParam: {
+            permissionType: Number(frame.permission_type ?? 1),
+            requestId: context.request_id,
+            workflowId: context.workflow.id,
+            nodeId: runtime.node_id || '',
+            dataSrc: 'NEW',
+            authSignatureStr: runtime.auth_signature || '',
+            authStr: runtime.auth_str || '',
+            readOnly: false,
+            identityId: runtime.identity_id || '',
+            identityType: Number(runtime.identity_type ?? 0),
+            isTest: false,
+            create: false,
+            mobile: false,
+            formId: context.form_id,
+            dataId: context.data_id,
+            source: 'view',
+            isAgent: false,
+            beAgentId: '0',
+            hideSysFieldArea: true,
+            viewFormNodeId: frame.view_form_node_id || runtime.node_id || '',
+            timestamp: Date.now(),
+            turnTodoUser: [],
+            sysFieldNewMode: true,
+            isOverrideViewConfig: true,
+        },
+        businessFields: context.businessFields || [],
+        moduleDataList: [],
+        dataList,
+        runDataList,
+    };
+}
+async function commandEditPrepare(args, env) {
+    const token = String(args.context ?? '');
+    if (!token)
+        throw workflowValidationError('context_required', '需要 editLoad 返回的 continuation（context）');
+    const lease = await verifyContextLease(env, token, 'workflow.editLoad');
+    const context = lease.payload;
+    if (context.kind !== 'EDIT')
+        throw workflowValidationError('context_kind_invalid', '该上下文不是 edit 链路上下文（需先 edit-load）');
+    const [main, detailValues] = splitInput(args.data);
+    const fields = Array.isArray(context.fields) ? context.fields : [];
+    const [entries, fieldAmbiguities] = bindInputFields(main, detailValues, fields);
+    if (fieldAmbiguities.length) {
+        return workflowSuccess('workflow.editPrepare', {
+            status: 'NEEDS_CONFIRMATION',
+            contextId: token,
+            message: '存在重名或无法识别的表单字段，请改用字段 id。',
+            ambiguities: fieldAmbiguities,
+        });
+    }
+    const editableIds = new Set(context.editableIds || []);
+    for (const entry of entries) {
+        const fid = String((entry.field && entry.field.id) ?? '');
+        if (fid && !editableIds.has(fid)) {
+            return workflowSuccess('workflow.editPrepare', {
+                status: 'NEEDS_CONFIRMATION',
+                contextId: token,
+                message: `字段 ${(entry.field && entry.field.name) || fid} 不可编辑（只读/禁用/不可见），不能修改。`,
+                notEditable: { fieldId: fid, name: (entry.field && entry.field.name) || '' },
+            });
+        }
+    }
+    const [details, valueAmbiguities, preview] = await resolveEntryValues(env, entries, context.form_id);
+    if (valueAmbiguities.length) {
+        return workflowSuccess('workflow.editPrepare', {
+            status: 'NEEDS_CONFIRMATION',
+            contextId: token,
+            message: '存在无法唯一解析的选项，或无法匹配的浏览按钮值，请让用户确认。',
+            ambiguities: valueAmbiguities,
+            linkageResult: '',
+        });
+    }
+    const merged = mergeDetails(context.currentDetails || [], details);
+    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true);
+    const merged2 = mergeLinkageDetails(merged, linkageDetails);
+    const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
+    const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
+    const [hiddenSubforms, rowHidden, , rowDisabled] = computeLinkageVisibility(context.viewLinkages, entries, context.currentDetails || [], linkageDetails, context.systemFieldValues);
+    const previewAll = [...preview];
+    const fieldsById = new Map();
+    for (const f of fields)
+        fieldsById.set(String(f.id ?? ''), f);
+    for (const detail of linkageDetails) {
+        const fid = String((detail.formField && detail.formField.id) ?? '').trim();
+        const field = fieldsById.get(fid);
+        if (!field)
+            continue;
+        const subFid = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        if (subFid)
+            continue;
+        const displayText = _detailDisplayText(detail) || (detail.dataOptions || []).map((o) => String(o.content ?? '')).filter(Boolean).join('、');
+        if (!displayText)
+            continue;
+        previewAll.push({ fieldId: fid, fieldName: field.name || fid, subFormId: '', value: displayText, linkage: true });
+    }
+    const session = await getSessionContext(env);
+    const outToken = await env.continuation.issue({ operation: 'workflow.editPrepare', baseUrl: session.baseUrl, profile: session.profile, userId: session.userId, payload: { context, prepared: { dataDetails: merged2, preview: previewAll } } }, CONTINUATION_TTL_MS);
+    return workflowSuccess('workflow.editPrepare', {
+        status: 'READY',
+        contextId: outToken,
+        requestId: context.requestId,
+        workflow: context.workflow,
+        message: '表单修改已准备；确认后调用 edit-save 保存（不校验必填，仅保存表单字段）。',
+        changedFields: preview,
+        linkageResult: linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), entries, new Set(context.layoutSubformIds || [])),
+        ...folderPayload,
+        confirmationRequired: true,
+        continuation: outToken,
+    });
+}
+function buildEditSaveBody(context, prepared) {
+    const runtime = context.runtime || {};
+    return {
+        module: 'workflow',
+        customParam: {
+            isCreate: false,
+            requestId: context.request_id,
+            isTest: false,
+            secretLevel: '0',
+            secretLevelValidity: '',
+            nodeId: runtime.node_id || '',
+            workflowId: context.workflow.id,
+            type: 23,
+            authSignatureStr: runtime.auth_signature || '',
+            authStr: runtime.auth_str || '',
+            identityId: runtime.identity_id || '',
+            identityType: Number(runtime.identity_type ?? 0),
+            monitorEditFormData: false,
+        },
+        employeeId: context.employee_id || runtime.employee_id || '',
+        formData: {
+            id: context.data_id,
+            updateTimeStamp: context.update_time_stamp || '',
+            module: 'workflow',
+            dataDelRows: [],
+            dataDetails: prepared.dataDetails || [],
+            client: 'pc',
+            dataStatus: 'temporary',
+            form: { id: context.form_id },
+            formLayout: { id: context.layout_id || '' },
+        },
+    };
+}
+async function commandEditSave(args, env) {
+    if (args.confirm !== true)
+        throw workflowValidationError('confirm_required', 'edit-save 需要 confirm=true（用户已明确确认本次修改）');
+    const token = String(args.context ?? '');
+    if (!token)
+        throw workflowValidationError('context_required', '需要 editPrepare 返回的 continuation（context）');
+    const lease = await verifyContextLease(env, token, 'workflow.editPrepare', true);
+    const { context, prepared } = lease.payload;
+    if (context.kind !== 'EDIT')
+        throw workflowValidationError('context_kind_invalid', '该上下文不是 edit 链路上下文');
+    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
+        const saveDetails = prepared.dataDetails || [];
+        const saveEntries = _entriesFromDefaults(saveDetails);
+        if (saveEntries.length) {
+            try {
+                const saveLinkage = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, saveEntries, new Set(['EVENT_SAVE_DATA']), saveDetails, true);
+                if (saveLinkage.length)
+                    prepared.dataDetails = mergeLinkageDetails(saveDetails, saveLinkage);
+            }
+            catch {
+                /* 跳过 */
+            }
+        }
+    }
+    // 阶段推进到"要发写入请求了"：此后再被中止/杀掉，重放只能按**结果不确定**处理（先只读核对），
+    // 而在此之前被中止则允许安全重试同一句柄（与 createApply 对称）。
+    await env.continuation.markStage(token, 'saving');
+    let data;
+    try {
+        const saveResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: formApiUrl(FORM_ENDPOINTS.save, context.frame.relate_type),
+            query: { formId: context.form_id, ...AJAX_QUERY },
+            body: buildEditSaveBody(context, resolvePrepared(context, prepared)),
+            operation: 'workflow.editSave',
+        });
+        data = responseData(saveResponse);
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw workflowPartialError('saveFormData 请求发送后连接中断，是否已保存不确定，禁止自动重试，请重新查询流程表单确认', { stage: 'saveFormData' }, { stage: 'saveFormData' });
+        }
+        throw error;
+    }
+    // responseData 已解包一层，此处不可再取 .data
+    const saveData = (data && typeof data === 'object') ? data : null;
+    if (!saveData || typeof saveData !== 'object' || !String(saveData.id ?? '').trim()) {
+        throw workflowPartialError('saveFormData 返回异常，禁止自动重试', { stage: 'saveFormData' });
+    }
+    const newTimeStamp = String(saveData.updateTimeStamp ?? context.update_time_stamp ?? '');
+    // saveFormData 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
+    // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
+    await env.continuation
+        .markStage(token, 'committed', { requestId: context.request_id })
+        .catch(() => undefined);
+    return workflowSuccess('workflow.editSave', {
+        status: 'EDIT_SAVED',
+        contextId: token,
+        requestId: context.request_id,
+        workflow: context.workflow,
+        message: '流程表单内容已保存（仅保存表单字段，未提交流程）。',
+        saved: { data_id: String(saveData.id ?? ''), updateTimeStamp: newTimeStamp, recordId: String(saveData.recordId ?? '') },
+        saveLinkage: Boolean(resolvePrepared(context, prepared).dataDetails?.length),
+    });
+}
+// ---------------------------------------------------------------------------
+// createList（查询可发起工作流）
+// ---------------------------------------------------------------------------
+async function commandCreateList(args, env) {
+    const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, { wfpBelongTypeCode: '1', loadOfsFlow: '0', clientCtrl: 1 });
+    // requestJson 内部已解包一层（responseData），此处不可再取 .data
+    const data = (response && typeof response === 'object') ? response : null;
+    if (!data || typeof data !== 'object')
+        throw workflowApiError('format_error', '工作流列表返回 data 格式错误');
+    const workflowId = String(args.workflowId ?? '').trim();
+    if (workflowId) {
+        const authorized = simplifyWorkflows(data);
+        const exact = authorized.filter((item) => String(item.id ?? '').trim() === workflowId);
+        if (exact.length) {
+            return workflowSuccess('workflow.createList', {
+                status: 'SELECTED',
+                workflow: exact[0],
+                selectionSource: 'workflowId',
+                message: '已按记忆中的 workflowId 精确确认可发起工作流，无需用户选择。',
+            });
+        }
+        return workflowSuccess('workflow.createList', {
+            status: 'NOT_FOUND',
+            query: args.name || '',
+            workflowId,
+            message: '记忆中的 workflowId 不在当前用户可发起工作流列表中，可能已无发起权限或工作流已停用。',
+            workflows: [],
+        });
+    }
+    const result = simplifyWorkflows(data, String(args.name ?? ''));
+    if (!result.length) {
+        return workflowSuccess('workflow.createList', { status: 'NOT_FOUND', query: args.name || '', workflows: [] });
+    }
+    if (result.length === 1) {
+        return workflowSuccess('workflow.createList', { status: 'SELECTED', workflow: result[0] });
+    }
+    // 多命中时**先按全名精确匹配优选**：候选里恰好有一个名字与用户所写完全相同的（如"总部费用报销"
+    // 对上「总部费用报销 / 总部费用报销流程 / 总部费用报销（自定义）」），就直接选中它，不让用户
+    // 为"是不是要多打几个字"再选一次。这与查询侧 `resolveTerm` 的候选优选是**同一套判据**。
+    // 只有在"没有任何候选与所写完全一致"（或完全一致的有多个、仍是歧义）时才请用户选择。
+    const keyword = String(args.name ?? '').trim().toLowerCase();
+    const exact = keyword
+        ? result.filter((item) => String(item.workflowname ?? '').trim().toLowerCase() === keyword)
+        : [];
+    if (exact.length === 1) {
+        return workflowSuccess('workflow.createList', {
+            status: 'SELECTED',
+            workflow: exact[0],
+            selectionSource: 'exactName',
+            message: `名称与「${args.name}」完全一致的工作流只有 1 个，已直接选中，无需用户选择。`,
+        });
+    }
+    const selected = exact.length ? exact : result;
+    return workflowSuccess('workflow.createList', {
+        status: 'NEEDS_SELECTION',
+        message: '匹配到多个工作流，且其中没有与所写名称完全一致的，请让用户选择后再继续。',
+        query: args.name || '',
+        workflows: selected,
+    });
+}
+function simplifyWorkflows(data, name = '') {
+    const groups = Array.isArray(data.listDataGroup) ? data.listDataGroup : [];
+    const typeNames = {};
+    for (const item of groups) {
+        if (item && typeof item === 'object')
+            typeNames[String(item.id)] = String(item.typename ?? '');
+    }
+    const items = Array.isArray(data.listData) ? data.listData : [];
+    const keyword = name.trim().toLowerCase();
+    const result = [];
+    const seen = new Set();
+    for (const item of items) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const workflowId = String(item.workflowid ?? item.id ?? '').trim();
+        const wfName = String(item.workflowname ?? item.workflowName ?? '').trim();
+        if (!workflowId || !wfName || seen.has(workflowId))
+            continue;
+        if (keyword && !wfName.toLowerCase().includes(keyword))
+            continue;
+        seen.add(workflowId);
+        result.push({
+            id: workflowId,
+            workflowname: wfName,
+            workflowdesc: String(item.workflowdesc ?? ''),
+            typename: typeNames[String(item.type)] ?? '',
+        });
+    }
+    result.sort((a, b) => (a.typename + a.workflowname + a.id).localeCompare(b.typename + b.workflowname + b.id));
+    return result;
+}
+// ---------------------------------------------------------------------------
+// operation 定义
+// ---------------------------------------------------------------------------
+const workflowCreateList = {
+    name: 'workflow.createList',
+    resource: 'workflow',
+    method: 'createList',
+    action: 'workflow.createList',
+    summary: '查询当前用户可发起的工作流列表（按名称或记忆 workflowId 精确确认）',
+    capability: 'create',
+    risk: 'read',
+    requiresConfirmation: false,
+    inputSchema: schemaOf({
+        name: { type: 'string', description: '工作流名称关键字（模糊匹配）' },
+        workflowId: { type: 'string', description: '记忆中已确认的工作流 ID；传入时按当前用户可发起列表精确校验并优先选中' },
+    }, { required: [] }),
+    handler: (args, env) => commandCreateList(args, env),
+};
+const workflowCreateForm = {
+    name: 'workflow.createForm',
+    resource: 'workflow',
+    method: 'createForm',
+    action: 'workflow.createForm',
+    summary: '初始化发起流程表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出字段清单 + fileUploadParams（不落业务数据）',
+    capability: 'create',
+    risk: 'read',
+    requiresConfirmation: false,
+    inputSchema: schemaOf({
+        workflowId: SCHEMA_REQUEST_ID,
+        relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
+    }, { required: ['workflowId'] }),
+    handler: (args, env) => commandCreateForm(args, env),
+};
+const workflowCreatePrepare = {
+    name: 'workflow.createPrepare',
+    resource: 'workflow',
+    method: 'createPrepare',
+    action: 'workflow.createPrepare',
+    summary: '收集并准备表单数据：绑定字段、解析选项/浏览按钮、校验只读字段、触发字段联动，产出确认预览 + continuation（不落业务数据）',
+    capability: 'create',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        context: SCHEMA_CONTINUATION,
+        data: {
+            type: 'object',
+            description: '表单字段值，结构 {"main":{...},"details":{"<subFormId>":[{...}]}}',
+            additionalProperties: true,
+        },
+        requestName: { type: 'string', description: '流程标题（form 返回 requestName 非空时直接用其值；为空时由模型按内容生成）' },
+        requestLevel: { type: 'string', description: '紧急程度（取 systemFields.levelOptions 的 code）' },
+        secLevel: { type: 'string', description: '密级（取 systemFields.secLevelOptions 的 id）' },
+        remark: { type: 'string', description: '签字意见' },
+        intent: { type: 'string', enum: ['submit', 'draft'], description: '意图：submit=提交审批（必填缺失阻断）；draft=仅保存草稿（必填缺失不阻断）' },
+    }, { required: ['context', 'data', 'intent'] }),
+    handler: (args, env) => commandCreatePrepare(args, env),
+};
+const workflowCreateApply = {
+    name: 'workflow.createApply',
+    resource: 'workflow',
+    method: 'createApply',
+    action: 'workflow.createApply',
+    summary: '明确确认后发起流程：写前复核只读字段 → build_save_body → fdLinkage → saveFormData → flow/create；结果不确定抛 partial error 禁止重试',
+    capability: 'create',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        context: SCHEMA_CONTINUATION,
+        confirm: SCHEMA_CONFIRM,
+        intent: { type: 'string', enum: ['submit', 'draft'], description: '意图（必填，独立于 prepare 的 intent）：submit=创建并提交审批；draft=仅保存草稿' },
+        question: { type: 'string', description: '用户发起时的原话（记忆保存参考）' },
+        verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
+    }, { required: ['context', 'confirm', 'intent'] }),
+    handler: (args, env) => commandCreateApply(args, env),
+};
+const workflowEditLoad = {
+    name: 'workflow.editLoad',
+    resource: 'workflow',
+    method: 'editLoad',
+    action: 'workflow.editLoad',
+    summary: '加载已存在流程表单：formDataAndLayout 返回当前值 + 可编辑字段 + 只读标记',
+    capability: 'edit',
+    risk: 'read',
+    requiresConfirmation: false,
+    inputSchema: schemaOf({ requestId: SCHEMA_REQUEST_ID }, { required: ['requestId'] }),
+    handler: (args, env) => commandEditLoad(args, env),
+};
+const workflowEditPrepare = {
+    name: 'workflow.editPrepare',
+    resource: 'workflow',
+    method: 'editPrepare',
+    action: 'workflow.editPrepare',
+    summary: '修改流程表单字段并触发字段联动（不校验必填），产出预览 + continuation',
+    capability: 'edit',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        context: SCHEMA_CONTINUATION,
+        data: {
+            type: 'object',
+            description: '要修改的字段值，结构 {"main":{...},"details":{"<subFormId>":[{...}]}}',
+            additionalProperties: true,
+        },
+    }, { required: ['context', 'data'] }),
+    handler: (args, env) => commandEditPrepare(args, env),
+};
+const workflowEditApply = {
+    name: 'workflow.editApply',
+    resource: 'workflow',
+    method: 'editApply',
+    action: 'workflow.editApply',
+    summary: '明确确认后保存修改后的表单字段（仅 saveFormData，不调 flow/save/submit）；不确定结果抛 partial error',
+    capability: 'edit',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        context: SCHEMA_CONTINUATION,
+        confirm: SCHEMA_CONFIRM,
+    }, { required: ['context', 'confirm'] }),
+    handler: (args, env) => commandEditSave(args, env),
+};
+export const workflowFormOperations = [
+    workflowCreateList,
+    workflowCreateForm,
+    workflowCreatePrepare,
+    workflowCreateApply,
+    workflowEditLoad,
+    workflowEditPrepare,
+    workflowEditApply,
+];