Method resolveInput

src/subgraph/ExecutableNodeDTO.ts:132–194

* Resolves the executable node & link IDs for a given input slot. * @param slot The slot index of the input. * @param visited Leave empty unless overriding this method. * A set of unique IDs, used to guard against infinite recursion. * If overriding, ensure that the set is passed on all

(slot: number, visited = new Set<string>())

   * @returns The node and the origin ID / slot index of the output.
   */
  resolveInput(slot: number, visited = new Set<string>()): ResolvedInput | undefined {
    const uniqueId = `${this.subgraphNode?.subgraph.id}:${this.node.id}[I]${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 input ${slot} of node ${nodeInfo}${pathInfo}. ` +
        `This creates an infinite loop in link resolution. UniqueID: [${uniqueId}]`,
      )
    }
    visited.add(uniqueId)

    const input = this.inputs.at(slot)
    if (!input) throw new SlotIndexError(`No input found for flattened id [${this.id}] slot [${slot}]`)

    // Nothing connected
    if (input.linkId == null) return

    const link = this.graph.getLink(input.linkId)
    if (!link) throw new InvalidLinkError(`No link found in parent graph for id [${this.id}] slot [${slot}] ${input.name}`)

    const { subgraphNode } = this

    // Link goes up and out of this subgraph
    if (subgraphNode && link.originIsIoNode) {
      const subgraphNodeInput = subgraphNode.inputs.at(link.origin_slot)
      if (!subgraphNodeInput) throw new SlotIndexError(`No input found for slot [${link.origin_slot}] ${input.name}`)

      // Nothing connected
      const linkId = subgraphNodeInput.link
      if (linkId == null) {
        const widget = subgraphNode.getWidgetFromSlot(subgraphNodeInput)
        if (!widget) return

        // Special case: SubgraphNode widget.
        return {
          node: this,
          origin_id: this.id,
          origin_slot: -1,
          widgetInfo: { value: widget.value },
        }
      }

      const outerLink = subgraphNode.graph.getLink(linkId)
      if (!outerLink) throw new InvalidLinkError(`No outer link found for slot [${link.origin_slot}] ${input.name}`)

      const subgraphNodeExecutionId = this.subgraphNodePath.join(":")
      const subgraphNodeDto = this.nodesByExecutionId.get(subgraphNodeExecutionId)
      if (!subgraphNodeDto) throw new Error(`No subgraph node DTO found for id [${subgraphNodeExecutionId}]`)

      return subgraphNodeDto.resolveInput(outerLink.target_slot, visited)
    }

    // Not part of a subgraph; use the original link
    const outputNode = this.graph.getNodeById(link.origin_id)
    if (!outputNode) throw new InvalidLinkError(`No input node found for id [${this.id}] slot [${slot}] ${input.name}`)

    const outputNodeExecutionId = [...this.subgraphNodePath, outputNode.id].join(":")