lan-low-code-cli 2.8.1 → 2.9.1

package/README.md

@@ -350,13 +350,17 @@ llc flow delete  --id <flowId> --yes
 
 **布局**由编译器生成，不要手写 `drawAttr.bounds`：
 
-- `--layout ide`（默认）：主链以 `--center-x`（默认 679）居中；`BranchNode` 为 56×56，其余节点 180×38；
-  分支后继与分支节点同层、泳道 ±1 左右对称；汇聚下移一层；层距 = 该层最高节点 + 52。
-  这与平台 mxGraph 编辑器「向下插入 / 左右插入」累积出的编排一致。
-- `--layout layered`：分支后继放到下一层，可读性更强但与平台手工习惯略有差异。
+- `--layout ide`（默认）：**dagre 分层布局**（Sugiyama：分层 → 层内排序 → 坐标分配）。
+  主链以 `--center-x`（默认 679）居中，`BranchNode` 56×56、其余 180×38；分支后继位于下一层，
+  父节点居中于子节点之上，汇聚节点居中于多个父节点下方；层间距 `--rank-padding`（默认 52），
+  同层间距 60。嵌套分支场景实测交叉数 0、线段总长比旧算法短约 16%。
+- `--layout layered`：旧版「rank + lane」算法，复刻 IDE 手工「左右插入」习惯（分支后继与分支节点同层、
+  左右对称）。保留用于兼容历史流程，分支嵌套时更容易出现长线和交叉。
 - `--layout passthrough`：沿用 spec 里的 `bounds`（用于回写平台导出的流程）。
 - `passthrough` 之外的模式下，`relative:false`、节点尺寸、连线 `sourceRef/targetRef` 与
-  `formulaConfig.branchFormulas`（引用真实连线 ID）、分支线 `exitX=0/1` 锚点均自动生成。
+  `formulaConfig.branchFormulas`（引用真实连线 ID）均自动生成；分支出线按实际相对位置写
+  `exitX=0/1`，多出边/多入边写 `exitX/entryX=0.25/0.75`，减少线条挤在同一点。
+- 布局依赖：`@dagrejs/dagre`（MIT）。CLI 其余逻辑仍不依赖任何前端包。
 
 **Schema 注入**：`--resolve-schema` 会为引用数据模型的节点调 `getSourceJsonSchema` /
 `getProcessDataOutJsonSchema` 补齐 `extraAttr.context_outputParam` / `context_bindFormId`。
@@ -373,6 +377,36 @@ llc flow delete  --id <flowId> --yes
 - `AddDataNode` / `AddOrUpdateNode`：分类表单或未填 `commitType` 时豁免 `flow`
 - 校验失败时输出 `field` 与修复建议，`flow validate` / `flow compile` 退出码为 `1`，不会写入环境
 
+**参数映射（`TransformNode` / `ExecuteNode` 等）**：
+
+```json
+{
+  "id": "N4",
+  "type": "TransformNode",
+  "name": "转换",
+  "config": {
+    "outParam": {
+      "fd_title": { "type": "string", "description": "标题" },
+      "fd_amount": { "type": "number" }
+    },
+    "mapping": {
+      "fd_title": "$N2.fd_title",
+      "fd_amount": "$N2.fd_amount"
+    }
+  }
+}
+```
+
+- `outParam` 可写字段映射对象（自动转成 `{id:'responseBody',type:'object',properties:{...}}` 的 JSON Schema 字符串），
+  也可直接写完整 Schema 或 Schema 字符串；编译器写入 `outParamType=1`
+- `mapping` 的 `$<节点id>.<路径>` 自动转成
+  `{sourceType:'node',sourcePath:'node.N2.fd_title',targetPath:'fd_title'}`；`$context.<路径>` 转为上下文映射
+- 编译器同时把出参 Schema 写入 `extraAttr.context_outputParam`，供下游映射与 IDE 显示
+- 未写 `mapping` 时，若上游节点已提供 `context.context_outputParam`，按同名字段自动推断，并给出
+  `MAPPING_AUTO_INFERRED` 提示
+- 常量或表达式请用 `{ "paramMappingWay": "formula", "valueFormula": "..." }`；
+  `ExecuteNode` / `InterfaceNode` / `SubActionNode` / `FlowBotsNode` 用同一 `mapping` 生成 `inputParamMapping`
+
 **边界与已知限制**：
 
 - `AddDataNode` / `AddOrUpdateNode` 的 `fields` 是平台真实结构

package/dist/commands/flow.js

