digitalsee-ai-flow-cli 0.9.15 → 0.9.23-beta

package/dist/services/classicNodePorts.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLASSIC_NODE_DESCRIPTORS = exports.SWITCH_NODE_PACKAGE_KEY = exports.SWITCH_DEFAULT_BRANCH_HANDLE = void 0;
+exports.isClassicNodeType = isClassicNodeType;
+exports.resolveClassicNodePorts = resolveClassicNodePorts;
+exports.readSwitchBranches = readSwitchBranches;
+exports.deriveSwitchOutputPorts = deriveSwitchOutputPorts;
+exports.resolveClassicNodeSchema = resolveClassicNodeSchema;
+exports.getAutoConnectRulesForNodeType = getAutoConnectRulesForNodeType;
+exports.applySwitchBranchesToSchema = applySwitchBranchesToSchema;
+exports.listClassicNodeTypes = listClassicNodeTypes;
+exports.SWITCH_DEFAULT_BRANCH_HANDLE = 'default-branch';
+/** NodePackage switch 的 action_key（dip.core.flow.switch） */
+exports.SWITCH_NODE_PACKAGE_KEY = 'dip.core.flow.switch';
+/** Loop / SelfLoop 的 loop → input 自环规则（NodePackage 节点也按 node_type 兜底注入） */
+const LOOP_AUTO_CONNECT = [{ source: 'loop', target: 'input' }];
+const EMPTY_PORTS = [];
+const ACTION_INPUTS = [
+    { name: 'input', displayName: '输入', maxConnections: 1 },
+];
+const ACTION_OUTPUTS = [
+    { name: 'output', displayName: '输出', maxConnections: 1 },
+];
+const TRIGGER_OUTPUTS = [
+    { name: 'output', displayName: '输出', maxConnections: 1 },
+];
+const CONDITION_OUTPUTS = [
+    { name: 'true', displayName: 'true', maxConnections: 1 },
+    { name: 'false', displayName: 'false', maxConnections: 1 },
+];
+const LOOP_OUTPUTS = [
+    { name: 'done', displayName: 'done', maxConnections: 1 },
+    { name: 'loop', displayName: 'loop', maxConnections: 1 },
+];
+const SWITCH_DEFAULT_OUTPUTS = [
+    { name: exports.SWITCH_DEFAULT_BRANCH_HANDLE, displayName: 'default', maxConnections: 1 },
+];
+const AGENT_INPUTS = [
+    { name: 'input', displayName: '输入' },
+    { name: 'ai_model', displayName: 'Chat Model', type: 'AI_LANGUAGE_MODEL', maxConnections: 1 },
+    { name: 'ai_memory', displayName: 'Memory', type: 'AI_MEMORY', maxConnections: 1 },
+    { name: 'ai_tool', displayName: 'Tools', type: 'AI_TOOL', maxConnections: 1 },
+];
+const BROWSER_INPUTS = [
+    { name: 'input', displayName: '输入' },
+    { name: 'ai_model', displayName: 'Chat Model', type: 'AI_LANGUAGE_MODEL', maxConnections: 1 },
+];
+/** AI 子节点出桩：id 固定 ai_model（与存量边数据兼容），type 随协议替换 */
+const aiSubOutput = (protocol) => ({
+    name: 'ai_model',
+    displayName: '输出',
+    type: protocol,
+    maxConnections: 1,
+});
+/** MCPServer / MCP_TRIGGER_NODE：入桩 MCP_SERVER 协议，出桩 BUILTIN_MCP 不限连接数 */
+const MCP_SERVER_INPUTS = [
+    { name: 'input', displayName: '输入', type: 'MCP_SERVER' },
+];
+const MCP_SERVER_OUTPUTS = [
+    { name: 'builtin_mcp', displayName: '输出', type: 'BUILTIN_MCP' },
+];
+/** BuiltinMCP：main 入桩，BUILTIN_MCP 出桩 max 1 */
+const BUILTIN_MCP_INPUTS = [{ name: 'input', displayName: '输入' }];
+const BUILTIN_MCP_OUTPUTS = [
+    { name: 'builtin_mcp', displayName: '输出', type: 'BUILTIN_MCP', maxConnections: 1 },
+];
+/** MCPTool / MCP_TOOLS_NODE：BUILTIN_MCP 入桩，main 出桩 */
+const MCP_TOOL_INPUTS = [
+    { name: 'input', displayName: '输入', type: 'BUILTIN_MCP' },
+];
+const MCP_TOOL_OUTPUTS = [
+    { name: 'output', displayName: '输出', maxConnections: 1 },
+];
+/** MCP return-variable 等形态：无出桩 */
+const NO_OUTPUT_PROTOCOLS = {
+    BUILTIN_MCP: { outputs: EMPTY_PORTS },
+    MCP_SERVER: { outputs: EMPTY_PORTS },
+};
+/**
+ * classic 静态端口表（唯一事实源，数据对齐 RCS CLASSIC_DESCRIPTORS）。
+ */
+exports.CLASSIC_NODE_DESCRIPTORS = {
+    StartEventNode: {
+        nodeType: 'StartEventNode',
+        label: '触发器节点',
+        description: '流程触发起点，无输入端口，单输出口',
+        inputs: EMPTY_PORTS,
+        outputs: TRIGGER_OUTPUTS,
+    },
+    ActionNode: {
+        nodeType: 'ActionNode',
+        label: '动作节点',
+        description: '常规动作节点；MCP return-variable 协议形态无输出端口',
+        inputs: ACTION_INPUTS,
+        outputs: ACTION_OUTPUTS,
+        byProtocol: NO_OUTPUT_PROTOCOLS,
+    },
+    ConditionNode: {
+        nodeType: 'ConditionNode',
+        label: '条件节点',
+        description: '条件分支，true/false 双出口',
+        inputs: ACTION_INPUTS,
+        outputs: CONDITION_OUTPUTS,
+    },
+    LoopNode: {
+        nodeType: 'LoopNode',
+        label: '循环节点',
+        description: '循环控制，done 出口走完流程，loop 出口配合 input 形成自环',
+        inputs: ACTION_INPUTS,
+        outputs: LOOP_OUTPUTS,
+        autoConnect: LOOP_AUTO_CONNECT,
+    },
+    SelfLoopNode: {
+        nodeType: 'SelfLoopNode',
+        label: '自环节点',
+        description: '自循环控制，loop → input 自环边为必需结构',
+        inputs: ACTION_INPUTS,
+        outputs: LOOP_OUTPUTS,
+        autoConnect: LOOP_AUTO_CONNECT,
+    },
+    SwitchNode: {
+        nodeType: 'SwitchNode',
+        label: '多分支节点',
+        description: '多路由分支；输出端口来自 properties.branches[].id（实例派生），default-branch 固定兜底',
+        inputs: ACTION_INPUTS,
+        outputs: SWITCH_DEFAULT_OUTPUTS,
+    },
+    AgentNode: {
+        nodeType: 'AgentNode',
+        label: 'Agent 节点',
+        description: 'AI Agent；底部 slave 桩按协议接收 AI 子节点（ai_model/ai_memory/ai_tool）',
+        inputs: AGENT_INPUTS,
+        outputs: ACTION_OUTPUTS,
+    },
+    BrowserNode: {
+        nodeType: 'BrowserNode',
+        label: '浏览器节点',
+        description: 'AI 浏览器操作；ai_model slave 桩接收语言模型子节点',
+        inputs: BROWSER_INPUTS,
+        outputs: ACTION_OUTPUTS,
+    },
+    AISubNode: {
+        nodeType: 'AISubNode',
+        label: 'AI 配置子节点',
+        description: 'AI 配置子节点（模型/记忆/工具），出桩 id 固定 ai_model，协议随类型',
+        inputs: EMPTY_PORTS,
+        outputs: [aiSubOutput('AI_LANGUAGE_MODEL')],
+        byProtocol: {
+            AI_MEMORY: { outputs: [aiSubOutput('AI_MEMORY')] },
+            AI_TOOL: { outputs: [aiSubOutput('AI_TOOL')] },
+        },
+    },
+    VectorStoreNode: {
+        nodeType: 'VectorStoreNode',
+        label: '向量存储节点',
+        description: '向量存储子节点',
+        inputs: EMPTY_PORTS,
+        outputs: [aiSubOutput('AI_LANGUAGE_MODEL')],
+        byProtocol: {
+            // 注意拼写：对齐 RCS NodeProtocol.AI_VECTOR_STORE = 'AI_VECTORSTORE'
+            AI_VECTORSTORE: { outputs: [aiSubOutput('AI_VECTORSTORE')] },
+        },
+    },
+    MCPServerNode: {
+        nodeType: 'MCPServerNode',
+        label: 'MCP 服务节点',
+        description: '旧 MCP 网关服务；入桩 MCP_SERVER 协议，builtin_mcp 出桩不限连接数',
+        inputs: MCP_SERVER_INPUTS,
+        outputs: MCP_SERVER_OUTPUTS,
+    },
+    MCP_TRIGGER_NODE: {
+        nodeType: 'MCP_TRIGGER_NODE',
+        label: 'MCP 网关触发节点',
+        description: '旧 MCP 网关触发形态，端口与 MCPServerNode 一致',
+        inputs: MCP_SERVER_INPUTS,
+        outputs: MCP_SERVER_OUTPUTS,
+    },
+    BuiltinMCPNode: {
+        nodeType: 'BuiltinMCPNode',
+        label: '内置 MCP 节点',
+        description: '内置 MCP 工具节点，BUILTIN_MCP 出桩 max 1',
+        inputs: BUILTIN_MCP_INPUTS,
+        outputs: BUILTIN_MCP_OUTPUTS,
+    },
+    MCPToolNode: {
+        nodeType: 'MCPToolNode',
+        label: 'MCP 工具节点',
+        description: 'MCP 工具调用；BUILTIN_MCP 入桩，MCP return-variable 形态无出桩',
+        inputs: MCP_TOOL_INPUTS,
+        outputs: MCP_TOOL_OUTPUTS,
+        byProtocol: NO_OUTPUT_PROTOCOLS,
+    },
+    MCP_TOOLS_NODE: {
+        nodeType: 'MCP_TOOLS_NODE',
+        label: 'MCP 网关工具列表节点',
+        description: 'MCP 网关工具列表形态，端口与 MCPToolNode 一致',
+        inputs: MCP_TOOL_INPUTS,
+        outputs: MCP_TOOL_OUTPUTS,
+        byProtocol: NO_OUTPUT_PROTOCOLS,
+    },
+    StickyNoteNode: {
+        nodeType: 'StickyNoteNode',
+        label: '便签节点',
+        description: '画布便签，无端口',
+        inputs: EMPTY_PORTS,
+        outputs: EMPTY_PORTS,
+    },
+};
+function toNodeSchemaPort(spec) {
+    return {
+        name: spec.name,
+        display_name: spec.displayName,
+        type: spec.type ?? 'main',
+        ...(spec.maxConnections !== undefined && spec.maxConnections !== null
+            ? { max_connections: spec.maxConnections }
+            : {}),
+    };
+}
+/** node_type 是否命中内置表 */
+function isClassicNodeType(nodeType) {
+    return (Boolean(nodeType) &&
+        Object.prototype.hasOwnProperty.call(exports.CLASSIC_NODE_DESCRIPTORS, nodeType));
+}
+/**
+ * 按 (node_type, protocol) 解析端口声明。
+ * protocol 缺失或未命中 byProtocol 时回退 type 级默认；未知 node_type 返回 null。
+ */
+function resolveClassicNodePorts(node) {
+    const descriptor = node.node_type ? exports.CLASSIC_NODE_DESCRIPTORS[node.node_type] : undefined;
+    if (!descriptor)
+        return null;
+    const protocol = node.protocol?.trim();
+    if (protocol) {
+        const override = descriptor.byProtocol?.[protocol];
+        if (override) {
+            return {
+                inputs: override.inputs ?? descriptor.inputs,
+                outputs: override.outputs ?? descriptor.outputs,
+            };
+        }
+    }
+    return { inputs: descriptor.inputs, outputs: descriptor.outputs };
+}
+/** 探测 + 规范化节点 branches（RCS switchNodePackage 语义：三容器探测 + id 修复） */
+function readSwitchBranches(data) {
+    const raw = unwrapSwitchProperties(data);
+    const branches = Array.isArray(raw?.branches) ? raw.branches : [];
+    const normalized = [];
+    const usedIds = new Set([exports.SWITCH_DEFAULT_BRANCH_HANDLE]);
+    let migrated = 0;
+    for (const item of branches) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const branch = item;
+        let id = String(branch.id ?? '');
+        const name = String(branch.name ?? '').trim() || `分支 ${normalized.length + 1}`;
+        if (!id.startsWith('branch') || id === exports.SWITCH_DEFAULT_BRANCH_HANDLE || usedIds.has(id)) {
+            do {
+                migrated++;
+                id = `branch-migrated-${migrated}`;
+            } while (usedIds.has(id));
+        }
+        usedIds.add(id);
+        normalized.push({ id, name });
+    }
+    return normalized;
+}
+/** 按序探测 config_schema → properties → params，各解包一层 properties/params */
+function unwrapSwitchProperties(data) {
+    const candidates = [data.config_schema, data.properties, data.params];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
+            continue;
+        const unwrapped = unwrapPropertiesLayer(candidate);
+        if (Array.isArray(unwrapped?.branches))
+            return unwrapped;
+    }
+    return undefined;
+}
+function unwrapPropertiesLayer(value) {
+    if (Array.isArray(value.branches))
+        return value;
+    const nested = value.properties;
+    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+        const unwrapped = nested;
+        if (Array.isArray(unwrapped.branches))
+            return unwrapped;
+    }
+    const params = value.params;
+    if (params && typeof params === 'object' && !Array.isArray(params)) {
+        const unwrapped = params;
+        if (Array.isArray(unwrapped.branches))
+            return unwrapped;
+    }
+    return value;
+}
+/**
+ * branches → 输出端口。classic SwitchNode 用静态模板（main/max1）；
+ * NodePackage switch 通过 options 传 schema 模板以继承约束。
+ * default-branch 固定追加在末尾；branches 为空时仅返回 [defaultPort]。
+ */
+function deriveSwitchOutputPorts(branches, options) {
+    const template = options?.template ?? {
+        name: 'branch-1',
+        display_name: '分支',
+        type: 'main',
+        max_connections: 1,
+    };
+    const defaultPort = options?.defaultPort ?? {
+        name: exports.SWITCH_DEFAULT_BRANCH_HANDLE,
+        display_name: 'default',
+        type: 'main',
+        max_connections: 1,
+    };
+    return [
+        ...branches.map((branch) => ({
+            ...template,
+            name: branch.id,
+            display_name: branch.name,
+        })),
+        defaultPort,
+    ];
+}
+/**
+ * 完整解析 classic 节点的内置 schema（含 SwitchNode 实例分支派生）。
+ * 未知 node_type 返回 null。
+ */
+function resolveClassicNodeSchema(node) {
+    const descriptor = node.node_type ? exports.CLASSIC_NODE_DESCRIPTORS[node.node_type] : undefined;
+    if (!descriptor)
+        return null;
+    const ports = resolveClassicNodePorts(node) ?? {
+        inputs: descriptor.inputs,
+        outputs: descriptor.outputs,
+    };
+    // Switch 分支端口由 deriveSwitchOutputPorts 产出（已是 NodeSchemaPort），不能再过 toNodeSchemaPort
+    const outputs = node.node_type === 'SwitchNode'
+        ? deriveSwitchOutputPorts(readSwitchBranches(node))
+        : (ports.outputs ?? []).map(toNodeSchemaPort);
+    return {
+        schemaKey: node.node_type,
+        inputs: (ports.inputs ?? []).map(toNodeSchemaPort),
+        outputs,
+        autoConnect: descriptor.autoConnect ?? [],
+    };
+}
+/** Loop/SelfLoop 的 loop→input 兜底（NodePackage 节点也按 node_type 注入，对齐 RCS nodeAutoConnect） */
+function getAutoConnectRulesForNodeType(nodeType) {
+    if (!nodeType)
+        return [];
+    const descriptor = exports.CLASSIC_NODE_DESCRIPTORS[nodeType];
+    return descriptor?.autoConnect ?? [];
+}
+/**
+ * NodePackage switch schema 应用实例分支（schema.key === 'dip.core.flow.switch' 时，
+ * 模板继承 schema 第一个非 default 输出的约束）；其余 schema 原样返回。
+ */
+function applySwitchBranchesToSchema(schema, node) {
+    if (schema.key !== exports.SWITCH_NODE_PACKAGE_KEY)
+        return schema;
+    const branches = readSwitchBranches(node);
+    if (branches.length === 0)
+        return schema;
+    const schemaOutputs = schema.outputs ?? [];
+    const template = schemaOutputs.find((port) => port.name !== exports.SWITCH_DEFAULT_BRANCH_HANDLE) ??
+        { name: 'branch-1', display_name: '分支', type: 'main' };
+    const defaultPort = schemaOutputs.find((port) => port.name === exports.SWITCH_DEFAULT_BRANCH_HANDLE) ??
+        {
+            name: exports.SWITCH_DEFAULT_BRANCH_HANDLE,
+            display_name: 'Default',
+            type: 'main',
+        };
+    return {
+        ...schema,
+        outputs: deriveSwitchOutputPorts(branches, { template, defaultPort }),
+    };
+}
+/** skills 渲染用：全部内置类型（保持表定义顺序） */
+function listClassicNodeTypes() {
+    return Object.values(exports.CLASSIC_NODE_DESCRIPTORS).map((d) => ({
+        nodeType: d.nodeType,
+        label: d.label,
+    }));
+}
+//# sourceMappingURL=classicNodePorts.js.map

