weaver-e10-builder 1.6.14 → 1.6.16

package/dist/services/actionflow/readback_verifier.js

@@ -83,14 +83,45 @@ function formulas(value, out = []) {
                 paramKey: config.paramKey,
                 comType: config.comType,
                 switchType: config.switchType,
+                ...(String(value.type) === '6' ? { paramSize: config.paramSize } : {}),
             },
         }));
+        if (Array.isArray(value.childs))
+            formulas(value.childs, out);
         return out;
     }
     for (const child of Object.values(value))
         formulas(child, out);
     return out;
 }
+/** 对比所有上下文公式实际引用的组件，包括容器和函数内的子公式。 */
+function contextSources(value, out = []) {
+    if (Array.isArray(value)) {
+        value.forEach((child) => contextSources(child, out));
+        return out;
+    }
+    if (!value || typeof value !== 'object')
+        return out;
+    const config = configObject(value.config);
+    if (String(value.type) === '3' && value.formulaType && value.source) {
+        out.push(stable({ type: '3', value: value.value, sourceNode: value.source, comId: config.comId }));
+    }
+    else if (String(value.type) === '10' && config.source) {
+        const inner = configObject(config.config);
+        out.push(stable({ type: '10', value: value.value, basisPath: config.value, sourceNode: config.source, comId: inner.comId }));
+    }
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'conditionDataJson' && typeof child === 'string') {
+            try {
+                contextSources(JSON.parse(child), out);
+            }
+            catch { /* 非 JSON 条件由其他校验处理 */ }
+        }
+        else
+            contextSources(child, out);
+    }
+    return out;
+}
 function assignmentValue(value) {
     const assign = asObject(value);
     if ('formulaType' in assign) {
@@ -104,23 +135,101 @@ function assignmentValue(value) {
                 switchType: config.switchType,
                 paramKey: config.paramKey,
                 comType: config.comType,
+                ...(String(assign.type) === '6' ? { paramSize: config.paramSize } : {}),
             },
         };
     }
     return canonical(assign);
 }
