lan-low-code-cli 2.6.0 → 2.7.0

package/dist/generator/flow/compiler.js

@@ -0,0 +1,397 @@
+"use strict";
+/**
+ * 动作流编译器：Flow Spec（声明式 JSON） → fdDesign（IDE 可回显的设计 JSON 字符串）
+ *
+ * 关键源码依据：
+ * - 节点结构 enter.tsx:367-393：{ id, code, name, type, nodeType, drawAttr:{bounds},
+ *   extraAttr:{context_*}, ...generateNodeData 字段 }
+ * - 连线结构 enter.tsx:395-407：{ id, name, type:'line', sourceRef, targetRef,
+ *   drawAttr:{style} }，不写 wayPoints
+ * - 保存/发布 enter.tsx:532-583：params = { ...dataSource, ...basicInfo,
+ *   fdDesign: JSON.stringify(...), fdStartWay }
+ * - 循环子画布 enter.tsx:357-365：subProcess = { nodes, lines, processVar, ... }
+ *
+ * 阶段 1 产出的是「结构 + 布局」合法的设计；extraAttr.context_* 由 spec.context
+ * 显式提供（或由后续阶段的 SchemaResolver 注入），不会凭空猜测。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasErrors = exports.NODE_SIZE = void 0;
+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 schema_1 = require("./schema");
+const validate_1 = require("./validate");
+Object.defineProperty(exports, "hasErrors", { enumerable: true, get: function () { return validate_1.hasErrors; } });
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function allocateId(ids, preferred) {
+    if (!ids.has(preferred))
+        return preferred;
+    for (let i = 2; i < 100; i++) {
+        const candidate = `${preferred}_${i}`;
+        if (!ids.has(candidate))
+            return candidate;
+    }
+    return `${preferred}_${Date.now().toString(36)}`;
+}
+/**
+ * 归一化图：自动补开始/结束节点、自动补首尾连线、分配 rank 与 lane。
+ *
+ * rank 语义：
+ * - ide 模式：BranchNode 的直接后继与分支节点同层（对应 IDE 的左右插入 R5）
+ * - layered 模式：所有边都推进一层
+ * lane 语义：lane 0 = 主链居中；分支目标取 ±1, ±2 … 左右对称。
+ */
+function normalizeGraph(spec, mode, hints = {}) {
+    const diagnostics = [];
+    const nodes = clone(spec.nodes);
+    const edges = [];
+    const seenEdge = new Set();
+    const addEdge = (edge) => {
+        const key = `${edge.from}->${edge.to}`;
+        if (seenEdge.has(key))
+            return;
+        seenEdge.add(key);
+        edges.push(edge);
+    };
+    for (const edge of clone(spec.edges))
+        addEdge(edge);
+    const ids = new Set(nodes.map((n) => n.id));
+    let start = nodes.find((n) => n.type === 'StartNode');
+    let end = nodes.find((n) => n.type === 'EndNode');
+    if (!start) {
+        const id = allocateId(ids, hints.startId ?? 'N1');
+        ids.add(id);
+        start = { id, type: 'StartNode', name: '开始' };
+        nodes.unshift(start);
+    }
+    if (!end) {
+        let maxN = 1;
+        for (const id of ids) {
+            const matched = /^N(\d+)$/.exec(id);
+            if (matched)
+                maxN = Math.max(maxN, Number(matched[1]));
+        }
+        const id = allocateId(ids, hints.endId ?? `N${maxN + 1}`);
+        ids.add(id);
+        end = { id, type: 'EndNode', name: '结束' };
+        nodes.push(end);
+    }
+    const startId = start.id;
+    const endId = end.id;
+    const degree = () => {
+        const incoming = new Map();
+        const outgoing = new Map();
+        for (const edge of edges) {
+            outgoing.set(edge.from, (outgoing.get(edge.from) ?? 0) + 1);
+            incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+        }
+        return { incoming, outgoing };
+    };
+    const business = nodes.filter((n) => n.id !== startId && n.id !== endId);
+    let deg = degree();
+    for (const node of business) {
+        if ((deg.incoming.get(node.id) ?? 0) === 0)
+            addEdge({ from: startId, to: node.id });
+    }
+    deg = degree();
+    for (const node of business) {
+        if ((deg.outgoing.get(node.id) ?? 0) === 0)
+            addEdge({ from: node.id, to: endId });
+    }
+    if (business.length === 0 && edges.length === 0)
+        addEdge({ from: startId, to: endId });
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const ranks = { [startId]: 0 };
+    const branchTargets = new Set();
+    for (const edge of edges) {
+        if (byId.get(edge.from)?.type === 'BranchNode')
+            branchTargets.add(edge.to);
+    }
+    // 迭代松弛求最长路径层级；不收敛即存在环
+    const limit = nodes.length + 2;
+    let converged = false;
+    for (let pass = 0; pass < limit; pass++) {
+        let changed = false;
+        for (const edge of edges) {
+            const fromRank = ranks[edge.from];
+            if (fromRank === undefined)
+                continue;
+            const sameRank = mode === 'ide' && byId.get(edge.from)?.type === 'BranchNode';
+            const candidate = sameRank ? fromRank : fromRank + 1;
+            if (ranks[edge.to] === undefined || candidate > ranks[edge.to]) {
+                ranks[edge.to] = candidate;
+                changed = true;
+            }
+        }
+        if (!changed) {
+            converged = true;
+            break;
+        }
+    }
+    if (!converged) {
+        diagnostics.push({ level: 'error', code: 'GRAPH_CYCLE', message: '图中存在环，动作流必须是 DAG（IDE 禁止回环）' });
+    }
+    const maxRank = Math.max(0, ...Object.values(ranks));
+    for (const node of nodes) {
+        if (ranks[node.id] === undefined) {
+            diagnostics.push({
+                level: 'warn', code: 'GRAPH_ORPHAN',
+                message: `节点 ${node.id} 未连接到主流程，已放置在末层`, nodeId: node.id,
+            });
+            ranks[node.id] = maxRank + 1;
+        }
+    }
+    const normalized = nodes.map((node) => ({
+        ...node,
+        _rank: node.rank ?? ranks[node.id] ?? 0,
+        _lane: node.lane ?? 0,
+        _isStart: node.id === startId,
+        _isEnd: node.id === endId,
+        _isBranchTarget: branchTargets.has(node.id),
+    }));
+    // 层内泳道分配：主链/分支节点优先占 lane 0，分支目标左右对称
+    const byRank = new Map();
+    for (const node of normalized) {
+        const group = byRank.get(node._rank) ?? [];
+        group.push(node);
+        byRank.set(node._rank, group);
+    }
+    for (const group of byRank.values()) {
+        const priority = (n) => n._isBranchTarget ? 2 : n._isStart || n._isEnd || n.type === 'BranchNode' ? 0 : 1;
+        group.sort((a, b) => priority(a) - priority(b));
+        const used = new Set();
+        for (const node of group) {
+            if (node.lane !== undefined) {
+                used.add(node.lane);
+                continue;
+            }
+            const candidates = node._isBranchTarget
+                ? [-1, 1, -2, 2, -3, 3, -4, 4]
+                : [0, -1, 1, -2, 2, -3, 3, -4, 4];
+            let lane = candidates.find((value) => !used.has(value));
+            if (lane === undefined)
+                lane = used.size + 1;
+            used.add(lane);
+            node._lane = lane;
+        }
+    }
+    return { graph: { nodes: normalized, edges, startId, endId }, diagnostics };
+}
+/** 构造 startNodeDef（startNode.tsx:193-216 的 fdProcessActive） */
+function buildStartNodeDef(node, ctx) {
+    const provided = node.config?.startNodeDef;
+    if (provided && typeof provided === 'object' && !Array.isArray(provided)) {
+        return provided;
+    }
+    const trigger = ctx.trigger ?? {};
+    const way = ctx.startWay;
+    // 平台落库的 inParam 是 JSON 字符串（真实 get 回包中 fdProcessActive.fdInParam 与
+    // startNodeDef.inParam 均为字符串）；spec 里允许写成对象，这里统一序列化。
+    const inParam = trigger.inParam !== undefined && typeof trigger.inParam !== 'string'
+        ? JSON.stringify(trigger.inParam)
+        : trigger.inParam;
+    if (way === 'StartActiveNode') {
+        const runTypes = Array.isArray(trigger.fdRunType) ? trigger.fdRunType : [];
+        const fdFormRelation = trigger.fdFormRelation ?? '0';
+        return {
+            type: way,
+            operateTrigger: runTypes.includes('operate') || trigger.operateTrigger === true,
+            bpmTrigger: runTypes.includes('bpm') || trigger.bpmTrigger === true,
+            apiTrigger: runTypes.includes('api') || trigger.apiTrigger === true,
+            inParamType: trigger.inParamType,
+            inParam,
+            fdFormRelation,
+            formId: fdFormRelation === '0' ? undefined : trigger.formId,
+            dataType: trigger.dataType ?? 1,
+            entityId: trigger.entityId,
+        };
+    }
+    return { type: way, ...trigger, ...(inParam !== undefined ? { inParam } : {}) };
+}
+function buildNode(node, bounds, ctx, branchDefaults, branchFormulas, diagnostics) {
+    const config = { ...(schema_1.NODE_DEFAULTS[node.type] ?? {}), ...(node.config ?? {}) };
+    const picked = {};
+    const whitelist = schema_1.NODE_FIELD_WHITELIST[node.type];
+    if (whitelist) {
+        for (const field of whitelist) {
+            if (field in config && config[field] !== undefined)
+                picked[field] = config[field];
+        }
+    }
+    else {
+        Object.assign(picked, config);
+    }
+    if (node._isStart && ctx.isRoot)
+        picked.startNodeDef = buildStartNodeDef(node, ctx);
+    if (node.type === 'BranchNode') {
+        const defaultTarget = branchDefaults.get(node.id);
+        if (defaultTarget !== undefined)
+            picked.defaultTargetRef = defaultTarget;
+        // 平台 IDE 的 branchFormulas[].line 引用连线 id；由编译器按实际出边自动生成。
+        const auto = branchFormulas.get(node.id);
+        if (picked.formulaConfig === undefined && auto !== undefined)
+            picked.formulaConfig = auto;
+    }
+    if (node.type === 'FilterDataNode' && picked.formula && typeof picked.formula === 'object') {
+        picked.formula = JSON.stringify(picked.formula);
+    }
+    // 循环节点子画布：独立坐标系、独立 ID 前缀（graphId = <父链>-<循环节点 id>）
+    if (node.subProcess) {
+        const subResult = compileGraph(node.subProcess, {
+            ...ctx,
+            startId: `${node.id}_1`,
+            endId: `${node.id}_2`,
+            centerX: ctx.options.subCenterX ?? ctx.centerX,
+            isRoot: false,
+        });
+        diagnostics.push(...subResult.diagnostics);
+        picked.subProcess = {
+            nodes: subResult.design.nodes,
+            lines: subResult.design.lines,
+            ...(node.subProcess.processVar ? { processVar: node.subProcess.processVar } : {}),
+            ...(node.subProcess.processVarInitConfigs !== undefined
+                ? { processVarInitConfigs: node.subProcess.processVarInitConfigs }
+                : {}),
+        };
+    }
+    const context = (node.context ?? {});
+    const extraAttr = {};
+    for (const key of schema_1.CONTEXT_KEYS) {
+        if (context[key] !== undefined)
+            extraAttr[key] = context[key];
+    }
+    return {
+        id: node.id,
+        // 真实平台保存时主画布节点通常不带 code（IDE 回显时以 id 兜底）；
+        // 仅当 spec 显式声明 code 时才写出。
+        ...(node.code ? { code: node.code } : {}),
+        name: node.name ?? node.type,
+        type: 'node',
+        nodeType: node.type,
+        ...(node.dynamicProps ? { dynamicProps: node.dynamicProps } : {}),
+        drawAttr: { bounds: bounds[node.id] ?? { x: 0, y: 0, ...(0, layout_1.nodeSize)(node.type) } },
+        extraAttr,
+        ...picked,
+    };
+}
+function compileGraph(spec, ctx) {
+    const mode = ctx.options.mode ?? 'ide';
+    const normalized = normalizeGraph(spec, mode, { startId: ctx.startId, endId: ctx.endId });
+    const graphDiagnostics = (0, validate_1.validateGraph)(normalized.graph, spec, ctx.startWay);
+    const diagnostics = [
+        ...normalized.diagnostics,
+        ...(ctx.isRoot ? graphDiagnostics : graphDiagnostics.filter((d) => !d.code.startsWith('START_'))),
+    ];
+    const layout = (0, layout_1.layoutGraph)(normalized.graph, { ...ctx.options, mode, centerX: ctx.centerX ?? ctx.options.centerX });
+    diagnostics.push(...layout.diagnostics);
+    const branchDefaults = new Map();
+    for (const edge of normalized.graph.edges) {
+        if (edge.default)
+            branchDefaults.set(edge.from, edge.to);
+    }
+    // 连线 id 先确定，formulaConfig.branchFormulas[].line 需要引用它们。
+    const nodeById = new Map(normalized.graph.nodes.map((n) => [n.id, n]));
+    const lineIdOf = new Map(normalized.graph.edges.map((e, i) => [e, `L${i + 1}`]));
+    const branchFormulas = new Map();
+    for (const node of normalized.graph.nodes) {
+        if (node.type !== 'BranchNode')
+            continue;
+        const outgoing = normalized.graph.edges.filter((e) => e.from === node.id);
+        if (outgoing.length === 0)
+            continue;
+        // 默认分支排 priority 1，其余按出边顺序；与真实 condition.tsx 的 branchFormulas 一致。
+        const ordered = [...outgoing].sort((a, b) => Number(Boolean(b.default)) - Number(Boolean(a.default)));
+        branchFormulas.set(node.id, {
+            branchFormulas: ordered.map((edge, index) => ({
+                line: lineIdOf.get(edge),
+                targetRef: edge.to,
+                priority: index + 1,
+                // 默认分支不配公式（与平台 condition.tsx 的 branchFormulas 一致）
+                ...(edge.formula !== undefined && !edge.default
+                    ? { formula: typeof edge.formula === 'string' ? edge.formula : JSON.stringify(edge.formula) }
+                    : {}),
+            })),
+        });
+    }
+    const nodes = normalized.graph.nodes.map((node) => buildNode(node, layout.bounds, ctx, branchDefaults, branchFormulas, diagnostics));
+    const lines = normalized.graph.edges.map((edge) => {
+        // 条件分支出边需要左右锚点，否则 IDE 里两条线会重叠（真实 style: exitX=0/1）。
+        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;`
+            : '';
+        return {
+            id: lineIdOf.get(edge),
+            name: edge.name ?? '',
+            type: 'line',
+            ...(edge.dynamicProps ? { dynamicProps: edge.dynamicProps } : {}),
+            sourceRef: edge.from,
+            targetRef: edge.to,
+            // 平台保存时 item.style 为空 → JSON.stringify 后 drawAttr 为 {}；
+            // 仅 --emit-waypoints 时额外写入 wayPoints（非 IDE 原生行为）。
+            drawAttr: ctx.options.emitWayPoints
+                ? { style, wayPoints: [] }
+                : isBranchOut ? { style } : {},
+        };
+    });
+    const design = {
+        nodes,
+        lines,
+        ...(spec.processVar ? { processVar: spec.processVar } : {}),
+        ...(spec.processVarInitConfigs !== undefined ? { processVarInitConfigs: spec.processVarInitConfigs } : {}),
+    };
+    const bounds = normalized.graph.nodes
+        .map((node) => ({
+        id: node.id,
+        type: node.type,
+        bounds: layout.bounds[node.id],
+        rank: node._rank,
+        lane: node._lane,
+    }))
+        .filter((item) => item.bounds !== undefined);
+    return { design, bounds, rankCenters: layout.rankCenters, diagnostics, graph: normalized.graph };
+}
+/**
+ * 编译入口：返回可直接与 basicInfo 一起提交给 addDraft / addPublish 的 fdDesign。
+ * 注意：调用方应在 hasErrors(result.diagnostics) 为真时阻止发包（除非 --force）。
+ */
+function compileFlow(spec, options = {}) {
+    const startWay = spec.startWay ?? 'StartActiveNode';
+    const diagnostics = (0, validate_1.validateSpec)(spec);
+    const graphResult = compileGraph(spec, {
+        startWay,
+        trigger: spec.trigger,
+        options,
+        centerX: options.centerX ?? spec.centerX,
+        isRoot: true,
+    });
+    diagnostics.push(...graphResult.diagnostics);
+    const basicInfo = {
+        fdName: spec.name,
+        fdCode: spec.code,
+        fdStartWay: startWay,
+        fdStatus: -1,
+        fdTransactionType: spec.fdTransactionType ?? 'multiTransaction',
+        fdLogDetail: spec.fdLogDetail ?? false,
+        ...(spec.appCode ? { fdAppCode: spec.appCode } : {}),
+        ...(spec.fdDesc !== undefined ? { fdDesc: spec.fdDesc } : {}),
+        ...(spec.fdCategory ? { fdCategory: spec.fdCategory } : {}),
+        ...(spec.fdIcon ? { fdIcon: spec.fdIcon } : {}),
+        ...(spec.fdId ? { fdId: spec.fdId } : {}),
+        ...(spec.basicInfo ?? {}),
+    };
+    return {
+        fdDesign: JSON.stringify(graphResult.design),
+        design: graphResult.design,
+        fdStartWay: startWay,
+        basicInfo,
+        bounds: graphResult.bounds,
+        diagnostics,
+    };
+}

package/dist/generator/flow/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./layout"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./schema-resolver"), exports);
+__exportStar(require("./compiler"), exports);

package/dist/generator/flow/layout.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * 动作流编排布局引擎
+ *
+ * 源码依据（均来自 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 回显原样使用
+ *
+ * 因此这里按「rank（逻辑层）+ lane（层内泳道）+ 中心线」复刻编排习惯：
+ * 主链居中，分支的直接后继与分支节点同层、左右对称，汇聚节点下移一层。
+ */
+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.nodeSize = nodeSize;
+exports.layoutGraph = layoutGraph;
+/** 与 styleSheet.ts nodeBounds 一致 */
+exports.NODE_SIZE = {
+    BranchNode: { width: 56, height: 56 },
+    general: { width: 180, height: 38 },
+};
+/** 主画布开始节点的 y（mxgraph/utils.tsx:130） */
+exports.START_Y = 80;
+/** R4 的层间距增量：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;
+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;
+    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') {
+                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 };
+    }
+    const maxRank = graph.nodes.reduce((max, n) => Math.max(max, n._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);
+        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)
+    const rankCenters = [];
+    const startNode = graph.nodes.find((n) => n._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;
+        // R5 的 ±2*distance：distance 取当前层最高节点对应的层间距
+        const laneGap = options.laneGap ?? 2 * gapOf(r);
+        const x = centerX - size.width / 2 + node._lane * laneGap;
+        const y = (rankCenters[r] ?? rankCenters[rankCenters.length - 1]) - size.height / 2;
+        bounds[node.id] = {
+            x: round(x),
+            y: round(y),
+            width: size.width,
+            height: size.height,
+            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 };
+}

package/dist/generator/flow/schema-resolver.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * SchemaResolver：联网补齐动作流节点的运行时上下文（extraAttr.context_*）
+ *
+ * 真实环境实测结论（2026-11-10，mkylxt）：
+ * - `getSourceJsonSchema` / `getProcessDataOutJsonSchema` 的 entityId 必须带
+ *   `sys-modeling#` 前缀，裸 id 返回 HTTP 500；返回值即 JSON Schema。
+ * - `getSourceFields` / `getConditionFields` / `loadDataModel` 用裸 id 正常。
+ * - 平台保存的 `extraAttr.context_bindFormId` 形如 `sys-modeling#<fdId>`。
+ * - 前端 `edit/content.tsx:55-87` 的 tempFormatFn 也会在打开编辑器时自动补
+ *   extraAttr，因此这里采用 best-effort：调用失败只告警，不阻断发布。
+ *
+ * 不做的事：不臆造 `fields` 的公式映射。真实 fields 是
+ * `{ field:{name,label,tableName,tableType,type}, value:{format:'formula'|'fixed',valueJson:'...'} }`
+ * 数组，公式引用形如 `${data.node.N1.fd_xxx}`，必须由 spec 原样提供或从
+ * golden 模板复制；本模块只校验字段名是否在目标表 Schema 中存在。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFlowSchema = resolveFlowSchema;
+const flow_1 = require("../../api/flow");
+function diagnose(out, level, code, message, nodeId) {
+    out.push({ level, code, message, nodeId });
+}
+async function tryCall(fn, label, out, strict, nodeId) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        diagnose(out, strict ? 'error' : 'warn', 'SCHEMA_FETCH_FAILED', `${label} 调用失败：${err.message.split('\n')[0]}`, nodeId);
+        return undefined;
+    }
+}
+/** 从节点扁平字段里取出目标实体 id（真实结构见 startNodeDef / dataSourceVO / target） */
+function entityIdOf(node) {
+    const candidates = [
+        node.startNodeDef,
+        node.dataSourceVO,
+        node.target,
+    ];
+    for (const candidate of candidates) {
+        const value = candidate?.entityId;
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function parseInParam(raw, out, nodeId) {
+    if (typeof raw !== 'string')
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        diagnose(out, 'warn', 'SCHEMA_INPARAM_INVALID', 'startNodeDef.inParam 不是合法 JSON 字符串，已跳过注入', nodeId);
+        return undefined;
+    }
+}
+/** 校验 fields[].field.name 是否存在于目标表 Schema（不改写字段结构） */
+function validateFieldNames(node, schema, out, nodeId) {
+    if (!schema || !Array.isArray(node.fields))
+        return;
+    const properties = schema.properties;
+    if (!properties)
+        return;
+    for (const item of node.fields) {
+        const field = item?.field;
+        const name = field?.name;
+        if (typeof name === 'string' && !(name in properties)) {
+            diagnose(out, 'warn', 'SCHEMA_FIELD_MISSING', `字段 ${name} 不在目标表 Schema 中，请核对 fdName`, nodeId);
+        }
+    }
+}
+async function resolveFlowSchema(client, spec, result, options = {}) {
+    const strict = Boolean(options.strict);
+    const diagnostics = [...result.diagnostics];
+    const startWay = spec.startWay ?? 'StartActiveNode';
+    const resolveNode = async (node, isRootCanvas) => {
+        const nodeId = String(node.id ?? '?');
+        const extra = (node.extraAttr ?? {});
+        node.extraAttr = extra;
+        const entityId = entityIdOf(node);
+        const isStart = node.nodeType === 'StartNode' && isRootCanvas;
+        let schema;
+        if (entityId) {
+            const qualified = (0, flow_1.qualifyEntityId)(entityId);
+            if (isStart && startWay === 'StartDataNode') {
+                const fetched = await tryCall(() => flow_1.flowApi.getDataOutJsonSchema(client, entityId), 'getProcessDataOutJsonSchema', diagnostics, strict, nodeId);
+                schema = fetched;
+                if (fetched) {
+                    const sourceForm = fetched.properties?.sourceForm;
+                    if (extra.context_fdInParam === undefined)
+                        extra.context_fdInParam = fetched;
+                    if (extra.context_nodeParam === undefined)
+                        extra.context_nodeParam = sourceForm ?? null;
+                }
+            }
+            else if (!isStart) {
+                const fetched = await tryCall(() => flow_1.flowApi.getJsonSchema(client, entityId), 'getSourceJsonSchema', diagnostics, strict, nodeId);
+                schema = fetched;
+                if (fetched && extra.context_outputParam === undefined) {
+                    extra.context_outputParam = fetched;
+                }
+            }
+            if (extra.context_bindFormId === undefined)
+                extra.context_bindFormId = qualified;
+        }
+        if (isStart) {
+            const startDef = node.startNodeDef;
+            if (extra.context_fdInParam === undefined && startDef?.inParam !== undefined) {
+                const parsed = parseInParam(startDef.inParam, diagnostics, nodeId);
+                if (parsed !== undefined)
+                    extra.context_fdInParam = parsed;
+            }
+            if (extra.context_isMulti === undefined) {
+                extra.context_isMulti = startDef?.dataType === 2;
+            }
+        }
+        validateFieldNames(node, schema, diagnostics, nodeId);
+        const subProcess = node.subProcess;
+        if (subProcess && Array.isArray(subProcess.nodes)) {
+            for (const child of subProcess.nodes)
+                await resolveNode(child, false);
+        }
+    };
+    for (const node of result.design.nodes) {
+        await resolveNode(node, true);
+    }
+    return {
+        ...result,
+        fdDesign: JSON.stringify(result.design),
+        diagnostics,
+    };
+}