weaver-e10-builder 1.0.8-beta → 1.0.10-beta

package/dist/services/actionflow/workflow_compiler.js

@@ -0,0 +1,1804 @@
+/**
+ * WorkflowDraft 到平台设计 JSON 的节点与拓扑编排。
+ * 对齐 Python 版 core/workflow_compiler.py（黄金参照）。
+ * 第 1 期聚焦：ApproveTrigger / ActionEbAdd / ActionEbUpdate / ActionEbDelete / Output 的编译主链。
+ */
+import { genSfId } from './id_generator.js';
+import fs from 'node:fs';
+import { get, getCompiler, getNodePost } from './components/index.js';
+import { findInMetadata, getTargetFormFields, getWorkflowDetailNames, getTargetDetailFields, getWorkflowDetailFields, getWorkflowFieldIds, workflowFieldId, getWorkflowContextFields, getWorkflowContextFieldsByKey } from './runtime_metadata.js';
+import { buildPersonFormula, buildSettingEntry, attachEsbAssign, resolveEnumConstant, resolveParamKey, resolveSourceFieldLabel, resolveSourceFieldType, normalizeConstantAssignment, lookupTargetFieldMeta, formulaFixedForAssignSwitch, formulaSystemVar, formulaContext, assignFlatContext, assignFlatContextDirect, getFormulaFn, formulaFunction, } from './formula_service.js';
+import { buildFormulaReference, buildUpdateFieldCondition } from './components/action_eb_update_compiler.js';
+import { resolveSystemParameter, isDateSystemParameter } from './system_params.js';
+import { conditionFieldFamily, filterFieldType, normalizeFilterOperator, conditionOperatorOverride, resolveFormCtx, buildFilterContextFormula, } from './filter_rules.js';
+const ENUM_COMPONENT_KEYS = new Set(['Select', 'RadioBox', 'Checkbox', 'MultiSelect', 'Radio']);
+function optionValues(field) {
+    if (!field || typeof field !== 'object')
+        return new Set();
+    const options = field.selectData || field.fieldConfig?.options || [];
+    if (!Array.isArray(options))
+        return new Set();
+    return new Set(options
+        .map((option) => String(option?.valueKey ?? option?.value ?? option?.id ?? ''))
+        .filter(Boolean));
+}
+function sourceFieldMeta(paramKey, meta) {
+    const workflowId = String(meta?._workflow_id || meta?._event_form_id || '');
+    const fields = workflowId ? getWorkflowContextFields()[workflowId] || {} : {};
+    const byKey = workflowId ? getWorkflowContextFieldsByKey()[workflowId] || {} : {};
+    const exact = byKey[paramKey];
+    if (exact && typeof exact === 'object')
+        return exact;
+    const tail = paramKey.split('.').at(-1)?.replace(/\[\]$/, '') || paramKey;
+    return Object.values(fields).find((field) => field && typeof field === 'object' && String(field.paramKey || '').split('.').at(-1)?.replace(/\[\]$/, '') === tail);
+}
+/**
+ * A context formula copies the source option value at runtime.  Cross-form
+ * Select fields often use different option IDs even when their labels match;
+ * silently compiling that copy produces an empty designer selection.  Refuse
+ * the unsafe plan and require a target-side fixed value or an explicit mapper.
+ */
+export function assertCompatibleEnumContextMapping(sourceKey, targetFieldId, result, meta) {
+    const target = lookupTargetFieldMeta(targetFieldId, result);
+    const source = sourceFieldMeta(sourceKey, meta);
+    const sourceKind = String(source?.componentKey || source?.type || '');
+    const targetKind = String(target?.componentKey || target?.type || '');
+    if (!ENUM_COMPONENT_KEYS.has(sourceKind) || !ENUM_COMPONENT_KEYS.has(targetKind))
+        return;
+    const sourceValues = optionValues(source);
+    const targetValues = optionValues(target);
+    if (!sourceValues.size || !targetValues.size)
+        return;
+    const isSameDomain = sourceValues.size === targetValues.size && [...sourceValues].every((value) => targetValues.has(value));
+    if (!isSameDomain) {
+        throw new Error(`枚举字段 '${source?.showName || source?.paramName || sourceKey}' 不能直接动态赋值到 '${target?.showName || targetFieldId}'：两表选项 ID 不一致。请改用目标表 constants，或提供显式 enumMapping。`);
+    }
+}
+// ── compile_component_data ──────────────────────────────────
+export function compileComponentData(draftParams, componentType, ctx, skipCompiler = false) {
+    const compiler = skipCompiler ? undefined : getCompiler(componentType);
+    if (compiler) {
+        const compilerCtx = {
+            ...ctx,
+            compileGeneric: (p, t, c) => compileComponentData(p, t, c, true),
+            buildFilterInput: ctx.buildFilterInput ?? buildFilterInput,
+            buildConditionDetail: ctx.buildConditionDetail ?? buildConditionDetail,
+        };
+        return compiler(draftParams, compilerCtx);
+    }
+    const comp = get(componentType) || {};
+    const meta = ctx.meta;
+    const appId = ctx.appId;
+    const actionIndex = ctx.actionIndex;
+    const eventNodeId = ctx.eventNodeId;
+    const eventName = ctx.eventName;
+    const lenient = ctx.lenient;
+    const params = { ...(draftParams || {}) };
+    for (const [legacyKey, currentKey] of Object.entries((comp.paramAliases || {}))) {
+        if (!(currentKey in params) && legacyKey in params)
+            params[currentKey] = params[legacyKey];
+    }
+    const mapping = comp.dataMapping || {};
+    const result = JSON.parse(JSON.stringify(comp.defaultData || {}));
+    for (const [draftKey, realKeysRaw] of Object.entries(mapping)) {
+        const val = params[draftKey];
+        if (val === null || val === undefined || val === '' || (Array.isArray(val) && val.length === 0) || (val && typeof val === 'object' && Object.keys(val).length === 0))
+            continue;
+        const targets = String(realKeysRaw).split(',').map((k) => k.trim());
+        for (const t of targets) {
+            if (t.startsWith('_')) {
+                try {
+                    handleSpecial(draftKey, t, val, result, meta, appId, actionIndex, eventNodeId, componentType, eventName);
+                }
+                catch (e) {
+                    if (!lenient)
+                        throw e;
+                }
+            }
+            else {
+                result[t] = val;
+            }
+        }
+    }
+    if (meta && !Object.values(mapping).includes('_targetForm')) {
+        autoTargetForm(result, params, meta, appId);
+    }
+    if (!('ebActionId' in result) && componentType.startsWith('ActionEb'))
+        result.ebActionId = '-1';
+    if (componentType.startsWith('ActionEb'))
+        result.type = componentType;
+    if (componentType === 'EventFormData')
+        normalizeEventFormDataTrigger(result, params, componentType);
+    return result;
+}
+/**
+ * EventFormData 触发时机归一化（真机验证 2026-08-19）：
+ * 平台 triggerTimes 是字符串数组，枚举 only afterAdd/afterUpdate/afterDelete/fieldDataChange
+ * （前端 weapp-esb ActionEbFormData/index.tsx selectData，后端 EventFormDataDTO List<String>）。
+ * plan 允许的写法：['afterAdd'] | 'afterAdd' | {triggerEvent:'afterAdd'} | {triggerTimes:[...]}，
+ * 并支持别名 afterCreate/afterSubmit→afterAdd、afterModify/afterUpdate→afterUpdate。
+ * 缺触发时机或值非法 → 显式抛错（不再静默丢弃导致设计器「触发时机」空白）。
+ */
+const EVENT_FORM_DATA_TRIGGER_ALIASES = {
+    afterAdd: 'afterAdd', afterCreate: 'afterAdd', afterSubmit: 'afterAdd', add: 'afterAdd',
+    afterUpdate: 'afterUpdate', afterModify: 'afterUpdate', update: 'afterUpdate', modify: 'afterUpdate',
+    afterDelete: 'afterDelete', delete: 'afterDelete', remove: 'afterDelete',
+    fieldDataChange: 'fieldDataChange', valueChange: 'fieldDataChange', change: 'fieldDataChange',
+};
+const EVENT_FORM_DATA_TRIGGER_OPTIONS = Object.values(EVENT_FORM_DATA_TRIGGER_ALIASES);
+function normalizeEventFormDataTrigger(result, params, componentType) {
+    const raw = result.triggerTimes ?? params.triggerTimes ?? params.triggerEvent ?? params.triggerTime;
+    const errors = [];
+    let items = [];
+    if (raw === null || raw === undefined || raw === '') {
+        errors.push('EventFormData 缺少触发时机 triggerTimes（应为数组/字符串，如 ["afterAdd"]）');
+    }
+    else if (Array.isArray(raw)) {
+        items = raw.map((v) => String(v));
+    }
+    else if (typeof raw === 'string') {
+        items = [raw];
+    }
+    else if (typeof raw === 'object') {
+        const ev = raw.triggerEvent ?? raw.event ?? raw.id ?? raw.type ?? '';
+        if (ev)
+            items = [String(ev)];
+        else if (Array.isArray(raw.triggerTimes))
+            items = raw.triggerTimes.map((v) => String(v));
+        else if (typeof raw.triggerTimes === 'string')
+            items = [String(raw.triggerTimes)];
+        else
+            errors.push(`EventFormData 触发时机对象无法解析: ${JSON.stringify(raw)}`);
+    }
+    else {
+        errors.push(`EventFormData 触发时机类型不支持: ${typeof raw}`);
+    }
+    const normalized = items
+        .map((it) => EVENT_FORM_DATA_TRIGGER_ALIASES[it] || '')
+        .filter((it) => it);
+    const unknown = items.filter((it) => !EVENT_FORM_DATA_TRIGGER_ALIASES[it]);
+    if (unknown.length)
+        errors.push(`EventFormData 触发时机含非法值 [${unknown.join(',')}]，合法枚举: ${[...new Set(EVENT_FORM_DATA_TRIGGER_OPTIONS)].join('/')}`);
+    if (errors.length)
+        throw new Error(errors.join('; '));
+    result.triggerTimes = normalized;
+    if (!('triggerType' in result))
+        result.triggerType = 'sequence';
+}
+// ── _handle_special ─────────────────────────────────────────
+function handleSpecial(draftKey, special, val, result, meta, appId, idx, eventId, componentType, eventName) {
+    if (special === '_person' && val && typeof val === 'object' && !Array.isArray(val)) {
+        const contract = get(componentType) || {};
+        const personTarget = contract.personTarget ?? 'person';
+        if (personTarget === null || personTarget === undefined)
+            return;
+        result[String(personTarget)] = buildPersonFormula(val, meta, appId, false, true);
+    }
+    else if (special === '_targetForm' && val && typeof val === 'object' && !Array.isArray(val)) {
+        fillTargetForm(result, val, meta, appId);
+    }
+    else if (special === '_updateId' || special === '_basisValueFormula') {
+        if (special === '_updateId') {
+            const wfId = String(meta?._workflow_id || '');
+            if (val && typeof val === 'object' && (val.kind === 'context' || val.key || val.paramKey)) {
+                const key = String(val.paramKey || val.key || val.fieldKey || '');
+                const resolved = resolveParamKey(wfId, key);
+                const label = String(val.label || val.name || key);
+                let wfName = String(meta?._upstream_workflow_name || '');
+                if (!wfName)
+                    wfName = String(meta?._upstream_form_name || '');
+                const pn = wfName ? `${wfName}.${label}` : label;
+                result.updateId = assignFlatContextDirect(resolved, label, String(eventId || val.source || '0'), appId, 'string', pn, meta);
+                // esbAssign.wId 指向当前数据动作节点（设计器动态赋值定位用），与 filterInput 修复同源。
+                attachEsbAssign(result.updateId, meta, String(eventId || val.source || '0'));
+            }
+            else {
+                result.updateId = buildFormulaReference(val, { meta, appId, eventId, componentType });
+                attachEsbAssign(result.updateId, meta, String(eventId || ''));
+            }
+        }
+        else {
+            result[special.slice(1)] = buildFormulaReference(val, { meta, appId, eventId, componentType });
+            attachEsbAssign(result[special.slice(1)], meta, String(eventId || ''));
+        }
+    }
+    else if (special === '_updateFieldCondition') {
+        const condition = buildUpdateFieldCondition(val, { meta, appId, eventId, componentType });
+        result.updateFieldCondition = condition;
+        (result.setting ??= {}).updateFieldCondition = JSON.parse(JSON.stringify(condition));
+        result.updateCondition = (condition.updateField || []).filter((it) => it && typeof it === 'object' && it.fieldKey).map((it) => String(it.fieldKey));
+    }
+    else if (special === '_setting_main') {
+        fillSetting(result, val, undefined, undefined, undefined, meta, appId, eventId, eventName, componentType);
+    }
+    else if (special === '_setting_mapping') {
+        result._pending_mapping ??= {};
+        if (val && typeof val === 'object' && !Array.isArray(val))
+            Object.assign(result._pending_mapping, val);
+        else if (Array.isArray(val)) {
+            for (const item of val)
+                if (item && typeof item === 'object')
+                    Object.assign(result._pending_mapping, item);
+        }
+    }
+    else if (special === '_setting_constants' || special === '_setting_formula') {
+        const pendingKey = special === '_setting_constants' ? '_pending_constants' : '_pending_formula';
+        result[pendingKey] ??= {};
+        if (val && typeof val === 'object' && !Array.isArray(val))
+            Object.assign(result[pendingKey], val);
+    }
+    else if (special === '_basisValue') {
+        handleBasisValue(val, result, meta, appId, eventId);
+    }
+    else if (special === '_setting_detail') {
+        result._pending_detail ??= [];
+        if (Array.isArray(val)) {
+            for (const item of val) {
+                if (item && typeof item === 'object' && item.detailTableId)
+                    result._pending_detail.push(item);
+            }
+        }
+    }
+    else if (special === '_filterInput') {
+        result.filterInput = buildFilterInput(result, val, meta, appId, componentType);
+    }
+    else if (special === '_bizWorkflowPath' && val && typeof val === 'object') {
+        const wfId = String(val.id || '');
+        let formIds = val.formIds;
+        if (!Array.isArray(formIds))
+            formIds = val.formId || val.objId ? [String(val.formId || val.objId)] : [];
+        result.workflowPath = [{
+                bridgeService: 'ebuilder', relateFormTypes: ['WEA_EBUILDER'],
+                name: String(val.name || val.text || ''),
+                formIds: formIds.filter(Boolean).map(String),
+                id: wfId,
+                createFlowId: String(val.createFlowId || wfId),
+                workflowtype: String(val.workflowtype ?? val.workflowType ?? appId ?? ''),
+            }];
+    }
+    else if (special === '_bizRequestName') {
+        if (typeof val === 'string' && val.trim())
+            result.requestName = formulaFixedForAssignSwitch(val);
+        else if (val && typeof val === 'object') {
+            if (val.systemValue || String(val.kind || '') === 'system_variable') {
+                const rawSystem = val.systemValue || val.key;
+                result.requestName = formulaSystemVar(rawSystem);
+            }
+            else {
+                const wfId = String(meta?._workflow_id || '');
+                const rqKey = resolveParamKey(wfId, String(val.key ?? val.value ?? ''));
+                result.requestName = formulaContext('', rqKey, { name: String(val.label || '') });
+                attachEsbAssign(result.requestName, meta, String(eventId || ''));
+            }
+        }
+    }
+    else if (special === '_bizOperateUser' && val && typeof val === 'object') {
+        result.operator = buildPersonFormula(val, meta, appId);
+    }
+    else if (special === '_meetingOperators' && val && typeof val === 'object') {
+        result.operators = buildPersonFormula(val, meta, appId);
+    }
+    else if (special === '_dateDataSource' && val && typeof val === 'object') {
+        const dsId = String(val.id || val.tableId || val.sourceId || '');
+        result.dataSource = {
+            isPhysical: true, physical: true,
+            groupId: String(val.groupId ?? val.appId ?? '-98'),
+            id: dsId, text: String(val.text || val.name || ''), type: String(val.type || 'FORM'),
+        };
+    }
+}
+function handleBasisValue(val, result, meta, appId, eventId) {
+    if (!val || typeof val !== 'object')
+        return;
+    let bvKey = String(val.paramKey || val.key || val.value || '').trim();
+    let bvLabel = String(val.label || val.name || '');
+    // 明细表依据值 paramKey 必须带 []（早期正确产物 FormData.{wfId}.{明细表id}[]）。
+    // plan 允许省略 []，编译器检测上下文存在数组版本时自动补齐（真机验证 2026-08-19：漏 [] 前端定位不到明细表标红）。
+    if (bvKey && !bvKey.includes('[]')) {
+        const wfId = String(meta?._workflow_id || '');
+        const keyIndex = wfId ? getWorkflowContextFieldsByKey()[String(wfId)] || {} : {};
+        const arrKey = `${bvKey}[]`;
+        if (keyIndex[arrKey] && !keyIndex[bvKey])
+            bvKey = arrKey;
+    }
+    if (bvKey) {
+        const idx = bvKey.lastIndexOf('.');
+        const bkHead = idx >= 0 ? bvKey.slice(0, idx) : '';
+        const bkTail = idx >= 0 ? bvKey.slice(idx + 1) : bvKey;
+        const realName = getWorkflowDetailNames()[bkHead]?.[bkTail.replace(/\[\]$/, '')];
+        if (realName)
+            bvLabel = realName;
+    }
+    if (!bvLabel)
+        bvLabel = bvKey;
+    if (bvKey) {
+        const tail = bvKey.includes('.') ? bvKey.slice(bvKey.lastIndexOf('.') + 1).replace(/\[\]$/, '') : bvKey.replace(/\[\]$/, '');
+        const bvId = /^\d+$/.test(tail) ? tail : bvKey;
+        result.basisValue = bvId;
+        const fId = genSfId();
+        const fBiz = genSfId();
+        const srcId = eventId || String(meta?._upstream_node_id || '');
+        const wnBv = String(meta?._upstream_workflow_name || '');
+        const bvParent = wnBv ? `${wnBv}.${bvLabel}[]` : `${bvLabel}[]`;
+        const bvfType = resolveSourceFieldType(bvKey, meta);
+        const bvfConfig = {
+            paramKey: bvKey, isMultCom: false, comType: 'ApproveTrigger', switchType: 'assign', parentComId: 0, formulaVersion: 'V1',
+            fieldInfo: { paramKey: bvKey, tablePrimaryKey: 'FormData' },
+            tableName: '表单数据', paramType: bvfType, parentName: bvParent, multName: '', multKey: '',
+            multTypeObj: {
+                allName: bvParent, currentName: bvParent,
+                currentParamKey: `FormData.${bvKey}`, allParamKey: `FormData.${bvKey}`,
+            },
+            comId: srcId, newParentName: bvParent,
+        };
+        const bvf = {
+            frontId: bvId, formulaType: bvfType, name: bvLabel, businessId: fBiz, id: fId,
+            source: srcId, type: '3', value: `FormData.${bvKey}`, childs: [], config: bvfConfig, parentId: '0',
+        };
+        // 依据值公式同样需要 esbAssign.wId 指向当前数据动作节点（设计器动态赋值定位用）。
+        attachEsbAssign(bvf, meta, srcId);
+        result.basisValueFormula = bvf;
+        result._pending_basis = { bassisValueId: bvId, bassisValue: JSON.parse(JSON.stringify(bvf)) };
+    }
+}
+function autoTargetForm(result, params, meta, appId) {
+    const tf = params.targetForm;
+    if (!tf || typeof tf !== 'object' || Array.isArray(tf))
+        return;
+    fillTargetForm(result, tf, meta, appId);
+}
+function fillTargetForm(result, tf, meta, appId) {
+    const form = findInMetadata(meta, 'forms', tf);
+    const fid = form ? form.id : (tf.id ?? tf.tableId ?? '');
+    const formRef = form || tf;
+    const formText = formRef.text || formRef.name || '';
+    const formAppId = (form || tf).groupId ?? (form || tf).appId ?? '';
+    const resolvedAppId = formAppId || fid;
+    const groupName = formRef.groupName ?? formText;
+    result.targetForm = { groupName, groupId: resolvedAppId, id: fid, text: formText, type: 'FORM' };
+    result.tableType = [{ name: formText, id: fid }];
+    result.appType = [{ pcUrl: `/ebdapp/view/${resolvedAppId}`, name: groupName, id: resolvedAppId }];
+    result.dataSource = { groupId: resolvedAppId, id: fid, text: formText, type: 'FORM' };
+    result.appId = resolvedAppId;
+    result.objId = fid;
+    if (appId) {
+        result.currentApplication = appId;
+        result.applicationId = appId;
+    }
+}
+// ── _fill_setting ───────────────────────────────────────────
+export function fillSetting(result, updates, mapping, constants, formula, meta, appId, eventId, eventName, componentType) {
+    if (!meta || typeof meta !== 'object')
+        meta = {};
+    const main = {};
+    const assignmentMode = (get(componentType) || {}).assignmentContextMode || '';
+    if (Array.isArray(updates)) {
+        for (const u of updates) {
+            if (!u || typeof u !== 'object')
+                continue;
+            const field = u.field ?? u.formField ?? u.fieldId ?? genSfId();
+            let fid = field;
+            let fieldType = 'Text';
+            if (field && typeof field === 'object') {
+                fid = field.id ?? field.key ?? genSfId();
+                const sourceType = field.type ?? '';
+                fieldType = { String: 'Text', string: 'Text', Number: 'NumberComponent', number: 'NumberComponent' }[sourceType] ?? (sourceType || 'Text');
+            }
+            main[String(fid)] = buildSettingEntry(String(fid), u, fieldType, meta, appId, String(eventId), 'OPERATE_EQUAL', componentType, false, assignmentMode);
+        }
+    }
+    if (mapping && typeof mapping === 'object' && !Array.isArray(mapping)) {
+        for (const [sourceKey, targetFieldIdRaw] of Object.entries(mapping)) {
+            const targetFieldId = targetFieldIdRaw;
+            let operate = 'OPERATE_EQUAL';
+            if (targetFieldId && typeof targetFieldId === 'object' && !Array.isArray(targetFieldId)) {
+                if (targetFieldId.systemValue) {
+                    const svKey = String(targetFieldId.systemValue);
+                    const tfid = String(targetFieldId.target || '');
+                    if (!tfid)
+                        throw new Error(`mapping 系统变量值缺少目标字段 id: 应传 {'target':'<目标字段id>', 'systemValue':'currentUser'}`);
+                    main[tfid] = buildSettingEntry(tfid, { kind: 'system_variable', key: svKey }, 'Text', meta, appId, String(eventId), 'OPERATE_EQUAL', componentType, false, assignmentMode);
+                    continue;
+                }
+                let raw = String(targetFieldId.target || targetFieldId.fieldId || '');
+                if (!raw)
+                    throw new Error('ActionEbAdd.mapping 依据值下级值缺少目标字段 id');
+                if (raw.startsWith('+')) {
+                    operate = 'OPERATE_PLUS';
+                    raw = raw.slice(1);
+                }
+                else if (raw.startsWith('-')) {
+                    operate = 'OPERATE_MINUS';
+                    raw = raw.slice(1);
+                }
+                const refKey = String(targetFieldId.paramKey || sourceKey);
+                const refLabel = String(targetFieldId.label || resolveSourceFieldLabel(refKey, meta, String(sourceKey)));
+                const refDetail = String(targetFieldId.detailLabel || '');
+                const assignment = { kind: 'context', paramKey: refKey, label: refLabel };
+                if (refDetail)
+                    assignment.detailLabel = refDetail;
+                assertCompatibleEnumContextMapping(refKey, raw, result, meta || {});
+                const srcParamKey = String(assignment.paramKey || sourceKey);
+                const srcFt = resolveSourceFieldType(srcParamKey, meta);
+                main[raw] = buildSettingEntry(raw, assignment, srcFt, meta, appId, String(eventId), operate, componentType, false, assignmentMode);
+            }
+            else {
+                let raw = String(targetFieldId);
+                if (raw.startsWith('+')) {
+                    operate = 'OPERATE_PLUS';
+                    raw = raw.slice(1);
+                }
+                else if (raw.startsWith('-')) {
+                    operate = 'OPERATE_MINUS';
+                    raw = raw.slice(1);
+                }
+                const refKey = String(sourceKey);
+                const assignment = { kind: 'context', paramKey: refKey, label: resolveSourceFieldLabel(refKey, meta, refKey) };
+                assertCompatibleEnumContextMapping(refKey, raw, result, meta || {});
+                const srcFt = resolveSourceFieldType(refKey, meta);
+                main[raw] = buildSettingEntry(raw, assignment, srcFt, meta, appId, String(eventId), operate, componentType, false, assignmentMode);
+            }
+        }
+    }
+    if (constants && typeof constants === 'object' && !Array.isArray(constants)) {
+        for (const [targetFieldId, value] of Object.entries(constants)) {
+            const tfid = String(targetFieldId);
+            let operateC = 'OPERATE_EQUAL';
+            let rawV = value;
+            if (typeof value === 'string' && value.length > 1 && (value[0] === '+' || value[0] === '-')) {
+                operateC = value[0] === '+' ? 'OPERATE_PLUS' : 'OPERATE_MINUS';
+                rawV = value.slice(1);
+            }
+            const fieldMeta = lookupTargetFieldMeta(tfid, result);
+            rawV = resolveEnumConstant(rawV, fieldMeta);
+            const [assignment, ft] = normalizeConstantAssignment(rawV, 'Text');
+            // 固定枚举值的外层 fieldType 必须是目标组件类型（例如 Select），
+            // 与手工保存 JSON 一致；使用默认 Text 会导致设计器下拉回显为空。
+            const targetFieldType = String(fieldMeta?.componentKey || fieldMeta?.type || ft);
+            main[tfid] = buildSettingEntry(tfid, assignment, targetFieldType, meta, appId, String(eventId), operateC, componentType, false, assignmentMode);
+        }
+    }
+    if (formula && typeof formula === 'object' && !Array.isArray(formula)) {
+        for (const [targetFieldId, fspecRaw] of Object.entries(formula)) {
+            const fspec = fspecRaw;
+            if (!fspec || typeof fspec !== 'object')
+                continue;
+            const op = fspec.op || 'add';
+            const fields = fspec.fields || [];
+            if (!fields.length)
+                continue;
+            const fnInfo = getFormulaFn(op);
+            const childs = [];
+            for (const fld of fields) {
+                const child = assignFlatContext(String(fld), String(fld), String(eventId), appId, 'double');
+                child.position = genSfId();
+                child.paramType = 'double';
+                child.componentKey = 'Number';
+                child.fieldType = 'number';
+                childs.push(child);
+            }
+            const bean = formulaFunction(fnInfo.fnId, fnInfo.name, childs, 'double', op, fnInfo.functionType || 'operation', undefined, appId);
+            const flatId = bean.id || genSfId();
+            const assign = Object.fromEntries(Object.entries(bean).filter(([k]) => !['configObject', 'childs', 'parentId', 'sortWeight', 'position'].includes(k)));
+            if (bean.childs)
+                assign.childs = bean.childs;
+            assign.applicationId ??= String(appId);
+            assign.id ??= String(flatId);
+            main[String(targetFieldId)] = {
+                formFieldKey: '',
+                value: {
+                    original: false, operate: 'OPERATE_EQUAL', switchType: 'assign', fieldKey: String(targetFieldId),
+                    assignType: '', multiSelect: false, fieldType: 'NumberComponent', assign, assignId: String(flatId),
+                },
+            };
+        }
+    }
+    const contract = get(componentType) || {};
+    const settingBehavior = contract.settingBehavior || {};
+    const completeOps = settingBehavior.completeFieldsForOpTypes || [];
+    if (completeOps.includes(result.opType)) {
+        const tfId = String((result.targetForm || {}).id || '');
+        const tff = tfId ? (getTargetFormFields()[tfId] || {}) : {};
+        for (const [fid, fmeta] of Object.entries(tff)) {
+            const fidS = String(fid);
+            if (fidS in main)
+                continue;
+            const ftype = String(fmeta.fieldType || fmeta.type || 'Text');
+            main[fidS] = { formFieldKey: '', value: { original: false, operate: 'OPERATE_EQUAL', fieldKey: fidS, multiSelect: false } };
+        }
+    }
+    result.setting = {
+        opType: result.opType ?? 'insert',
+        updatePolicy: result.updatePolicy ?? 'ALL',
+        dataDrWithCalc: false,
+        main,
+        detail: [],
+        updateFieldCondition: { updateField: [] },
+    };
+}
+// ── filter 筛选条件树 ───────────────────────────────────────
+function isFilterGroup(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const children = value.conditions ?? value.datas;
+    if (!Array.isArray(children))
+        return false;
+    return !['left', 'right', 'field', 'operator', 'value', 'id', 'key', 'fieldName'].some((k) => k in value);
+}
+function filterGroupChildren(value) {
+    const children = value.conditions ?? value.datas ?? [];
+    if (!Array.isArray(children))
+        throw new Error('filterCondition 分组的 conditions 必须是数组');
+    if (!children.length)
+        throw new Error('filterCondition 分组至少需要一条条件');
+    return children;
+}
+function filterRelationship(value) {
+    const text = String(value ?? '1').trim().toLowerCase();
+    if (['1', 'and', '&&'].includes(text))
+        return '1';
+    if (['0', 'or', '||'].includes(text))
+        return '0';
+    throw new Error('filterCondition relationship 只支持 and/or（或 1/0）');
+}
+function containsFilterGroup(value) {
+    if (isFilterGroup(value))
+        return true;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const children = value.conditions ?? value.datas;
+        if (Array.isArray(children))
+            return children.some(containsFilterGroup);
+        return false;
+    }
+    if (Array.isArray(value))
+        return value.some(containsFilterGroup);
+    return false;
+}
+function rejectUnsupportedFilterModes(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const mode = String(value.type ?? value.mode ?? '').trim().toLowerCase();
+        if (['sql', 'sql_where', 'http'].includes(mode))
+            throw new Error('filterCondition 不支持 SQL/HTTP 条件；请使用表单字段条件树');
+        for (const item of Object.values(value))
+            rejectUnsupportedFilterModes(item);
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value)
+            rejectUnsupportedFilterModes(item);
+    }
+}
+export function buildFilterInput(result, val, meta, appId, componentType = '', allowTree = true) {
+    componentType = String(componentType || '');
+    if (allowTree && containsFilterGroup(val)) {
+        return buildFilterTree(result, val, meta, appId, componentType);
+    }
+    const eventLocalFilter = (get(componentType) || {}).filterValueScope === 'local';
+    let conditions;
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+        if (val.condition && typeof val.condition === 'object')
+            conditions = [val.condition];
+        else if ('conditions' in val)
+            conditions = val.conditions;
+        else
+            conditions = [val];
+    }
+    else if (Array.isArray(val))
+        conditions = val;
+    else
+        conditions = [];
+    const formId = result.objId || (result.targetForm || {}).id || (result.dataSource || {}).id || (result.dataSource || {}).sourceId || '';
+    const fctx = resolveFormCtx(result, meta, formId);
+    const form = findInMetadata(meta, 'forms', { id: formId }) || {};
+    const fieldIndex = {};
+    for (const f of form.fields || [])
+        fieldIndex[String(f.id || '')] = f;
+    Object.assign(fieldIndex, getTargetFormFields()[String(formId)] || {});
+    const datas = [];
+    const timeStamp = String(Date.now());
+    conditions.forEach((c, idx) => {
+        if (!c || typeof c !== 'object')
+            return;
+        const left = c.left && typeof c.left === 'object' ? c.left : c;
+        let fieldId = '';
+        let label = '';
+        let right;
+        if (left.field && typeof left.field === 'object' && left.field.id) {
+            fieldId = String(left.field.id);
+            label = left.field.label || left.field.name || fieldId;
+            if (c.right && typeof c.right === 'object')
+                right = c.right;
+            else if (c.value && typeof c.value === 'object')
+                right = c.value;
+            else
+                right = { value: c.value ?? '' };
+        }
+        else if (left.key || left.id) {
+            fieldId = String(left.key ?? left.id ?? '');
+            label = left.label ?? left.name ?? '';
+            right = c.right ?? c.value ?? '';
+        }
+        else {
+            fieldId = '';
+            label = '';
+            right = '';
+        }
+        const fmeta = fieldIndex[fieldId] || {};
+        if (!fmeta || Object.keys(fmeta).length === 0) {
+            throw new Error(`filterCondition 左侧字段 id='${fieldId}' 不在目标表单 '${formId}' 的实时字段列表中`);
+        }
+        const schema = fmeta.schema && typeof fmeta.schema === 'object' ? fmeta.schema : {};
+        const rawFieldType = String(fmeta.type || fmeta.fieldType || schema.fieldType || 'String');
+        const compType = String(fmeta.componentKey || schema.componentKey || schema.compType || 'Text');
+        const family = conditionFieldFamily(compType, rawFieldType);
+        const fieldType = filterFieldType(rawFieldType, compType);
+        label = String(label || fmeta.showName || fmeta.name || fieldId);
+        let rawConfig = fmeta.config;
+        if (typeof rawConfig === 'string') {
+            try {
+                rawConfig = JSON.parse(rawConfig);
+            }
+            catch {
+                rawConfig = {};
+            }
+        }
+        let multiSelect = fmeta.multiSelect;
+        if (multiSelect === undefined && rawConfig && typeof rawConfig === 'object' && 'isSingle' in rawConfig)
+            multiSelect = !Boolean(rawConfig.isSingle);
+        const isMultiSelect = multiSelect === true || String(multiSelect).toLowerCase() === 'true';
+        if (right && typeof right === 'object' && right.kind === 'context' && !right.type) {
+            throw new Error("filterCondition 不支持 value.kind:'context'；请使用 right:{type:'context',paramKey:'<真实paramKey>',label:'<显示名>'}");
+        }
+        let rightType = right && typeof right === 'object' ? String(right.type || 'fixed').trim().toLowerCase() : 'fixed';
+        if (right && typeof right === 'object' && right.paramKey && !right.type) {
+            throw new Error("filterCondition 动态右值缺少 type:'context'；请使用 right:{type:'context',paramKey:'<真实paramKey>',label:'<显示名>'}");
+        }
+        if (['manual', 'constant', 'const'].includes(rightType))
+            rightType = 'fixed';
+        else if (['dynamic', 'assign', 'workflowfield', 'workflow_field'].includes(rightType))
+            rightType = 'context';
+        else if (['formfield', 'form_field'].includes(rightType))
+            rightType = 'formfield';
+        else if (['custom', 'custombyhandler'].includes(rightType))
+            rightType = 'custombyhander';
+        else if (['platform', 'condition'].includes(rightType))
+            rightType = 'native';
+        if (!['fixed', 'system', 'context', 'formfield', 'selectdata', 'custombyhander', 'native', 'varfield', 'filterval'].includes(rightType)) {
+            throw new Error(`filterCondition 右值 type='${rightType}' 不支持; 支持 fixed/manual/context/formField/selectData/customByHander/native/varField/filterVal`);
+        }
+        // 原生「当前时间/当前日期」改写为系统参数（真机验证 2026-08-18）：平台 native type 列表不含 currentTime/currentDate
+        // 等具体 token，原样透传后 conditionData.value="" 触发设计器「右值未配置」判断（外面能显示摘要，点进去空）。
+        // 与 system_params 的 currentTime→{time}/currentDate→{date} 映射一致，落到 system 路径后走完整校验+value 非空。
+        if (rightType === 'native') {
+            const m = (right && typeof right === 'object' ? String(right.mode || right.conditionType || right.nativeType || '') : '').toLowerCase();
+            if (['currenttime', 'now', 'current_time'].includes(m)) {
+                rightType = 'system';
+                if (right && typeof right === 'object')
+                    right.value = '{time}';
+                else
+                    right = '{time}';
+            }
+            else if (['currentdate', 'today', 'current_date'].includes(m)) {
+                rightType = 'system';
+                if (right && typeof right === 'object')
+                    right.value = '{date}';
+                else
+                    right = '{date}';
+            }
+        }
+        if (rightType === 'fixed' && right && typeof right === 'object') {
+            try {
+                resolveSystemParameter(right.value ?? '');
+                rightType = 'system';
+            }
+            catch { /* not a system token */ }
+        }
+        if (rightType === 'system') {
+            const systemValue = right && typeof right === 'object' ? String(right.value ?? '') : String(right);
+            const resolvedSystemValue = resolveSystemParameter(systemValue);
+            if (family === 'date' && !isDateSystemParameter(resolvedSystemValue))
+                throw new Error('filterCondition 日期/日期时间字段只能使用日期类系统参数');
+            if (right && typeof right === 'object')
+                right.value = resolvedSystemValue;
+        }
+        if (eventLocalFilter && ['context', 'formfield', 'custombyhander'].includes(rightType)) {
+            throw new Error('EventFormData 的 ConditionSet 不支持上下文右值；前端未启用 supportEsbAssign，请改用固定值或无值操作符');
+        }
+        const isContext = ['context', 'formfield', 'custombyhander'].includes(rightType);
+        const isNative = ['native', 'varfield', 'filterval'].includes(rightType);
+        const filterValueType = String((right && typeof right === 'object' ? right.filterValueType : '') || c.filterValueType || '');
+        const allowedOverride = conditionOperatorOverride(fmeta, family, compType, fieldId, filterValueType);
+        let contextIsArray = false;
+        let value;
+        if (isContext) {
+            [value, contextIsArray] = buildFilterContextFormula(right, meta, appId, fieldType, compType);
+        }
+        else {
+            let rawValue = right && typeof right === 'object' ? (right.value ?? right.id ?? right.name ?? '') : right;
+            const preserveBrowserPayload = isNative || ['reference', 'file', 'doc_folder', 'app_tag'].includes(family);
+            if (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue) && !preserveBrowserPayload)
+                rawValue = rawValue.value ?? rawValue.id ?? rawValue.name ?? '';
+            else if (Array.isArray(rawValue) && !preserveBrowserPayload) {
+                rawValue = rawValue.map((v) => (v && typeof v === 'object' ? (v.value ?? v.id ?? v.name ?? '') : v));
+            }
+            value = rawValue;
+        }
+        const func = normalizeFilterOperator(c.operator ?? 'eq', family, { contextIsArray, multiSelect: isMultiSelect, allowedOverride });
+        const isNullary = ['empty', 'nempty'].includes(func);
+        if (isNullary)
+            value = '';
+        else if (func === 'range') {
+            if (isContext)
+                throw new Error('filterCondition range 动态右值必须提供两个原生端点，不能使用单个 context');
+            if (!Array.isArray(value) || value.length !== 2)
+                throw new Error('filterCondition range 右值必须是长度为 2 的数组 [起始值, 结束值]');
+        }
+        let valueText = '';
+        if (right && typeof right === 'object' && (right.label || right.name))
+            valueText = String(right.label || right.name);
+        else if (value && typeof value === 'object' && !Array.isArray(value))
+            valueText = String(value.name || value.value || '');
+        else if (Array.isArray(value))
+            valueText = value.map((v) => (v && typeof v === 'object' ? String(v.content || v.label || v.name || v.id || '') : String(v))).join(',');
+        else if (typeof value === 'string')
+            valueText = value;
+        const conditionData = { func, text: isNullary ? '' : valueText, value };
+        if (!isNullary) {
+            if (isContext) {
+                const valStr = value && typeof value === 'object' ? String(value.value || '') : '';
+                const valTail = valStr.includes('.') ? valStr.slice(valStr.lastIndexOf('.') + 1) : valStr;
+                const isApprovalField = typeof valStr === 'string' && valStr.startsWith('ApprovalData.') && !/^\d+$/.test(valTail);
+                if (isApprovalField || rightType === 'formfield' || (value && typeof value === 'object' && String(value.value || '').startsWith('FormData.')))
+                    conditionData.type = 'formField';
+                else if (rightType === 'custombyhander' || family === 'reference')
+                    conditionData.type = 'custombyhander';
+            }
+            else if (isNative) {
+                const nativeMode = String((right && typeof right === 'object' ? (right.mode || right.conditionType || right.nativeType) : '') || { varfield: 'varField', filterval: 'filterVal' }[rightType] || '');
+                if (!nativeMode)
+                    throw new Error('filterCondition native 右值必须提供 mode/conditionType/nativeType');
+                conditionData.type = nativeMode;
+            }
+            else if (rightType === 'system') {
+                conditionData.type = '';
+            }
+            else if (family === 'reference' || rightType === 'selectdata') {
+                conditionData.type = 'selectData';
+            }
+            else if (family === 'select' || family === 'boolean') {
+                conditionData.type = '';
+            }
+        }
+        if (!isNullary && isContext) {
+            const renderType = conditionData.type;
+            // esbAssign.wId 必须指向「当前节点」（filterInput 所属节点），不是上游 event 节点。
+            // 设计器用它对 orginFlowDatas 定位当前组件；指向 event 会导致打开动态赋值时右侧「暂无数据」。
+            let esbWid = String(meta && typeof meta === 'object' ? (meta._upstream_node_id || '') : '');
+            if (!esbWid && value && typeof value === 'object')
+                esbWid = String(value.source || '');
+            if (!esbWid && meta && typeof meta === 'object')
+                esbWid = String(meta._upstream_w_id || '');
+            if (!esbWid)
+                esbWid = timeStamp.slice(0, 13);
+            conditionData.isEsb = true;
+            conditionData.esbAssign = { wId: esbWid, textarea: false, withoutDftNum: true };
+            void renderType;
+        }
+        else if (!isNullary) {
+            conditionData.isEsb = false;
+        }
+        if (right && typeof right === 'object') {
+            for (const nativeKey of ['customSelect', 'filterValueType', 'matchType', 'changeTrigger']) {
+                if (nativeKey in right)
+                    conditionData[nativeKey] = right[nativeKey];
+            }
+        }
+        const originBrowserType = String(fmeta.originBrowserType || (rawConfig && typeof rawConfig === 'object' ? rawConfig.originBrowserType : '') || (['select', 'reference'].includes(family) ? 'browser' : ''));
+        const item = {
+            isParent: false, fieldName: fieldId, mainField: true, module: '', subTableId: '',
+            parentNode: timeStamp + String(idx), type: 'condition', optionType: '',
+            compType, objId: String(fctx.objId || formId), id: fieldId, text: label,
+            conditions: conditionData, originBrowserType, fieldType,
+            key: timeStamp + String(idx + 1), multiSelect: String(Boolean(multiSelect)).toLowerCase(),
+        };
+        if (rawFieldType)
+            item.dbFieldType = rawFieldType;
+        datas.push(item);
+    });
+    return { isNewFilter: true, isParent: true, datas, parentNode: '', relationship: '1', key: timeStamp };
+}
+function buildFilterTree(result, value, meta, appId, componentType) {
+    rejectUnsupportedFilterModes(value);
+    let rootSource;
+    if (isFilterGroup(value))
+        rootSource = value;
+    else if (Array.isArray(value))
+        rootSource = { relationship: 'and', conditions: value };
+    else if (value && typeof value === 'object' && Array.isArray(value.conditions))
+        rootSource = value;
+    else
+        rootSource = { relationship: 'and', conditions: [value] };
+    const build = (source) => {
+        if (isFilterGroup(source)) {
+            return {
+                isNewFilter: true, isParent: true,
+                datas: filterGroupChildren(source).map(build),
+                parentNode: '', relationship: filterRelationship(source.relationship), key: '',
+            };
+        }
+        const compiled = buildFilterInput(result, [JSON.parse(JSON.stringify(source))], meta, appId, componentType, false);
+        if (compiled.datas.length !== 1)
+            throw new Error('filterCondition 叶子必须是单个有效条件');
+        return compiled.datas[0];
+    };
+    const tree = build(rootSource);
+    const baseKey = String(Date.now());
+    let sequence = 0;
+    const assignTreeIds = (node, parentKey = '', isRoot = false) => {
+        let key;
+        if (isRoot)
+            key = baseKey;
+        else {
+            sequence += 1;
+            key = `${baseKey}${sequence}`;
+        }
+        node.key = key;
+        node.parentNode = parentKey;
+        node.isNewFilter = true;
+        if (node.isParent) {
+            node.relationship = filterRelationship(node.relationship);
+            for (const child of node.datas || [])
+                assignTreeIds(child, key);
+        }
+    };
+    assignTreeIds(tree, '', true);
+    return tree;
+}
+// ── Condition 条件分支 ──────────────────────────────────────
+const CONDITION_OPT_CODE_MAP = {
+    // ESB WfpRuleDesign getCustomData 的实际枚举：1/2/3/4 是大小比较，5/6 是等于/不等于。
+    eq: 5, '==': 5, '=': 5, '等于': 5,
+    neq: 6, '!=': 6, '<>': 6, '不等于': 6, ne: 6,
+    gt: 1, '>': 1, '大于': 1, lt: 3, '<': 3, '小于': 3,
+    gte: 2, '>=': 2, '大于等于': 2, lte: 4, '<=': 4, '小于等于': 4,
+    contains: 9, contain: 9, '包含': 9, notcontains: 10, notcontain: 10, '不包含': 10,
+    in: 11, '属于': 11, notin: 12, not_in: 12, '不属于': 12,
+    empty: 13, isnull: 13, '为空': 13, nempty: 14, isnotnull: 14, '不为空': 14,
+};
+const CONDITION_OPT_LABEL_MAP = {
+    1: '大于', 2: '大于等于', 3: '小于', 4: '小于等于', 5: '等于', 6: '不等于',
+    9: '包含', 10: '不包含', 11: '属于', 12: '不属于', 13: '为空', 14: '不为空',
+    23: '是', 24: '否',
+};
+const CONDITION_OPERATOR_CODES_BY_FAMILY = {
+    string: new Set([5, 6, 9, 10, 13, 14]),
+    number: new Set([1, 2, 3, 4, 5, 6, 13, 14]),
+    date: new Set([1, 2, 3, 4, 5, 6, 13, 14]),
+    datetime: new Set([1, 2, 3, 4, 5, 6, 13, 14]),
+    time: new Set([1, 2, 3, 4, 5, 6, 13, 14]),
+    bool: new Set([23, 24]),
+    browser: new Set([5, 6, 9, 10, 11, 12, 13, 14]),
+    list: new Set([5, 6, 11, 12, 13, 14]),
+};
+function conditionFieldShape(workflowId, fieldKey, fieldLabel) {
+    const fields = getWorkflowContextFields()[workflowId] || {};
+    const raw = fields[fieldKey] || fields[fieldLabel] || Object.values(fields).find((item) => String(item?.id || item?.paramId || '') === fieldKey);
+    const type = String(raw?.paramType || raw?.paramTypeString || raw?.componentKey || '').toLowerCase();
+    if (['int', 'integer', 'number', 'double', 'float', 'money', 'numbercomponent'].includes(type))
+        return { family: 'number', prefix: 'Number', formulaType: 'double' };
+    if (['datetime', 'datetimepicker', 'datetimesecondcomponent'].includes(type))
+        return { family: 'datetime', prefix: 'DateTime', formulaType: 'datetime' };
+    if (['date', 'datepicker', 'datecomponent'].includes(type))
+        return { family: 'date', prefix: 'Date', formulaType: 'date' };
+    if (['time', 'timepicker', 'timecomponent'].includes(type))
+        return { family: 'time', prefix: 'Time', formulaType: 'time' };
+    if (['bool', 'boolean', 'switch', 'checkbox'].includes(type))
+        return { family: 'bool', prefix: 'Bool', formulaType: 'bool' };
+    if (['employee', 'department', 'role', 'position', 'browser', 'browserbutton', 'relatebrowser'].includes(type))
+        return { family: 'browser', prefix: 'Browser', formulaType: 'string' };
+    if (['select', 'multiselect', 'radio', 'radiobox', 'checkboxgroup'].includes(type))
+        return { family: 'list', prefix: 'List', formulaType: 'json' };
+    if (Boolean(raw?.arrs) || ['list', 'json', 'array'].includes(type))
+        return { family: 'list', prefix: 'List', formulaType: 'json' };
+    return { family: 'string', prefix: 'String', formulaType: 'string' };
+}
+function conditionRelationCode(value) {
+    const relation = String(value ?? 'and').trim().toLowerCase();
+    return ['2', 'or', '||', '或'].includes(relation) ? 2 : 1;
+}
+function conditionItems(condition) {
+    const items = condition.conditions ?? condition.childrens ?? condition.rules ?? [];
+    return Array.isArray(items) ? items.filter((item) => Boolean(item && typeof item === 'object')) : [];
+}
+function conditionFormulaType(right, shape, sourceId) {
+    if (right?.formula && typeof right.formula === 'object')
+        return JSON.parse(JSON.stringify(right.formula));
+    const kind = String(right?.type || right?.kind || 'fixed').trim().toLowerCase();
+    const raw = right && typeof right === 'object' ? (right.paramKey ?? right.key ?? right.value ?? '') : right;
+    if (kind === 'fixed' || kind === 'constant' || kind === 'manual') {
+        if (['browser', 'list'].includes(shape.family)) {
+            throw new Error(`Condition ${shape.family} 类型固定右值必须提供平台回读 formula，不能伪造为文本`);
+        }
+        // ConditionRule 的固定右值不是普通组件的 AssignWrapper；后者无法被规则编辑器回填。
+        return {
+            formulaType: shape.formulaType,
+            name: String(raw),
+            businessId: genSfId(),
+            selectType: '-1',
+            id: genSfId(),
+            type: '1',
+            value: String(raw),
+            fieldType: shape.formulaType,
+        };
+    }
+    if (kind === 'system' || kind === 'system_variable') {
+        const bean = formulaSystemVar(String(raw));
+        bean.formulaType = shape.formulaType;
+        bean.fieldType = shape.formulaType;
+        return bean;
+    }
+    if (['context', 'dynamic', 'formfield', 'form_field'].includes(kind)) {
+        const key = String(raw || '').replace(/^(FormData|ApprovalData)\./, '');
+        if (!key)
+            throw new Error('Condition 动态右值必须提供 paramKey/key/value 或完整 formula');
+        const bean = formulaContext(String(right?.source || right?.comId || sourceId), key, {
+            name: String(right?.label || right?.name || key),
+            fieldType: shape.formulaType,
+            componentType: String(right?.componentType || right?.comType || 'ApproveTrigger'),
+        });
+        bean.businessId = String(right?.businessId || bean.businessId || '0');
+        return bean;
+    }
+    throw new Error(`Condition 右值 type='${kind}' 不支持；请使用 fixed/system/context 或提供完整 formula`);
+}
+export function hasConditionExpression(condition) {
+    if (!condition || typeof condition !== 'object')
+        return false;
+    const data = condition;
+    return Boolean(data.left && typeof data.left === 'object') || conditionItems(data).length > 0;
+}
+function buildSingleConditionDetail(condition, sourceId, meta = null) {
+    if (!condition || typeof condition !== 'object')
+        return {};
+    const left = condition.left || {};
+    const requestedFieldKey = String(left.key || left.value || '').trim();
+    const requestedLabel = String(left.label || left.name || requestedFieldKey || '').trim();
+    const operator = String(condition.operator || '').trim().toLowerCase();
+    const workflowId = meta && typeof meta === 'object' ? String(meta._workflow_id || '') : '';
+    // 条件计划允许使用完整 paramKey、paramName、真实字段 id 或界面显示名；统一回到
+    // workflow-context-fields 的原始字段，避免把 label/内部字段名拼成不存在的路径。
+    const contextFields = workflowId ? Object.values(getWorkflowContextFields()[workflowId] || {}) : [];
+    const rawField = contextFields.find((field) => {
+        if (!field || typeof field !== 'object')
+            return false;
+        return [field.paramKey, field.paramName, field.showName, field.id, field.paramId]
+            .some((candidate) => String(candidate ?? '') === requestedFieldKey || String(candidate ?? '') === requestedLabel);
+    }) || null;
+    const fieldKey = String(rawField?.paramKey || requestedFieldKey);
+    const fieldLabel = String(rawField?.showName || rawField?.paramName || requestedLabel || fieldKey);
+    const isEnquiryCount = ['count', 'response.count', 'Response.response.count'].includes(requestedFieldKey);
+    if (requestedFieldKey && !isEnquiryCount && workflowId) {
+        const wfFields = getWorkflowFieldIds()[workflowId] || {};
+        if (!rawField && Object.keys(wfFields).length && !(requestedFieldKey in wfFields) && !(requestedLabel in wfFields)) {
+            throw new Error(`Condition.left.key='${requestedFieldKey}' 未在流程 '${workflowId}' 的实时上下文中找到。请传完整 paramKey、字段显示名或 getComponentContext 返回的字段对象。`);
+        }
+    }
+    const shape = conditionFieldShape(workflowId, fieldKey, fieldLabel);
+    const opt = CONDITION_OPT_CODE_MAP[operator];
+    if (!opt)
+        throw new Error(`Condition 操作符 '${condition.operator}' 不支持`);
+    if (!CONDITION_OPERATOR_CODES_BY_FAMILY[shape.family]?.has(opt)) {
+        throw new Error(`Condition 字段 '${fieldLabel}' 类型=${shape.family} 不支持操作 '${condition.operator}'`);
+    }
+    const optLabel = CONDITION_OPT_LABEL_MAP[opt] ?? '等于';
+    const needRight = !(opt === 13 || opt === 14);
+    const right = condition.right || {};
+    const rightValue = right.value ?? '';
+    const rightLabel = String(right.label || rightValue || '').trim();
+    const conditionCn = needRight ? `(${fieldLabel} ${optLabel} ${rightLabel})` : `(${fieldLabel} ${optLabel})`;
+    const cid = genSfId(), exprId = genSfId(), mapBase = genSfId(), mapIdVal = genSfId();
+    const ebId = genSfId(), baseId = genSfId(), dvId = genSfId(), ev1 = genSfId(), ev2 = genSfId();
+    const fieldId = rawField ? String(rawField.id || rawField.paramId || '') : (workflowId ? workflowFieldId(workflowId, requestedFieldKey) : '');
+    let paramKeyId, valueId, comType;
+    if (isEnquiryCount) {
+        paramKeyId = 'response.count';
+        valueId = 'response.count';
+        comType = 'EnquiryForm';
+    }
+    else if (rawField) {
+        paramKeyId = String(rawField.paramKey);
+        valueId = `ApprovalData.${paramKeyId}`;
+        comType = 'ApproveTrigger';
+    }
+    else if (fieldId && workflowId && fieldId !== fieldKey) {
+        paramKeyId = `${workflowId}.${fieldId}`;
+        valueId = `FormData.${workflowId}.${fieldId}`;
+        comType = 'ApproveTrigger';
+    }
+    else {
+        paramKeyId = fieldKey;
+        valueId = fieldKey ? `FormData.${fieldKey}` : '';
+        comType = 'EbGetDataById';
+    }
+    const upstreamWId = meta && typeof meta === 'object' ? String(meta._upstream_w_id || '') : '';
+    const contextWId = isEnquiryCount ? String(sourceId) : (upstreamWId || String(sourceId));
+    // customFieldType.id/businessId 是条件编辑器中“本次选择上下文”的 FormulaBean
+    // 实例 ID，不是业务字段 ID。真实字段身份只由 config.paramKey 承载。若把两者
+    // 写成字段 id（例如 17），saveCondition 会返回 haveData=false，仅保留空骨架，
+    // 用户再次保存条件时就会清空。手工创建的回读也使用独立的分布式实例 ID。
+    const customFieldId = genSfId();
+    const customFieldBiz = genSfId();
+    // 流程字段需保留“流程 ID.字段名”的上下文显示路径，规则编辑器才能定位来源。
+    const contextDisplayName = rawField && workflowId ? `${workflowId}.${fieldLabel}` : fieldLabel;
+    const leftOperand = {
+        expressionBaseId: baseId, [`${shape.prefix}CompareOptionLeft`]: opt, dataValueId: dvId,
+        elementValue2Id: ev2, elementValue1Id: ev1, selectType: 97,
+        customFieldType: {
+            paramType: shape.formulaType, formulaType: shape.formulaType, name: fieldLabel, businessId: customFieldBiz,
+            selectType: '-1', id: customFieldId, source: contextWId, type: '3', value: valueId,
+            config: {
+                paramKey: paramKeyId, isMultCom: false, comType, parentComId: '0',
+                fieldInfo: { paramKey: paramKeyId, tablePrimaryKey: rawField ? 'ApprovalData' : 'FormData' },
+                tableName: rawField ? '流程数据' : '表单数据', paramType: shape.formulaType, parentName: contextDisplayName, multName: '', multKey: '',
+                multTypeObj: { allName: contextDisplayName, currentName: contextDisplayName, currentParamKey: valueId, allParamKey: valueId },
+                comId: contextWId, newParentName: contextDisplayName,
+            },
+            fieldType: shape.formulaType,
+        },
+    };
+    if (needRight) {
+        leftOperand[`${shape.prefix}TextValueLeft`] = conditionFormulaType(right, shape, contextWId);
+    }
+    const dataJson = JSON.stringify({
+        sourceId: sourceId ? String(sourceId) : '-1',
+        expressionId: exprId, mapBaseId: mapBase, conditionId: cid,
+        // saveCondition 自身会为同一层的规则生成 AND/OR 表达式组。
+        // 单条规则若先在这里包一层 group，会在服务端变成“根 → AND → AND → 叶子”，
+        // 条件编辑器打开后显示为多余嵌套。直接提交叶子，与手工新建单条件一致。
+        childrens: [leftOperand],
+        mapId: mapIdVal, source: 8, relation: 1,
+    });
+    return {
+        conditionId: cid, conditionCn, mapBaseId: mapBase, mapId: mapIdVal,
+        sourceIds: sourceId ? [sourceId] : [],
+        conditionDataJson: dataJson,
+    };
+}
+function buildConditionExpressionNodes(condition, sourceId, meta) {
+    const items = conditionItems(condition);
+    if (items.length > 0) {
+        const relation = conditionRelationCode(condition.relationship ?? condition.relation);
+        const built = items.map((item) => buildConditionExpressionNodes(item, sourceId, meta));
+        return {
+            nodes: [{ expressionId: genSfId(), relation, childrens: built.flatMap((item) => item.nodes) }],
+            text: `(${built.map((item) => item.text).join(relation === 2 ? ' 或 ' : ' 且 ')})`,
+        };
+    }
+    if (!condition.left || typeof condition.left !== 'object') {
+        throw new Error('Condition 规则组中的每个叶子都必须包含 left 字段');
+    }
+    const detail = buildSingleConditionDetail(condition, sourceId, meta);
+    const tree = JSON.parse(String(detail.conditionDataJson || '{}'));
+    const nodes = Array.isArray(tree.childrens) ? tree.childrens : [];
+    if (!nodes.length)
+        throw new Error('Condition 叶子未生成 ExpressionBean');
+    return { nodes, text: String(detail.conditionCn || '') };
+}
+/**
+ * 编译 ESB Condition 的 ExpressionBean。
+ * 支持旧版单叶子 {left, operator, right}，以及 {relationship, conditions:[...]} 规则组。
+ */
+export function buildConditionDetail(condition, sourceId, meta = null) {
+    if (!condition || typeof condition !== 'object')
+        return {};
+    const built = buildConditionExpressionNodes(condition, sourceId, meta);
+    const relation = conditionRelationCode(condition.relationship ?? condition.relation);
+    const cid = genSfId(), exprId = genSfId(), mapBase = genSfId(), mapIdVal = genSfId();
+    const dataJson = JSON.stringify({
+        sourceId: sourceId ? String(sourceId) : '-1',
+        expressionId: exprId, mapBaseId: mapBase, conditionId: cid,
+        childrens: built.nodes,
+        mapId: mapIdVal, source: 8, relation,
+    });
+    return {
+        conditionId: cid, conditionCn: built.text, mapBaseId: mapBase, mapId: mapIdVal,
+        sourceIds: sourceId ? [sourceId] : [], conditionDataJson: dataJson,
+    };
+}
+// ── _build_setting_detail ───────────────────────────────────
+export function buildSettingDetail(nodeData, detailItems, meta, appId, eventId, nodeType) {
+    if (!Array.isArray(detailItems))
+        return;
+    const detailOut = [];
+    for (const item of detailItems) {
+        if (!item || typeof item !== 'object' || !item.detailTableId)
+            continue;
+        const ele = { detailTableId: String(item.detailTableId) };
+        if (item.updateFieldCondition && typeof item.updateFieldCondition === 'object') {
+            ele.updateFieldCondition = buildUpdateFieldCondition(item.updateFieldCondition, { meta, appId, eventId: String(eventId), componentType: nodeType });
+        }
+        else {
+            ele.updateFieldCondition = { updateField: [] };
+        }
+        const eleData = {};
+        // 明细项依据值：引用整个明细表，source=event 节点 id, frontId=明细表 id。
+        if (item.basisValue && typeof item.basisValue === 'object') {
+            const bvVal = item.basisValue;
+            const bvKey = String(bvVal.paramKey || bvVal.key || '').trim();
+            const bvLabel = String(bvVal.label || bvVal.name || bvKey);
+            if (bvKey) {
+                const bvType = resolveSourceFieldType(bvKey, meta);
+                let prefix = '';
+                if (meta && typeof meta === 'object') {
+                    prefix = String(meta._upstream_workflow_name || '');
+                    if (!prefix)
+                        prefix = String(meta._upstream_form_name || '');
+                }
+                const parentName = prefix ? `${prefix}.${bvLabel}[]` : `${bvLabel}[]`;
+                const bvSubformId = bvKey.includes('[]') ? bvKey.split('[]')[0].includes('.') ? bvKey.split('[]')[0].slice(bvKey.split('[]')[0].lastIndexOf('.') + 1) : bvKey : bvKey;
+                ele.basisValue = {
+                    frontId: bvSubformId,
+                    formulaType: bvType,
+                    name: bvLabel,
+                    id: genSfId(),
+                    source: String(eventId),
+                    type: '3',
+                    value: `FormData.${bvKey}`,
+                    childs: [],
+                    config: {
+                        paramKey: bvKey,
+                        paramType: bvType,
+                        isMultCom: false,
+                        switchType: 'assign',
+                        parentName,
+                        multName: '',
+                        multKey: '',
+                        multTypeObj: {
+                            allName: parentName, currentName: parentName,
+                            currentParamKey: `FormData.${bvKey}`, allParamKey: `FormData.${bvKey}`,
+                        },
+                        comId: String(eventId),
+                        comType: 'ApproveTrigger',
+                        newParentName: parentName,
+                        fieldInfo: { paramKey: bvKey, tablePrimaryKey: 'FormData' },
+                    },
+                    parentId: '0',
+                };
+            }
+        }
+        const mapping = item.mapping || {};
+        const constants = item.constants || {};
+        if (mapping && typeof mapping === 'object' && !Array.isArray(mapping)) {
+            for (const [sourceKey, targetFieldIdRaw] of Object.entries(mapping)) {
+                const targetFieldId = targetFieldIdRaw;
+                let operate = 'OPERATE_EQUAL';
+                let assignment;
+                if (targetFieldId && typeof targetFieldId === 'object' && !Array.isArray(targetFieldId)) {
+                    let raw = String(targetFieldId.target || targetFieldId.fieldId || '');
+                    if (!raw)
+                        throw new Error('detail.mapping 依据值下级值缺少目标字段 id: 应传 {"target":"<目标明细字段id>", "paramKey":"<源paramKey>", ...}');
+                    if (raw.startsWith('+')) {
+                        operate = 'OPERATE_PLUS';
+                        raw = raw.slice(1);
+                    }
+                    else if (raw.startsWith('-')) {
+                        operate = 'OPERATE_MINUS';
+                        raw = raw.slice(1);
+                    }
+                    const refKey = String(targetFieldId.paramKey || sourceKey);
+                    const refLabel = String(targetFieldId.label || sourceKey);
+                    const refDetail = String(targetFieldId.detailLabel || '');
+                    assignment = { kind: 'context', paramKey: refKey, label: refLabel };
+                    if (refDetail)
+                        assignment.detailLabel = refDetail;
+                    eleData[raw] = buildSettingEntry(raw, assignment, 'Text', meta, appId, eventId, operate, nodeType, true, '');
+                }
+                else {
+                    let raw = String(targetFieldId);
+                    if (raw.startsWith('+')) {
+                        operate = 'OPERATE_PLUS';
+                        raw = raw.slice(1);
+                    }
+                    else if (raw.startsWith('-')) {
+                        operate = 'OPERATE_MINUS';
+                        raw = raw.slice(1);
+                    }
+                    assignment = { kind: 'context', paramKey: String(sourceKey), label: resolveSourceFieldLabel(String(sourceKey), meta, String(sourceKey)) };
+                    eleData[raw] = buildSettingEntry(raw, assignment, 'Text', meta, appId, eventId, operate, nodeType, true, '');
+                }
+            }
+        }
+        if (constants && typeof constants === 'object' && !Array.isArray(constants)) {
+            for (const [targetFieldIdRaw, valueRaw] of Object.entries(constants)) {
+                const targetFieldId = String(targetFieldIdRaw);
+                const value = valueRaw;
+                const [assignment, ft] = normalizeConstantAssignment(value, 'Text');
+                eleData[targetFieldId] = buildSettingEntry(targetFieldId, assignment, ft, meta, appId, eventId, 'OPERATE_EQUAL', nodeType, true, '');
+            }
+        }
+        // detail 自动按名补全
+        const targetFormId = String((nodeData.targetForm || {}).id || '');
+        autoFillDetailMapping(eleData, item, targetFormId, meta, appId, eventId, nodeType);
+        ele.data = eleData;
+        if (item.deleteFields)
+            ele.deleteFields = item.deleteFields;
+        if (item.operateType)
+            ele.operateType = item.operateType;
+        else
+            ele.operateType = 'insert';
+        if (item.updateFieldCondition && typeof item.updateFieldCondition === 'object')
+            ele.updateFieldCondition = item.updateFieldCondition;
+        detailOut.push(ele);
+    }
+    if (detailOut.length)
+        nodeData.setting.detail = detailOut;
+}
+export function autoFillDetailMapping(eleData, item, targetFormId, meta, appId, eventId, nodeType) {
+    if (!item || typeof item !== 'object' || !item.detailTableId)
+        return;
+    const bvVal = item.basisValue;
+    if (!bvVal || typeof bvVal !== 'object')
+        return;
+    const bvKey = String(bvVal.paramKey || bvVal.key || '').trim();
+    const bvLabel = String(bvVal.label || bvVal.name || '');
+    if (!bvKey || !bvKey.includes('[]'))
+        return;
+    const wfId = String(meta._workflow_id || '');
+    const subformId = bvKey.split('[]')[0].includes('.') ? bvKey.split('[]')[0].slice(bvKey.split('[]')[0].lastIndexOf('.') + 1) : bvKey.split('[]')[0];
+    const targetFields = targetFormId ? (getTargetDetailFields()[String(targetFormId)] || {})[String(item.detailTableId)] || {} : {};
+    const sourceFields = getWorkflowDetailFields()[wfId]?.[subformId] || {};
+    if (Object.keys(targetFields).length === 0 || Object.keys(sourceFields).length === 0)
+        return;
+    for (const [tid, tmetaRaw] of Object.entries(targetFields)) {
+        const tmeta = tmetaRaw;
+        const tidS = String(tid);
+        if (tidS in eleData)
+            continue;
+        const tname = String(tmeta.name || tmeta.showName || '');
+        if (!tname || !(tname in sourceFields))
+            continue;
+        const srcPk = sourceFields[tname];
+        const assignment = { kind: 'context', paramKey: srcPk, label: tname };
+        if (bvLabel)
+            assignment.detailLabel = bvLabel;
+        eleData[tidS] = buildSettingEntry(tidS, assignment, String(tmeta.componentKey || tmeta.type || 'Text'), meta, appId, eventId, 'OPERATE_EQUAL', nodeType, true, '');
+    }
+}
+// ── convert_node ────────────────────────────────────────────
+export function convertNode(draftAction, isEvent = false, meta = null, appId = '', actionIndex = 0, eventNodeId = '', eventName = '', previousNodeId = '0', lenient = false) {
+    const nodeType = draftAction.type;
+    const comp = get(nodeType) || {};
+    const display = comp.display || {};
+    const rawId = draftAction.id;
+    let nid = genSfId();
+    if (rawId !== undefined && rawId !== null) {
+        const parsed = Number(rawId);
+        if (Number.isFinite(parsed))
+            nid = String(parsed);
+    }
+    const nidStr = String(nid);
+    // 当前节点 id 供 filterInput 的 esbAssign.wId 使用（设计器用其定位当前组件）。
+    if (meta && typeof meta === 'object')
+        meta._upstream_node_id = nidStr;
+    const ctx = { meta: meta || {}, appId, actionIndex, eventNodeId: eventNodeId || nidStr, eventName, lenient, compileGeneric: (p, t, c) => compileComponentData(p, t, c, true), buildFilterInput, buildConditionDetail };
+    let node = {
+        id: nidStr, wId: nidStr,
+        name: draftAction.name ?? display.componentName ?? nodeType,
+        type: nodeType,
+        attr: { icon: display.icon ?? 'Icon-default' },
+        data: compileComponentData(draftAction.params || {}, nodeType, ctx),
+        parentId: '0',
+    };
+    const nodeData = node.data || {};
+    const pendingMapping = nodeData._pending_mapping;
+    delete nodeData._pending_mapping;
+    const pendingConstants = nodeData._pending_constants;
+    delete nodeData._pending_constants;
+    const pendingFormula = nodeData._pending_formula;
+    delete nodeData._pending_formula;
+    let pendingDetail = nodeData._pending_detail;
+    delete nodeData._pending_detail;
+    const formDataPayload = comp.formDataPayload;
+    if (formDataPayload && typeof formDataPayload === 'object' && (pendingMapping || pendingConstants || pendingFormula || pendingDetail)) {
+        // ApproveCreate 新建流程：字段映射进 formData.main/detail（BPM 流程表单字段）。
+        fillSetting(nodeData, undefined, pendingMapping, pendingConstants, pendingFormula, meta || {}, appId, eventNodeId || nidStr, eventName, nodeType);
+        if (pendingDetail && typeof nodeData.setting === 'object') {
+            buildSettingDetail(nodeData, pendingDetail, meta || {}, appId, eventNodeId || nidStr, nodeType);
+        }
+        const setting = nodeData.setting;
+        delete nodeData.setting;
+        const main = (setting || {}).main || {};
+        const detailOut = (setting || {}).detail || [];
+        nodeData.formData = { main, detail: detailOut, dataDrWithCalc: false };
+        const fieldsMetaKey = String(formDataPayload.fieldsMetaKey || '_bizFields');
+        let bizFields = meta && typeof meta === 'object' ? (meta[fieldsMetaKey] || {}) : {};
+        if (!bizFields || Object.keys(bizFields).length === 0)
+            bizFields = draftAction.params?.[fieldsMetaKey] || {};
+        nodeData.fields = {
+            main: bizFields && typeof bizFields === 'object' ? (bizFields.main || []) : [],
+            detail: bizFields && typeof bizFields === 'object' ? (bizFields.detail || []) : [],
+        };
+    }
+    else if (pendingDetail && !(pendingMapping || pendingConstants || pendingFormula)) {
+        // 只有明细表赋值（无主表 mapping/constants）：先 _fill_setting 生成空 main + setting，再放回 detail。
+        fillSetting(nodeData, undefined, undefined, undefined, undefined, meta || {}, appId, eventNodeId || nidStr, eventName, nodeType);
+        nodeData._pending_detail = pendingDetail;
+        nodeData.formDataId = genSfId();
+    }
+    else if (formDataPayload && typeof formDataPayload === 'object') {
+        // 声明 formDataPayload 的组件即使没有字段映射，也显式携带表单数据容器。
+        nodeData.formData ??= { main: {}, detail: [], dataDrWithCalc: false };
+        nodeData.fields ??= { main: [], detail: [] };
+        nodeData.formDataId ??= genSfId();
+    }
+    else if ((pendingMapping || pendingConstants || pendingFormula) && !('setting' in nodeData)) {
+        let m = { ...(meta || {}) };
+        const tf = nodeData.targetForm || {};
+        if (tf.text || tf.name)
+            m._upstream_form_name = tf.text || tf.name;
+        if (tf.id)
+            m._upstream_table_id = String(tf.id);
+        if (eventName)
+            m._upstream_name = eventName;
+        if (nodeData.workflowId)
+            m._workflow_id = String(nodeData.workflowId);
+        if (pendingDetail)
+            nodeData._pending_detail = pendingDetail;
+        fillSetting(nodeData, undefined, pendingMapping, pendingConstants, pendingFormula, m, appId, eventNodeId || nidStr, eventName, nodeType);
+    }
+    const pendingBasis = nodeData._pending_basis;
+    delete nodeData._pending_basis;
+    if (pendingBasis && typeof nodeData.setting === 'object' && nodeData.setting) {
+        Object.assign(nodeData.setting, pendingBasis);
+    }
+    // 若既有旧 updates(-setting_main)又有新 mapping/constants，合并到已有 main。
+    // 对齐 Python 版 convert_node 的二次合并逻辑（该分支不传 field_type，会用默认 "Text" 覆盖）。
+    const assignmentMode = comp.assignmentContextMode || '';
+    if ((pendingMapping || pendingConstants) && typeof nodeData.setting === 'object' && nodeData.setting) {
+        const main = nodeData.setting.main || {};
+        if (pendingMapping && typeof pendingMapping === 'object') {
+            for (const [sourceKey, targetFieldIdRaw] of Object.entries(pendingMapping)) {
+                const targetFieldId = targetFieldIdRaw;
+                if (targetFieldId && typeof targetFieldId === 'object')
+                    continue;
+                let raw = String(targetFieldId);
+                let operate = 'OPERATE_EQUAL';
+                if (raw.startsWith('+')) {
+                    operate = 'OPERATE_PLUS';
+                    raw = raw.slice(1);
+                }
+                else if (raw.startsWith('-')) {
+                    operate = 'OPERATE_MINUS';
+                    raw = raw.slice(1);
+                }
+                main[raw] = buildSettingEntry(raw, { kind: 'context', paramKey: String(sourceKey), label: String(sourceKey) }, 'Text', meta || {}, appId, eventNodeId || nidStr, operate, nodeType, false, assignmentMode);
+            }
+        }
+        if (pendingConstants && typeof pendingConstants === 'object') {
+            for (const [targetFieldIdRaw, valueRaw] of Object.entries(pendingConstants)) {
+                const targetFieldId = String(targetFieldIdRaw);
+                const value = valueRaw;
+                let operateC = 'OPERATE_EQUAL';
+                let rawV = value;
+                if (typeof value === 'string' && value.length > 1 && (value[0] === '+' || value[0] === '-')) {
+                    operateC = value[0] === '+' ? 'OPERATE_PLUS' : 'OPERATE_MINUS';
+                    rawV = value.slice(1);
+                }
+                const targetFieldMeta = lookupTargetFieldMeta(targetFieldId, nodeData);
+                rawV = resolveEnumConstant(rawV, targetFieldMeta);
+                const [assignment, ft] = normalizeConstantAssignment(rawV, 'Text');
+                const targetFieldType = String(targetFieldMeta?.componentKey || targetFieldMeta?.type || ft);
+                main[targetFieldId] = buildSettingEntry(targetFieldId, assignment, targetFieldType, meta || {}, appId, eventNodeId || nidStr, operateC, nodeType, false, assignmentMode);
+            }
+        }
+        nodeData.setting.main = main;
+        nodeData.setting.opType = nodeData.setting.opType ?? 'insert';
+    }
+    pendingDetail = nodeData._pending_detail;
+    delete nodeData._pending_detail;
+    if (pendingDetail && Array.isArray(pendingDetail) && pendingDetail.length && typeof nodeData.setting === 'object') {
+        buildSettingDetail(nodeData, pendingDetail, meta || {}, appId, eventNodeId || nidStr, nodeType);
+    }
+    if (isEvent) {
+        node.triggerType = comp.triggerType ?? 'WorkflowTrigger';
+        node.triggerTypeName = comp.triggerTypeName ?? (nodeType === 'ApproveTrigger' ? '流程事件触发' : nodeType);
+        node.costTime = 0;
+        if (display.iconColor)
+            node.attr.iconColor = display.iconColor;
+        const nd = node.data || {};
+        for (const [key, value] of Object.entries(comp.nodeDataDefaults || {})) {
+            nd[key] ??= JSON.parse(JSON.stringify(value));
+        }
+    }
+    else {
+        node.componentId = nidStr;
+        // 首节点（previousNodeId=event）通常不写 sources，平台对 ActionEb 等数据/动作组件自动接 event；
+        // 但 EnquiryForm 查询组件不适用该约定——漏 sources 会被平台判定为「起始执行组件」，
+        // 报「有两个起始执行组件」（真机验证 2026-08-27，sjrdemo 环境）。
+        const needsEventSource = nodeType === 'EnquiryForm' && ['', '0', String(eventNodeId)].includes(String(previousNodeId));
+        if (!['', '0', String(eventNodeId)].includes(String(previousNodeId)) || needsEventSource) {
+            node.sources = [{ wId: needsEventSource ? String(eventNodeId) : String(previousNodeId) }];
+        }
+    }
+    // 设计器通过“添加操作”创建节点时，除平台执行 DTO 外还会保留组件目录项。
+    // 这套前端节点壳（尤其是 MultipleExecution 的 originId/options）决定容器
+    // 内部编辑能否被前端 Store 正确回写；只发 componentId 的后端简化节点会
+    // 造成循环内条件保存后显示为空。目录由运行时接口读取，避免租户硬编码。
+    const catalogOption = !isEvent && meta && typeof meta === 'object'
+        ? (meta._componentOptions || {})[nodeType]
+        : undefined;
+    if (catalogOption && typeof catalogOption === 'object') {
+        const option = JSON.parse(JSON.stringify(catalogOption));
+        option.content ??= option.actionName || option.eventName || '';
+        node.nodeType = nodeType === 'MultipleExecution' ? 'MultipleExecution' : 'Normal';
+        node.comType = nodeType;
+        node.previousId = String(previousNodeId || '0');
+        node.isAdd = true;
+        node.isLock = false;
+        node.ignoreFlowCheck = true;
+        node.originId = String(option.id || '');
+        node.options = option;
+        node.componentDesc = String(option.des || option.componentDesc || node.name || '');
+        node.componentDescLabel = option.componentDescLabel;
+        node.componentName = String(option.eventName || option.actionName || option.componentName || node.name || '');
+        node.componentNameLabel = option.componentNameLabel;
+        node.name = String(option.actionName || option.eventName || node.name || nodeType);
+        node.nameMultilang = node.name;
+        node.attr = { ...node.attr, ...(option.icon ? { icon: option.icon } : {}) };
+        delete node.componentId;
+        delete node.sources;
+    }
+    const defaultPerson = comp.defaultPerson;
+    if (defaultPerson && typeof defaultPerson === 'object' && !isEvent) {
+        const data = node.data || {};
+        if (!('person' in data)) {
+            data.person = buildPersonFormula(defaultPerson, meta || {}, appId, false, Boolean(defaultPerson.direct));
+            node.data = data;
+        }
+    }
+    // 组件画布节点后处理（如 SendMessage 的 person/shareList）
+    const postNode = getNodePost(nodeType);
+    if (postNode) {
+        node = postNode(node, { draftAction, meta: meta || {}, appId, eventNodeId, isEvent });
+    }
+    return node;
+}
+// ── convert_condition ───────────────────────────────────────
+export function convertCondition(draftAction, meta = null, appId = '', actionIndex = 0, eventId = '', previousNodeId = '0', lenient = false) {
+    const node = convertNode(draftAction, false, meta, appId, actionIndex, eventId, '', previousNodeId, lenient);
+    const src = draftAction.params && typeof draftAction.params === 'object' ? draftAction.params : {};
+    const branches = draftAction.branches || src.branches || [];
+    if (!branches || branches.length === 0) {
+        node.data.trueBranchActions = [];
+        node.data.falseBranchActions = [];
+        node.data.otherConditionBranch = [];
+        return node;
+    }
+    const conditionalBranches = [];
+    let elseBranchActions = null;
+    for (let i = 0; i < branches.length; i++) {
+        const branch = branches[i];
+        let cond = branch && typeof branch === 'object' ? branch.condition : null;
+        if (!cond || typeof cond !== 'object')
+            cond = {};
+        const isElse = cond.type === 'else';
+        const hasRealCond = !isElse && hasConditionExpression(cond);
+        const bacts = [];
+        let branchPreviousId = '0';
+        for (const a of branch.actions || []) {
+            if (a.type === 'Output')
+                continue;
+            const branchNode = convertNode(a, false, meta, appId, i, eventId, '', branchPreviousId, lenient);
+            bacts.push(branchNode);
+            branchPreviousId = branchNode.wId;
+        }
+        if (hasRealCond) {
+            conditionalBranches.push([cond, bacts, String(branch.name || '满足条件')]);
+        }
+        else {
+            if (elseBranchActions === null)
+                elseBranchActions = bacts;
+        }
+    }
+    const trueBranchActions = conditionalBranches.length ? conditionalBranches[0][1] : [];
+    const falseBranchActions = elseBranchActions || [];
+    const otherBranchActions = [];
+    for (let index = 0; index < conditionalBranches.length - 1; index++) {
+        const [cond, actions, name] = conditionalBranches[index + 1];
+        const branchId = genSfId();
+        const detail = buildConditionDetail(cond, String(previousNodeId), meta);
+        otherBranchActions.push({
+            id: branchId, wId: branchId, branchName: name || `条件${index + 2}`,
+            conditionId: detail.conditionId || '', conditionDetail: detail, branchActions: actions,
+        });
+    }
+    node.data.trueBranchActions = trueBranchActions;
+    node.data.falseBranchActions = falseBranchActions;
+    node.data.otherConditionBranch = otherBranchActions;
+    if (conditionalBranches.length) {
+        const detail = buildConditionDetail(conditionalBranches[0][0], String(previousNodeId), meta);
+        node.data.conditionDetail = detail;
+        node.data.conditionId = detail.conditionId;
+    }
+    if (previousNodeId && !['0', String(eventId)].includes(String(previousNodeId))) {
+        node.sources = [{ wId: String(previousNodeId) }];
+    }
+    return node;
+}
+/** 将简化计划中的循环体编译进 MultipleExecution.data.actions。 */
+export function convertMultipleExecution(draftAction, meta = null, appId = '', actionIndex = 0, eventId = '', eventName = '', previousNodeId = '0', lenient = false) {
+    const node = convertNode(draftAction, false, meta, appId, actionIndex, eventId, eventName, previousNodeId, lenient);
+    // 对齐前端 NodeConfig 的循环节点初始数据。data.id 不是画布 wId：它是循环组件
+    // 的配置数据标识；缺失时循环可显示，却无法持久化其中手工新增的条件或赋值。
+    node.data ??= {};
+    node.data.id ??= genSfId();
+    node.data.tempCycleMode ??= String(node.data.cycleMode ?? '1');
+    node.data.type ??= 'MultipleExecution';
+    node.data.applicationId ??= String(appId);
+    node.data.sceneId ??= String(meta?._scene_id || '');
+    node.data.multiParallelFlag ??= '0';
+    // 前端递归展开循环体时使用这两个路径标识构造循环内上下文；根循环为空，
+    // 循环体第一层以当前循环画布节点为 key。缺失会让手工编辑后的状态落回根链。
+    node.multKey ??= '';
+    node.multName ??= '';
+    const body = Array.isArray(draftAction.actions) ? draftAction.actions : [];
+    if (!body.length)
+        throw new Error('MultipleExecution.actions 循环体不能为空');
+    const actions = [];
+    // 循环体首节点在画布中的 previousId 必须为 0；parentId 才是循环容器。
+    // 若把 sources 指向循环节点，前端回读会找不到循环内起始节点并将其画到循环外。
+    let bodyPreviousId = '0';
+    for (let index = 0; index < body.length; index++) {
+        const action = body[index];
+        if (action?.type === 'Output')
+            continue;
+        if (action?.type === 'MultipleExecution')
+            throw new Error('MultipleExecution 暂不支持嵌套循环');
+        const bodyNode = action?.type === 'Condition'
+            ? convertCondition(action, meta, appId, index, eventId, bodyPreviousId, lenient)
+            : convertNode(action, false, meta, appId, index, eventId, eventName, bodyPreviousId, lenient);
+        // 前端 dealBackData 展开 data.actions 后，依赖 parentId 将节点挂进循环画布；
+        // 缺失时会被当作主链节点，循环容器显示为空。
+        bodyNode.parentId = node.wId;
+        bodyNode.multKey = node.multKey ? `${node.multKey}.${node.wId}` : String(node.wId);
+        bodyNode.multName = node.multName ? `${node.multName}.${node.name}` : String(node.name);
+        bodyNode.ignoreFlowCheck = true;
+        // 前端以 sources[0] ? sources[0].wId : 0 还原 previousId。
+        // [{}] 会还原为 undefined，循环体找不到起始节点；首节点必须为空数组。
+        if (index === 0)
+            bodyNode.sources = [];
+        actions.push(bodyNode);
+        bodyPreviousId = bodyNode.wId;
+    }
+    if (!actions.length)
+        throw new Error('MultipleExecution.actions 循环体必须包含至少一个非 Output 动作');
+    node.data.actions = actions;
+    return node;
+}
+// ── 辅助层 / 骨架 / 别名替换 ───────────────────────────────
+export function buildAssistLayer(event, actions) {
+    const nodes = [{ id: event.id, type: event.type, layout: { x: 100, y: 100, width: 200, height: 80 } }];
+    let y = 220;
+    for (const a of actions) {
+        nodes.push({ id: a.id, type: a.type, layout: { x: 100, y, width: 200, height: 80 } });
+        y += 130;
+    }
+    return { nodes, edges: [], layout: { offsetX: 0, offsetY: 0, zoom: 1.0 } };
+}
+function registerRealNodeIds(draftNode, realNode, nodeIds) {
+    const draftId = String(draftNode?.id ?? '');
+    const realId = String(realNode?.id ?? '');
+    if (draftId && realId)
+        nodeIds[draftId] = realId;
+}
+function replaceFormulaSourceAliases(value, nodeIds) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (String(value.type) === '3' && 'formulaType' in value) {
+            const source = value.source;
+            if (typeof source === 'string' && source in nodeIds)
+                value.source = nodeIds[source];
+        }
+        const cfg = value.config;
+        if (typeof cfg === 'string') {
+            try {
+                const cfgObj = JSON.parse(cfg);
+                if (cfgObj && typeof cfgObj === 'object' && typeof cfgObj.comId === 'string' && cfgObj.comId in nodeIds) {
+                    cfgObj.comId = nodeIds[cfgObj.comId];
+                    value.config = JSON.stringify(cfgObj);
+                }
+            }
+            catch { /* ignore */ }
+        }
+        else if (cfg && typeof cfg === 'object' && typeof cfg.comId === 'string' && cfg.comId in nodeIds) {
+            cfg.comId = nodeIds[cfg.comId];
+        }
+        for (const child of Object.values(value))
+            replaceFormulaSourceAliases(child, nodeIds);
+    }
+    else if (Array.isArray(value)) {
+        for (const child of value)
+            replaceFormulaSourceAliases(child, nodeIds);
+    }
+}
+function buildSkeletonNode(actionType, previousNodeId, actionIndex = 0) {
+    const comp = get(actionType) || {};
+    const disp = comp.display || {};
+    const nodeId = genSfId();
+    const node = {
+        id: nodeId, wId: nodeId,
+        name: disp.typeName || disp.componentName || actionType,
+        nameMultilang: disp.typeName || disp.componentName || actionType,
+        type: actionType, typeName: disp.typeName || actionType,
+        attr: { icon: disp.icon ?? 'Icon-eb-mcolor' },
+        sources: [{ id: String(previousNodeId), wId: String(previousNodeId), status: [] }],
+        data: JSON.parse(JSON.stringify(comp.defaultData || {})),
+        parentId: '0',
+    };
+    if (actionType.startsWith('ActionEb')) {
+        node.data.ebActionId ??= '-1';
+        node.data.type = actionType;
+    }
+    return node;
+}
+// ── convert（主入口）────────────────────────────────────────
+export function convert(draft, appId = '', sceneId = '', metadataPath = '', lenient = false) {
+    let meta = {};
+    if (metadataPath)
+        meta = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+    if (!meta || typeof meta !== 'object')
+        meta = {};
+    meta._scene_id = String(sceneId || '');
+    meta._componentOptions = draft._componentOptions && typeof draft._componentOptions === 'object'
+        ? draft._componentOptions
+        : {};
+    let draftEvent = draft.event || {};
+    let draftActions = draft.actions || [];
+    const lenientWarnings = [];
+    if ('resolvedPlan' in draft) {
+        const rp = draft.resolvedPlan;
+        draftEvent = rp.event || {};
+        draftActions = rp.actions || [];
+    }
+    const eventNode = convertNode(draftEvent, true, meta, appId);
+    const eventId = eventNode.id;
+    const eventName = String(eventNode.attr?.componentName || eventNode.data?.typeName || eventNode.name || '流程触发');
+    const eventData = eventNode.data || {};
+    const workflowPath = eventData.workflowPath || [];
+    let workflowId = '';
+    if (Array.isArray(workflowPath) && workflowPath.length && workflowPath[0] && typeof workflowPath[0] === 'object') {
+        workflowId = String(workflowPath[0].id ?? '');
+    }
+    if (!workflowId && draftEvent && typeof draftEvent === 'object') {
+        const eventParams = draftEvent.params || {};
+        const eventWorkflowPath = eventParams.workflowPath;
+        if (eventWorkflowPath && typeof eventWorkflowPath === 'object' && !Array.isArray(eventWorkflowPath))
+            workflowId = String(eventWorkflowPath.id ?? '');
+        if (!workflowId)
+            workflowId = String(draftEvent.workflowId ?? '');
+    }
+    if (!workflowId && eventData && typeof eventData === 'object') {
+        const ds = eventData.dataSource || {};
+        let dsId = String(ds.id || '');
+        if (!dsId) {
+            const tf = eventData.targetForm || {};
+            dsId = String(tf.id || eventData.objId || '');
+        }
+        if (dsId)
+            workflowId = dsId;
+    }
+    const workflowModule = String(eventData.module ?? 'workflow');
+    if (workflowId) {
+        meta._workflow_id = workflowId;
+        let eventFormId = '';
+        let wfFids = [];
+        if (Array.isArray(workflowPath) && workflowPath.length && workflowPath[0] && typeof workflowPath[0] === 'object')
+            wfFids = workflowPath[0].formIds || [];
+        else if (workflowPath && typeof workflowPath === 'object' && !Array.isArray(workflowPath))
+            wfFids = workflowPath.formIds || [];
+        if (wfFids.length)
+            eventFormId = String(wfFids[0]);
+        else {
+            const evType = String(draftEvent?.type || '');
+            if (['TimeBatchTrigger', 'EventFormData', 'DateTrigger', 'EnquiryForm'].includes(evType))
+                eventFormId = workflowId;
+        }
+        meta._event_form_id = eventFormId;
+        meta._upstream_component_type = String(draftEvent?.type || 'ApproveTrigger');
+        let wfName = '';
+        if (Array.isArray(workflowPath) && workflowPath.length && workflowPath[0] && typeof workflowPath[0] === 'object')
+            wfName = String(workflowPath[0].name || workflowPath[0].text || '');
+        else if (workflowPath && typeof workflowPath === 'object' && !Array.isArray(workflowPath))
+            wfName = String(workflowPath.name || workflowPath.text || '');
+        if (!wfName && draft && typeof draft === 'object')
+            wfName = String(draft.workflowName || '');
+        if (!wfName && draft && typeof draft === 'object') {
+            const evParams = (draft.event || {}).params || {};
+            const an = evParams.approveNode;
+            if (an && typeof an === 'object')
+                wfName = String(an.workflowName || '');
+        }
+        meta._upstream_workflow_name = wfName;
+        if (!meta._upstream_form_name && eventData && typeof eventData === 'object') {
+            let srcName = '';
+            const ds = eventData.dataSource || {};
+            if (ds && typeof ds === 'object')
+                srcName = String(ds.text || ds.name || '');
+            if (!srcName) {
+                const tf = eventData.targetForm || {};
+                if (tf && typeof tf === 'object')
+                    srcName = String(tf.text || tf.name || '');
+            }
+            if (srcName)
+                meta._upstream_form_name = srcName;
+        }
+        meta._upstream_w_id = String(eventNode.id || '');
+    }
+    const realActions = [];
+    let previousNode = eventNode;
+    for (let i = 0; i < draftActions.length; i++) {
+        const a = draftActions[i];
+        const prevId = previousNode.id;
+        let node;
+        try {
+            if (a.type === 'Condition') {
+                node = convertCondition(a, meta, appId, i, eventId, prevId, lenient);
+            }
+            else if (a.type === 'MultipleExecution') {
+                node = convertMultipleExecution(a, meta, appId, i, eventId, eventName, prevId, lenient);
+            }
+            else {
+                node = convertNode(a, false, meta, appId, i, eventId, eventName, prevId, lenient);
+            }
+        }
+        catch (e) {
+            if (!lenient)
+                throw e;
+            node = buildSkeletonNode(String(a.type || ''), String(prevId), i);
+            lenientWarnings.push(`actions[${i}](${a.type}) 转换失败已降级为骨架节点(字段未生成): ${e}`);
+        }
+        if (['ActionEbAdd', 'ActionEbUpdate'].includes(a.type) && workflowId) {
+            const nodeData = node.data ?? (node.data = {});
+            nodeData.workflowModule ??= workflowModule;
+            nodeData.workflowId ??= workflowId;
+        }
+        realActions.push(node);
+        if (workflowId)
+            meta._workflow_id = workflowId;
+        previousNode = node;
+    }
+    const sourceNodeIds = { event: String(eventNode.id), trigger: String(eventNode.id) };
+    registerRealNodeIds(draftEvent, eventNode, sourceNodeIds);
+    draftActions.forEach((draftAction, idx) => registerRealNodeIds(draftAction, realActions[idx], sourceNodeIds));
+    replaceFormulaSourceAliases(realActions, sourceNodeIds);
+    const assist = buildAssistLayer(eventNode, realActions);
+    const design = {
+        appId: appId ? String(appId) : genSfId(),
+        sceneId: sceneId ? String(sceneId) : genSfId(),
+        event: eventNode,
+        actions: realActions,
+        assistLayer: JSON.stringify(assist),
+        reloadFormula: [],
+        version: 1,
+    };
+    const coerced = coerceIdsToStr(design);
+    if (lenient)
+        coerced._lenient_warnings = lenientWarnings;
+    return coerced;
+}
+// ── _coerce_ids_to_str ──────────────────────────────────────
+const ID_KEYS = new Set(['id', 'wId', 'componentId', 'parentId', 'parentNode', 'frontId']);
+export function coerceIdsToStr(obj) {
+    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (ID_KEYS.has(k) && (typeof v === 'number' || typeof v === 'bigint'))
+                out[k] = String(v);
+            else
+                out[k] = coerceIdsToStr(v);
+        }
+        return out;
+    }
+    if (Array.isArray(obj))
+        return obj.map(coerceIdsToStr);
+    return obj;
+}
+//# sourceMappingURL=workflow_compiler.js.map