+function basisValueShape(value) {
+    const basis = asObject(value);
+    if (!Object.keys(basis).length)
+        return undefined;
+    const config = configObject(basis.config);
+    const fieldInfo = asObject(config.fieldInfo);
+    return canonical({
+        formulaType: basis.formulaType,
+        type: basis.type,
+        value: basis.value,
+        frontId: basis.frontId,
+        sourceNode: basis.source,
+        config: {
+            paramKey: config.paramKey,
+            paramType: config.paramType,
+            switchType: config.switchType,
+            parentName: config.parentName,
+            newParentName: config.newParentName,
+            comType: config.comType,
+            comId: config.comId,
+            tableName: config.tableName,
+            fieldInfo: {
+                paramKey: fieldInfo.paramKey,
+                tablePrimaryKey: fieldInfo.tablePrimaryKey,
+            },
+        },
+    });
+}
+function detailAssignments(setting) {
+    const details = Array.isArray(setting.detail) ? setting.detail : [];
+    const result = {};
+    for (const item of details) {
+        const table = asObject(item);
+        const tableId = String(table.detailTableId || '').trim();
+        if (!tableId)
+            continue;
+        const fields = {};
+        for (const [fieldId, entry] of Object.entries(asObject(table.data))) {
+            const value = asObject(asObject(entry).value);
+            const assign = asObject(value.assign);
+            if (!Object.keys(assign).length)
+                continue;
+            fields[fieldId] = canonical({
+                operate: value.operate,
+                switchType: value.switchType,
+                assign: assignmentValue(assign),
+            });
+        }
+        if (Object.keys(fields).length || Object.keys(asObject(table.basisValue)).length) {
+            result[tableId] = { basisValue: basisValueShape(table.basisValue), fields };
+        }
+    }
+    return result;
+}
+function detailBasisIssues(data, label) {
+    const setting = asObject(data.setting);
+    const details = Array.isArray(setting.detail) ? setting.detail : [];
+    const issues = [];
+    for (const item of details) {
+        const table = asObject(item);
+        const fields = Object.values(asObject(table.data)).some((entry) => {
+            const assign = asObject(asObject(asObject(entry).value).assign);
+            return Object.keys(assign).length > 0;
+        });
+        if (fields && !Object.keys(asObject(table.basisValue)).length) {
+            issues.push(`${label}.setting.detail[${String(table.detailTableId || '?')}] 配置了字段赋值但缺少 basisValue`);
+        }
+    }
+    return issues;
+}
 function settingAssignments(data) {
     const setting = asObject(data.setting);
     const main = asObject(setting.main);
     const result = {};
     for (const [fieldId, entry] of Object.entries(main)) {
         const value = asObject(asObject(entry).value);
+        // HRM 的完整字段骨架包含未赋值字段；平台可能为其补充默认操作和空 assign。
+        // 只比较真实赋值，避免空占位规范化被误判为业务变更。
+        if (!Object.keys(asObject(value.assign)).length)
+            continue;
         result[fieldId] = canonical({
             operate: value.operate,
             switchType: value.switchType,
             assign: assignmentValue(value.assign),
         });
     }
+    const details = detailAssignments(setting);
+    if (Object.keys(details).length)
+        result.detail = details;
     const update = asObject(data.updateFieldCondition);
     if (Array.isArray(update.updateField) && update.updateField.length > 0)
         result.updateField = canonical(update.updateField);
@@ -299,6 +408,16 @@ export function verifyReadback(sent, read) {
         }
         const sentData = asObject(expected.node.data);
         const readData = asObject(actual.node.data);
+        issues.push(...detailBasisIssues(sentData, `${expected.path}.sent`));
+        issues.push(...detailBasisIssues(readData, `${expected.path}.read`));
+        for (const [name, sentBasis, readBasis] of [
+            ['basisValueFormula', sentData.basisValueFormula, readData.basisValueFormula],
+            ['setting.bassisValue', asObject(sentData.setting).bassisValue, asObject(readData.setting).bassisValue],
+        ]) {
+            if (sentBasis && stable(basisValueShape(sentBasis)) !== stable(basisValueShape(readBasis))) {
+                issues.push(`${expected.path}.${name} 依据值或来源节点与回读不一致`);
+            }
+        }
         const expectedForm = targetForm(sentData);
         if (Object.keys(expectedForm).length) {
             const actualForm = targetForm(readData);
@@ -314,10 +433,21 @@ export function verifyReadback(sent, read) {
         }
         const expectedAssignments = settingAssignments(sentData);
         const actualAssignments = settingAssignments(readData);
-        if (Object.keys(expectedAssignments).length && stable(expectedAssignments) !== stable(actualAssignments)) {
+        const sentSetting = asObject(sentData.setting);
+        const hasAssignmentContract = (sentSetting.main && typeof sentSetting.main === 'object' && !Array.isArray(sentSetting.main))
+            || Array.isArray(sentSetting.detail)
+            || Object.keys(expectedAssignments).length > 0;
+        if (hasAssignmentContract && stable(expectedAssignments) !== stable(actualAssignments)) {
             issues.push(`${expected.path}.字段赋值与回读不一致`);
             assignmentDiffs[expected.path] = { sent: expectedAssignments, read: actualAssignments };
         }
+        const expectedSettingCondition = asObject(sentSetting.updateFieldCondition);
+        if (Array.isArray(expectedSettingCondition.updateField) && expectedSettingCondition.updateField.length) {
+            const actualSettingCondition = asObject(asObject(readData.setting).updateFieldCondition);
+            if (stable(expectedSettingCondition.updateField) !== stable(actualSettingCondition.updateField)) {
+                issues.push(`${expected.path}.setting.updateFieldCondition 与回读不一致`);
+            }
+        }
         const expectedFilter = filter(sentData);
         const actualFilter = filter(readData);
         for (const issue of referenceFilterIssues(rawFilter(sentData), `${expected.path}.filterInput`)) {
@@ -342,6 +472,10 @@ export function verifyReadback(sent, read) {
         if (expectedFormulae.length && !containsAll(expectedFormulae, formulas(readData))) {
             issues.push(`${expected.path}.动态公式在回读中缺失或被改写`);
         }
+        const expectedSources = contextSources(sentData);
+        if (expectedSources.length && !containsAll(expectedSources, contextSources(readData))) {
+            issues.push(`${expected.path}.动态赋值来源组件在回读中缺失或被改写`);
+        }
         if (expected.node.type === 'EnquiryForm') {
             const expectedFields = queryFieldIds(sentData);
             const actualFields = queryFieldIds(readData);
@@ -360,4 +494,3 @@ export function verifyReadback(sent, read) {
         issues, assignmentDiffs, filterDiffs, unverified,
     };
 }
-//# sourceMappingURL=readback_verifier.js.map

package/dist/services/actionflow/request.js

@@ -12,4 +12,3 @@ export async function requestFrontend(client, path, opts = {}) {
     }
     return client.post(url, opts.jsonBody);
 }
-//# sourceMappingURL=request.js.map

package/dist/services/actionflow/runtime_metadata.js

@@ -167,4 +167,3 @@ export function registerWorkflowDetailName(workflowId, subFormId, showName) {
     const idx = (WORKFLOW_DETAIL_NAMES[String(workflowId)] ??= {});
     idx[String(subFormId)] = String(showName);
 }
-//# sourceMappingURL=runtime_metadata.js.map

package/dist/services/actionflow/save_workflow_draft.js

@@ -38,8 +38,7 @@ export function stripTemporaryConditionIds(tree) {
 /**
  * 递归收集所有 ESB Rule 条件。
  *
- * 分支条件位于 conditionDetail/otherConditionBranch；循环体本身也可能是
- * MultipleExecution.data.actions，其中包含分支节点。它们都必须先经
+ * 分支条件位于 conditionDetail/otherConditionBranch；它们必须先经
  * saveCondition 持久化，不能与 e-builder 的 filterInput 混为一谈。
  */
 export function collectConditionDetails(node, out) {
@@ -53,13 +52,12 @@ export function collectConditionDetails(node, out) {
     const d = node.data || {};
     if (d.conditionDetail && typeof d.conditionDetail === 'object')
         out.push(d.conditionDetail);
+    for (const a of d.actions || [])
+        collectConditionDetails(a, out);
     for (const key of ['trueBranchActions', 'falseBranchActions']) {
         for (const a of d[key] || [])
             collectConditionDetails(a, out);
     }
-    // MultipleExecution 的循环体存放在 data.actions，而非设计根 actions。
-    for (const a of d.actions || [])
-        collectConditionDetails(a, out);
     for (const ob of d.otherConditionBranch || []) {
         if (ob && typeof ob === 'object') {
             if (ob.conditionDetail && typeof ob.conditionDetail === 'object')
@@ -204,8 +202,7 @@ export async function persistConditionDetails(design, client) {
         // buildConditionDetail 已将顶层业务 AND/OR 作为根关系写入；不要固定成 AND，
         // 否则顶层 OR 会被改义，也会重新制造根 AND → 子 AND 的多余嵌套。
         tree.relation = Number(tree.relation) === 2 ? 2 : 1;
-        // 循环条件根来源固定为 -1；真实触发来源由 customFieldType.source/comId
-        // 与 sourceIds 表达。改成事件节点会建出不同于前端的映射记录。
+        // 真实触发来源由 customFieldType.source/comId 与 sourceIds 表达。
         tree.sourceId = '-1';
         tree.isEdit = false;
         stripTemporaryConditionIds(tree);
@@ -450,15 +447,16 @@ export async function saveWorkflowDraft(design, client, appName = 'AI生成的
         };
     }
     // 步骤 3: 默认正式保存并启用；仅显式 mode=stash 时调用暂存接口。
+    const modeLabel = mode === 'stash' ? '暂存' : mode === 'disabled' ? '保存（不启用）' : '保存并启用';
     let saveResponse;
     try {
         saveResponse = mode === 'stash'
             ? await dc.saveStashSnapshot(client, design)
-            : await dc.saveDesign(client, design, true);
+            : await dc.saveDesign(client, design, mode === 'publish');
         if (saveResponse?.code !== 200) {
             const retry = mode === 'stash'
                 ? await dc.saveStashSnapshot(client, design)
-                : await dc.saveDesign(client, design, true);
+                : await dc.saveDesign(client, design, mode === 'publish');
             if (retry?.code === 200)
                 saveResponse = retry;
         }
@@ -466,13 +464,13 @@ export async function saveWorkflowDraft(design, client, appName = 'AI生成的
         if (code !== 200) {
             return {
                 ok: false, appId, sceneId,
-                msg: `${mode === 'stash' ? '暂存' : '保存并启用'}失败:code=${code}, msg=${saveResponse?.msg || ''}`,
+                msg: `${modeLabel}失败:code=${code}, msg=${saveResponse?.msg || ''}`,
                 appResponse, saveResponse, checkResponse, readBack: null,
             };
         }
     }
     catch (e) {
-        return { ok: false, appId, sceneId, msg: `${mode === 'stash' ? '暂存' : '保存并启用'}异常:${e?.message || e}`, appResponse, saveResponse: null, checkResponse, readBack: null };
+        return { ok: false, appId, sceneId, msg: `${modeLabel}异常:${e?.message || e}`, appResponse, saveResponse: null, checkResponse, readBack: null };
     }
     sceneId = responseSceneId(saveResponse, sceneId);
     design.sceneId = sceneId;
@@ -498,7 +496,7 @@ export async function saveWorkflowDraft(design, client, appName = 'AI生成的
                 };
                 readBack = mode === 'stash'
                     ? { ...verified, stashed: true, attempts: attempt, note: '暂存快照已通过 getStashSnapshot 回读校验，尚未发布正式版本', debug }
-                    : { ...verified, published: true, enabled: true, attempts: attempt, note: '正式版本已通过 getDesignBySceneId 回读校验并启用', debug };
+                    : { ...verified, published: true, enabled: mode === 'publish', attempts: attempt, note: mode === 'disabled' ? '正式版本已回读，未启用' : '正式版本已通过 getDesignBySceneId 回读校验并启用', debug };
                 break;
             }
             catch (e) {
@@ -514,7 +512,7 @@ export async function saveWorkflowDraft(design, client, appName = 'AI生成的
     else {
         readBack = mode === 'stash'
             ? { ok: true, stashed: true, note: '暂存已保存；调用方显式跳过 getStashSnapshot 回读校验' }
-            : { ok: true, published: true, enabled: true, note: '正式版本已保存并启用；调用方显式跳过回读校验' };
+            : { ok: true, published: true, enabled: mode === 'publish', note: '正式版本已保存；调用方显式跳过回读校验' };
     }
     const readBackOk = readBack?.ok !== false;
     const readBackComplete = readBack?.complete !== false;
@@ -526,14 +524,13 @@ export async function saveWorkflowDraft(design, client, appName = 'AI生成的
         sceneId,
         workflowUrl: `${base(client)}/sp/esb/efdesigner?application=${appId}`,
         msg: readBackOk && readBackComplete
-            ? `${mode === 'stash' ? '暂存成功' : '保存并启用成功'}${newAppCreated ? `(新建应用: ${appName})` : ''}`
+            ? `${modeLabel}成功${newAppCreated ? `(新建应用: ${appName})` : ''}`
             : readBackOk
-                ? `${mode === 'stash' ? '暂存' : '保存并启用'}成功，但正式回读未覆盖全部配置；动作流已保留，需人工核验`
-                : `${mode === 'stash' ? '暂存' : '保存并启用'}已写入，但正式回读校验失败；动作流已保留，需人工核验`,
+                ? `${modeLabel}成功，但正式回读未覆盖全部配置；动作流已保留，需人工核验`
+                : `${modeLabel}已写入，但正式回读校验失败；动作流已保留，需人工核验`,
         appResponse,
         saveResponse,
         checkResponse,
         readBack,
     };
 }
-//# sourceMappingURL=save_workflow_draft.js.map

package/dist/services/actionflow/step_branches.js

@@ -23,4 +23,3 @@ export function getStepBranches(step) {
     const inner = step.params?.branches;
     return Array.isArray(inner) ? inner : [];
 }
-//# sourceMappingURL=step_branches.js.map

package/dist/services/actionflow/system_params.js

@@ -55,4 +55,3 @@ export function isDateSystemParameter(value) {
     const token = resolveSystemParameter(value);
     return DATE_TOKENS.has(token) || OFFSET_TOKEN.test(token) || RECENT_TOKEN.test(token);
 }
-//# sourceMappingURL=system_params.js.map

package/dist/services/actionflow/trigger_common.js

@@ -48,4 +48,3 @@ export function buildTriggerOperators(value) {
         name: String(item.name || item.text || ''),
     }));
 }
-//# sourceMappingURL=trigger_common.js.map

package/dist/services/actionflow/update_service.js

@@ -12,6 +12,8 @@ import { getApplication, getComponentsForDesign, getDesign, getVersionList, save
 import { genSfId } from './id_generator.js';
 import { validateActionflowComponentConstraints } from './plan_constraints.js';
 import { persistConditionDetails } from './save_workflow_draft.js';
+import { getTenantFunctionRegistry } from './functions_source.js';
+import { buildAssignBean } from './formula_service.js';
 function asObject(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -532,24 +534,115 @@ function applyOperations(design, operations) {
     next.addIds = [...new Set([...(Array.isArray(next.addIds) ? next.addIds : []), ...addedNodeIds])];
     return { design: next, addedNodeIds, deletedNodeIds };
 }
-function containsPatch(actual, expected, path = '') {
+export function containsPatch(actual, expected, path = '', inFormula = false) {
+    if (inFormula && path.endsWith('/config') && typeof actual === 'string' && typeof expected === 'string') {
+        try {
+            actual = JSON.parse(actual);
+            expected = JSON.parse(expected);
+        }
+        catch { /* compare strings */ }
+    }
+    if (inFormula && typeof actual === 'string' && expected && typeof expected === 'object') {
+        try {
+            actual = JSON.parse(actual);
+        }
+        catch { /* compare normally */ }
+    }
+    if (inFormula && typeof expected === 'string' && actual && typeof actual === 'object') {
+        try {
+            expected = JSON.parse(expected);
+        }
+        catch { /* compare normally */ }
+    }
     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}`));
+        return expected.every((value, index) => containsPatch(actual[index], value, `${path}/${index}`, inFormula));
     }
     if (expected && typeof expected === 'object' && !Array.isArray(expected)) {
         if (!actual || typeof actual !== 'object' || Array.isArray(actual))
             return false;
+        const formula = inFormula || (expected.formulaType !== undefined && expected.type !== undefined);
         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}`);
+            if (formula && ['id', 'assignId', 'parentId', 'businessId', 'applicationId'].includes(key))
+                return true;
+            return containsPatch(actual[key], value, `${path}/${key}`, formula);
         });
     }
     return JSON.stringify(actual) === JSON.stringify(expected);
 }
+/** 仅校验本次修改涉及的公式，函数协议来自当前租户实时目录。 */
+export function validateUpdatedFunctions(value, registry, path = 'operations') {
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => validateUpdatedFunctions(item, registry, `${path}[${index}]`));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    if (String(value.type) === '6' && value.formulaType) {
+        const name = String(value.name || '').trim();
+        const matches = registry.filter((entry) => entry.name.toUpperCase() === name.toUpperCase());
+        if (matches.length !== 1)
+            throw new Error(`${path} 函数 '${name}' 未在当前租户函数目录中唯一匹配`);
+        let config = value.config;
+        if (typeof config === 'string') {
+            try {
+                config = JSON.parse(config);
+            }
+            catch {
+                throw new Error(`${path} 函数 '${name}' config 不是合法 JSON`);
+            }
+        }
+        const actual = config?.paramSize;
+        if (actual === undefined || actual === null || String(actual) !== String(matches[0].paramSize)) {
+            throw new Error(`${path} 函数 '${name}' 的 paramSize 应为 ${matches[0].paramSize}，当前为 ${actual ?? '空'}`);
+        }
+    }
+    for (const [key, child] of Object.entries(value))
+        validateUpdatedFunctions(child, registry, `${path}.${key}`);
+}
+function hasUpdatedFunction(value) {
+    if (Array.isArray(value))
+        return value.some(hasUpdatedFunction);
+    if (!value || typeof value !== 'object')
+        return false;
+    return String(value.type) === '6' && Boolean(value.formulaType)
+        || String(value.kind || value.assignmentKind || '') === 'function'
+        || Object.values(value).some(hasUpdatedFunction);
+}
+function hasParamSize(value) {
+    if (Array.isArray(value))
+        return value.some(hasParamSize);
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.prototype.hasOwnProperty.call(value, 'paramSize') || Object.values(value).some(hasParamSize);
+}
+export function compileUpdateFunctions(value, registry, appId) {
+    if (Array.isArray(value))
+        return value.map((item) => compileUpdateFunctions(item, registry, appId));
+    if (!value || typeof value !== 'object')
+        return value;
+    if (String(value.kind || value.assignmentKind || '') === 'function') {
+        const checkArgs = (arg) => {
+            if (Array.isArray(arg)) {
+                arg.forEach(checkArgs);
+                return;
+            }
+            if (!arg || typeof arg !== 'object')
+                return;
+            if (['context', 'reference', 'query_result'].includes(String(arg.kind || arg.assignmentKind || ''))) {
+                throw new Error('update 语义函数暂不支持上下文参数；请先查询真实上下文并使用完整平台公式');
+            }
+            Object.values(arg).forEach(checkArgs);
+        };
+        checkArgs(value.args || value.arguments || []);
+        return buildAssignBean(value, 'formula', String(value.valueType || 'string'), { _function_registry: registry }, appId);
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, compileUpdateFunctions(child, registry, appId)]));
+}
 function verifyUpdateReadback(sent, read, operations, deletedNodeIds, addedNodeIds) {
     const issues = [];
     const sentEntries = nodeEntries(sent);
@@ -690,6 +783,21 @@ export async function runUpdate(payload, client) {
     catch (error) {
         return { valid: false, appId, sceneId, errors: [`修改前备份失败: ${String(error?.message || error)}`], message: '已停止修改，未调用保存接口' };
     }
+    const needsFunctionRegistry = operations.some((operation) => hasUpdatedFunction(operation)
+        || hasParamSize(operation) || (typeof operation.path === 'string' && /\/paramSize$/.test(operation.path)));
+    let functionRegistry = [];
+    if (needsFunctionRegistry) {
+        try {
+            functionRegistry = await getTenantFunctionRegistry(client);
+            for (let index = 0; index < operations.length; index++) {
+                operations[index] = compileUpdateFunctions(operations[index], functionRegistry, appId);
+                validateUpdatedFunctions(operations[index], functionRegistry, `operations[${index}]`);
+            }
+        }
+        catch (error) {
+            return { valid: false, appId, sceneId, backupFile, errors: [String(error?.message || error)], message: '函数目录或公式校验失败，未调用保存接口' };
+        }
+    }
     try {
         await hydrateAddedComponentShells(client, operations);
     }
@@ -703,6 +811,21 @@ export async function runUpdate(payload, client) {
     catch (error) {
         return { valid: false, appId, sceneId, backupFile, errors: [String(error?.message || error)], message: '修改操作执行失败，未调用保存接口' };
     }
+    if (needsFunctionRegistry) {
+        try {
+            for (const operation of operations) {
+                if (operation.op === 'edit-node' && hasParamSize(operation.patch)) {
+                    validateUpdatedFunctions(findNode(next.design.actions || [], String(operation.nodeId)), functionRegistry);
+                }
+                if (operation.op === 'replace' && /\/config\/paramSize$/.test(operation.path)) {
+                    validateUpdatedFunctions(pointerGet(next.design, operation.path.replace(/\/config\/paramSize$/, '')), functionRegistry);
+                }
+            }
+        }
+        catch (error) {
+            return { valid: false, appId, sceneId, backupFile, errors: [String(error?.message || error)], message: '函数公式校验失败，未调用保存接口' };
+        }
+    }
     // 新增条件分支必须先通过 ESB 条件服务持久化，取得真实 conditionId/mapId，
     // 再提交 saveDesign；直接把 otherConditionBranch 拼进设计会被平台拒绝。
     for (const operation of operations) {
@@ -827,4 +950,3 @@ export async function runUpdate(payload, client) {
         message: `已有动作流修改成功，正式版本${saveAndStart ? '保持启用' : '保持未启用'}，已完成回读校验`,
     };
 }
-//# sourceMappingURL=update_service.js.map

package/dist/services/actionflow/webhook_source.js

@@ -101,4 +101,3 @@ export async function resolveWebhookAuthApps(plan, client) {
     params.authAppIds = applications;
     delete params.authAppNames;
 }
-//# sourceMappingURL=webhook_source.js.map