fix: show promoted advanced widgets on ECS (#15423)

## Summary

Forward-ports the promoted advanced-widget visibility invariant from
#14647 to the store-backed ECS rendering path.

Promoted host inputs are user-selected public controls and bypass only
the advanced-widget filter. Explicitly hidden widgets remain hidden.

## Red-green verification

- `4e2084d8a0` adds canvas and App Mode regressions; both fail on the
ECS base because visibility only recognizes external links.
- `796648dcae` derives promotion from the host input's canonical
`widgetId`; all regressions pass.

## Test plan

- [x] Confirm canvas regression fails before the fix
- [x] Confirm App Mode regression fails before the fix
- [x] Confirm targeted unit suite passes after the fix (39 tests)
- [x] Run typecheck, lint, and format checks

---------

Co-authored-by: Amp <amp@ampcode.com>

Author: christian-byrne

browser_tests/tests/subgraph/subgraphPromotion.spec.ts

@@ -94,6 +94,63 @@ test.describe(
       'Promoted Widget Visibility in Vue Mode',
       { tag: ['@vue-nodes'] },
       () => {
+        test(
+          'Promoted advanced widget remains visible when global advanced widgets are disabled',
+          { tag: ['@node'] },
+          async ({ comfyPage }) => {
+            const subgraphNodeId =
+              await test.step('Convert a node with hidden advanced widgets to a subgraph', async () => {
+                await comfyPage.settings.setSetting(
+                  'Comfy.Node.AlwaysShowAdvancedWidgets',
+                  false
+                )
+                const modelSamplingNode = await comfyPage.nodeOps.addNode(
+                  'ModelSamplingFlux',
+                  {},
+                  { x: 500, y: 200 }
+                )
+                await comfyPage.nextFrame()
+                await expect(
+                  comfyPage.vueNodes.getNodeLocator(
+                    String(modelSamplingNode.id)
+                  )
+                ).toBeVisible()
+
+                await modelSamplingNode.click('title')
+                const subgraphNode = await modelSamplingNode.convertToSubgraph()
+                return String(subgraphNode.id)
+              })
+
+            await test.step('Promote an advanced interior widget', async () => {
+              await comfyPage.vueNodes.enterSubgraph(subgraphNodeId)
+              const interiorNode =
+                comfyPage.vueNodes.getNodeByTitle('ModelSamplingFlux')
+              await expect(interiorNode).toBeVisible()
+              await interiorNode
+                .getByText('Show advanced inputs', { exact: true })
+                .click()
+              await expect(
+                interiorNode.getByLabel('max_shift', { exact: true })
+              ).toBeVisible()
+              await comfyPage.subgraph.promoteWidget(interiorNode, 'max_shift')
+              await comfyPage.subgraph.exitViaBreadcrumb()
+            })
+
+            await test.step('Keep the promoted widget visible on the host', async () => {
+              await expectPromotedWidgetNamesToContain(
+                comfyPage,
+                subgraphNodeId,
+                'max_shift'
+              )
+              await expect(
+                comfyPage.vueNodes
+                  .getNodeLocator(subgraphNodeId)
+                  .getByLabel('max_shift', { exact: true })
+              ).toBeVisible()
+            })
+          }
+        )
+
         test('Promoted text widget renders and enters the subgraph in Vue mode', async ({
           comfyPage
         }) => {

src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts

@@ -278,12 +278,16 @@ describe('promoted subgraph widgets', () => {
     cleanupComplexPromotionFixtureNodeType()
   })
 
-  function processHostWidget(graph: LGraph, hostNode: SubgraphNode) {
+  function processHostWidget(
+    graph: LGraph,
+    hostNode: SubgraphNode,
+    explicitWidgetIds = true
+  ) {
     const id = hostNode.widgets[0]?.widgetId
     if (!id) throw new Error('Expected the promoted host widget to be keyed')
     return computeProcessedWidgets({
       nodeData: hostNode._state,
-      widgetIds: [id],
+      widgetIds: explicitWidgetIds ? [id] : undefined,
       graphId: graph.id,
       showAdvanced: false,
       isGraphReady: true,
@@ -292,6 +296,17 @@ describe('promoted subgraph widgets', () => {
     })[0]
   }
 
+  function setHostWidgetOptions(
+    hostNode: SubgraphNode,
+    options: IBaseWidget['options']
+  ) {
+    const id = hostNode.widgets[0]?.widgetId
+    if (!id) throw new Error('Expected the promoted host widget to be keyed')
+    if (!useWidgetValueStore().updateOptions(id, options)) {
+      throw new Error('Expected promoted host widget state')
+    }
+  }
+
   function recordInteriorError() {
     useExecutionErrorStore().recordNodeErrors({
       [SOURCE_EXECUTION_ID]: {
@@ -324,6 +339,24 @@ describe('promoted subgraph widgets', () => {
     )
   })
 
+  it.for([
+    ['shows on the node canvas', { advanced: true }, false, true],
+    ['shows when selected in App Mode', { advanced: true }, true, true],
+    [
+      'stays hidden when explicitly hidden',
+      { advanced: true, hidden: true },
+      true,
+      false
+    ]
+  ] as const)('%s', ([, options, explicitWidgetIds, visible]) => {
+    const { graph, hostNode } = setupComplexPromotionFixture()
+    setHostWidgetOptions(hostNode, options)
+
+    expect(processHostWidget(graph, hostNode, explicitWidgetIds).visible).toBe(
+      visible
+    )
+  })
+
   it('clears errors on both the interior source and the host', () => {
     const { graph, hostNode } = setupComplexPromotionFixture()
     recordInteriorError()

src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts

@@ -146,6 +146,7 @@ function buildSlotMetadata(
       originOutputName: link
         ? originNode?.outputs?.[link.originSlot]?.name
         : undefined,
+      promoted: input.widgetId !== undefined,
       type: String(input.type)
     }
     if (input.name) metadata.set(input.name, slotInfo)
@@ -166,11 +167,11 @@ function getHostNode(
 function isWidgetVisible(
   options: IWidgetOptions,
   showAdvanced: boolean,
-  linked = false
+  ignoreAdvanced = false
 ): boolean {
   const hidden = options.hidden ?? false
   const advanced = options.advanced ?? false
-  return !hidden && (!advanced || showAdvanced || linked)
+  return !hidden && (!advanced || showAdvanced || ignoreAdvanced)
 }
 
 function hasWidgetError(
@@ -375,7 +376,11 @@ function processWidget(
     )
 
   const slotInfo = ctx.slotMetadata.get(widgetState.name)
-  const visible = isWidgetVisible(options, ctx.showAdvanced, slotInfo?.linked)
+  const visible = isWidgetVisible(
+    options,
+    ctx.showAdvanced,
+    slotInfo?.linked || slotInfo?.promoted
+  )
   const isDisabled = slotInfo?.linked || widgetState.disabled
   const widgetOptions = isDisabled ? { ...options, disabled: true } : options
   const value = widgetState.value as WidgetValue

src/renderer/extensions/vueNodes/types/widgetGrid.ts

@@ -10,6 +10,7 @@ export interface WidgetSlotMetadata {
   linked: boolean
   originNodeId?: NodeId
   originOutputName?: string
+  promoted: boolean
   type: string
 }
 

src/stores/widgetValueStore.test.ts

@@ -230,6 +230,24 @@ describe('useWidgetValueStore', () => {
       ).toBe(false)
     })
 
+    it('updateOptions preserves existing options and reports missing widgets', () => {
+      const store = useWidgetValueStore()
+      store.registerWidget(
+        seedA,
+        state('number', 100, { options: { min: 0, max: 10 } })
+      )
+
+      expect(store.updateOptions(seedA, { advanced: true })).toBe(true)
+      expect(store.getWidget(seedA)?.options).toEqual({
+        min: 0,
+        max: 10,
+        advanced: true
+      })
+      expect(
+        store.updateOptions(widgetId(graphA, toNodeId('missing'), 'seed'), {})
+      ).toBe(false)
+    })
+
     it('deleteWidget removes registered widgets from node order', () => {
       const store = useWidgetValueStore()
       const steps = widgetId(graphA, toNodeId('node-1'), 'steps')

src/stores/widgetValueStore.ts

@@ -157,6 +157,16 @@ export const useWidgetValueStore = defineStore('widgetValue', () => {
     return true
   }
 
+  function updateOptions(
+    widgetId: WidgetId,
+    options: Partial<WidgetState['options']>
+  ): boolean {
+    const state = getWidget(widgetId)
+    if (!state) return false
+    state.options = { ...state.options, ...options }
+    return true
+  }
+
   function deleteWidget(widgetId: WidgetId): boolean {
     if (!isWidgetId(widgetId)) return false
 
@@ -241,6 +251,7 @@ export const useWidgetValueStore = defineStore('widgetValue', () => {
     getWidget,
     getWidgetRenderState,
     setValue,
+    updateOptions,
     deleteWidget,
     getNodeWidgets,
     getNodeWidgetIds,