test: add failing e2e repro for FE-1539 subgraph unpack boundary links

browser_tests/fixtures/helpers/SubgraphHelper.ts

@@ -373,6 +373,15 @@ export class SubgraphHelper {
       .then((m) => m.clickMenuItemExact(`Un-Promote Widget: ${widgetName}`))
   }
 
+  async unpackViaContextMenu(nodeTitle: string): Promise<void> {
+    const node = this.comfyPage.vueNodes.getNodeByTitle(nodeTitle)
+    const fixture = await this.comfyPage.vueNodes.getFixtureByTitle(nodeTitle)
+    await this.comfyPage.contextMenu.openForVueNode(fixture.header)
+    await this.comfyPage.contextMenu.clickMenuItemExact('Unpack Subgraph')
+    await expect(node).toHaveCount(0)
+    await this.comfyPage.nextFrame()
+  }
+
   async enterSubgraphWithFallback(nodeId: string): Promise<void> {
     const targetNodeId = parseNodeId(nodeId)
     if (!targetNodeId) {

browser_tests/tests/subgraph/subgraphUnpackUnconnectedInput.spec.ts

@@ -0,0 +1,80 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
+import { SubgraphHelper } from '@e2e/fixtures/helpers/SubgraphHelper'
+
+test.describe(
+  'Subgraph unpack with unconnected input slots',
+  { tag: ['@subgraph', '@vue-nodes'] },
+  () => {
+    const SUBGRAPH_NODE_TITLE = 'New Subgraph'
+    const CLIP_TEXT_ENCODE_TITLE = 'CLIP Text Encode (Prompt)'
+    const MISSING_LINK_ID_ERROR = 'Missing Link ID when unpacking'
+    const PROMPT_TEXT = 'a painting of a hedgehog'
+
+    test.beforeEach(async ({ comfyPage }) => {
+      await comfyPage.workflow.loadWorkflow(
+        'subgraphs/subgraph-with-promoted-text-widget'
+      )
+      await expect(
+        comfyPage.vueNodes.getNodeByTitle(SUBGRAPH_NODE_TITLE)
+      ).toBeVisible()
+    })
+
+    test('does not log "Missing Link ID" for boundary links whose host input is unconnected', async ({
+      comfyPage
+    }) => {
+      const { warnings, dispose } = SubgraphHelper.collectConsoleWarnings(
+        comfyPage.page,
+        [MISSING_LINK_ID_ERROR]
+      )
+
+      try {
+        await comfyPage.subgraph.unpackViaContextMenu(SUBGRAPH_NODE_TITLE)
+        expect(warnings).toEqual([])
+      } finally {
+        dispose()
+      }
+    })
+
+    test('keeps the promoted widget value when the host input is unconnected', async ({
+      comfyPage
+    }) => {
+      const promotedText = comfyPage.vueNodes.getWidgetByName(
+        SUBGRAPH_NODE_TITLE,
+        'text'
+      )
+      await promotedText.fill(PROMPT_TEXT)
+      await promotedText.blur()
+      await expect(promotedText).toHaveValue(PROMPT_TEXT)
+
+      await comfyPage.subgraph.unpackViaContextMenu(SUBGRAPH_NODE_TITLE)
+
+      await expect(
+        comfyPage.vueNodes.getWidgetByName(CLIP_TEXT_ENCODE_TITLE, 'text')
+      ).toHaveValue(PROMPT_TEXT)
+    })
+
+    test('restores the promoted widget value when the unpack is undone', async ({
+      comfyPage
+    }) => {
+      const promotedText = comfyPage.vueNodes.getWidgetByName(
+        SUBGRAPH_NODE_TITLE,
+        'text'
+      )
+      await promotedText.fill(PROMPT_TEXT)
+      await promotedText.blur()
+      await expect(promotedText).toHaveValue(PROMPT_TEXT)
+
+      await comfyPage.subgraph.unpackViaContextMenu(SUBGRAPH_NODE_TITLE)
+      await comfyPage.keyboard.undo()
+
+      await expect(
+        comfyPage.vueNodes.getNodeByTitle(SUBGRAPH_NODE_TITLE)
+      ).toBeVisible()
+      await expect(
+        comfyPage.vueNodes.getWidgetByName(SUBGRAPH_NODE_TITLE, 'text')
+      ).toHaveValue(PROMPT_TEXT)
+    })
+  }
+)

src/core/graph/subgraph/adoptPromotedWidgetValue.ts

@@ -0,0 +1,30 @@
+import type { INodeInputSlot } from '@/lib/litegraph/src/interfaces'
+import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { isWidgetValue } from '@/lib/litegraph/src/types/widgets'
+import { useWidgetValueStore } from '@/stores/widgetValueStore'
+
+/**
+ * Copies a promoted host widget's value onto the interior widget it forwards to.
+ *
+ * A promoted input holds the user-facing value on the host subgraph node and
+ * never writes it through, so unpacking must move it or the edit is lost.
+ */
+export function adoptPromotedWidgetValue(
+  hostInput: INodeInputSlot,
+  targetNode: LGraphNode,
+  targetSlot: number
+): void {
+  const { widgetId } = hostInput
+  if (!widgetId) return
+
+  const value = useWidgetValueStore().getWidget(widgetId)?.value
+  if (value === undefined || !isWidgetValue(value)) return
+
+  const targetInput = targetNode.inputs.at(targetSlot)
+  if (!targetInput) return
+
+  const widget = targetNode.getWidgetFromSlot(targetInput)
+  if (!widget) return
+
+  widget.value = value
+}

src/lib/litegraph/src/LGraph.ts

@@ -1,5 +1,6 @@
 import { toString } from 'es-toolkit/compat'
 
+import { adoptPromotedWidgetValue } from '@/core/graph/subgraph/adoptPromotedWidgetValue'
 import {
   SUBGRAPH_INPUT_ID,
   SUBGRAPH_OUTPUT_ID
@@ -2083,11 +2084,19 @@ export class LGraph
     for (const [, link] of subgraphNode.subgraph._links) {
       let externalParentId: RerouteId | undefined
       if (link.origin_id === SUBGRAPH_INPUT_ID) {
-        const outerLinkId = subgraphNode.inputs[link.origin_slot].link
-        if (!outerLinkId) {
+        const hostInput = subgraphNode.inputs.at(link.origin_slot)
+        if (!hostInput) {
           console.error('Missing Link ID when unpacking')
           continue
         }
+        const outerLinkId = hostInput.link
+        if (outerLinkId == null) {
+          const interiorNode = this.getNodeById(nodeIdMap.get(link.target_id))
+          if (interiorNode) {
+            adoptPromotedWidgetValue(hostInput, interiorNode, link.target_slot)
+          }
+          continue
+        }
         const outerLink = this.links[outerLinkId]
         link.origin_id = outerLink.origin_id
         link.origin_slot = outerLink.origin_slot

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

@@ -1,11 +1,20 @@
-import { assert, beforeEach, describe, expect, it } from 'vitest'
+import {
+  assert,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  onTestFinished,
+  vi
+} from 'vitest'
 
 import {
   LGraphGroup,
   LGraphNode,
   LiteGraph
 } from '@/lib/litegraph/src/litegraph'
 import type { LGraph, ISlotType } from '@/lib/litegraph/src/litegraph'
+import { useWidgetValueStore } from '@/stores/widgetValueStore'
 
 import {
   createTestSubgraph,
@@ -200,5 +209,93 @@ describe('SubgraphConversion', () => {
       }
       expect(linkRefCount).toBe(4)
     })
+
+    describe('Unconnected boundary inputs', () => {
+      const PROMOTED_TEXT_TYPE = 'Fixture/PromotedText'
+
+      class PromotedTextNode extends LGraphNode {
+        constructor() {
+          super('PromotedText')
+          this.serialize_widgets = true
+          const input = this.addInput('text', 'STRING')
+          input.widget = { name: 'text' }
+          this.addWidget('text', 'text', 'stale interior value', () => {})
+        }
+      }
+
+      function createPromotedTextSubgraph() {
+        LiteGraph.registered_node_types[PROMOTED_TEXT_TYPE] = PromotedTextNode
+        onTestFinished(() => {
+          delete LiteGraph.registered_node_types[PROMOTED_TEXT_TYPE]
+        })
+
+        const subgraph = createTestSubgraph({
+          inputs: [{ name: 'text', type: 'STRING' }]
+        })
+        const subgraphNode = createTestSubgraphNode(subgraph)
+        const graph = subgraphNode.graph!
+        graph.add(subgraphNode)
+
+        const inner = LiteGraph.createNode(PROMOTED_TEXT_TYPE)
+        assert(inner)
+        subgraph.add(inner)
+        subgraph.inputNode.slots[0].connect(inner.inputs[0], inner)
+
+        const { widgetId } = subgraphNode.inputs[0]
+        assert(widgetId)
+        return { graph, subgraphNode, hostWidgetId: widgetId }
+      }
+
+      it('Should not report a missing link for a promoted widget input', () => {
+        const { graph, subgraphNode } = createPromotedTextSubgraph()
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+        graph.unpackSubgraph(subgraphNode)
+
+        expect(errorSpy).not.toHaveBeenCalled()
+      })
+
+      it('Should hand the promoted host value to the interior widget', () => {
+        const { graph, subgraphNode, hostWidgetId } =
+          createPromotedTextSubgraph()
+        useWidgetValueStore().setValue(hostWidgetId, 'host edit')
+
+        graph.unpackSubgraph(subgraphNode)
+
+        const unpacked = graph.nodes.find(
+          (node) => node.type === PROMOTED_TEXT_TYPE
+        )
+        expect(unpacked?.widgets?.[0].value).toBe('host edit')
+      })
+
+      it('Should leave the interior value alone when the host has no value', () => {
+        const { graph, subgraphNode } = createPromotedTextSubgraph()
+
+        graph.unpackSubgraph(subgraphNode)
+
+        const unpacked = graph.nodes.find(
+          (node) => node.type === PROMOTED_TEXT_TYPE
+        )
+        expect(unpacked?.widgets?.[0].value).toBe('stale interior value')
+      })
+
+      it('Should not report a missing link for an unconnected plain input', () => {
+        const subgraph = createTestSubgraph({
+          inputs: [{ name: 'value', type: 'number' }]
+        })
+        const subgraphNode = createTestSubgraphNode(subgraph)
+        const graph = subgraphNode.graph!
+        graph.add(subgraphNode)
+
+        const inner = createNode(subgraph, ['number'])
+        subgraph.inputNode.slots[0].connect(inner.inputs[0], inner)
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+        graph.unpackSubgraph(subgraphNode)
+
+        expect(errorSpy).not.toHaveBeenCalled()
+        expect(graph.nodes.length).toBe(1)
+      })
+    })
   })
 })