Method resolveOutput

src/subgraph/ExecutableNodeDTO.ts:203–263

* Determines whether this output is a valid endpoint for a link (non-virtual, non-bypass). * @param slot The slot index of the output. * @param type The type of the input * @param visited A set of unique IDs to guard against infinite recursion. See resolveInput. * @returns The no

(slot: number, type: ISlotType, visited: Set<string>)

   * @returns The node and the origin ID / slot index of the output.
   */
  resolveOutput(slot: number, type: ISlotType, visited: Set<string>): ResolvedInput | undefined {
    const uniqueId = `${this.subgraphNode?.subgraph.id}:${this.node.id}[O]${slot}`
    if (visited.has(uniqueId)) {
      const nodeInfo = `${this.node.id}${this.node.title ? ` (${this.node.title})` : ""}`
      const pathInfo = this.subgraphNodePath.length > 0 ? ` at path ${this.subgraphNodePath.join(":")}` : ""
      throw new RecursionError(
        `Circular reference detected while resolving output ${slot} of node ${nodeInfo}${pathInfo}. ` +
        `This creates an infinite loop in link resolution. UniqueID: [${uniqueId}]`,
      )
    }
    visited.add(uniqueId)

    // Upstreamed: Bypass nodes are bypassed using the first input with matching type
    if (this.mode === LGraphEventMode.BYPASS) {
      const { inputs } = this

      // Bypass nodes by finding first input with matching type
      const parentInputIndexes = Object.keys(inputs).map(Number)
      // Prioritise exact slot index
      const indexes = [slot, ...parentInputIndexes]
      const matchingIndex = indexes.find(i => inputs[i]?.type === type)

      // No input types match
      if (matchingIndex === undefined) {
        console.debug(`[ExecutableNodeDTO.resolveOutput] No input types match type [${type}] for id [${this.id}] slot [${slot}]`, this)
        return
      }

      return this.resolveInput(matchingIndex, visited)
    }

    const { node } = this
    if (node.isSubgraphNode()) return this.#resolveSubgraphOutput(slot, type, visited)

    // Upstreamed: Other virtual nodes are bypassed using the same input/output index (slots must match)
    if (node.isVirtualNode) {
      if (this.inputs.at(slot)) return this.resolveInput(slot, visited)

      // Fallback check for nodes performing link redirection
      const virtualLink = this.node.getInputLink(slot)
      if (virtualLink) {
        const outputNode = this.graph.getNodeById(virtualLink.origin_id)
        if (!outputNode) throw new InvalidLinkError(`Virtual node failed to resolve parent [${this.id}] slot [${slot}]`)

        const outputNodeExecutionId = [...this.subgraphNodePath, outputNode.id].join(":")
        const outputNodeDto = this.nodesByExecutionId.get(outputNodeExecutionId)
        if (!outputNodeDto) throw new Error(`No output node DTO found for id [${outputNode.id}]`)

        return outputNodeDto.resolveOutput(virtualLink.origin_slot, type, visited)
      }

      // Virtual nodes without a matching input should be discarded.
      return
    }

    return {
      node: this,
      origin_id: this.id,