@@ -290,7 +290,7 @@ function registerFlowCommand(program) {
         .command('compile')
         .description('把 Flow Spec 编译为可直接提交的 fdDesign（含编排布局与离线校验）')
         .requiredOption('--spec <@file|json>', 'Flow Spec：@文件路径 或内联 JSON 字符串')
-        .option('--layout <mode>', '布局模式：ide（默认，分支同层左右对称）| layered | passthrough（沿用已有坐标）')
+        .option('--layout <mode>', '布局模式：ide（默认，dagre 分层）| layered（旧版同层分支）| passthrough（沿用已有坐标）')
         .option('--center-x <n>', '主链中心 x，默认 679（对应 1920 宽屏）')
         .option('--rank-padding <n>', '层间距增量，默认 52（层距 = 该层最高节点 + 52）')
         .option('--lane-gap <n>', '泳道间距覆盖值，默认 2 × 层距')
@@ -319,7 +319,7 @@ function registerFlowCommand(program) {
         .command('validate')
         .description('只做离线校验（图结构 / 必填 / 编码 / 布局重叠），不输出设计')
         .requiredOption('--spec <@file|json>', 'Flow Spec：@文件路径 或内联 JSON 字符串')
-        .option('--layout <mode>', '布局模式：ide | layered | passthrough')
+        .option('--layout <mode>', '布局模式：ide（默认，dagre 分层）| layered（旧版同层分支）| passthrough（沿用坐标）')
         .option('--center-x <n>', '主链中心 x')
         .option('--rank-padding <n>', '层间距增量')
         .option('--lane-gap <n>', '泳道间距')
@@ -579,7 +579,7 @@ function registerFlowCommand(program) {
         .option('--enable', '成功后调用 startup 启用')
         .option('--resolve-schema', '联网补齐 extraAttr.context_*（SchemaResolver）')
         .option('--strict-schema', 'Schema 拉取失败时升级为错误')
-        .option('--layout <mode>', '布局模式：ide | layered | passthrough')
+        .option('--layout <mode>', '布局模式：ide（默认，dagre 分层）| layered（旧版同层分支）| passthrough（沿用坐标）')
         .option('--center-x <n>', '主链中心 x')
         .option('--lane-gap <n>', '泳道间距')
         .option('--min-gap <n>', '最小边缘间隙')
@@ -687,7 +687,7 @@ function registerFlowCommand(program) {
         .option('--no-ignore-bounds', '比较时也包含 drawAttr.bounds')
         .option('--resolve-schema', '对比前联网补齐 extraAttr.context_*（与发布时的选项保持一致）')
         .option('--strict-schema', 'Schema 拉取失败时升级为错误')
-        .option('--layout <mode>', '布局模式：ide | layered | passthrough')
+        .option('--layout <mode>', '布局模式：ide（默认，dagre 分层）| layered（旧版同层分支）| passthrough（沿用坐标）')
         .option('--center-x <n>', '主链中心 x')
         .option('--json', '以 JSON 输出差异')).action(async (opts) => {
         const spec = readJsonInput(String(opts.spec), '--spec');

package/dist/commands/operation.js

@@ -291,9 +291,11 @@ function buildCreatePayload(opts, flow) {
             fdModelName: FLOW_MODEL_NAME,
             fdCode: flow.fdCode,
         };
-        const incParams = buildIncParams(opts.incParams);
-        if (incParams !== undefined)
-            config.incParams = incParams;
+        const builtInc = buildIncParams(opts.incParams);
+        if (builtInc) {
+            config.incParams = builtInc.incParams;
+            config.formIncParams = builtInc.formIncParams;
+        }
         const active = flow.fdProcessActive ?? {};
         if (active.fdFormId) {
             // 动作流绑定了表单：按钮按当前文档 id/ids 传参
@@ -343,7 +345,17 @@ function assertTriggerableFlow(flow) {
         throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 未开启「操作触发」，请在 trigger.fdRunType 中包含 operate 后重新发布`);
     }
 }
-/** --inc-params 支持 @file 或内联 JSON；返回平台要求的 [{field:{name},value:{val}}] */
+/**
+ * 编译动作流入参。
+ *
+ * 平台落库结构（addOperationModal/content.tsx:533-576）：
+ *   fdConfig.incParams     = [{ batchNo: 'B001' }, { repeat: 2 }]
+ *   fdConfig.formIncParams = [{ field: { name: 'batchNo' } }, ...]
+ * 入参支持三种写法：
+ *   对象 { "batchNo": "B001", "repeat": 2 }
+ *   数组 [{ "batchNo": "B001" }]
+ *   数组 [{ "field": { "name": "batchNo" }, "value": { "val": "B001" } }]
+ */
 function buildIncParams(input) {
     if (input === undefined || input === null || input === '')
         return undefined;
@@ -355,9 +367,33 @@ function buildIncParams(input) {
     catch (err) {
         throw new Error(`--inc-params 不是合法 JSON：${err.message}`);
     }
-    if (!Array.isArray(parsed))
-        throw new Error('--inc-params 需为数组：[{field:{name},value:{val}}]');
-    return parsed;
+    const entries = [];
+    const pushEntry = (name, value) => {
+        entries.push({ [name]: value });
+    };
+    if (Array.isArray(parsed)) {
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const record = item;
+            const field = record.field;
+            if (field && typeof field.name === 'string') {
+                const value = record.value;
+                pushEntry(field.name, value && 'val' in value ? value.val : record.value);
+                continue;
+            }
+            Object.entries(record).forEach(([name, value]) => pushEntry(name, value));
+        }
+    }
+    else if (parsed && typeof parsed === 'object') {
+        Object.entries(parsed).forEach(([name, value]) => pushEntry(name, value));
+    }
+    if (entries.length === 0)
+        return undefined;
+    return {
+        incParams: entries,
+        formIncParams: entries.map((entry) => ({ field: { name: Object.keys(entry)[0] } })),
+    };
 }
 /**
  * 基于现有操作构造 update 请求体。
@@ -440,9 +476,11 @@ function buildUpdatePayload(current, opts, flow) {
             fdModelName: FLOW_MODEL_NAME,
             fdCode: flow.fdCode,
         };
-        const incParams = buildIncParams(opts.incParams);
-        if (incParams !== undefined)
-            config.incParams = incParams;
+        const builtInc = buildIncParams(opts.incParams);
+        if (builtInc) {
+            config.incParams = builtInc.incParams;
+            config.formIncParams = builtInc.formIncParams;
+        }
     }
     else {
         const dialogId = opts.dialogId !== undefined

package/dist/generator/flow/compiler.js

@@ -20,6 +20,7 @@ exports.normalizeGraph = normalizeGraph;
 exports.compileFlow = compileFlow;
 const layout_1 = require("./layout");
 Object.defineProperty(exports, "NODE_SIZE", { enumerable: true, get: function () { return layout_1.NODE_SIZE; } });
+const mapping_1 = require("./mapping");
 const schema_1 = require("./schema");
 const validate_1 = require("./validate");
 Object.defineProperty(exports, "hasErrors", { enumerable: true, get: function () { return validate_1.hasErrors; } });
@@ -104,6 +105,10 @@ function normalizeGraph(spec, mode, hints = {}) {
     if (business.length === 0 && edges.length === 0)
         addEdge({ from: startId, to: endId });
     const byId = new Map(nodes.map((n) => [n.id, n]));
+    // 在必填校验与节点实例化之前统一补齐参数映射（TransformNode 等）
+    for (const node of nodes) {
+        (0, mapping_1.prepareNodeConfig)(node, diagnostics, { edges, byId });
+    }
     const ranks = { [startId]: 0 };
     const branchTargets = new Set();
     for (const edge of edges) {
@@ -317,15 +322,34 @@ function compileGraph(spec, ctx) {
         });
     }
     const nodes = normalized.graph.nodes.map((node) => buildNode(node, layout.bounds, ctx, branchDefaults, branchFormulas, diagnostics));
+    const incomingCount = new Map();
+    const outgoingCount = new Map();
+    for (const edge of normalized.graph.edges) {
+        incomingCount.set(edge.to, (incomingCount.get(edge.to) ?? 0) + 1);
+        outgoingCount.set(edge.from, (outgoingCount.get(edge.from) ?? 0) + 1);
+    }
     const lines = normalized.graph.edges.map((edge) => {
-        // 条件分支出边需要左右锚点，否则 IDE 里两条线会重叠（真实 style: exitX=0/1）。
+        // 多出边/多入边按实际相对位置设置锚点，避免多条线挤在节点同一点。
+        // 条件分支：左右侧出（exitX=0/1）；汇聚：左/右 1/4 处入（entryX=0.25/0.75）。
         const source = nodeById.get(edge.from);
-        const target = nodeById.get(edge.to);
         const isBranchOut = source?.type === 'BranchNode';
-        const exitX = isBranchOut && target ? (target._lane < 0 ? 0 : target._lane > 0 ? 1 : 0.5) : 0.5;
-        const style = isBranchOut
-            ? `line;exitX=${exitX};exitY=0.5;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;`
-            : '';
+        const sourceBounds = layout.bounds[edge.from];
+        const targetBounds = layout.bounds[edge.to];
+        const sourceCenterX = sourceBounds ? sourceBounds.x + sourceBounds.width / 2 : undefined;
+        const targetCenterX = targetBounds ? targetBounds.x + targetBounds.width / 2 : undefined;
+        const leftOfTarget = sourceCenterX !== undefined && targetCenterX !== undefined ? sourceCenterX < targetCenterX : true;
+        let style = '';
+        if (isBranchOut) {
+            const exitX = sourceCenterX !== undefined && targetCenterX !== undefined
+                ? (targetCenterX < sourceCenterX ? 0 : targetCenterX > sourceCenterX ? 1 : 0.5)
+                : 0.5;
+            style = `line;exitX=${exitX};exitY=0.5;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;`;
+        }
+        else if ((outgoingCount.get(edge.from) ?? 0) > 1 || (incomingCount.get(edge.to) ?? 0) > 1) {
+            const exitX = (outgoingCount.get(edge.from) ?? 0) > 1 ? (leftOfTarget ? 0.25 : 0.75) : 0.5;
+            const entryX = (incomingCount.get(edge.to) ?? 0) > 1 ? (leftOfTarget ? 0.25 : 0.75) : 0.5;
+            style = `line;exitX=${exitX};exitY=1;exitDx=0;exitDy=0;entryX=${entryX};entryY=0;entryDx=0;entryDy=0;`;
+        }
         return {
             id: lineIdOf.get(edge),
             name: edge.name ?? '',
@@ -337,7 +361,7 @@ function compileGraph(spec, ctx) {
             // 仅 --emit-waypoints 时额外写入 wayPoints（非 IDE 原生行为）。
             drawAttr: ctx.options.emitWayPoints
                 ? { style, wayPoints: [] }
-                : isBranchOut ? { style } : {},
+                : style ? { style } : {},
         };
     });
     const design = {

package/dist/generator/flow/layout.js

@@ -2,22 +2,26 @@
 /**
  * 动作流编排布局引擎
  *
- * 源码依据（均来自 action-flow-ide）：
- * - 尺寸表 styleSheet.ts:339-347：BranchNode 56×56，其余 180×38；回显时宽高被强制覆盖
- * - 种子 mxgraph/utils.tsx:93-135：N1 在 (C-90, 80)、N2 在 (C-90, 166)，L1 直连
- * - 向下插入 R4（mxgraph/utils.tsx:422-465,1408-1428）：distance = h_prev + 52，
- *   cy_new = cy_prev + distance，下游整体 y += distance
- * - 左右插入 R5（mxgraph/utils.tsx:442-458,568-584）：与源节点同层中心线，
- *   x = C - w/2 ± 2*distance
- * - 无整图自动布局、无后端布局服务；坐标是持久化契约，IDE 回显原样使用
+ * 坐标是持久化契约：IDE 回显 `drawAttr.bounds` 时原样使用，不会重算，
+ * 也没有整图自动布局或后端布局服务，因此坐标质量直接决定连线是否可读。
  *
- * 因此这里按「rank（逻辑层）+ lane（层内泳道）+ 中心线」复刻编排习惯：
- * 主链居中，分支的直接后继与分支节点同层、左右对称，汇聚节点下移一层。
+ * 两种模式：
+ * - `ide`（默认）：dagre 分层布局（Sugiyama：分层 → 层内排序 → 坐标分配）。
+ *   分支后继位于下一层，父节点由 dagre 居中于子节点之上，汇聚节点居中于多个父节点下方，
+ *   能显著减少长边与交叉。dagre 是 mxGraph 生态常用的布局库（MIT）。
+ * - `layered`：旧版「rank + lane」算法，复刻 IDE 手工「左右插入」习惯——
+ *   分支后继与分支节点同层、左右对称。保留用于兼容历史流程，但分支多时线段较乱。
+ * - `passthrough`：原样沿用节点 bounds（UI 导出流程回写）。
+ *
+ * 尺寸与坐标依据：
+ * - styleSheet.ts:339-347：BranchNode 56×56，其余 180×38
+ * - mxgraph/utils.tsx:93-135：主画布起始 y=80
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CENTER_X = exports.MIN_GAP = exports.RANK_PADDING = exports.START_Y = exports.NODE_SIZE = void 0;
+exports.DEFAULT_NODE_GAP = exports.DEFAULT_CENTER_X = exports.MIN_GAP = exports.RANK_PADDING = exports.START_Y = exports.NODE_SIZE = void 0;
 exports.nodeSize = nodeSize;
 exports.layoutGraph = layoutGraph;
+const dagre_1 = require("@dagrejs/dagre");
 /** 与 styleSheet.ts nodeBounds 一致 */
 exports.NODE_SIZE = {
     BranchNode: { width: 56, height: 56 },
@@ -25,76 +29,192 @@ exports.NODE_SIZE = {
 };
 /** 主画布开始节点的 y（mxgraph/utils.tsx:130） */
 exports.START_Y = 80;
-/** R4 的层间距增量：distance = h_prev + 52 */
+/** 层间距增量：distance = h_prev + 52 */
 exports.RANK_PADDING = 52;
 /**
  * 最小边缘间隙，默认 40。
  *
  * IDE 常规编排的垂直间隙由 R4 推导：gap = 52 + (h_prev - h_new)/2；
  * 38 高节点后紧跟 56 高 BranchNode 时最小为 52 - (56-38)/2 = 43px。
- * 因此不能照搬 mxHierarchicalLayout 的 interRankCellSpacing=50（该值只在
- * 折叠/展开时生效），否则正常分支流程会被误判为布局重叠。
  */
 exports.MIN_GAP = 40;
 /** W=1920 时 (1920-562)/2；CLI 无浏览器宽度，可用 --center-x 覆盖 */
 exports.DEFAULT_CENTER_X = 679;
+/** dagre 同层节点默认水平间距 */
+exports.DEFAULT_NODE_GAP = 60;
 function nodeSize(nodeType) {
     return exports.NODE_SIZE[nodeType] ?? exports.NODE_SIZE.general;
 }
 const round = (v) => Math.round(v * 100) / 100;
 function layoutGraph(graph, options = {}) {
     const mode = options.mode ?? 'ide';
-    const centerX = options.centerX ?? exports.DEFAULT_CENTER_X;
-    const padding = options.rankPadding ?? exports.RANK_PADDING;
-    const minGap = options.minGap ?? exports.MIN_GAP;
+    if (mode === 'passthrough')
+        return layoutPassthrough(graph);
+    if (mode === 'layered')
+        return layoutLayered(graph, options);
+    return layoutDagre(graph, options);
+}
+/* ------------------------------------------------------------------ 重叠 / 负坐标检查 */
+function checkBounds(graph, bounds, minGap) {
     const diagnostics = [];
-    const bounds = {};
-    // passthrough：原样沿用已有坐标（P1 克隆 / UI 导出流程回写）
-    if (mode === 'passthrough') {
-        for (const node of graph.nodes) {
-            const size = nodeSize(node.type);
-            const given = node.bounds;
-            if (!given || typeof given.x !== 'number' || typeof given.y !== 'number') {
+    const placed = graph.nodes.filter((node) => bounds[node.id]);
+    for (let i = 0; i < placed.length; i++) {
+        for (let j = i + 1; j < placed.length; j++) {
+            const a = bounds[placed[i].id];
+            const b = bounds[placed[j].id];
+            const horizontal = a.x < b.x + b.width + minGap && b.x < a.x + a.width + minGap;
+            const vertical = a.y < b.y + b.height + minGap && b.y < a.y + a.height + minGap;
+            if (horizontal && vertical) {
                 diagnostics.push({
                     level: 'error',
-                    code: 'LAYOUT_MISSING_BOUNDS',
-                    message: `passthrough 模式要求节点提供 bounds.{x,y}：${node.id}`,
-                    nodeId: node.id,
+                    code: 'LAYOUT_OVERLAP',
+                    message: `节点 ${placed[i].id} 与 ${placed[j].id} 的布局重叠或间距不足 ${minGap}px`,
+                    nodeId: placed[j].id,
                 });
-                continue;
             }
-            bounds[node.id] = {
-                x: given.x,
-                y: given.y,
-                width: size.width,
-                height: size.height,
-                relative: given.relative ?? false,
-            };
         }
-        return { bounds, rankCenters: [], diagnostics };
     }
-    const maxRank = graph.nodes.reduce((max, n) => Math.max(max, n._rank), 0);
+    for (const node of placed) {
+        const b = bounds[node.id];
+        if (b.x < 0 || b.y < 0) {
+            diagnostics.push({
+                level: 'warn',
+                code: 'LAYOUT_NEGATIVE',
+                message: `节点 ${node.id} 坐标为负 (${b.x}, ${b.y})，IDE 中可能显示不全`,
+                nodeId: node.id,
+            });
+        }
+    }
+    return diagnostics;
+}
+/* ------------------------------------------------------------------ passthrough */
+function layoutPassthrough(graph) {
+    const diagnostics = [];
+    const bounds = {};
+    for (const node of graph.nodes) {
+        const size = nodeSize(node.type);
+        const given = node.bounds;
+        if (!given || typeof given.x !== 'number' || typeof given.y !== 'number') {
+            diagnostics.push({
+                level: 'error',
+                code: 'LAYOUT_MISSING_BOUNDS',
+                message: `passthrough 模式要求节点提供 bounds.{x,y}：${node.id}`,
+                nodeId: node.id,
+            });
+            continue;
+        }
+        bounds[node.id] = {
+            x: given.x,
+            y: given.y,
+            width: size.width,
+            height: size.height,
+            relative: given.relative ?? false,
+        };
+    }
+    return { bounds, rankCenters: [], diagnostics };
+}
+/* ------------------------------------------------------------------ dagre（默认） */
+function layoutDagre(graph, options) {
+    const centerX = options.centerX ?? exports.DEFAULT_CENTER_X;
+    const minGap = options.minGap ?? exports.MIN_GAP;
+    const diagnostics = [];
+    const g = new dagre_1.graphlib.Graph({ multigraph: true });
+    g.setGraph({
+        rankdir: 'TB',
+        nodesep: options.nodeGap ?? exports.DEFAULT_NODE_GAP,
+        ranksep: options.rankPadding ?? exports.RANK_PADDING,
+        marginx: 0,
+        marginy: 0,
+    });
+    g.setDefaultEdgeLabel(() => ({}));
+    for (const node of graph.nodes) {
+        const size = nodeSize(node.type);
+        g.setNode(node.id, { width: size.width, height: size.height });
+    }
+    graph.edges.forEach((edge, index) => {
+        if (!g.hasNode(edge.from) || !g.hasNode(edge.to))
+            return;
+        g.setEdge(edge.from, edge.to, {}, `e${index}`);
+    });
+    try {
+        (0, dagre_1.layout)(g);
+    }
+    catch (err) {
+        diagnostics.push({
+            level: 'warn',
+            code: 'LAYOUT_DAGRE_FAILED',
+            message: `dagre 布局失败，已回退到 layered：${err.message.split('\n')[0]}`,
+        });
+        return layoutLayered(graph, options);
+    }
+    const start = graph.nodes.find((node) => node._isStart) ?? graph.nodes[0];
+    const startLabel = start ? g.node(start.id) : undefined;
+    const startSize = start ? nodeSize(start.type) : exports.NODE_SIZE.general;
+    const startX = startLabel && typeof startLabel.x === 'number' ? startLabel.x : undefined;
+    const startY = startLabel && typeof startLabel.y === 'number' ? startLabel.y : undefined;
+    const offsetX = startX !== undefined ? centerX - startX : 0;
+    const offsetY = startY !== undefined ? exports.START_Y - (startY - startSize.height / 2) : exports.START_Y;
+    const raw = new Map();
+    let minX = Number.POSITIVE_INFINITY;
+    for (const node of graph.nodes) {
+        const label = g.node(node.id);
+        if (!label || typeof label.x !== 'number' || typeof label.y !== 'number')
+            continue;
+        const size = nodeSize(node.type);
+        const x = label.x + offsetX - size.width / 2;
+        const y = label.y + offsetY - size.height / 2;
+        raw.set(node.id, { x, y });
+        minX = Math.min(minX, x);
+    }
+    // 负坐标会显示不全：整体右移
+    const shiftX = Number.isFinite(minX) && minX < 0 ? 20 - minX : 0;
+    const bounds = {};
+    const centers = new Set();
+    for (const node of graph.nodes) {
+        const point = raw.get(node.id);
+        if (!point)
+            continue;
+        const size = nodeSize(node.type);
+        bounds[node.id] = {
+            x: round(point.x + shiftX),
+            y: round(point.y),
+            width: size.width,
+            height: size.height,
+            relative: false,
+        };
+        centers.add(Math.round(point.y + size.height / 2));
+    }
+    diagnostics.push(...checkBounds(graph, bounds, minGap));
+    return { bounds, rankCenters: [...centers].sort((a, b) => a - b), diagnostics };
+}
+/* ------------------------------------------------------------------ 旧版 layered */
+function layoutLayered(graph, options) {
+    const centerX = options.centerX ?? exports.DEFAULT_CENTER_X;
+    const padding = options.rankPadding ?? exports.RANK_PADDING;
+    const minGap = options.minGap ?? exports.MIN_GAP;
+    const bounds = {};
+    const maxRank = graph.nodes.reduce((max, node) => Math.max(max, node._rank), 0);
     // 每层取最高节点，决定「该层到下一层」的间距：38→90、56→108
     const rankHeight = [];
     for (let r = 0; r <= maxRank; r++) {
-        const heights = graph.nodes.filter((n) => n._rank === r).map((n) => nodeSize(n.type).height);
+        const heights = graph.nodes.filter((node) => node._rank === r).map((node) => nodeSize(node.type).height);
         rankHeight[r] = heights.length > 0 ? Math.max(...heights) : exports.NODE_SIZE.general.height;
     }
     const gapOf = (r) => (rankHeight[r] ?? exports.NODE_SIZE.general.height) + padding;
-    // 中心线：cy(0) = 80 + h_start/2 = 99；cy(r) = cy(r-1) + gap(r-1)
+    // 中心线：cy(0) = 80 + h_start/2；cy(r) = cy(r-1) + gap(r-1)
     const rankCenters = [];
-    const startNode = graph.nodes.find((n) => n._isStart);
+    const startNode = graph.nodes.find((node) => node._isStart);
     rankCenters[0] = exports.START_Y + (startNode ? nodeSize(startNode.type).height : exports.NODE_SIZE.general.height) / 2;
     for (let r = 1; r <= maxRank; r++) {
         rankCenters[r] = rankCenters[r - 1] + gapOf(r - 1);
     }
     for (const node of graph.nodes) {
         const size = nodeSize(node.type);
-        const r = node._rank;
+        const rank = node._rank;
         // R5 的 ±2*distance：distance 取当前层最高节点对应的层间距
-        const laneGap = options.laneGap ?? 2 * gapOf(r);
+        const laneGap = options.laneGap ?? 2 * gapOf(rank);
         const x = centerX - size.width / 2 + node._lane * laneGap;
-        const y = (rankCenters[r] ?? rankCenters[rankCenters.length - 1]) - size.height / 2;
+        const y = (rankCenters[rank] ?? rankCenters[rankCenters.length - 1]) - size.height / 2;
         bounds[node.id] = {
             x: round(x),
             y: round(y),
@@ -103,34 +223,5 @@ function layoutGraph(graph, options = {}) {
             relative: false,
         };
     }
-    // 矩形重叠检查（含最小间隙）
-    const placed = graph.nodes.filter((n) => bounds[n.id]);
-    for (let i = 0; i < placed.length; i++) {
-        for (let j = i + 1; j < placed.length; j++) {
-            const a = bounds[placed[i].id];
-            const b = bounds[placed[j].id];
-            const horizontal = a.x < b.x + b.width + minGap && b.x < a.x + a.width + minGap;
-            const vertical = a.y < b.y + b.height + minGap && b.y < a.y + a.height + minGap;
-            if (horizontal && vertical) {
-                diagnostics.push({
-                    level: 'error',
-                    code: 'LAYOUT_OVERLAP',
-                    message: `节点 ${placed[i].id} 与 ${placed[j].id} 的布局重叠或间距不足 ${minGap}px`,
-                    nodeId: placed[j].id,
-                });
-            }
-        }
-    }
-    for (const node of placed) {
-        const b = bounds[node.id];
-        if (b.x < 0 || b.y < 0) {
-            diagnostics.push({
-                level: 'warn',
-                code: 'LAYOUT_NEGATIVE',
-                message: `节点 ${node.id} 坐标为负 (${b.x}, ${b.y})，IDE 中可能显示不全；可增大 --center-x / --lane-gap`,
-                nodeId: node.id,
-            });
-        }
-    }
-    return { bounds, rankCenters, diagnostics };
+    return { bounds, rankCenters, diagnostics: checkBounds(graph, bounds, minGap) };
 }

package/dist/generator/flow/mapping.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * 参数映射编译器
+ *
+ * 平台里映射的持久化结构只有两种（`configuration/controls/paramMapping/index.tsx:100-135`）：
+ *   point:   { paramMappingWay:'point',   pointMappings:[{ sourceType, sourcePath, targetPath }] }
+ *   formula: { paramMappingWay:'formula', valueFormula:'<JSON 字符串>' }
+ *
+ * spec 里允许更友好的写法（编译后会被删除，不落库）：
+ *   "config": {
+ *     "outParam": { "fd_title": { "type": "string", "description": "标题" } },
+ *     "mapping":  { "fd_title": "$N2.fd_title", "fd_amount": "$N2.fd_amount" }
+ *   }
+ *
+ * - `outParam` 也接受完整 JSON Schema（含 type/properties）或 JSON 字符串；
+ * - `mapping` 的值支持 `$<节点id>.<路径>` 与 `$context.<路径>`；
+ * - 也接受 `{ paramMappingWay:'formula', valueFormula:'...' }` 或 pointMappings 数组直接透传。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareNodeConfig = prepareNodeConfig;
+const JSON_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'array', 'object']);
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const NODE_REF = /^\$([0-9a-zA-Z_]{2,32})\.(.+)$/;
+const CONTEXT_REF = /^\$context\.(.+)$/;
+function targetPathOf(key) {
+    const index = key.indexOf('.');
+    return index >= 0 ? key.slice(index + 1) : key;
+}
+/** 字段映射 → JSON Schema（`{id:'responseBody', type:'object', properties:{...}}`） */
+function buildSchemaFromFields(fields) {
+    const properties = {};
+    for (const [name, raw] of Object.entries(fields)) {
+        if (isRecord(raw)) {
+            properties[name] = { id: name, required: false, ...raw };
+            continue;
+        }
+        if (typeof raw === 'string' && JSON_TYPES.has(raw)) {
+            properties[name] = { id: name, type: raw, required: false, description: '' };
+            continue;
+        }
+        properties[name] = {
+            id: name,
+            type: 'string',
+            required: false,
+            ...(typeof raw === 'string' && raw ? { description: raw } : {}),
+        };
+    }
+    return { id: 'responseBody', type: 'object', description: '', properties };
+}
+/** 统一 outParam：字符串原样保留，对象转成 JSON Schema 字符串 */
+function normalizeOutParam(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return {};
+        try {
+            const parsed = JSON.parse(trimmed);
+            return isRecord(parsed) ? { text: trimmed, schema: parsed } : { text: value };
+        }
+        catch {
+            return { text: value };
+        }
+    }
+    if (isRecord(value)) {
+        const isSchema = 'type' in value || 'properties' in value || '$ref' in value;
+        const schema = isSchema
+            ? { id: 'responseBody', type: 'object', description: '', ...value }
+            : buildSchemaFromFields(value);
+        return { text: JSON.stringify(schema), schema };
+    }
+    return {};
+}
+function parseMappingSource(expr) {
+    if (typeof expr !== 'string')
+        return undefined;
+    const value = expr.trim();
+    const contextMatch = CONTEXT_REF.exec(value);
+    if (contextMatch) {
+        return { sourceType: 'context', sourcePath: `context.${contextMatch[1]}` };
+    }
+    const nodeMatch = NODE_REF.exec(value);
+    if (nodeMatch) {
+        return { sourceType: 'node', sourcePath: `node.${nodeMatch[1]}.${nodeMatch[2]}` };
+    }
+    return undefined;
+}
+/** `{ 目标字段: 表达式 }` → pointMappings */
+function buildPointMapping(mapping, diagnostics, nodeId, field) {
+    const pointMappings = [];
+    for (const [target, expr] of Object.entries(mapping)) {
+        if (target === 'paramMappingWay' || target === 'pointMappings' || target === 'valueFormula')
+            continue;
+        const source = parseMappingSource(expr);
+        if (!source) {
+            diagnostics.push({
+                level: 'warn',
+                code: 'MAPPING_VALUE_UNSUPPORTED',
+                message: `节点 ${nodeId} 的映射 ${target} 不是 $节点.路径 / $context.路径 形式，已跳过`,
+                nodeId,
+                field,
+                hint: '常量或表达式请改用 { "paramMappingWay": "formula", "valueFormula": "..." }',
+            });
+            continue;
+        }
+        pointMappings.push({ sourceType: source.sourceType, sourcePath: source.sourcePath, targetPath: targetPathOf(target) });
+    }
+    if (pointMappings.length === 0)
+        return undefined;
+    return { paramMappingWay: 'point', pointMappings };
+}
+/** 把 spec 的 mapping 统一成平台结构 */
+function buildMapping(input, diagnostics, nodeId, field) {
+    if (typeof input === 'string') {
+        const value = input.trim();
+        if (!value)
+            return undefined;
+        if (value.startsWith('{'))
+            return { paramMappingWay: 'formula', valueFormula: value };
+        diagnostics.push({
+            level: 'error', code: 'MAPPING_FORMULA_INVALID',
+            message: `节点 ${nodeId} 的 ${field} 字符串必须是 valueFormula 的 JSON`, nodeId, field,
+        });
+        return undefined;
+    }
+    if (Array.isArray(input)) {
+        return input.length > 0 ? { paramMappingWay: 'point', pointMappings: input } : undefined;
+    }
+    if (!isRecord(input))
+        return undefined;
+    if (input.paramMappingWay === 'formula') {
+        if (typeof input.valueFormula === 'string' && input.valueFormula.trim()) {
+            return { paramMappingWay: 'formula', valueFormula: input.valueFormula };
+        }
+        if (input.valueFormula !== undefined) {
+            return { paramMappingWay: 'formula', valueFormula: JSON.stringify(input.valueFormula) };
+        }
+        diagnostics.push({
+            level: 'error', code: 'MAPPING_FORMULA_REQUIRED',
+            message: `节点 ${nodeId} 的 ${field} 声明 paramMappingWay=formula 但缺少 valueFormula`, nodeId, field,
+        });
+        return undefined;
+    }
+    return buildPointMapping(input, diagnostics, nodeId, field);
+}
+/** 平台要求 valueFormula 是字符串；对象写法统一序列化 */
+function normalizeMappingValue(value) {
+    if (!isRecord(value))
+        return value;
+    if (value.valueFormula !== undefined && typeof value.valueFormula !== 'string') {
+        return { ...value, valueFormula: JSON.stringify(value.valueFormula) };
+    }
+    return value;
+}
+/** 上游已有 `context_outputParam` 时，按同名字段自动补齐 point 映射 */
+function inferFromUpstream(node, outputNames, graph) {
+    for (const edge of graph.edges.filter((item) => item.to === node.id)) {
+        const upstream = graph.byId.get(edge.from);
+        const upstreamContext = upstream?.context;
+        const schema = upstreamContext?.context_outputParam;
+        if (!isRecord(schema))
+            continue;
+        const properties = isRecord(schema.properties) ? schema.properties : undefined;
+        if (!properties)
+            continue;
+        const pointMappings = outputNames
+            .filter((name) => name in properties)
+            .map((name) => ({
+            sourceType: 'node',
+            sourcePath: `node.${edge.from}.${name}`,
+            targetPath: name,
+        }));
+        if (pointMappings.length > 0)
+            return { pointMappings, upstreamId: edge.from };
+    }
+    return undefined;
+}
+/**
+ * 在归一化阶段就地补齐节点配置（校验与实例化都会读取同一份 config）。
+ * 只处理参数映射相关的 nodeType，其余节点原样返回。
+ */
+function prepareNodeConfig(node, diagnostics, graph) {
+    const config = { ...(node.config ?? {}) };
+    node.config = config;
+    if (node.type === 'TransformNode') {
+        const normalized = normalizeOutParam(config.outParam);
+        if (normalized.text) {
+            config.outParam = normalized.text;
+            if (config.outParamType === undefined)
+                config.outParamType = 1;
+            if (normalized.schema) {
+                // IDE 的 onParamChange 会把出参 Schema 写入 context_outputParam（transformNode.tsx:64-67）
+                node.context = { ...(node.context ?? {}), context_outputParam: normalized.schema };
+            }
+        }
+        else if (config.outParam !== undefined) {
+            diagnostics.push({
+                level: 'error', code: 'OUT_PARAM_INVALID',
+                message: `节点 ${node.id} 的 config.outParam 需为 JSON Schema 字符串或字段映射对象`,
+                nodeId: node.id, field: 'outParam',
+            });
+        }
+        if (config.outputParamMapping !== undefined) {
+            config.outputParamMapping = normalizeMappingValue(config.outputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.outputParamMapping = generated;
+        }
+        if (config.outputParamMapping === undefined && normalized.schema && isRecord(normalized.schema.properties) && graph) {
+            const names = Object.keys(normalized.schema.properties);
+            const inferred = inferFromUpstream(node, names, graph);
+            if (inferred) {
+                config.outputParamMapping = { paramMappingWay: 'point', pointMappings: inferred.pointMappings };
+                diagnostics.push({
+                    level: 'warn', code: 'MAPPING_AUTO_INFERRED',
+                    message: `节点 ${node.id} 未提供 mapping，已按上游 ${inferred.upstreamId} 的同名字段自动生成 ${inferred.pointMappings.length} 条映射`,
+                    nodeId: node.id, field: 'outputParamMapping',
+                });
+            }
+        }
+        delete config.mapping;
+        return;
+    }
+    if (node.type === 'EndNode') {
+        const normalized = normalizeOutParam(config.outParam);
+        if (normalized.text) {
+            config.outParam = normalized.text;
+            // 主动触发的结束节点 outParamType=0（endNode.tsx:46）
+            if (config.outParamType === undefined)
+                config.outParamType = 0;
+            if (normalized.schema) {
+                node.context = { ...(node.context ?? {}), context_outputParam: normalized.schema };
+            }
+        }
+        if (config.outputParamMapping !== undefined) {
+            config.outputParamMapping = normalizeMappingValue(config.outputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.outputParamMapping = generated;
+        }
+        delete config.mapping;
+        return;
+    }
+    if (['ExecuteNode', 'InterfaceNode', 'SubActionNode', 'FlowBotsNode'].includes(node.type)) {
+        if (config.inputParamMapping !== undefined) {
+            config.inputParamMapping = normalizeMappingValue(config.inputParamMapping);
+        }
+        else if (config.mapping !== undefined) {
+            const generated = buildMapping(config.mapping, diagnostics, node.id, 'mapping');
+            if (generated)
+                config.inputParamMapping = generated;
+        }
+        delete config.mapping;
+    }
+}

package/dist/index.js

@@ -12,7 +12,7 @@ const locale_1 = require("./commands/locale");
 const operation_1 = require("./commands/operation");
 const template_1 = require("./commands/template");
 const logger_1 = require("./utils/logger");
-const VERSION = '2.8.1';
+const VERSION = '2.9.1';
 const program = new commander_1.Command();
 exports.program = program;
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lan-low-code-cli",
-  "version": "2.8.1",
+  "version": "2.9.1",
   "description": "lan-low-code cli：低代码表单引擎命令行工具（创建表单、获取可用字段、自动完善表单字段）",
   "keywords": [
     "low-code",
@@ -29,6 +29,7 @@
     "pack:skill": "node scripts/pack.js --target skill"
   },
   "dependencies": {
+    "@dagrejs/dagre": "1.1.5",
     "commander": "^11.1.0"
   },
   "devDependencies": {

package/skills/lan-low-code-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.8.1
+version: 2.9.1
 author: Pig George
 description: Operate the Landray low-code form engine through the `llc` CLI. Use when the user asks to create, inspect, modify, publish, or delete low-code apps and forms; generate field configs; configure layouts (grid/tabs), field permissions, options, i18n, or control actions (onChange/onLoad); or run pre-publish validation. Also use for troubleshooting form loading/rendering errors.
 tags:

package/skills/lan-low-code-cli/SKILL.zh-CN.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.8.1
+version: 2.9.1
 author: Pig George
 description: 通过 `llc` CLI 操作蓝凌低代码表单引擎。适用于：创建、查看、修改、发布或删除低代码应用与表单；生成字段配置；配置布局（栅格/页签）、字段权限、选项、多语言、控件动作（onChange/onLoad）；或执行发布前校验、排查表单加载/渲染报错。
 tags:

package/skills/lan-low-code-cli/references/cli-contract.md

@@ -271,11 +271,14 @@ Application-scoped action flows. Every write command needs `--yes` and an explic
 
 - `--code` must match `^[a-zA-Z0-9_]{1,30}$`; node `id` `^[0-9a-zA-Z_]{2,32}$`. Start/End nodes
   and their edges are auto-added; disconnected roots/leaves are wired automatically.
-- **Layout**: `ide` (default) reproduces the platform's arrangement — main chain centred on
-  `--center-x` (default `679`), `BranchNode` 56×56, branch successors on the same rank at lanes ±1,
-  join one rank lower, rank spacing `maxHeight + 52`. `layered` pushes branch successors to the
-  next rank; `passthrough` keeps `bounds` from the spec. `drawAttr.bounds` uses top-left `x/y` with
-  `relative:false` and is persisted verbatim by the IDE (it never recomputes coordinates).
+- **Layout**: `ide` (default) uses **dagre** (Sugiyama: layering → ordering → coordinates). Main chain
+  centred on `--center-x` (default `679`), `BranchNode` 56×56 and others 180×38, branch successors on
+  the next rank, parents centred over children, joins centred under parents, rank gap
+  `--rank-padding` (default 52), same-rank gap 60. `layered` keeps the legacy rank+lane algorithm
+  (branch successors on the same rank, left/right symmetric); `passthrough` keeps `bounds` from the
+  spec. `drawAttr.bounds` uses top-left `x/y` with `relative:false` and is persisted verbatim by the
+  IDE (it never recomputes coordinates). Branch edges get `exitX=0/1` from the actual relative x;
+  multi-in/multi-out edges get `exitX`/`entryX` 0.25/0.75 to avoid sharing one anchor point.
 - Branch handling: `defaultTargetRef` comes from the edge with `"default": true`; a
   `formulaConfig.branchFormulas` referencing the real line IDs is generated automatically, and branch
   edges get `exitX=0/1` anchor styles so they do not overlap in the designer.
@@ -296,6 +299,14 @@ Application-scoped action flows. Every write command needs `--yes` and an explic
   `loopDefine.type`; `MessageNode` validates `notifyType`/`subject`/`templateCode`/`linkPage`/`linkUrl`
   by `subjectType` and `messageLink.linkType`; `AddDataNode`/`AddOrUpdateNode` skip `flow` for
   category forms or when `commitType` is absent. Diagnostics carry `field` and `hint`; errors exit `1`.
+- **Parameter mapping shorthand**: `TransformNode` accepts `config.outParam` as a field map
+  (`{"fd_title":{"type":"string","description":"标题"}}`) or a full JSON Schema / Schema string, plus
+  `config.mapping` as `{"targetPath":"$<nodeId>.<path>"}` (also `$context.<path>`). The compiler emits
+  `outParamType=1`, `outParam` (Schema string), `outputParamMapping` (`pointMappings`) and copies the
+  Schema into `extraAttr.context_outputParam`. When `mapping` is absent it is inferred from an upstream
+  `context.context_outputParam` by matching field names (`MAPPING_AUTO_INFERRED` warning). Constants or
+  expressions require `{"paramMappingWay":"formula","valueFormula":"..."}`. `ExecuteNode` /
+  `InterfaceNode` / `SubActionNode` / `FlowBotsNode` reuse `config.mapping` for `inputParamMapping`.
 - Publishing derives `fdProcessActive` on the backend from `startNodeDef`; `fdStatus=1` means enabled.
   `flow logs` endpoints vary by deployment (`ModelingProcessLog/findAll` vs
   `sysModelingLog/findAllWithAppId`); use `--endpoint` if the defaults fail.

package/skills/lan-low-code-cli/references/cli-contract.zh-CN.md

@@ -260,10 +260,12 @@ llc operation detach --form-id <fdId> --operation-id <operationId>            #
 
 - `--code` 需匹配 `^[a-zA-Z0-9_]{1,30}$`；节点 `id` 需匹配 `^[0-9a-zA-Z_]{2,32}$`。
   开始/结束节点及其连线自动补齐，无入边/无出边的业务节点自动接线。
-- **布局**：`ide`（默认）复刻平台编排——主链以 `--center-x`（默认 `679`）居中，`BranchNode`
-  为 56×56，分支后继与分支节点同层、泳道 ±1，汇聚下移一层，层距 = 该层最高节点 + 52。
-  `layered` 把分支后继放到下一层；`passthrough` 沿用 spec 中的 `bounds`。
-  `drawAttr.bounds` 是左上角 `x/y` 且带 `relative:false`，IDE **原样持久化、不会重算坐标**。
+- **布局**：`ide`（默认）使用 **dagre**（Sugiyama：分层 → 层内排序 → 坐标分配）。主链以
+  `--center-x`（默认 `679`）居中，`BranchNode` 56×56、其余 180×38；分支后继位于下一层，父节点
+  居中于子节点之上，汇聚节点居中于多个父节点下方；层间距 `--rank-padding`（默认 52），同层间距 60。
+  `layered` 保留旧版 rank+lane 算法（分支后继与分支节点同层、左右对称）；`passthrough` 沿用 spec
+  中的 `bounds`。`drawAttr.bounds` 是左上角 `x/y` 且带 `relative:false`，IDE **原样持久化、不会重算坐标**。
+  分支出线按实际相对位置写 `exitX=0/1`；多出边/多入边写 `exitX`/`entryX` 0.25/0.75，避免共用一个锚点。
 - 分支处理：`defaultTargetRef` 取自 `"default": true` 的出边；自动生成引用真实连线 ID 的
   `formulaConfig.branchFormulas`；分支连线写入 `exitX=0/1` 锚点，避免 IDE 内两条线重叠。
 - `--resolve-schema` 通过 `getSourceJsonSchema` / `getProcessDataOutJsonSchema` 补齐
@@ -282,6 +284,14 @@ llc operation detach --form-id <fdId> --operation-id <operationId>            #
   校验 `notifyType` / `subject` / `templateCode` / `linkPage` / `linkUrl`；
   `AddDataNode` / `AddOrUpdateNode` 在分类表单或未填 `commitType` 时豁免 `flow`。
   诊断会带 `field` 与 `hint`，有错误时退出码为 `1`。
+- **参数映射简写**：`TransformNode` 的 `config.outParam` 可写字段映射对象
+  （`{"fd_title":{"type":"string","description":"标题"}}`），也可写完整 JSON Schema 或 Schema 字符串；
+  `config.mapping` 支持 `{"目标字段":"$<节点id>.<路径>"}`（也支持 `$context.<路径>`）。编译器会输出
+  `outParamType=1`、`outParam`（Schema 字符串）、`outputParamMapping`（`pointMappings`），并把 Schema
+  写入 `extraAttr.context_outputParam`。未写 `mapping` 时，会按上游 `context.context_outputParam`
+  的同名字段自动推断，并给出 `MAPPING_AUTO_INFERRED` 提示。常量或表达式需改用
+  `{"paramMappingWay":"formula","valueFormula":"..."}`。`ExecuteNode` / `InterfaceNode` /
+  `SubActionNode` / `FlowBotsNode` 复用 `config.mapping` 生成 `inputParamMapping`。
 - 发布时后端从 `startNodeDef` 派生 `fdProcessActive`；`fdStatus=1` 表示已启用。
   `flow logs` 端点因部署而异（`ModelingProcessLog/findAll` 与
   `sysModelingLog/findAllWithAppId`）；默认都失败时用 `--endpoint` 指定。