fix(subgraph): avoid positional bypass links

src/lib/litegraph/src/subgraph/ExecutableNodeDTO.test.ts

@@ -11,6 +11,7 @@ import { toNodeId } from '@/types/nodeId'
 
 import {
   createNestedSubgraphs,
+  createTestRootGraph,
   createTestSubgraph,
   createTestSubgraphNode,
   resetSubgraphFixtureState
@@ -361,6 +362,55 @@ describe('Bypass node output resolution', () => {
     expect(resolved).toBeDefined()
     expect(resolved?.node).toBe(upstreamDto)
   })
+
+  it('should not pair an unrelated subgraph input with a bypassed output', () => {
+    const rootGraph = createTestRootGraph()
+    const subgraph = createTestSubgraph({
+      rootGraph,
+      inputs: [{ name: 'input', type: 'IMAGE' }],
+      outputs: [{ name: 'output', type: 'IMAGE' }]
+    })
+    const subgraphNode = createTestSubgraphNode(subgraph, {
+      id: 1,
+      parentGraph: rootGraph
+    })
+    rootGraph.add(subgraphNode)
+
+    const unrelatedNode = new LGraphNode('Unrelated interior node')
+    unrelatedNode.addOutput('source', 'IMAGE')
+    subgraph.add(unrelatedNode)
+
+    const upstreamNode = new LGraphNode('Upstream')
+    upstreamNode.addOutput('image', 'IMAGE')
+    rootGraph.add(upstreamNode)
+    upstreamNode.connect(0, subgraphNode, 0)
+
+    const nodesByExecutionId = new Map()
+    const upstreamDto = new ExecutableNodeDTO(
+      upstreamNode,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    const subgraphDto = new ExecutableNodeDTO(
+      subgraphNode,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    nodesByExecutionId.set(upstreamDto.id, upstreamDto)
+    nodesByExecutionId.set(subgraphDto.id, subgraphDto)
+
+    subgraphNode.mode = LGraphEventMode.BYPASS
+    const warningSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const resolved = subgraphDto.resolveOutput(0, 'IMAGE', new Set())
+
+      expect(resolved).toBeUndefined()
+    } finally {
+      warningSpy.mockRestore()
+    }
+  })
 })
 
 describe('ALWAYS mode node output resolution', () => {

src/lib/litegraph/src/subgraph/ExecutableNodeDTO.ts

@@ -347,6 +347,10 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
    * @returns The index of the input slot on this node, otherwise `-1`.
    */
   private _getBypassSlotIndex(slot: number, type: ISlotType) {
+    if (this.node.isSubgraphNode()) {
+      return this._getSubgraphBypassSlotIndex(slot, type)
+    }
+
     const { inputs } = this
     const oppositeInput = inputs[slot]
     const outputType = this.node.outputs[slot].type
@@ -377,6 +381,32 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
     )
   }
 
+  /**
+   * Subgraph inputs and outputs are independent boundary slots, so their
+   * positions cannot establish a bypass relationship.  Only an output wired
+   * directly to a subgraph input inside the subgraph can be bypassed to that
+   * input; outputs produced by interior nodes have no safe external shortcut.
+   */
+  private _getSubgraphBypassSlotIndex(slot: number, type: ISlotType) {
+    const { node } = this
+    if (!node.isSubgraphNode()) return -1
+
+    const output = node.outputs.at(slot)
+    if (!output) return -1
+
+    const innerLink = node.resolveSubgraphOutputLink(slot)
+    if (!innerLink?.subgraphInput) return -1
+
+    const inputSlot = innerLink.link.origin_slot
+    const input = this.inputs.at(inputSlot)
+    if (!input) return -1
+
+    return LiteGraph.isValidConnection(input.type, output.type) &&
+      LiteGraph.isValidConnection(input.type, type)
+      ? inputSlot
+      : -1
+  }
+
   /**
    * Resolves the link inside a subgraph node, from the subgraph IO node to the node inside the subgraph.
    * @param slot The slot index of the output on the subgraph node.