weaver-e10-builder 1.0.11-beta → 1.1.0

package/dist/services/actionflow/update_service.js

@@ -0,0 +1,767 @@
+/**
+ * 已有动作流的保留式更新。
+ *
+ * 更新不是重新生成：先读取正式设计，基于原设计执行显式操作，再用原 appId/
+ * sceneId 和正式回读中的原节点 ID 调用 saveDesign。未被操作覆盖的节点和属性不会被重建；
+ * 平台创建新版时可能重分配动作/出口 ID，回读按新版结构校验。
+ * 更新不得改变 event 触发器；触发器变更必须走新建动作流。正式更新始终保存为新版本。
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { checkDesign, getApplication, getComponentsForDesign, getDesign, getVersionList, saveDesign } from './design_client.js';
+import { genSfId } from './id_generator.js';
+import { validateActionflowComponentConstraints } from './plan_constraints.js';
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function currentEnabledState(status) {
+    const value = String(status ?? '').toLowerCase();
+    if (['start_using', 'using', 'enabled', '1', 'true'].includes(value))
+        return true;
+    if (['forbidden', 'stop_using', 'not_start', 'notusing', 'disabled', 'disable', 'draft', '0', 'false'].includes(value))
+        return false;
+    return undefined;
+}
+function versionEntryId(entry) {
+    return String(entry?.id || entry?.sceneId || entry?.versionId || '').trim();
+}
+function findNewVersionId(versionResponse, previousSceneId, previousVersion) {
+    const versions = Array.isArray(versionResponse?.data?.actionFlowVersions)
+        ? versionResponse.data.actionFlowVersions
+        : [];
+    const candidates = versions
+        .map((entry) => ({ id: versionEntryId(entry), version: Number(entry?.version || 0), updateTime: String(entry?.updateTime || '') }))
+        .filter((entry) => entry.id && entry.id !== previousSceneId && entry.version > previousVersion)
+        .sort((a, b) => b.version - a.version || b.updateTime.localeCompare(a.updateTime));
+    return candidates[0]?.id || '';
+}
+function pointerParts(path) {
+    if (typeof path !== 'string' || !path.startsWith('/') || path === '/')
+        throw new Error(`路径必须是以 / 开头的 JSON Pointer: ${path}`);
+    return path.slice(1).split('/').map((part) => part.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+function pointerGet(root, path) {
+    return pointerParts(path).reduce((current, part) => {
+        if (current == null || !(part in Object(current)))
+            throw new Error(`路径不存在: ${path}`);
+        return current[part];
+    }, root);
+}
+function pointerParent(root, path) {
+    const parts = pointerParts(path);
+    const key = parts.pop();
+    let parent = root;
+    for (const part of parts) {
+        if (parent == null || !(part in Object(parent)))
+            throw new Error(`路径不存在: ${path}`);
+        parent = parent[part];
+    }
+    return { parent, key };
+}
+function deepMerge(target, patch) {
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch))
+        return clone(patch);
+    const result = asObject(target);
+    for (const [key, value] of Object.entries(patch)) {
+        result[key] = value && typeof value === 'object' && !Array.isArray(value)
+            ? deepMerge(result[key], value)
+            : clone(value);
+    }
+    return result;
+}
+function childArrays(node) {
+    const data = asObject(node.data);
+    const result = [];
+    for (const key of ['actions', 'trueBranchActions', 'falseBranchActions']) {
+        if (Array.isArray(data[key]))
+            result.push({ key, array: data[key] });
+    }
+    if (Array.isArray(data.otherConditionBranch)) {
+        data.otherConditionBranch.forEach((branch, index) => {
+            if (Array.isArray(branch?.branchActions))
+                result.push({ key: `otherConditionBranch[${index}].branchActions`, array: branch.branchActions });
+        });
+    }
+    return result;
+}
+function findNode(nodes, nodeId) {
+    for (const raw of nodes || []) {
+        const node = asObject(raw);
+        if (String(node.id || node.wId || '') === nodeId)
+            return node;
+        for (const child of childArrays(node)) {
+            const found = findNode(child.array, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function findNodeContainer(nodes, nodeId) {
+    for (let index = 0; index < (nodes || []).length; index += 1) {
+        const node = asObject(nodes[index]);
+        if (String(node.id || node.wId || '') === nodeId)
+            return { array: nodes, index, node };
+        for (const child of childArrays(node)) {
+            const found = findNodeContainer(child.array, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function collectNodeIds(node, out = []) {
+    const id = String(node.id || node.wId || '');
+    if (id)
+        out.push(id);
+    for (const child of childArrays(node)) {
+        for (const item of child.array)
+            collectNodeIds(asObject(item), out);
+    }
+    return out;
+}
+/** 保持设计器画布骨架与动作树同步；平台保存时会校验两者不能出现悬空节点。 */
+function syncAssistLayer(design, deletedNodeIds) {
+    if (typeof design.assistLayer !== 'string')
+        return;
+    let layer;
+    try {
+        layer = asObject(JSON.parse(design.assistLayer));
+    }
+    catch {
+        return;
+    }
+    if (!Array.isArray(layer.nodes))
+        return;
+    const deleted = new Set(deletedNodeIds);
+    const actionNodes = Array.isArray(design.actions) ? design.actions.map(asObject) : [];
+    const liveNodes = allNodes(design);
+    const eventId = String(asObject(design.event).id || asObject(design.event).wId || '');
+    const liveIds = new Set([eventId, ...liveNodes.map((node) => String(node.id || node.wId || '')).filter(Boolean)]);
+    const known = new Map();
+    for (const raw of layer.nodes) {
+        const node = asObject(raw);
+        const id = String(node.id || node.wId || '');
+        if (id && !deleted.has(id))
+            known.set(id, node);
+    }
+    const ordered = [];
+    if (eventId && known.has(eventId))
+        ordered.push(known.get(eventId));
+    actionNodes.forEach((action, index) => {
+        const id = String(action.id || action.wId || '');
+        if (!id)
+            return;
+        const existing = known.get(id);
+        const layout = asObject(existing?.layout);
+        ordered.push(existing || {
+            id,
+            type: String(action.type || ''),
+            layout: { x: 100, y: 220 + index * 130, width: 200, height: 80 },
+        });
+        // 仅给新增且缺少画布坐标的节点补坐标；既有节点布局不被更新器重排。
+        if (!existing)
+            ordered[ordered.length - 1].layout = { x: 100, y: 220 + index * 130, width: 200, height: 80 };
+        else if (!Object.keys(layout).length)
+            ordered[ordered.length - 1].layout = { x: 100, y: 220 + index * 130, width: 200, height: 80 };
+    });
+    // 分支/循环节点也必须保留在画布骨架中；版本保存可能重分配节点 ID，
+    // 因此只保留当前动作树中的节点，不能把上一版本的悬空节点带入新版。
+    const used = new Set(ordered.map((node) => String(node.id || node.wId || '')));
+    liveNodes.slice(actionNodes.length).forEach((action, index) => {
+        const id = String(action.id || action.wId || '');
+        if (!id || used.has(id))
+            return;
+        const existing = known.get(id);
+        ordered.push(existing || {
+            id,
+            type: String(action.type || ''),
+            layout: { x: 100, y: 220 + (actionNodes.length + index) * 130, width: 200, height: 80 },
+        });
+        used.add(id);
+    });
+    for (const node of layer.nodes) {
+        const id = String(asObject(node).id || asObject(node).wId || '');
+        if (id && liveIds.has(id) && !deleted.has(id) && !used.has(id))
+            ordered.push(asObject(node));
+    }
+    layer.nodes = ordered;
+    design.assistLayer = JSON.stringify(layer);
+}
+/** getDesignBySceneId 会展开 EventButton 的展示字段；saveDesign 只接受创建时的写入 DTO。 */
+function normalizeEventForSave(event, appId = '') {
+    const source = asObject(event);
+    if (String(source.type || '') !== 'EventButton')
+        return clone(source);
+    const raw = asObject(source.data);
+    const targetForm = asObject(raw.targetForm);
+    const data = {
+        type: 'EventButton',
+        // 新建动作流使用 -1；已有动作流必须保留平台已分配的按钮组件 ID，不能把更新误当成新建。
+        eventButtonId: raw.eventButtonId || '-1',
+        sourceType: raw.sourceType || 'FORM',
+        triggerType: raw.triggerType || 'sequence',
+        targetForm: clone(targetForm),
+        tableType: Array.isArray(raw.tableType) ? clone(raw.tableType) : [],
+        appType: Array.isArray(raw.appType) ? clone(raw.appType) : [],
+        dataSource: { ...clone(asObject(raw.dataSource)), text: asObject(raw.dataSource).text || targetForm.text || '' },
+        appId: raw.appId || '',
+        objId: raw.objId || '',
+        currentApplication: raw.currentApplication || source.applicationId || appId,
+        applicationId: raw.applicationId || source.applicationId || appId,
+        buttonType: Array.isArray(raw.buttonType) ? raw.buttonType.map((button) => {
+            const item = asObject(button);
+            return {
+                id: item.id,
+                // 回读名称可能追加“(编辑保存)”等展示后缀，写入 DTO 使用按钮真实名称。
+                name: String(item.name || '').replace(/\([^)]*\)$/, ''),
+                buttonLocation: item.buttonLocation,
+                asyncExecution: item.asyncExecution ?? false,
+            };
+        }) : [],
+    };
+    return {
+        id: source.id,
+        wId: source.wId || source.id,
+        name: source.name || '按钮触发',
+        nameMultilang: source.nameMultilang || source.name || '按钮触发',
+        type: 'EventButton',
+        attr: clone(asObject(source.attr)),
+        data,
+        parentId: '0',
+        triggerType: 'WorkflowTrigger',
+        triggerTypeName: 'EventButton',
+        costTime: 0,
+    };
+}
+function flattenComponentOptions(value, out = {}) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => flattenComponentOptions(item, out));
+        return out;
+    }
+    if (!value || typeof value !== 'object')
+        return out;
+    if (value.type && value.id && (value.actionName || value.eventName || value.componentName))
+        out[String(value.type)] ??= value;
+    Object.values(value).forEach((child) => flattenComponentOptions(child, out));
+    return out;
+}
+/** 新增节点若来自简化描述，补齐设计器“添加组件”时写入的原生目录壳。 */
+function applyComponentShell(node, option) {
+    node.nodeType = node.nodeType || 'Normal';
+    node.comType = node.comType || node.type;
+    node.isAdd ??= true;
+    node.isLock ??= false;
+    node.ignoreFlowCheck ??= true;
+    node.originId = String(node.originId || option.id || '');
+    node.options ??= clone(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.type || '');
+    node.componentNameLabel ??= option.componentNameLabel;
+    node.nameMultilang ??= node.name;
+    node.attr = { ...asObject(node.attr), ...(option.icon ? { icon: option.icon } : {}) };
+}
+const ACTION_WRITE_KEYS = [
+    'id', 'wId', 'name', 'nameMultilang', 'type', 'typeName', 'attr', 'data', 'parentId', 'sources',
+    'nodeType', 'comType', 'previousId', 'isAdd', 'isLock', 'ignoreFlowCheck', 'originId', 'options',
+    'componentDesc', 'componentDescLabel', 'componentName', 'componentNameLabel',
+];
+/**
+ * getDesignBySceneId 返回的是设计器回读模型，节点上还夹带了列表展示和编辑态字段。
+ * saveDesign 接收的是设计器写入模型；尤其是已有节点也必须带上设计器目录壳和链路字段。
+ * 这里只做模型边界转换，不改变节点 ID 或业务属性。
+ */
+function normalizeActionForSave(node, parentId, previousId, appId, option) {
+    const result = {};
+    for (const key of ACTION_WRITE_KEYS)
+        if (key in node)
+            result[key] = clone(node[key]);
+    result.id = String(node.id || node.wId || '');
+    result.wId = String(node.wId || node.id || result.id);
+    result.name = node.name || node.componentName || node.type || '';
+    result.nameMultilang = node.nameMultilang || result.name;
+    result.type = node.type;
+    result.typeName = node.typeName || node.componentName || result.name;
+    result.attr = asObject(result.attr);
+    result.data = asObject(result.data);
+    result.parentId = node.parentId || parentId || '0';
+    if (previousId)
+        result.previousId = previousId;
+    if (option && (!node.originId || !node.options))
+        applyComponentShell(result, option);
+    // These are generated defaults in the designer's write model, not readback-only metadata.
+    result.data.currentApplication ??= appId;
+    result.data.applicationId ??= appId;
+    if (node.type === 'EnquiryForm') {
+        const source = asObject(result.data.dataSource);
+        const target = asObject(source);
+        // 查询组件的回读会附带 enquiryId/operatorId 等运行时实例字段；保存时使用
+        // 设计器的 LOGIC 数据源 DTO，避免把一次回读实例当成新的运行时对象提交。
+        result.data.dataSource = {
+            sourceId: target.sourceId || target.id || '',
+            isPhysical: target.isPhysical ?? target.physical ?? true,
+            peratorId: '',
+            authorityFlag: target.authorityFlag ?? result.data.authorityFlag ?? '0',
+            groupId: target.groupId || 'weaver-ebuilder-form-service',
+            opType: target.opType || result.data.opType || 'list',
+            type: target.type || 'LOGIC',
+            id: target.id || target.sourceId || '',
+            enquiryId: '-1',
+            text: String(target.text || '').replace(/\([^)]*\)$/, ''),
+            usage: '',
+            objType: '',
+            module: '',
+            appId: target.appId || appId,
+            enableFlag: '3',
+            ebuilderDataConfig: target.ebuilderDataConfig || {
+                dataSetup: { dataSource: 'ALL', dataPermission: 'HAVE_PERMISSION_DATA' },
+                type: 'LOGIC',
+            },
+            opText: target.opText || JSON.stringify(asObject(result.data.filterInput)),
+        };
+        const person = asObject(result.data.person);
+        if (Object.keys(person).length) {
+            result.data.person = {
+                formulaType: person.formulaType || 'string',
+                name: person.name || '{userid}',
+                type: person.type || '9',
+                value: person.value || '{userid}',
+                childs: Array.isArray(person.childs) ? person.childs : [],
+                config: person.config || { paramType: 'string', formulaVersion: 'V1' },
+            };
+        }
+        delete result.data.versionNum;
+    }
+    if (node.type === 'Output') {
+        result.data = {
+            outputStatus: result.data.outputStatus ?? '1',
+            reminder: result.data.reminder ?? '0',
+            triggerFlag: result.data.triggerFlag ?? false,
+            pageAction: result.data.pageAction ?? '0',
+            nextAction: result.data.nextAction ?? false,
+            fixedData: Array.isArray(result.data.fixedData) ? result.data.fixedData : [],
+            reminderMsgFormula: result.data.reminderMsgFormula ?? '',
+            customOutputData: result.data.customOutputData ?? '',
+            currentApplication: appId,
+            applicationId: appId,
+        };
+    }
+    return result;
+}
+function normalizeActionTreeForSave(design, appId, options) {
+    const eventId = String(asObject(design.event).id || asObject(design.event).wId || '');
+    const walk = (nodes, parentId, firstPreviousId) => {
+        let previousId = firstPreviousId;
+        for (let index = 0; index < (nodes || []).length; index += 1) {
+            const raw = asObject(nodes[index]);
+            const id = String(raw.id || raw.wId || '');
+            const normalized = normalizeActionForSave(raw, parentId, previousId, appId, options[String(raw.type || '')]);
+            nodes[index] = normalized;
+            previousId = id || previousId;
+            for (const child of childArrays(normalized))
+                walk(child.array, id || parentId, id || parentId);
+        }
+    };
+    if (Array.isArray(design.actions))
+        walk(design.actions, '0', eventId);
+}
+async function hydrateAddedComponentShells(client, operations) {
+    const pending = operations.filter((operation) => operation.op === 'add-node' && !operation.node.originId && !operation.node.options);
+    if (!pending.length)
+        return;
+    const response = await getComponentsForDesign(client);
+    const options = flattenComponentOptions(response?.data ?? response);
+    for (const operation of pending) {
+        const option = options[String(operation.node.type)];
+        if (!option)
+            throw new Error(`当前租户设计器目录未返回新增组件: ${operation.node.type}`);
+        applyComponentShell(operation.node, option);
+    }
+}
+async function normalizeExistingComponentShells(client, design) {
+    const nodes = allNodes(design);
+    const missing = nodes.some((node) => !node.originId || !node.options);
+    let options = {};
+    if (missing) {
+        const response = await getComponentsForDesign(client);
+        options = flattenComponentOptions(response?.data ?? response);
+    }
+    normalizeActionTreeForSave(design, String(design.appId || ''), options);
+}
+function allNodes(design) {
+    const result = [];
+    const walk = (nodes) => {
+        for (const raw of nodes || []) {
+            const node = asObject(raw);
+            result.push(node);
+            for (const child of childArrays(node))
+                walk(child.array);
+        }
+    };
+    walk(Array.isArray(design.actions) ? design.actions : []);
+    return result;
+}
+function nodeEntries(design) {
+    const result = [];
+    const walk = (nodes, basePath) => {
+        for (let index = 0; index < (nodes || []).length; index += 1) {
+            const node = asObject(nodes[index]);
+            const path = `${basePath}/${index}`;
+            result.push({ node, path, id: String(node.id || node.wId || '') });
+            for (const child of childArrays(node))
+                walk(child.array, `${path}/data/${child.key}`);
+        }
+    };
+    walk(Array.isArray(design.actions) ? design.actions : [], '/actions');
+    return result;
+}
+function validateOperation(operation, index) {
+    if (!operation || typeof operation !== 'object' || typeof operation.op !== 'string')
+        throw new Error(`operations[${index}] 缺少 op`);
+    if (operation.op === 'edit-node') {
+        if (!operation.nodeId || !operation.patch || typeof operation.patch !== 'object' || Array.isArray(operation.patch))
+            throw new Error(`operations[${index}] edit-node 必须提供 nodeId 和对象 patch`);
+        if ('id' in operation.patch || 'wId' in operation.patch)
+            throw new Error(`operations[${index}] 不允许修改节点 id/wId；已有节点必须保留原 ID`);
+        return;
+    }
+    if (operation.op === 'delete-node') {
+        if (!operation.nodeId)
+            throw new Error(`operations[${index}] delete-node 缺少 nodeId`);
+        return;
+    }
+    if (operation.op === 'add-node') {
+        if (typeof operation.parentPath !== 'string' || !operation.parentPath.startsWith('/actions'))
+            throw new Error(`operations[${index}] add-node.parentPath 必须指向 /actions 下的数组`);
+        if (!operation.node || typeof operation.node !== 'object' || Array.isArray(operation.node) || !operation.node.type)
+            throw new Error(`operations[${index}] add-node.node 必须是包含 type 的平台节点对象`);
+        if (operation.index !== undefined && (!Number.isInteger(operation.index) || operation.index < 0))
+            throw new Error(`operations[${index}] add-node.index 必须是非负整数`);
+        return;
+    }
+    if (operation.op === 'replace' || operation.op === 'remove') {
+        if (typeof operation.path !== 'string' || !operation.path.startsWith('/'))
+            throw new Error(`operations[${index}] ${operation.op} 缺少合法 path`);
+        if (operation.path === '/event' || operation.path.startsWith('/event/')) {
+            throw new Error(`operations[${index}] 不能修改动作流触发器 event；触发器必须保持不变。如需变更触发器，请新建动作流`);
+        }
+        if (operation.path === '/appId' || operation.path === '/sceneId' || operation.path === '/version' || operation.path === '/secretKey')
+            throw new Error(`operations[${index}] 不允许修改平台版本锁字段`);
+        if (/(^|\/)(id|wId)$/.test(operation.path))
+            throw new Error(`operations[${index}] 不允许通过 path 修改 ID；已有节点必须保留原 ID`);
+        return;
+    }
+    throw new Error(`operations[${index}] 不支持的操作: ${operation.op}`);
+}
+function applyOperations(design, operations) {
+    const next = clone(design);
+    const addedNodeIds = [];
+    const deletedNodeIds = [];
+    const deletedSet = new Set();
+    const existingIds = new Set(allNodes(next).map((node) => String(node.id || node.wId || '')).filter(Boolean));
+    operations.forEach((operation, index) => {
+        if (operation.op === 'edit-node') {
+            const node = findNode(Array.isArray(next.actions) ? next.actions : [], String(operation.nodeId));
+            if (!node)
+                throw new Error(`operations[${index}] 找不到节点 ${operation.nodeId}`);
+            const merged = deepMerge(node, operation.patch);
+            Object.assign(node, merged, { id: node.id, wId: node.wId });
+            return;
+        }
+        if (operation.op === 'delete-node') {
+            if (deletedSet.has(String(operation.nodeId)))
+                throw new Error(`operations[${index}] 节点 ${operation.nodeId} 已被删除`);
+            const container = findNodeContainer(Array.isArray(next.actions) ? next.actions : [], String(operation.nodeId));
+            if (!container)
+                throw new Error(`operations[${index}] 找不到节点 ${operation.nodeId}`);
+            const ids = collectNodeIds(container.node);
+            container.array.splice(container.index, 1);
+            ids.forEach((id) => { deletedSet.add(id); deletedNodeIds.push(id); });
+            return;
+        }
+        if (operation.op === 'add-node') {
+            const array = pointerGet(next, operation.parentPath);
+            if (!Array.isArray(array))
+                throw new Error(`operations[${index}] add-node.parentPath 不是数组: ${operation.parentPath}`);
+            const node = clone(operation.node);
+            const nodeId = String(node.id || node.wId || genSfId());
+            const candidateIds = collectNodeIds(node);
+            if (candidateIds.some((id) => existingIds.has(id) || addedNodeIds.includes(id))) {
+                const conflict = candidateIds.find((id) => existingIds.has(id) || addedNodeIds.includes(id));
+                throw new Error(`operations[${index}] 新节点或其子节点 ID 已存在: ${conflict}`);
+            }
+            node.id = nodeId;
+            node.wId ??= nodeId;
+            node.data ??= {};
+            const insertionIndex = operation.index === undefined ? array.length : Math.min(operation.index, array.length);
+            array.splice(insertionIndex, 0, node);
+            collectNodeIds(node).forEach((id) => { if (!addedNodeIds.includes(id))
+                addedNodeIds.push(id); });
+            return;
+        }
+        const { parent, key } = pointerParent(next, operation.path);
+        if (operation.op === 'replace') {
+            if (Array.isArray(parent) && key === '-')
+                parent.push(clone(operation.value));
+            else if (Array.isArray(parent))
+                parent[Number(key)] = clone(operation.value);
+            else
+                parent[key] = clone(operation.value);
+        }
+        else if (Array.isArray(parent)) {
+            parent.splice(Number(key), 1);
+        }
+        else {
+            delete parent[key];
+        }
+    });
+    next.deleteActions = [...new Set([...(Array.isArray(next.deleteActions) ? next.deleteActions : []), ...deletedNodeIds])];
+    next.addIds = [...new Set([...(Array.isArray(next.addIds) ? next.addIds : []), ...addedNodeIds])];
+    return { design: next, addedNodeIds, deletedNodeIds };
+}
+function containsPatch(actual, expected, path = '') {
+    if (Array.isArray(expected)) {
+        if (!Array.isArray(actual) || actual.length !== expected.length)
+            return false;
+        return expected.every((value, index) => containsPatch(actual[index], value, `${path}/${index}`));
+    }
+    if (expected && typeof expected === 'object' && !Array.isArray(expected)) {
+        if (!actual || typeof actual !== 'object' || Array.isArray(actual))
+            return false;
+        return Object.entries(expected).every(([key, value]) => {
+            // source.id 由平台在保存/回读时动态重分配，wId 才是稳定的节点关联键。
+            if (key === 'id' && path.split('/').includes('sources'))
+                return true;
+            return containsPatch(actual[key], value, `${path}/${key}`);
+        });
+    }
+    return JSON.stringify(actual) === JSON.stringify(expected);
+}
+function verifyUpdateReadback(sent, read, operations, deletedNodeIds, addedNodeIds) {
+    const issues = [];
+    const sentEntries = nodeEntries(sent);
+    const readEntries = nodeEntries(read);
+    const readById = new Map(readEntries.map((entry) => [entry.id, entry]));
+    const usedReadEntries = new Set();
+    const matched = new Map();
+    // 新版本保存时平台可能重分配动作节点 ID。先按 ID 校验；ID 不一致时按
+    // 动作树路径和类型定位，避免把平台正常的版本复制误报成内容丢失。
+    const matchReadEntry = (sentEntry) => {
+        const byId = sentEntry.id ? readById.get(sentEntry.id) : undefined;
+        if (byId && !usedReadEntries.has(byId))
+            return byId;
+        const byPath = readEntries.find((entry) => !usedReadEntries.has(entry)
+            && entry.path === sentEntry.path && String(entry.node.type || '') === String(sentEntry.node.type || ''));
+        if (byPath)
+            return byPath;
+        const sameTypeAndName = readEntries.filter((entry) => !usedReadEntries.has(entry)
+            && String(entry.node.type || '') === String(sentEntry.node.type || '')
+            && String(entry.node.name || '') === String(sentEntry.node.name || ''));
+        return sameTypeAndName.length === 1 ? sameTypeAndName[0] : undefined;
+    };
+    for (const entry of sentEntries) {
+        const actual = matchReadEntry(entry);
+        if (actual) {
+            usedReadEntries.add(actual);
+            matched.set(entry.id || entry.path, actual);
+        }
+        else if (addedNodeIds.includes(entry.id)) {
+            issues.push(`新增节点 ${entry.id} 未出现在回读设计`);
+        }
+        else {
+            issues.push(`未修改节点在回读中缺失: ${entry.id || entry.path}`);
+        }
+    }
+    for (const id of deletedNodeIds)
+        if (readById.has(id))
+            issues.push(`删除节点 ${id} 仍存在于回读设计`);
+    if (sentEntries.length !== readEntries.length) {
+        issues.push(`回读节点数量不一致: 期望 ${sentEntries.length}，实际 ${readEntries.length}`);
+    }
+    for (const operation of operations) {
+        if (operation.op === 'edit-node') {
+            const sentEntry = sentEntries.find((entry) => entry.id === String(operation.nodeId));
+            const actual = sentEntry ? matched.get(sentEntry.id || sentEntry.path) : undefined;
+            if (!actual)
+                issues.push(`编辑节点 ${operation.nodeId} 未出现在回读设计`);
+            else if (!containsPatch(actual.node, operation.patch))
+                issues.push(`编辑节点 ${operation.nodeId} 的修改内容未完整回读`);
+        }
+        if ((operation.op === 'replace' || operation.op === 'remove') && operation.path.startsWith('/actions')) {
+            if (operation.op === 'replace') {
+                try {
+                    if (!containsPatch(pointerGet(read, operation.path), operation.value))
+                        issues.push(`路径 ${operation.path} 的修改内容未回读`);
+                }
+                catch {
+                    issues.push(`路径 ${operation.path} 在回读中不存在`);
+                }
+            }
+            if (operation.op === 'remove') {
+                try {
+                    pointerGet(read, operation.path);
+                    issues.push(`路径 ${operation.path} 删除后仍存在`);
+                }
+                catch { /* expected */ }
+            }
+        }
+    }
+    const sentIds = sentEntries.map((entry) => entry.id).filter(Boolean);
+    return { ok: issues.length === 0, issues, nodeCount: { sent: sentEntries.length, back: readEntries.length }, deletedNodeIds, addedNodeIds };
+}
+function backupDesign(raw, appId, requestedPath) {
+    const path = resolve(requestedPath || `.actionflow-plans/backups/actionflow-${appId}-${Date.now()}.json`);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(raw, null, 2), 'utf-8');
+    return path;
+}
+export async function runUpdate(payload, client) {
+    const appId = String(payload.appId || '').trim();
+    if (!appId)
+        return { valid: false, errors: ['必须提供精确的 appId；修改已有动作流不按名称匹配'], message: '修改参数不完整' };
+    if (!Array.isArray(payload.operations) || payload.operations.length === 0)
+        return { valid: false, errors: ['必须提供非空 operations 数组；未声明的节点和属性保持不变'], message: '修改参数不完整' };
+    try {
+        payload.operations.forEach(validateOperation);
+    }
+    catch (error) {
+        return { valid: false, errors: [String(error?.message || error)], message: '修改操作格式错误' };
+    }
+    const operations = clone(payload.operations);
+    let app;
+    let versions;
+    try {
+        app = await getApplication(client, appId);
+        if (app?.code !== 200 || app?.status === false || !app?.data)
+            return { valid: false, errors: [app?.msg || `动作流 ${appId} 不存在`], message: '目标动作流读取失败' };
+        versions = await getVersionList(client, appId);
+    }
+    catch (error) {
+        return { valid: false, errors: [String(error?.message || error)], message: '目标动作流读取失败' };
+    }
+    let sceneId = String(payload.sceneId || versions?.data?.activeVersion || app.data.activeVersion || '').trim();
+    if (!sceneId)
+        return { valid: false, errors: ['目标动作流没有可用的 activeVersion/sceneId'], message: '目标动作流读取失败' };
+    let raw;
+    try {
+        raw = await getDesign(client, sceneId);
+    }
+    catch (error) {
+        return { valid: false, appId, sceneId, errors: [String(error?.message || error)], message: '正式设计读取失败' };
+    }
+    if (raw?.code !== 200 || raw?.status === false || !raw?.data || typeof raw.data !== 'object') {
+        return { valid: false, appId, sceneId, errors: [raw?.msg || '正式设计响应中没有可修改的 data'], message: '正式设计读取失败' };
+    }
+    let backupFile = '';
+    try {
+        backupFile = backupDesign(raw, appId, payload.backupFile);
+    }
+    catch (error) {
+        return { valid: false, appId, sceneId, errors: [`修改前备份失败: ${String(error?.message || error)}`], message: '已停止修改，未调用保存接口' };
+    }
+    try {
+        await hydrateAddedComponentShells(client, operations);
+    }
+    catch (error) {
+        return { valid: false, appId, sceneId, backupFile, errors: [`新增组件目录壳准备失败: ${String(error?.message || error)}`], message: '新增组件未取得当前租户原生目录，未调用保存接口' };
+    }
+    let next;
+    try {
+        next = applyOperations(asObject(raw.data), operations);
+    }
+    catch (error) {
+        return { valid: false, appId, sceneId, backupFile, errors: [String(error?.message || error)], message: '修改操作执行失败，未调用保存接口' };
+    }
+    // 防御性校验：即使以后增加新的操作类型，也不能通过更新链路改掉触发器。
+    if (JSON.stringify(next.design.event ?? null) !== JSON.stringify(raw.data.event ?? null)) {
+        return {
+            valid: false, appId, sceneId, backupFile,
+            errors: ['更新计划试图修改动作流触发器 event；触发器必须保持不变。如需变更触发器，请新建动作流'],
+            message: '触发器不可在已有动作流上修改，未调用保存接口',
+        };
+    }
+    const constraintError = validateActionflowComponentConstraints(next.design);
+    if (constraintError) {
+        return { valid: false, appId, sceneId, backupFile, errors: [constraintError], message: '修改后的动作流组件组合校验未通过，未调用保存接口' };
+    }
+    next.design.appId = appId;
+    next.design.sceneId = sceneId;
+    next.design.event = normalizeEventForSave(next.design.event, appId);
+    next.design.secretKey = String(raw.data.secretKey || versions?.data?.actionFlowVersions?.[0]?.secretKey || '');
+    next.design.version = Number(raw.data.version || 1);
+    syncAssistLayer(next.design, next.deletedNodeIds);
+    try {
+        await normalizeExistingComponentShells(client, next.design);
+    }
+    catch (error) {
+        return { valid: false, appId, sceneId, backupFile, errors: [`既有节点保存模型转换失败: ${String(error?.message || error)}`], message: '未取得当前租户组件目录，未调用保存接口' };
+    }
+    const inferredEnabledState = currentEnabledState(app.data.status);
+    if (typeof payload.saveAndStart !== 'boolean' && inferredEnabledState === undefined) {
+        return { valid: false, appId, sceneId, backupFile, errors: [`无法识别目标动作流启用状态: ${String(app.data.status ?? '(empty)')}；为避免误启用或误停用，请显式传 saveAndStart`], message: '启用状态无法安全继承，未调用保存接口' };
+    }
+    const saveAndStart = typeof payload.saveAndStart === 'boolean' ? payload.saveAndStart : inferredEnabledState;
+    try {
+        const checked = await checkDesign(client, next.design);
+        if (checked?.code !== 200 || checked?.status === false)
+            return { valid: false, appId, sceneId, backupFile, errors: [`check预检失败: ${checked?.msg || checked?.code || '未知错误'}`], message: '修改预检未通过，未调用保存接口' };
+        // 已有动作流更新必须创建平台新版本，不能覆盖当前正式版本。
+        const saved = await saveDesign(client, next.design, saveAndStart, true);
+        if (saved?.code !== 200 || saved?.status === false)
+            return { valid: false, saved: false, appId, sceneId, backupFile, saveAndStart, errors: [`保存已有动作流失败: ${saved?.msg || saved?.code || '未知错误'}`], message: '保存失败，原动作流未被自动覆盖' };
+        let returnedSceneId = String(saved?.data?.sceneId || saved?.data?.versionId || '').trim();
+        if (!returnedSceneId || returnedSceneId === sceneId) {
+            // saveDesign 在部分租户只返回成功状态，不返回新版本 ID。保存新版后
+            // 必须重新查版本列表，不能拿旧 sceneId 回读并误报“新版校验通过”。
+            const refreshedVersions = await getVersionList(client, appId);
+            returnedSceneId = findNewVersionId(refreshedVersions, sceneId, Number(raw.data.version || 1));
+        }
+        if (!returnedSceneId) {
+            return {
+                valid: false, saved: true, appId, sceneId, backupFile, saveAndStart,
+                errors: ['已调用保存新版，但未能从保存响应或版本列表定位新版本 ID；未用旧版本冒充回读'],
+                message: '新版已保存，但无法安全定位新版进行回读校验',
+            };
+        }
+        sceneId = returnedSceneId;
+        next.design.sceneId = returnedSceneId;
+    }
+    catch (error) {
+        return { valid: false, saved: false, appId, sceneId, backupFile, saveAndStart, errors: [String(error?.message || error)], message: '保存已有动作流异常，未执行自动回滚' };
+    }
+    let readBackRaw;
+    let readBack = null;
+    let lastError = '';
+    for (let attempt = 1; attempt <= 2; attempt += 1) {
+        try {
+            readBackRaw = await getDesign(client, sceneId);
+            if (readBackRaw?.code !== 200 || readBackRaw?.status === false) {
+                lastError = readBackRaw?.msg || `getDesignBySceneId code=${readBackRaw?.code}`;
+                continue;
+            }
+            readBack = verifyUpdateReadback(next.design, asObject(readBackRaw.data), operations, next.deletedNodeIds, next.addedNodeIds);
+            readBack.attempts = attempt;
+            break;
+        }
+        catch (error) {
+            lastError = String(error?.message || error);
+        }
+    }
+    if (!readBack)
+        return { valid: false, saved: true, appId, sceneId, backupFile, saveAndStart, errors: [`保存后回读失败: ${lastError || '未返回正式设计'}`], message: '保存已调用，但回读失败；已停止，不自动回滚' };
+    if (readBack.ok !== true)
+        return { valid: false, saved: true, appId, sceneId, backupFile, saveAndStart, readBack, errors: readBack.issues || ['保存后回读校验失败'], message: '保存已写入，但回读校验未通过；已停止，不自动回滚' };
+    return {
+        valid: true, saved: true, appId, sceneId,
+        workflowUrl: `${(client.auth?.getBaseUrl() || '').replace(/\/$/, '')}/sp/esb/efdesigner?application=${appId}`,
+        backupFile, saveAndStart, operations: operations.length,
+        addedNodeIds: next.addedNodeIds, deletedNodeIds: next.deletedNodeIds,
+        readBack, design: next.design,
+        message: `已有动作流修改成功，正式版本${saveAndStart ? '保持启用' : '保持未启用'}，已完成回读校验`,
+    };
+}
+//# sourceMappingURL=update_service.js.map