package/dist/services/portValidator.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PORT_TYPE = void 0;
+exports.validateFlowPorts = validateFlowPorts;
+exports.validateSingleEdge = validateSingleEdge;
+const nodeSchemaCache_1 = require("@/utils/nodeSchemaCache");
+const classicNodePorts_1 = require("@/services/classicNodePorts");
+exports.DEFAULT_PORT_TYPE = 'main';
+const normalizeNodeKeyList = (value) => Array.isArray(value)
+    ? value.filter((item) => typeof item === 'string' && Boolean(item.trim()))
+    : [];
+const normalizePort = (port) => ({
+    name: port.name,
+    displayName: port.display_name || port.name,
+    type: typeof port.type === 'string' && port.type.trim() ? port.type.trim() : exports.DEFAULT_PORT_TYPE,
+    required: Boolean(port.required),
+    maxConnections: port.max_connections !== undefined &&
+        port.max_connections !== null &&
+        Number.isFinite(port.max_connections)
+        ? Math.max(0, Math.trunc(port.max_connections))
+        : null,
+    allowedSourceNodeKeys: normalizeNodeKeyList(port.allowed_source_node_keys),
+    allowedTargetNodeKeys: normalizeNodeKeyList(port.allowed_target_node_keys),
+    deniedSourceNodeKeys: normalizeNodeKeyList(port.denied_source_node_keys),
+    deniedTargetNodeKeys: normalizeNodeKeyList(port.denied_target_node_keys),
+});
+const displayHandle = (handle) => handle || '(未指定)';
+const formatHandleList = (ports) => ports.length
+    ? ports
+        .map((p) => p.displayName && p.displayName !== p.name ? `${p.name}（${p.displayName}）` : p.name)
+        .join('、')
+    : '（无）';
+const includesKey = (keys, identity) => Boolean(identity && keys.includes(identity));
+const rejectedByAllowlist = (keys, identity) => Boolean(keys.length && !includesKey(keys, identity));
+/** 端口间协议/白黑名单规则校验（不含 max_connections 与 required，二者按端口聚合检查） */
+function checkPortRules(sourcePort, targetPort, sourceIdentity, targetIdentity) {
+    // 协议/type 比较大小写不敏感（对齐 RCS connectionCheck；对存量只放宽不收紧）
+    if (sourcePort.type.toLowerCase() !== targetPort.type.toLowerCase()) {
+        return 'PORT_TYPE_MISMATCH';
+    }
+    // 黑名单优先于白名单：同一个 node key 同时出现时必须拒绝
+    if (includesKey(targetPort.deniedSourceNodeKeys, sourceIdentity)) {
+        return 'SOURCE_NODE_DENIED';
+    }
+    if (includesKey(sourcePort.deniedTargetNodeKeys, targetIdentity)) {
+        return 'TARGET_NODE_DENIED';
+    }
+    if (rejectedByAllowlist(targetPort.allowedSourceNodeKeys, sourceIdentity)) {
+        return 'SOURCE_NODE_NOT_ALLOWED';
+    }
+    if (rejectedByAllowlist(sourcePort.allowedTargetNodeKeys, targetIdentity)) {
+        return 'TARGET_NODE_NOT_ALLOWED';
+    }
+    return null;
+}
+function describeRuleViolation(code, sourcePort, targetPort, sourceIdentity, targetIdentity) {
+    switch (code) {
+        case 'PORT_TYPE_MISMATCH':
+            return `端口类型不匹配：${sourcePort.type} 输出不能连接到 ${targetPort.type} 输入`;
+        case 'SOURCE_NODE_DENIED':
+            return `目标输入端口 ${targetPort.name} 禁止源节点 ${sourceIdentity}`;
+        case 'TARGET_NODE_DENIED':
+            return `源输出端口 ${sourcePort.name} 禁止目标节点 ${targetIdentity}`;
+        case 'SOURCE_NODE_NOT_ALLOWED':
+            return `源节点 ${sourceIdentity || '(未声明 node key)'} 不在目标输入端口 ${targetPort.name} 白名单中`;
+        case 'TARGET_NODE_NOT_ALLOWED':
+            return `目标节点 ${targetIdentity || '(未声明 node key)'} 不在源输出端口 ${sourcePort.name} 白名单中`;
+        default:
+            return code;
+    }
+}
+function countPortConnections(edges, nodeId, portName, side) {
+    return edges.filter((edge) => {
+        if (side === 'source') {
+            return edge.source === nodeId && (edge.sourceHandle || exports.DEFAULT_PORT_TYPE) === portName;
+        }
+        return (edge.target === nodeId &&
+            (edge.targetHandle || exports.DEFAULT_PORT_TYPE) === portName &&
+            // 自环边（source === target，如 auto_connections 声明的 retry -> main）
+            // 不占 target 端口 max_connections 名额
+            edge.source !== edge.target);
+    }).length;
+}
+async function resolveNodeSchemas(nodes) {
+    const entries = new Map();
+    const unresolved = [];
+    await Promise.all(nodes.map(async (node) => {
+        const nodeId = node.n_id || node.id;
+        const actionKey = node.action_key;
+        const actionVer = node.action_ver;
+        if (actionKey && actionVer !== undefined && actionVer !== null) {
+            // NodePackage 节点：远端 schema + switch 实例分支派生 + Loop/SelfLoop 自环兜底
+            let schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(actionKey), Number(actionVer));
+            if (!schema) {
+                unresolved.push({ nodeId, actionKey: String(actionKey), actionVer: Number(actionVer) });
+                return;
+            }
+            schema = (0, classicNodePorts_1.applySwitchBranchesToSchema)(schema, node);
+            entries.set(nodeId, {
+                nodeId,
+                schemaKey: schema.key,
+                inputs: (schema.inputs || []).map(normalizePort),
+                outputs: (schema.outputs || []).map(normalizePort),
+                autoConnect: (0, classicNodePorts_1.getAutoConnectRulesForNodeType)(node.node_type),
+            });
+            return;
+        }
+        // classic/legacy 节点：内置端口表（未知 node_type 跳过，避免误报）
+        const classic = (0, classicNodePorts_1.resolveClassicNodeSchema)(node);
+        if (classic) {
+            entries.set(nodeId, {
+                nodeId,
+                schemaKey: classic.schemaKey,
+                inputs: classic.inputs.map(normalizePort),
+                outputs: classic.outputs.map(normalizePort),
+                autoConnect: classic.autoConnect,
+            });
+        }
+    }));
+    return { entries, unresolved };
+}
+function validateEdge(edge, sourceEntry, targetEntry, allEdges) {
+    const violations = [];
+    const base = {
+        edgeId: edge.id,
+        sourceNodeId: edge.source,
+        targetNodeId: edge.target,
+        sourceHandle: edge.sourceHandle,
+        targetHandle: edge.targetHandle,
+    };
+    if (edge.source === edge.target) {
+        // 自环边须命中节点声明的 autoConnect 配对（如 LOOP 的 loop → input）才放行
+        const allowed = sourceEntry.autoConnect.some((rule) => rule.source === edge.sourceHandle && rule.target === edge.targetHandle);
+        if (!allowed) {
+            const hint = sourceEntry.autoConnect.length
+                ? `；允许的自环端口对: ${sourceEntry.autoConnect
+                    .map((rule) => `${rule.source} → ${rule.target}`)
+                    .join('、')}`
+                : '';
+            violations.push({
+                ...base,
+                code: 'SELF_CONNECTION_NOT_ALLOWED',
+                message: `节点 ${edge.source} 不能连接到自身${hint}`,
+            });
+            return violations;
+        }
+        // 命中 autoConnect：放行并继续端口存在性 / type / max 校验
+    }
+    const sourcePort = sourceEntry.outputs.find((p) => p.name === (edge.sourceHandle || exports.DEFAULT_PORT_TYPE));
+    if (!sourcePort) {
+        violations.push({
+            ...base,
+            code: 'SOURCE_PORT_NOT_FOUND',
+            message: `源节点不存在输出端口 ${displayHandle(edge.sourceHandle)}，可用输出端口: ${formatHandleList(sourceEntry.outputs)}`,
+        });
+        return violations;
+    }
+    const targetPort = targetEntry.inputs.find((p) => p.name === (edge.targetHandle || exports.DEFAULT_PORT_TYPE));
+    if (!targetPort) {
+        violations.push({
+            ...base,
+            code: 'TARGET_PORT_NOT_FOUND',
+            message: `目标节点不存在输入端口 ${displayHandle(edge.targetHandle)}，可用输入端口: ${formatHandleList(targetEntry.inputs)}`,
+        });
+        return violations;
+    }
+    const ruleCode = checkPortRules(sourcePort, targetPort, sourceEntry.schemaKey, targetEntry.schemaKey);
+    if (ruleCode) {
+        violations.push({
+            ...base,
+            code: ruleCode,
+            message: describeRuleViolation(ruleCode, sourcePort, targetPort, sourceEntry.schemaKey, targetEntry.schemaKey),
+        });
+    }
+    // max_connections：按端口维度聚合已有边数量（校验当前 flow 全量边）
+    if (sourcePort.maxConnections !== null) {
+        const count = countPortConnections(allEdges, edge.source, sourcePort.name, 'source');
+        if (count > sourcePort.maxConnections) {
+            violations.push({
+                ...base,
+                code: 'SOURCE_MAX_CONNECTIONS_EXCEEDED',
+                message: `源输出端口 ${sourcePort.name} 连接数 ${count} 超过上限 ${sourcePort.maxConnections}`,
+            });
+        }
+    }
+    if (targetPort.maxConnections !== null) {
+        const count = countPortConnections(allEdges, edge.target, targetPort.name, 'target');
+        if (count > targetPort.maxConnections) {
+            violations.push({
+                ...base,
+                code: 'TARGET_MAX_CONNECTIONS_EXCEEDED',
+                message: `目标输入端口 ${targetPort.name} 连接数 ${count} 超过上限 ${targetPort.maxConnections}`,
+            });
+        }
+    }
+    return violations;
+}
+function validateRequiredInputs(entries, edges) {
+    const violations = [];
+    const connected = new Set(edges.map((e) => `${e.target}::${e.targetHandle || exports.DEFAULT_PORT_TYPE}`));
+    for (const entry of entries.values()) {
+        for (const port of entry.inputs) {
+            if (port.required && !connected.has(`${entry.nodeId}::${port.name}`)) {
+                violations.push({
+                    code: 'REQUIRED_INPUT_NOT_CONNECTED',
+                    message: `节点 ${entry.nodeId} 的必需输入端口 ${port.name} 没有连线`,
+                    targetNodeId: entry.nodeId,
+                    targetHandle: port.name,
+                });
+            }
+        }
+    }
+    return violations;
+}
+/**
+ * 对 flow 全量 nodes + edges 做 node_schema 端口级校验。
+ *
+ * classic 节点（无 action_key/action_ver）按内置端口表（classicNodePorts）参与校验，
+ * 未知 node_type 的 legacy 节点跳过；NodePackage schema 拉取失败记入 unresolvedNodes 并跳过。
+ */
+async function validateFlowPorts(input) {
+    const { entries, unresolved } = await resolveNodeSchemas(input.nodes);
+    const violations = [];
+    for (const edge of input.edges) {
+        const sourceEntry = entries.get(edge.source);
+        const targetEntry = entries.get(edge.target);
+        // 只有两端都有 node_schema 时才做端口级校验（legacy 端跳过，避免误报）
+        if (sourceEntry && targetEntry) {
+            violations.push(...validateEdge(edge, sourceEntry, targetEntry, input.edges));
+        }
+    }
+    violations.push(...validateRequiredInputs(entries, input.edges));
+    return {
+        violations,
+        checkedNodeCount: entries.size,
+        unresolvedNodes: unresolved,
+    };
+}
+/**
+ * 单边预检：校验一条准备创建的边（尚未加入现有 edges）。
+ * 两端均可解析端口（NodePackage schema 或 classic 内置表）时才校验；
+ * 任一端为未知 node_type 的 legacy 节点返回空数组。
+ */
+async function validateSingleEdge(input) {
+    const { entries } = await resolveNodeSchemas(input.nodes);
+    const sourceEntry = entries.get(input.newEdge.source);
+    const targetEntry = entries.get(input.newEdge.target);
+    if (!sourceEntry || !targetEntry) {
+        return [];
+    }
+    const edge = {
+        id: '(new-edge)',
+        source: input.newEdge.source,
+        target: input.newEdge.target,
+        sourceHandle: input.newEdge.sourceHandle,
+        targetHandle: input.newEdge.targetHandle,
+    };
+    return validateEdge(edge, sourceEntry, targetEntry, [...input.existingEdges, edge]);
+}
+//# sourceMappingURL=portValidator.js.map