From 88874e0bd8f2c021a398eda42929c901db429893 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 02:41:24 +0900
Subject: [PATCH 01/18] fix: hide local values for linked standard widgets

---
 .../widgets/linked_multiline_string.json      |  72 +++++++
 browser_tests/fixtures/selectors.ts           |   2 +
 .../widgets/int/integerWidget.spec.ts         |  47 +++--
 .../text/multilineStringWidget.spec.ts        |  49 +++++
 src/locales/en/main.json                      |   1 +
 .../vueNodes/components/NodeWidgets.test.ts   |  99 +++++++++-
 .../vueNodes/components/NodeWidgets.vue       |  81 ++++++--
 .../composables/useProcessedWidgets.test.ts   | 177 +++++++++++++++++-
 .../composables/useProcessedWidgets.ts        |  40 +++-
 .../composables/useWidgetRenderer.test.ts     |  52 +++++
 .../widgets/registry/widgetRegistry.ts        |  20 ++
 11 files changed, 596 insertions(+), 44 deletions(-)
 create mode 100644 browser_tests/assets/widgets/linked_multiline_string.json

diff --git a/browser_tests/assets/widgets/linked_multiline_string.json b/browser_tests/assets/widgets/linked_multiline_string.json
new file mode 100644
index 00000000000..87573f64630
--- /dev/null
+++ b/browser_tests/assets/widgets/linked_multiline_string.json
@@ -0,0 +1,72 @@
+{
+  "last_node_id": 2,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "CLIPTextEncode",
+      "pos": [440, 80],
+      "size": [520, 280],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": null
+        },
+        {
+          "name": "text",
+          "type": "STRING",
+          "widget": {
+            "name": "text"
+          },
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": ["stale local prompt"]
+    },
+    {
+      "id": 2,
+      "type": "PrimitiveString",
+      "pos": [40, 120],
+      "size": [315, 58],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [1]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PrimitiveString"
+      },
+      "widgets_values": ["authoritative upstream prompt"]
+    }
+  ],
+  "links": [[1, 2, 0, 1, 1, "STRING"]],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "offset": [0, 0],
+      "scale": 1
+    }
+  },
+  "version": 0.4
+}
diff --git a/browser_tests/fixtures/selectors.ts b/browser_tests/fixtures/selectors.ts
index b4138bf547f..b6489597c3a 100644
--- a/browser_tests/fixtures/selectors.ts
+++ b/browser_tests/fixtures/selectors.ts
@@ -168,6 +168,8 @@ export const TestIds = {
   widgets: {
     container: 'node-widgets',
     widget: 'node-widget',
+    linkedContent: 'linked-widget-content',
+    linkedPlaceholder: 'linked-widget-placeholder',
     layoutFieldLabel: 'widget-layout-field-label',
     formDropdownMenu: 'form-dropdown-menu',
     decrement: 'decrement',
diff --git a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
index 985d9f17d05..46099ec7ad3 100644
--- a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
@@ -2,41 +2,56 @@ import {
   comfyExpect as expect,
   comfyPageFixture as test
 } from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
 
 test.describe('Vue Integer Widget', { tag: '@vue-nodes' }, () => {
-  test('should be disabled and not allow changing value when link connected to slot', async ({
+  test('should hide a linked value and restore the control after disconnect', async ({
     comfyPage
   }) => {
     await comfyPage.workflow.loadWorkflow('vueNodes/linked-int-widget')
 
-    const seedWidget = comfyPage.vueNodes
-      .getWidgetByName('KSampler', 'seed')
-      .first()
-    const controls = comfyPage.vueNodes.getInputNumberControls(seedWidget)
-    const initialValue = Number(await controls.input.inputValue())
-
-    // Verify widget is disabled when linked
-    await expect(controls.incrementButton).toBeDisabled()
-    await expect(controls.decrementButton).toBeDisabled()
-    await expect(controls.input).toHaveValue(initialValue.toString())
+    const samplerNode = comfyPage.vueNodes.getNodeByTitle('KSampler').first()
+    const placeholder = samplerNode.getByTestId(
+      TestIds.widgets.linkedPlaceholder
+    )
+    const linkedContent = samplerNode.getByTestId(TestIds.widgets.linkedContent)
+    const nodeBounds = await samplerNode.boundingBox()
+    const [samplerNodeRef] =
+      await comfyPage.nodeOps.getNodeRefsByType('KSampler')
+    if (!samplerNodeRef || !nodeBounds) {
+      throw new Error('Linked KSampler node did not render')
+    }
+    const seedWidgetRef = await samplerNodeRef.getWidgetByName('seed')
+    const initialValue = Number(await seedWidgetRef.getValue())
 
-    await expect(seedWidget).toBeVisible()
+    await expect(placeholder).toHaveAccessibleName('seed: Linked input')
+    await expect(linkedContent).toHaveAttribute('inert', '')
+    await expect(
+      samplerNode.getByRole('spinbutton', { name: 'seed' })
+    ).toHaveCount(0)
+    await placeholder.click()
+    await expect.poll(() => seedWidgetRef.getValue()).toBe(initialValue)
 
-    // Delete the node that is linked to the slot (freeing up the widget)
-    // Click on the header to select the node (clicking center may land on
-    // the widget area where pointerdown.stop prevents node selection)
     await comfyPage.vueNodes
       .getNodeByTitle('Int')
       .locator('.lg-node-header')
       .click()
     await comfyPage.vueNodes.deleteSelected()
 
-    // Test widget works when unlinked
+    await expect(placeholder).toHaveCount(0)
+    const seedWidget = comfyPage.vueNodes
+      .getWidgetByName('KSampler', 'seed')
+      .first()
+    const controls = comfyPage.vueNodes.getInputNumberControls(seedWidget)
+    await expect(controls.input).toHaveValue(initialValue.toString())
     await controls.incrementButton.click()
     await expect(controls.input).toHaveValue((initialValue + 1).toString())
 
     await controls.decrementButton.click()
     await expect(controls.input).toHaveValue(initialValue.toString())
+    await expect
+      .poll(async () => (await samplerNode.boundingBox())?.height)
+      .toBe(nodeBounds.height)
   })
 
   test('displays control widgets with default state', async ({ comfyPage }) => {
diff --git a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
index 61b9c9131e9..a2d32f508c2 100644
--- a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
@@ -3,6 +3,7 @@ import {
   comfyPageFixture as test
 } from '@e2e/fixtures/ComfyPage'
 import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
 
 test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
   test.afterEach(async ({ comfyPage }) => {
@@ -46,6 +47,54 @@ test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
     await expect(textarea).toHaveValue('Keep me around')
   })
 
+  test('hides a linked core prompt without changing node geometry', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('widgets/linked_multiline_string')
+
+    const clipNode = getFirstClipNode(comfyPage)
+    const placeholder = clipNode.getByTestId(TestIds.widgets.linkedPlaceholder)
+    const linkedContent = clipNode.getByTestId(TestIds.widgets.linkedContent)
+    const hiddenTextarea = clipNode.locator('textarea')
+    const nodeBounds = await clipNode.boundingBox()
+
+    await expect(placeholder).toHaveAttribute(
+      'data-linked-display',
+      'expanding'
+    )
+    await expect(placeholder).toHaveAccessibleName('text: Linked input')
+    await expect(linkedContent).toHaveAttribute('inert', '')
+    await expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
+    await expect(clipNode.getByRole('textbox', { name: 'text' })).toHaveCount(0)
+    await expect(hiddenTextarea).toHaveValue('stale local prompt')
+
+    await hiddenTextarea.evaluate((element) => element.focus())
+    await expect
+      .poll(() =>
+        hiddenTextarea.evaluate((element) => document.activeElement === element)
+      )
+      .toBe(false)
+
+    const [clipNodeRef] =
+      await comfyPage.nodeOps.getNodeRefsByType('CLIPTextEncode')
+    if (!clipNodeRef || !nodeBounds) {
+      throw new Error('Linked CLIPTextEncode node did not render')
+    }
+    const textInput = await clipNodeRef.getInput(1)
+    await textInput.removeLinks()
+    await comfyPage.nextFrame()
+
+    await expect(placeholder).toHaveCount(0)
+    const restoredTextarea = getFirstMultilineStringWidget(comfyPage)
+    await expect(restoredTextarea).toBeVisible()
+    await expect(restoredTextarea).toHaveValue('stale local prompt')
+    await restoredTextarea.fill('restored local prompt')
+    await expect(restoredTextarea).toHaveValue('restored local prompt')
+    await expect
+      .poll(async () => (await clipNode.boundingBox())?.height)
+      .toBe(nodeBounds.height)
+  })
+
   test('should use native context menu when focused', async ({ comfyPage }) => {
     const textarea = getFirstMultilineStringWidget(comfyPage)
     const vueContextMenu = comfyPage.page.locator('.p-contextmenu')
diff --git a/src/locales/en/main.json b/src/locales/en/main.json
index b417a114d87..aea8f517219 100644
--- a/src/locales/en/main.json
+++ b/src/locales/en/main.json
@@ -3355,6 +3355,7 @@
     "Set Group Nodes to Always": "Set Group Nodes to Always"
   },
   "widgets": {
+    "linkedInput": "Linked input",
     "boolean": {
       "true": "true",
       "false": "false"
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
index 065bc66756b..da2ee578494 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
@@ -1,7 +1,7 @@
 /* eslint-disable testing-library/no-container */
 /* eslint-disable testing-library/no-node-access */
 import { createTestingPinia } from '@pinia/testing'
-import { render } from '@testing-library/vue'
+import { render, screen, within } from '@testing-library/vue'
 import { setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
@@ -36,7 +36,7 @@ const WidgetStub = {
   name: 'WidgetStub',
   props: ['widget', 'nodeId', 'nodeType', 'modelValue'],
   template:
-    '<div class="widget-stub" :data-node-type="nodeType">{{ nodeType }}</div>'
+    '<button class="widget-stub" :data-node-type="nodeType">{{ modelValue }}</button>'
 }
 
 vi.mock(
@@ -352,4 +352,99 @@ describe('NodeWidgets', () => {
 
     expect(ids).toStrictEqual([seedAEntityId, seedBEntityId])
   })
+
+  it('keeps linked content mounted but inert and hidden from accessibility', () => {
+    const linkedWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'prompt')
+    const nodeData = createMockNodeData('TestNode', [
+      createMockWidget({
+        widgetId: linkedWidgetId,
+        name: 'prompt',
+        type: 'text',
+        slotMetadata: {
+          index: 0,
+          linked: true,
+          type: 'STRING'
+        }
+      })
+    ])
+
+    const { container } = renderComponent(nodeData, () => {
+      useWidgetValueStore().registerWidget(linkedWidgetId, {
+        type: 'text',
+        value: 'stale local prompt',
+        options: {}
+      })
+    })
+
+    const linkedContent = screen.getByTestId('linked-widget-content')
+    expect(linkedContent).toHaveAttribute('inert')
+    expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
+    expect(container.querySelector('.widget-stub')).not.toBeNull()
+    expect(within(linkedContent).queryByRole('button')).toBeNull()
+    expect(
+      screen.getByRole('img', { name: 'prompt: Linked input' })
+    ).toBeVisible()
+    expect(
+      screen.getByTestId('linked-widget-placeholder')
+    ).not.toHaveTextContent('stale local prompt')
+  })
+
+  it('places indicators on unlabeled switches and full labeled controls', () => {
+    const labeledWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'labeled')
+    const nodeData = createMockNodeData('TestNode', [
+      createMockWidget({
+        name: 'unlabeled',
+        type: 'boolean',
+        slotMetadata: {
+          index: 0,
+          linked: true,
+          type: 'BOOLEAN'
+        }
+      }),
+      createMockWidget({
+        widgetId: labeledWidgetId,
+        name: 'labeled',
+        type: 'toggle',
+        slotMetadata: {
+          index: 1,
+          linked: true,
+          type: 'BOOLEAN'
+        }
+      })
+    ])
+
+    renderComponent(nodeData, () => {
+      useWidgetValueStore().registerWidget(labeledWidgetId, {
+        type: 'toggle',
+        value: false,
+        options: { off: 'No', on: 'Yes' }
+      })
+    })
+
+    const placeholders = screen.getAllByTestId('linked-widget-placeholder')
+    expect(placeholders[0]).toHaveAttribute('data-linked-display', 'switch')
+    expect(placeholders[1]).toHaveAttribute('data-linked-display', 'control')
+  })
+
+  it('keeps the expanding textarea component mounted while linked', () => {
+    const nodeData = createMockNodeData('CLIPTextEncode', [
+      createMockWidget({
+        name: 'text',
+        type: 'customtext',
+        slotMetadata: {
+          index: 1,
+          linked: true,
+          type: 'STRING'
+        }
+      })
+    ])
+
+    const { container } = renderComponent(nodeData)
+
+    expect(container.querySelector('.widget-stub')).not.toBeNull()
+    expect(screen.getByTestId('linked-widget-placeholder')).toHaveAttribute(
+      'data-linked-display',
+      'expanding'
+    )
+  })
 })
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
index 7c190408fa2..c9ffd6ab011 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
@@ -53,28 +53,69 @@
           />
         </div>
         <!-- Widget Component -->
-        <AppInput
-          :widget-id="widget.widgetId"
-          :name="widget.name"
-          :enable="canSelectInputs && !widget.simplified.options?.disabled"
+        <div
+          class="contents"
+          :aria-hidden="widget.linkedDisplay ? 'true' : undefined"
+          :inert="widget.linkedDisplay ? true : undefined"
+          :data-testid="
+            widget.linkedDisplay ? 'linked-widget-content' : undefined
+          "
         >
-          <component
-            :is="widget.vueComponent"
-            v-model="widget.value"
-            v-tooltip.left="widget.tooltipConfig"
-            :widget="widget.simplified"
-            :node-id="nodeData?.id"
-            :node-type="nodeType"
-            :class="
-              cn(
-                'col-span-2',
-                widget.hasError && 'font-bold text-node-stroke-error'
-              )
+          <AppInput
+            :widget-id="widget.widgetId"
+            :name="widget.name"
+            :enable="
+              canSelectInputs &&
+              !widget.simplified.options?.disabled &&
+              !widget.linkedDisplay
             "
-            @update:model-value="widget.updateHandler"
-            @contextmenu="widget.handleContextMenu"
-          />
-        </AppInput>
+          >
+            <component
+              :is="widget.vueComponent"
+              v-model="widget.value"
+              v-tooltip.left="widget.tooltipConfig"
+              :widget="widget.simplified"
+              :node-id="nodeData?.id"
+              :node-type="nodeType"
+              :class="
+                cn(
+                  'col-span-2',
+                  widget.hasError && 'font-bold text-node-stroke-error'
+                )
+              "
+              @update:model-value="widget.updateHandler"
+              @contextmenu="widget.handleContextMenu"
+            />
+          </AppInput>
+        </div>
+        <div
+          v-if="widget.linkedDisplay"
+          data-testid="linked-widget-placeholder"
+          :data-linked-display="widget.linkedDisplay"
+          role="img"
+          :aria-label="`${widget.simplified.label || widget.simplified.name}: ${st(
+            'widgets.linkedInput',
+            'Linked input'
+          )}`"
+          :title="st('widgets.linkedInput', 'Linked input')"
+          :class="
+            cn(
+              'pointer-events-auto z-20 row-start-1 flex cursor-default items-center justify-center overflow-hidden bg-component-node-widget-background-disabled text-component-node-foreground-secondary select-none',
+              widget.simplified.borderStyle,
+              widget.linkedDisplay === 'expanding'
+                ? 'col-span-2 col-start-2 size-full rounded-lg'
+                : widget.linkedDisplay === 'switch'
+                  ? 'col-start-3 h-6 w-10 self-center justify-self-end rounded-full'
+                  : 'col-start-3 rounded-md'
+            )
+          "
+          @pointerdown.stop
+          @pointermove.stop
+          @pointerup.stop
+          @contextmenu="widget.handleContextMenu"
+        >
+          <i class="icon-[lucide--link] size-4" aria-hidden="true" />
+        </div>
       </div>
     </template>
   </div>
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index a36bc0fe375..f878ae35aea 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -27,10 +27,13 @@ import { validationError } from '@/utils/__tests__/nodeErrorHelpers'
 const GRAPH_ID = 'graph-test'
 const NODE_ID = toNodeId(1)
 
-const { executionIdToNodeLocatorId } = vi.hoisted(() => ({
-  executionIdToNodeLocatorId: vi.fn()
+const { executionIdToNodeLocatorId, showNodeOptions } = vi.hoisted(() => ({
+  executionIdToNodeLocatorId: vi.fn(),
+  showNodeOptions: vi.fn()
 }))
 
+vi.mock('@/composables/graph/useMoreOptionsMenu', () => ({ showNodeOptions }))
+
 vi.mock('@/utils/graphTraversalUtil', async (importActual) => {
   const actual = await importActual<typeof GraphTraversalUtil>()
   return {
@@ -70,7 +73,7 @@ const noopUi = {
   handleNodeRightClick: () => {}
 }
 
-function processWidgets(widgets: SafeWidgetData[]) {
+function processWidgets(widgets: SafeWidgetData[], ui: typeof noopUi = noopUi) {
   return computeProcessedWidgets({
     nodeData: {
       id: NODE_ID,
@@ -87,7 +90,7 @@ function processWidgets(widgets: SafeWidgetData[]) {
     showAdvanced: false,
     isGraphReady: false,
     rootGraph: null,
-    ui: noopUi
+    ui
   })
 }
 
@@ -737,6 +740,172 @@ describe('computeProcessedWidgets borderStyle', () => {
   })
 })
 
+describe('computeProcessedWidgets linked presentation', () => {
+  const linkedSlot = {
+    index: 0,
+    linked: true,
+    originNodeId: toNodeId(2),
+    originOutputName: 'value',
+    type: 'STRING'
+  }
+
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+    showNodeOptions.mockClear()
+  })
+
+  it('hides a linked standard value without applying a second disabled appearance', () => {
+    const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
+    useWidgetValueStore().registerWidget(id, {
+      type: 'string',
+      value: 'stale local prompt',
+      options: {}
+    })
+    const widget = createMockWidget({
+      widgetId: id,
+      nodeId: NODE_ID,
+      name: 'prompt',
+      type: 'string',
+      slotMetadata: linkedSlot
+    })
+
+    const [linked] = processWidgets([widget])
+
+    expect(linked.linkedDisplay).toBe('control')
+    expect(linked.value).toBe('stale local prompt')
+    expect(linked.simplified.options?.disabled).toBeUndefined()
+    expect(linked.tooltipConfig.disabled).toBe(true)
+    expect(linked.simplified.linkedUpstream).toEqual({
+      nodeId: toNodeId(2),
+      outputName: 'value'
+    })
+  })
+
+  it('restores the standard widget state after disconnect', () => {
+    const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
+    useWidgetValueStore().registerWidget(id, {
+      type: 'string',
+      value: 'local prompt',
+      options: {}
+    })
+    const widget = createMockWidget({
+      widgetId: id,
+      nodeId: NODE_ID,
+      name: 'prompt',
+      type: 'string',
+      slotMetadata: linkedSlot
+    })
+
+    expect(processWidgets([widget])[0].linkedDisplay).toBe('control')
+
+    const [unlinked] = processWidgets([
+      {
+        ...widget,
+        slotMetadata: { ...linkedSlot, linked: false }
+      }
+    ])
+
+    expect(unlinked.linkedDisplay).toBeUndefined()
+    expect(unlinked.value).toBe('local prompt')
+    expect(unlinked.simplified.options?.disabled).toBeUndefined()
+    expect(unlinked.simplified.linkedUpstream).toBeUndefined()
+    expect(unlinked.tooltipConfig.disabled).toBeUndefined()
+  })
+
+  it('distinguishes unlabeled switches from labeled toggle groups', () => {
+    const switchWidget = createMockWidget({
+      name: 'enabled',
+      type: 'boolean',
+      slotMetadata: { ...linkedSlot, type: 'BOOLEAN' }
+    })
+    const toggleId = widgetId(GRAPH_ID, NODE_ID, 'mode')
+    useWidgetValueStore().registerWidget(toggleId, {
+      type: 'boolean',
+      value: false,
+      options: { off: 'Disabled', on: 'Enabled' }
+    })
+    const toggleWidget = createMockWidget({
+      widgetId: toggleId,
+      nodeId: NODE_ID,
+      name: 'mode',
+      type: 'toggle',
+      slotMetadata: { ...linkedSlot, type: 'BOOLEAN' }
+    })
+
+    expect(processWidgets([switchWidget])[0].linkedDisplay).toBe('switch')
+    expect(processWidgets([toggleWidget])[0].linkedDisplay).toBe('control')
+  })
+
+  it.for(['textarea', 'TEXTAREA', 'multiline', 'customtext'])(
+    'uses the expanding linked display for %s',
+    (type) => {
+      const widget = createMockWidget({
+        name: 'text',
+        type,
+        slotMetadata: linkedSlot
+      })
+
+      expect(processWidgets([widget])[0].linkedDisplay).toBe('expanding')
+    }
+  )
+
+  it.for(['range', 'curve', 'imagecrop', 'boundingbox', 'gradientslider'])(
+    'keeps the upstream-relaying %s widget rendered',
+    (type) => {
+      const widget = createMockWidget({
+        type,
+        slotMetadata: linkedSlot
+      })
+
+      const [processed] = processWidgets([widget])
+
+      expect(processed.linkedDisplay).toBeUndefined()
+      expect(processed.simplified.options?.disabled).toBe(true)
+      expect(processed.simplified.linkedUpstream).toEqual({
+        nodeId: toNodeId(2),
+        outputName: 'value'
+      })
+    }
+  )
+
+  it('opens only node actions for a hidden linked widget', () => {
+    const handleNodeRightClick = vi.fn()
+    const event = fromAny<PointerEvent, unknown>({
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn()
+    })
+    const widget = createMockWidget({
+      name: 'prompt',
+      type: 'text',
+      slotMetadata: linkedSlot
+    })
+
+    processWidgets([widget], {
+      ...noopUi,
+      handleNodeRightClick
+    })[0].handleContextMenu(event)
+
+    expect(handleNodeRightClick).toHaveBeenCalledWith(event, NODE_ID)
+    expect(showNodeOptions).toHaveBeenCalledWith(event)
+  })
+
+  it('retains widget actions when the widget is unlinked', () => {
+    const event = fromAny<PointerEvent, unknown>({
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn()
+    })
+    const widget = createMockWidget({
+      name: 'prompt',
+      nodeId: NODE_ID,
+      type: 'text'
+    })
+
+    processWidgets([widget])[0].handleContextMenu(event)
+
+    expect(showNodeOptions).toHaveBeenCalledWith(event, 'prompt', NODE_ID)
+  })
+})
+
 describe('createWidgetUpdateHandler (via computeProcessedWidgets)', () => {
   it('calls widget.callback with the new value when widgetState exists', () => {
     const callback = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
index 664280d3cb2..e32d3f335ed 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
@@ -21,6 +21,7 @@ import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetD
 import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
 import {
   getComponent,
+  shouldHideLinkedWidgetContent,
   shouldExpand,
   shouldRenderAsVue
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
@@ -66,6 +67,7 @@ interface ProcessedWidget {
   hasError: boolean
   hidden: boolean
   id?: string
+  linkedDisplay?: 'control' | 'expanding' | 'switch'
   widgetId?: WidgetId
   name: string
   renderKey: string
@@ -79,6 +81,31 @@ interface ProcessedWidget {
   slotMetadata?: WidgetSlotMetadata
 }
 
+function getLinkedDisplay(
+  widget: SafeWidgetData,
+  options: IWidgetOptions
+): ProcessedWidget['linkedDisplay'] {
+  if (
+    !widget.slotMetadata?.linked ||
+    !shouldHideLinkedWidgetContent(widget.type)
+  ) {
+    return undefined
+  }
+
+  if (shouldExpand(widget.type)) return 'expanding'
+
+  const type = widget.type.toLowerCase()
+  if (
+    (type === 'boolean' || type === 'toggle') &&
+    options.on == null &&
+    options.off == null
+  ) {
+    return 'switch'
+  }
+
+  return 'control'
+}
+
 interface WidgetUiCallbacks {
   getTooltipConfig: (widget: SafeWidgetData, fullVal?: string) => TooltipOptions
   handleNodeRightClick: (e: PointerEvent, nodeId: NodeId) => void
@@ -330,7 +357,9 @@ export function computeProcessedWidgets({
 
     const value = widgetState?.value as WidgetValue
 
-    const isDisabled = slotMetadata?.linked || widgetState?.disabled
+    const linkedDisplay = getLinkedDisplay(widget, mergedOptions)
+    const isDisabled =
+      (!linkedDisplay && slotMetadata?.linked) || widgetState?.disabled
     const widgetOptions = isDisabled
       ? { ...mergedOptions, disabled: true }
       : mergedOptions
@@ -380,11 +409,17 @@ export function computeProcessedWidgets({
       isTooltipValueType(widget.type) && String(value).length > 10
         ? String(value)
         : undefined
-    const tooltipConfig = ui.getTooltipConfig(widget, valueTooltip)
+    const tooltipConfig = linkedDisplay
+      ? { disabled: true }
+      : ui.getTooltipConfig(widget, valueTooltip)
     const handleContextMenu = (e: PointerEvent) => {
       e.preventDefault()
       e.stopPropagation()
       if (nodeId !== undefined) ui.handleNodeRightClick(e, nodeId)
+      if (linkedDisplay) {
+        showNodeOptions(e)
+        return
+      }
       showNodeOptions(
         e,
         widget.name,
@@ -407,6 +442,7 @@ export function computeProcessedWidgets({
         missingMediaStore
       ),
       hidden: mergedOptions.hidden ?? false,
+      linkedDisplay,
       widgetId: widget.widgetId,
       name: widget.name,
       renderKey,
diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
index 0e03787558d..30001db280d 100644
--- a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
@@ -5,6 +5,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   getComponent,
   isEssential,
+  shouldHideLinkedWidgetContent,
   shouldRenderAsVue,
   FOR_TESTING
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
@@ -141,6 +142,57 @@ describe('widgetRegistry', () => {
     })
   })
 
+  describe('shouldHideLinkedWidgetContent', () => {
+    it.for([
+      'text',
+      'string',
+      'STRING',
+      'int',
+      'INT',
+      'float',
+      'FLOAT',
+      'number',
+      'slider',
+      'boolean',
+      'BOOLEAN',
+      'toggle',
+      'combo',
+      'COMBO',
+      'color',
+      'COLOR',
+      'textarea',
+      'TEXTAREA',
+      'multiline',
+      'customtext'
+    ])('includes the standard %s widget type', (type) => {
+      expect(shouldHideLinkedWidgetContent(type)).toBe(true)
+    })
+
+    it.for([
+      'range',
+      'curve',
+      'imagecrop',
+      'boundingbox',
+      'bounds',
+      'gradientslider',
+      'asset',
+      'galleria',
+      'colors',
+      'chart',
+      'audiorecord',
+      'markdown',
+      'load3D',
+      'painter',
+      'imagecompare',
+      'boundingboxes',
+      'videoedit',
+      'legacy',
+      'custom_widget'
+    ])('excludes the special or fallback %s widget type', (type) => {
+      expect(shouldHideLinkedWidgetContent(type)).toBe(false)
+    })
+  })
+
   describe('isEssential', () => {
     it('should identify essential widget types', () => {
       expect(isEssential('int')).toBe(true)
diff --git a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
index f197ed7b957..9c200d073a3 100644
--- a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
+++ b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
@@ -306,6 +306,26 @@ export const shouldRenderAsVue = (widget: Partial<SafeWidgetData>): boolean => {
   return !widget.options?.canvasOnly && !!widget.type
 }
 
+const LINKED_CONTENT_HIDDEN_TYPES = new Set([
+  'text',
+  'string',
+  'int',
+  'float',
+  'number',
+  'slider',
+  'boolean',
+  'toggle',
+  'combo',
+  'color',
+  'textarea',
+  'multiline',
+  'customtext'
+])
+
+export function shouldHideLinkedWidgetContent(type: string): boolean {
+  return LINKED_CONTENT_HIDDEN_TYPES.has(type.toLowerCase())
+}
+
 const EXPANDING_TYPES = [
   'textarea',
   'markdown',

From 3fdcbfdce34e14dc3a07ce637330f2845a9dbf0a Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 03:33:21 +0900
Subject: [PATCH 02/18] fix: harden linked standard widget state

---
 .../widgets/int/integerWidget.spec.ts         |   2 +
 .../text/multilineStringWidget.spec.ts        |   1 +
 .../ui/color-picker/ColorPicker.test.ts       |  47 ++++++++
 .../ui/color-picker/ColorPicker.vue           |  11 +-
 .../vueNodes/components/NodeWidgets.test.ts   |   3 +-
 .../vueNodes/components/NodeWidgets.vue       |   2 +-
 .../composables/useProcessedWidgets.test.ts   | 112 +++++++++++++++++-
 .../composables/useProcessedWidgets.ts        |  37 +++---
 .../components/WidgetColorPicker.test.ts      |   9 ++
 .../widgets/components/WidgetColorPicker.vue  |   6 +-
 .../widgets/components/WidgetSelect.vue       |  92 +++-----------
 .../components/WidgetSelectDefault.test.ts    |  20 ++++
 .../components/WidgetSelectDefault.vue        |   6 +-
 .../components/WidgetToggleSwitch.test.ts     |  14 +++
 .../widgets/components/WidgetToggleSwitch.vue |   2 +-
 .../composables/useWidgetRenderer.test.ts     |  52 --------
 .../widgets/registry/widgetRegistry.ts        |  34 +++---
 .../widgets/utils/widgetSelectMode.ts         |  54 +++++++++
 18 files changed, 332 insertions(+), 172 deletions(-)
 create mode 100644 src/components/ui/color-picker/ColorPicker.test.ts
 create mode 100644 src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts

diff --git a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
index 46099ec7ad3..1ca97d9dabc 100644
--- a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
@@ -15,6 +15,7 @@ test.describe('Vue Integer Widget', { tag: '@vue-nodes' }, () => {
       TestIds.widgets.linkedPlaceholder
     )
     const linkedContent = samplerNode.getByTestId(TestIds.widgets.linkedContent)
+    const hiddenInput = linkedContent.locator('input[role="spinbutton"]')
     const nodeBounds = await samplerNode.boundingBox()
     const [samplerNodeRef] =
       await comfyPage.nodeOps.getNodeRefsByType('KSampler')
@@ -26,6 +27,7 @@ test.describe('Vue Integer Widget', { tag: '@vue-nodes' }, () => {
 
     await expect(placeholder).toHaveAccessibleName('seed: Linked input')
     await expect(linkedContent).toHaveAttribute('inert', '')
+    await expect(hiddenInput).toBeDisabled()
     await expect(
       samplerNode.getByRole('spinbutton', { name: 'seed' })
     ).toHaveCount(0)
diff --git a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
index a2d32f508c2..e793de778d1 100644
--- a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
@@ -65,6 +65,7 @@ test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
     await expect(placeholder).toHaveAccessibleName('text: Linked input')
     await expect(linkedContent).toHaveAttribute('inert', '')
     await expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
+    await expect(hiddenTextarea).toBeDisabled()
     await expect(clipNode.getByRole('textbox', { name: 'text' })).toHaveCount(0)
     await expect(hiddenTextarea).toHaveValue('stale local prompt')
 
diff --git a/src/components/ui/color-picker/ColorPicker.test.ts b/src/components/ui/color-picker/ColorPicker.test.ts
new file mode 100644
index 00000000000..e1a9b5d82da
--- /dev/null
+++ b/src/components/ui/color-picker/ColorPicker.test.ts
@@ -0,0 +1,47 @@
+import { render, screen, waitFor } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { describe, expect, it } from 'vitest'
+import { createI18n } from 'vue-i18n'
+
+import ColorPicker from './ColorPicker.vue'
+
+const i18n = createI18n({
+  legacy: false,
+  locale: 'en',
+  messages: {
+    en: {
+      color: {
+        alpha: 'Alpha',
+        hex: 'Hex',
+        hue: 'Hue',
+        rgba: 'RGBA',
+        saturationBrightness: 'Color saturation and brightness'
+      }
+    }
+  }
+})
+
+describe('ColorPicker', () => {
+  it('closes an open popover when disabled', async () => {
+    const user = userEvent.setup()
+    const { rerender } = render(ColorPicker, {
+      global: { plugins: [i18n] },
+      props: { modelValue: '#112233' }
+    })
+    const trigger = screen.getByRole('button')
+
+    await user.click(trigger)
+    expect(
+      await screen.findByRole('textbox', { name: 'Hex' })
+    ).toBeInTheDocument()
+
+    await rerender({ disabled: true, modelValue: '#112233' })
+
+    await waitFor(() => {
+      expect(
+        screen.queryByRole('textbox', { name: 'Hex' })
+      ).not.toBeInTheDocument()
+    })
+    expect(trigger).toBeDisabled()
+  })
+})
diff --git a/src/components/ui/color-picker/ColorPicker.vue b/src/components/ui/color-picker/ColorPicker.vue
index 8215e4e7a3f..e92c7bcd336 100644
--- a/src/components/ui/color-picker/ColorPicker.vue
+++ b/src/components/ui/color-picker/ColorPicker.vue
@@ -14,7 +14,7 @@ import { cn } from '@comfyorg/tailwind-utils'
 
 import ColorPickerPanel from './ColorPickerPanel.vue'
 
-const { alpha = true } = defineProps<{
+const { alpha = true, disabled = false } = defineProps<{
   class?: string
   disabled?: boolean
   alpha?: boolean
@@ -69,6 +69,13 @@ const displayHex = computed(() => rgbToHex(baseRgb.value).toLowerCase())
 
 const isOpen = ref(false)
 const contentStyle = useModalLiftedZIndex(isOpen)
+
+watch(
+  () => disabled,
+  (isDisabled) => {
+    if (isDisabled) isOpen.value = false
+  }
+)
 </script>
 
 <template>
@@ -77,7 +84,7 @@ const contentStyle = useModalLiftedZIndex(isOpen)
       <slot name="trigger">
         <button
           type="button"
-          :disabled="$props.disabled"
+          :disabled
           :class="
             cn(
               'flex h-8 w-full items-center overflow-clip rounded-lg border border-transparent bg-component-node-widget-background pr-2 outline-none hover:bg-component-node-widget-background-hovered disabled:cursor-not-allowed disabled:opacity-50',
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
index da2ee578494..29ac72e0e8d 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
@@ -36,7 +36,7 @@ const WidgetStub = {
   name: 'WidgetStub',
   props: ['widget', 'nodeId', 'nodeType', 'modelValue'],
   template:
-    '<button class="widget-stub" :data-node-type="nodeType">{{ modelValue }}</button>'
+    '<button class="widget-stub" :data-node-type="nodeType" :disabled="widget.options?.disabled">{{ modelValue }}</button>'
 }
 
 vi.mock(
@@ -380,6 +380,7 @@ describe('NodeWidgets', () => {
     expect(linkedContent).toHaveAttribute('inert')
     expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
     expect(container.querySelector('.widget-stub')).not.toBeNull()
+    expect(container.querySelector('.widget-stub')).toBeDisabled()
     expect(within(linkedContent).queryByRole('button')).toBeNull()
     expect(
       screen.getByRole('img', { name: 'prompt: Linked input' })
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
index c9ffd6ab011..f720c83b7e4 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
@@ -100,7 +100,7 @@
           :title="st('widgets.linkedInput', 'Linked input')"
           :class="
             cn(
-              'pointer-events-auto z-20 row-start-1 flex cursor-default items-center justify-center overflow-hidden bg-component-node-widget-background-disabled text-component-node-foreground-secondary select-none',
+              'pointer-events-auto z-20 row-start-1 flex cursor-default items-center justify-center overflow-hidden bg-component-node-widget-background text-component-node-foreground-secondary select-none',
               widget.simplified.borderStyle,
               widget.linkedDisplay === 'expanding'
                 ? 'col-span-2 col-start-2 size-full rounded-lg'
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index f878ae35aea..acf9d66b285 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -16,6 +16,8 @@ import { widgetId } from '@/types/widgetId'
 import type * as GraphTraversalUtil from '@/utils/graphTraversalUtil'
 
 import type { SafeWidgetData } from '@/composables/graph/useGraphNodeManager'
+import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetDOM.vue'
+import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
 import {
   computeProcessedWidgets,
   getWidgetIdentity,
@@ -27,12 +29,22 @@ import { validationError } from '@/utils/__tests__/nodeErrorHelpers'
 const GRAPH_ID = 'graph-test'
 const NODE_ID = toNodeId(1)
 
-const { executionIdToNodeLocatorId, showNodeOptions } = vi.hoisted(() => ({
+const {
+  executionIdToNodeLocatorId,
+  isAssetAPIEnabled,
+  shouldUseAssetBrowser,
+  showNodeOptions
+} = vi.hoisted(() => ({
   executionIdToNodeLocatorId: vi.fn(),
+  isAssetAPIEnabled: vi.fn(() => false),
+  shouldUseAssetBrowser: vi.fn(() => false),
   showNodeOptions: vi.fn()
 }))
 
 vi.mock('@/composables/graph/useMoreOptionsMenu', () => ({ showNodeOptions }))
+vi.mock('@/platform/assets/services/assetService', () => ({
+  assetService: { isAssetAPIEnabled, shouldUseAssetBrowser }
+}))
 
 vi.mock('@/utils/graphTraversalUtil', async (importActual) => {
   const actual = await importActual<typeof GraphTraversalUtil>()
@@ -751,10 +763,12 @@ describe('computeProcessedWidgets linked presentation', () => {
 
   beforeEach(() => {
     setActivePinia(createTestingPinia({ stubActions: false }))
+    isAssetAPIEnabled.mockReturnValue(false)
+    shouldUseAssetBrowser.mockReturnValue(false)
     showNodeOptions.mockClear()
   })
 
-  it('hides a linked standard value without applying a second disabled appearance', () => {
+  it('hides a linked standard value and disables its mounted control', () => {
     const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
     useWidgetValueStore().registerWidget(id, {
       type: 'string',
@@ -773,7 +787,7 @@ describe('computeProcessedWidgets linked presentation', () => {
 
     expect(linked.linkedDisplay).toBe('control')
     expect(linked.value).toBe('stale local prompt')
-    expect(linked.simplified.options?.disabled).toBeUndefined()
+    expect(linked.simplified.options?.disabled).toBe(true)
     expect(linked.tooltipConfig.disabled).toBe(true)
     expect(linked.simplified.linkedUpstream).toEqual({
       nodeId: toNodeId(2),
@@ -781,6 +795,39 @@ describe('computeProcessedWidgets linked presentation', () => {
     })
   })
 
+  it.for([
+    'text',
+    'string',
+    'STRING',
+    'int',
+    'INT',
+    'float',
+    'FLOAT',
+    'number',
+    'slider',
+    'boolean',
+    'BOOLEAN',
+    'toggle',
+    'combo',
+    'COMBO',
+    'color',
+    'COLOR'
+  ])('uses the linked control display for the registered %s type', (type) => {
+    const widget = createMockWidget({
+      type,
+      slotMetadata: linkedSlot
+    })
+
+    const [processed] = processWidgets([widget])
+
+    expect(processed.linkedDisplay).toBe(
+      type === 'boolean' || type === 'BOOLEAN' || type === 'toggle'
+        ? 'switch'
+        : 'control'
+    )
+    expect(processed.simplified.options?.disabled).toBe(true)
+  })
+
   it('restores the standard widget state after disconnect', () => {
     const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
     useWidgetValueStore().registerWidget(id, {
@@ -849,6 +896,65 @@ describe('computeProcessedWidgets linked presentation', () => {
     }
   )
 
+  it.for([
+    ['String', false, WidgetLegacy],
+    ['CoMbO', true, WidgetDOM]
+  ] as const)(
+    'keeps the unregistered mixed-case %s fallback visible',
+    ([type, isDOMWidget, component]) => {
+      const widget = createMockWidget({
+        isDOMWidget,
+        type,
+        slotMetadata: linkedSlot
+      })
+
+      const [processed] = processWidgets([widget])
+
+      expect(processed.linkedDisplay).toBeUndefined()
+      expect(processed.simplified.options?.disabled).toBe(true)
+      expect(processed.vueComponent).toBe(component)
+    }
+  )
+
+  it.for([
+    { name: 'asset alias', type: 'asset', spec: undefined },
+    {
+      name: 'upload-media COMBO',
+      type: 'COMBO',
+      spec: {
+        type: 'COMBO',
+        name: 'image',
+        image_upload: true
+      }
+    }
+  ] as const)('keeps the linked $name rendered', ({ type, spec }) => {
+    const widget = createMockWidget({
+      name: 'image',
+      type,
+      spec,
+      slotMetadata: linkedSlot
+    })
+
+    const [processed] = processWidgets([widget])
+
+    expect(processed.linkedDisplay).toBeUndefined()
+    expect(processed.simplified.options?.disabled).toBe(true)
+  })
+
+  it('keeps an asset-browser combo rendered while hiding an ordinary combo', () => {
+    shouldUseAssetBrowser.mockReturnValue(true)
+    const widget = createMockWidget({
+      name: 'ckpt_name',
+      type: 'COMBO',
+      slotMetadata: linkedSlot
+    })
+
+    expect(processWidgets([widget])[0].linkedDisplay).toBeUndefined()
+
+    shouldUseAssetBrowser.mockReturnValue(false)
+    expect(processWidgets([widget])[0].linkedDisplay).toBe('control')
+  })
+
   it.for(['range', 'curve', 'imagecrop', 'boundingbox', 'gradientslider'])(
     'keeps the upstream-relaying %s widget rendered',
     (type) => {
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
index e32d3f335ed..d8c347fdc2a 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
@@ -12,6 +12,7 @@ import { showNodeOptions } from '@/composables/graph/useMoreOptionsMenu'
 import type { IWidgetOptions } from '@/lib/litegraph/src/types/widgets'
 import { LGraphEventMode } from '@/lib/litegraph/src/types/globalEnums'
 import { useSettingStore } from '@/platform/settings/settingStore'
+import { assetService } from '@/platform/assets/services/assetService'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { app } from '@/scripts/app'
 import type { NodeError } from '@/schemas/apiSchema'
@@ -21,10 +22,11 @@ import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetD
 import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
 import {
   getComponent,
-  shouldHideLinkedWidgetContent,
+  getLinkedWidgetFamily,
   shouldExpand,
   shouldRenderAsVue
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
 import { nodeTypeValidForApp } from '@/stores/appModeStore'
 import {
   stripGraphPrefix,
@@ -83,23 +85,25 @@ interface ProcessedWidget {
 
 function getLinkedDisplay(
   widget: SafeWidgetData,
-  options: IWidgetOptions
+  options: IWidgetOptions,
+  nodeType: string
 ): ProcessedWidget['linkedDisplay'] {
-  if (
-    !widget.slotMetadata?.linked ||
-    !shouldHideLinkedWidgetContent(widget.type)
-  ) {
-    return undefined
+  if (!widget.slotMetadata?.linked) return undefined
+
+  const family = getLinkedWidgetFamily(widget.type)
+  if (!family) return undefined
+
+  if (family === 'combo') {
+    const mode = resolveWidgetSelectMode(widget, {
+      assetApiEnabled: assetService.isAssetAPIEnabled(),
+      useAssetBrowser: assetService.shouldUseAssetBrowser(nodeType, widget.name)
+    })
+    if (mode.isDropdownUIWidget) return undefined
   }
 
-  if (shouldExpand(widget.type)) return 'expanding'
+  if (family === 'textarea') return 'expanding'
 
-  const type = widget.type.toLowerCase()
-  if (
-    (type === 'boolean' || type === 'toggle') &&
-    options.on == null &&
-    options.off == null
-  ) {
+  if (family === 'boolean' && options.on == null && options.off == null) {
     return 'switch'
   }
 
@@ -357,9 +361,8 @@ export function computeProcessedWidgets({
 
     const value = widgetState?.value as WidgetValue
 
-    const linkedDisplay = getLinkedDisplay(widget, mergedOptions)
-    const isDisabled =
-      (!linkedDisplay && slotMetadata?.linked) || widgetState?.disabled
+    const linkedDisplay = getLinkedDisplay(widget, mergedOptions, nodeData.type)
+    const isDisabled = slotMetadata?.linked || widgetState?.disabled
     const widgetOptions = isDisabled
       ? { ...mergedOptions, disabled: true }
       : mergedOptions
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
index 6d05a06c6a8..984d227348c 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
@@ -19,12 +19,14 @@ const WidgetLayoutFieldStub = defineComponent({
 const ColorPickerStub = defineComponent({
   name: 'ColorPicker',
   props: {
+    disabled: { type: Boolean, default: false },
     modelValue: { type: String, default: '' }
   },
   emits: ['update:modelValue'],
   template: `<input
     data-testid="color-picker-input"
     :value="modelValue"
+    :disabled
     @input="$emit('update:modelValue', $event.target.value)"
   />`
 })
@@ -99,6 +101,13 @@ describe('WidgetColorPicker Value Binding', () => {
       expect(screen.getByTestId('color-picker-input')).toBeInTheDocument()
     })
 
+    it('disables the color picker from widget options', () => {
+      const widget = createColorWidget('#ff0000', { disabled: true })
+      renderComponent(widget, '#ff0000')
+
+      expect(screen.getByTestId('color-picker-input')).toBeDisabled()
+    })
+
     it('renders layout field wrapper', () => {
       const widget = createColorWidget('#ff0000')
       renderComponent(widget, '#ff0000')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
index d71ae699296..f032ac4334a 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
@@ -1,6 +1,10 @@
 <template>
   <WidgetLayoutField :widget="widget">
-    <ColorPicker v-model="localValue" @update:model-value="onUpdate" />
+    <ColorPicker
+      v-model="localValue"
+      :disabled="Boolean(widget.options?.disabled)"
+      @update:model-value="onUpdate"
+    />
   </WidgetLayoutField>
 </template>
 
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
index 1fef32bdd89..22fe423fd59 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
@@ -28,15 +28,13 @@ import WidgetSelectDefault from '@/renderer/extensions/vueNodes/widgets/componen
 import WidgetSelectDropdown from '@/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue'
 import WidgetWithControl from '@/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue'
 import type { LayoutMode } from '@/renderer/extensions/vueNodes/widgets/components/form/dropdown/types'
+import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
 import type { ResultItemType } from '@/schemas/apiSchema'
-import { isComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
-import type { ComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
 import type {
   SimplifiedControlWidget,
   SimplifiedWidget,
   WidgetValue
 } from '@/types/simplifiedWidget'
-import type { AssetKind } from '@/types/widgetTypes'
 
 type SelectControlWidget = SimplifiedControlWidget<WidgetValue>
 
@@ -47,84 +45,24 @@ const props = defineProps<{
 
 const modelValue = defineModel<WidgetValue>()
 
-const comboSpec = computed<ComboInputSpec | undefined>(() => {
-  if (props.widget.spec && isComboInputSpec(props.widget.spec)) {
-    return props.widget.spec
-  }
-  return undefined
-})
-
-const specDescriptor = computed<{
-  kind: AssetKind
-  allowUpload: boolean
-  folder: ResultItemType | undefined
-  subfolder: string | undefined
-}>(() => {
-  const spec = comboSpec.value
-  if (!spec) {
-    return {
-      kind: 'unknown',
-      allowUpload: false,
-      folder: undefined,
-      subfolder: undefined
-    }
-  }
-
-  const {
-    image_upload,
-    animated_image_upload,
-    video_upload,
-    image_folder,
-    audio_upload,
-    mesh_upload,
-    upload_subfolder
-  } = spec
-
-  let kind: AssetKind = 'unknown'
-  if (video_upload) {
-    kind = 'video'
-  } else if (image_upload || animated_image_upload) {
-    kind = 'image'
-  } else if (audio_upload) {
-    kind = 'audio'
-  } else if (mesh_upload) {
-    kind = 'mesh'
-  }
-
-  // TODO: add support for models (checkpoints, VAE, LoRAs, etc.) -- get widgetType from spec
-
-  const allowUpload =
-    image_upload === true ||
-    animated_image_upload === true ||
-    video_upload === true ||
-    audio_upload === true ||
-    mesh_upload === true
-
-  const folder = mesh_upload ? 'input' : image_folder
-
-  return {
-    kind,
-    allowUpload,
-    folder,
-    subfolder: upload_subfolder
-  }
-})
-
-const isAssetMode = computed(
-  () =>
-    assetService.shouldUseAssetBrowser(props.nodeType, props.widget.name) ||
-    (assetService.isAssetAPIEnabled() && props.widget.type === 'asset')
+const mode = computed(() =>
+  resolveWidgetSelectMode(props.widget, {
+    assetApiEnabled: assetService.isAssetAPIEnabled(),
+    useAssetBrowser: assetService.shouldUseAssetBrowser(
+      props.nodeType,
+      props.widget.name
+    )
+  })
 )
 
-const assetKind = computed(() => specDescriptor.value.kind)
-const isDropdownUIWidget = computed(
-  () => isAssetMode.value || assetKind.value !== 'unknown'
-)
-const allowUpload = computed(() => specDescriptor.value.allowUpload)
+const assetKind = computed(() => mode.value.assetKind)
+const isAssetMode = computed(() => mode.value.isAssetMode)
+const isDropdownUIWidget = computed(() => mode.value.isDropdownUIWidget)
+const allowUpload = computed(() => mode.value.allowUpload)
 const uploadFolder = computed<ResultItemType>(() => {
-  return specDescriptor.value.folder ?? 'input'
+  return mode.value.uploadFolder ?? 'input'
 })
-const uploadSubfolder = computed(() => specDescriptor.value.subfolder)
+const uploadSubfolder = computed(() => mode.value.uploadSubfolder)
 const defaultLayoutMode = computed<LayoutMode>(() => {
   return isAssetMode.value ? 'list' : 'grid'
 })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
index 0b510420166..afd207b78eb 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
@@ -381,6 +381,26 @@ describe('WidgetSelectDefault', () => {
       expect(screen.getByTestId('widget-select-default-trigger')).toBeDisabled()
     })
 
+    it('closes an open overlay when widget options become disabled', async () => {
+      const { rerender, user } = renderComponent(createWidget(['a', 'b']), 'a')
+
+      await openDropdown(user)
+      expect(
+        screen.getByTestId('widget-select-default-overlay')
+      ).toBeInTheDocument()
+
+      await rerender({
+        widget: createWidget(['a', 'b'], { disabled: true })
+      })
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId('widget-select-default-overlay')
+        ).not.toBeInTheDocument()
+      })
+      expect(screen.getByTestId('widget-select-default-trigger')).toBeDisabled()
+    })
+
     it('uses getOptionLabel for trigger and option labels', async () => {
       const { user } = renderComponent(
         createWidget(['hash-a'], {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
index d991ddc6366..6a9fb99fbb4 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
@@ -162,7 +162,7 @@ import {
   ComboboxRoot,
   ComboboxTrigger
 } from 'reka-ui'
-import { computed, ref } from 'vue'
+import { computed, ref, watch } from 'vue'
 import type { CSSProperties } from 'vue'
 
 import { useRestoreFocusOnViewportPointer } from '@/renderer/extensions/vueNodes/widgets/composables/useRestoreFocusOnViewportPointer'
@@ -380,4 +380,8 @@ function handleOpenChange(open: boolean) {
     searchQuery.value = ''
   }
 }
+
+watch(disabled, (isDisabled) => {
+  if (isDisabled) handleOpenChange(false)
+})
 </script>
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
index e0517fcc4f0..e677cd2d1d3 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
@@ -286,6 +286,20 @@ describe('WidgetToggleSwitch Value Binding', () => {
       }
     })
 
+    it('disables ToggleGroup when disabled is set', () => {
+      const widget = createToggleWidget(false, {
+        on: 'yes',
+        off: 'no',
+        disabled: true
+      })
+      mountComponent(widget, false)
+
+      const buttons = screen.getAllByRole('button')
+      for (const button of buttons) {
+        expect(button).toBeDisabled()
+      }
+    })
+
     it('keeps an implicit switch unchanged when read_only is set', async () => {
       const widget = createToggleWidget(false, { read_only: true })
       const onModelUpdate = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
index 30a02c1e14d..365e7bebbe0 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
@@ -4,7 +4,7 @@
       v-if="hasLabels"
       type="single"
       :model-value="modelValue ? 'on' : 'off'"
-      :disabled="Boolean(widget.options?.read_only)"
+      :disabled="Boolean(widget.options?.read_only || widget.options?.disabled)"
       :class="
         cn(
           WidgetInputBaseClass,
diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
index 30001db280d..0e03787558d 100644
--- a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetRenderer.test.ts
@@ -5,7 +5,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   getComponent,
   isEssential,
-  shouldHideLinkedWidgetContent,
   shouldRenderAsVue,
   FOR_TESTING
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
@@ -142,57 +141,6 @@ describe('widgetRegistry', () => {
     })
   })
 
-  describe('shouldHideLinkedWidgetContent', () => {
-    it.for([
-      'text',
-      'string',
-      'STRING',
-      'int',
-      'INT',
-      'float',
-      'FLOAT',
-      'number',
-      'slider',
-      'boolean',
-      'BOOLEAN',
-      'toggle',
-      'combo',
-      'COMBO',
-      'color',
-      'COLOR',
-      'textarea',
-      'TEXTAREA',
-      'multiline',
-      'customtext'
-    ])('includes the standard %s widget type', (type) => {
-      expect(shouldHideLinkedWidgetContent(type)).toBe(true)
-    })
-
-    it.for([
-      'range',
-      'curve',
-      'imagecrop',
-      'boundingbox',
-      'bounds',
-      'gradientslider',
-      'asset',
-      'galleria',
-      'colors',
-      'chart',
-      'audiorecord',
-      'markdown',
-      'load3D',
-      'painter',
-      'imagecompare',
-      'boundingboxes',
-      'videoedit',
-      'legacy',
-      'custom_widget'
-    ])('excludes the special or fallback %s widget type', (type) => {
-      expect(shouldHideLinkedWidgetContent(type)).toBe(false)
-    })
-  })
-
   describe('isEssential', () => {
     it('should identify essential widget types', () => {
       expect(isEssential('int')).toBe(true)
diff --git a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
index 9c200d073a3..f0068ba9acf 100644
--- a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
+++ b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
@@ -306,24 +306,26 @@ export const shouldRenderAsVue = (widget: Partial<SafeWidgetData>): boolean => {
   return !widget.options?.canvasOnly && !!widget.type
 }
 
-const LINKED_CONTENT_HIDDEN_TYPES = new Set([
-  'text',
-  'string',
-  'int',
-  'float',
-  'number',
-  'slider',
-  'boolean',
-  'toggle',
-  'combo',
-  'color',
-  'textarea',
-  'multiline',
-  'customtext'
+export type LinkedWidgetFamily = 'boolean' | 'combo' | 'control' | 'textarea'
+
+const linkedWidgetFamilies = new Map<Component, LinkedWidgetFamily>([
+  [WidgetInputText, 'control'],
+  [WidgetInputNumber, 'control'],
+  [WidgetToggleSwitch, 'boolean'],
+  [WidgetSelect, 'combo'],
+  [WidgetColorPicker, 'control'],
+  [WidgetTextarea, 'textarea']
 ])
 
-export function shouldHideLinkedWidgetContent(type: string): boolean {
-  return LINKED_CONTENT_HIDDEN_TYPES.has(type.toLowerCase())
+const LINKED_WIDGET_EXCLUDED_ALIASES = new Set(['asset', 'gradientslider'])
+
+export function getLinkedWidgetFamily(
+  type: string
+): LinkedWidgetFamily | undefined {
+  if (LINKED_WIDGET_EXCLUDED_ALIASES.has(type)) return undefined
+
+  const component = getComponent(type)
+  return component ? linkedWidgetFamilies.get(component) : undefined
 }
 
 const EXPANDING_TYPES = [
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts b/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts
new file mode 100644
index 00000000000..b21dfc557a7
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts
@@ -0,0 +1,54 @@
+import type { ResultItemType } from '@/schemas/apiSchema'
+import { isComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { AssetKind } from '@/types/widgetTypes'
+
+interface WidgetSelectModeWidget {
+  type: string
+  spec?: InputSpec
+}
+
+interface WidgetSelectModeContext {
+  assetApiEnabled: boolean
+  useAssetBrowser: boolean
+}
+
+export function resolveWidgetSelectMode(
+  widget: WidgetSelectModeWidget,
+  { assetApiEnabled, useAssetBrowser }: WidgetSelectModeContext
+) {
+  const spec =
+    widget.spec && isComboInputSpec(widget.spec) ? widget.spec : undefined
+
+  let assetKind: AssetKind = 'unknown'
+  if (spec?.video_upload) {
+    assetKind = 'video'
+  } else if (spec?.image_upload || spec?.animated_image_upload) {
+    assetKind = 'image'
+  } else if (spec?.audio_upload) {
+    assetKind = 'audio'
+  } else if (spec?.mesh_upload) {
+    assetKind = 'mesh'
+  }
+
+  const allowUpload =
+    spec?.image_upload === true ||
+    spec?.animated_image_upload === true ||
+    spec?.video_upload === true ||
+    spec?.audio_upload === true ||
+    spec?.mesh_upload === true
+  const uploadFolder: ResultItemType | undefined = spec?.mesh_upload
+    ? 'input'
+    : spec?.image_folder
+  const isAssetMode =
+    useAssetBrowser || (assetApiEnabled && widget.type === 'asset')
+
+  return {
+    allowUpload,
+    assetKind,
+    isAssetMode,
+    isDropdownUIWidget: isAssetMode || assetKind !== 'unknown',
+    uploadFolder,
+    uploadSubfolder: spec?.upload_subfolder
+  }
+}

From d7bad62606bbacca7656d4fbc91f94c178dc8f3a Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 12:30:12 +0900
Subject: [PATCH 03/18] fix: preserve linked widget surfaces

---
 .../vueNodes/linked-standard-widgets.json     | 134 +++++++++++++
 .../linked/linkedStandardWidgets.spec.ts      | 149 +++++++++++++++
 .../parameters/WidgetItem.test.ts             | 171 ++++++++++++++++-
 .../rightSidePanel/parameters/WidgetItem.vue  |  17 +-
 .../vueNodes/components/NodeWidgets.test.ts   |  82 +-------
 .../vueNodes/components/NodeWidgets.vue       |  38 +---
 .../composables/useProcessedWidgets.test.ts   | 102 ++++------
 .../composables/useProcessedWidgets.ts        |  61 +++---
 .../widgets/components/LinkedWidgetStatus.vue |  56 ++++++
 .../components/ValueControlButton.test.ts     |  15 ++
 .../widgets/components/ValueControlButton.vue |  10 +-
 .../widgets/components/WidgetColorPicker.vue  |   2 +-
 .../components/WidgetInputText.test.ts        |  28 +++
 .../widgets/components/WidgetInputText.vue    |   1 +
 .../components/WidgetSelectDropdown.test.ts   |  54 +++++-
 .../components/WidgetSelectDropdown.vue       |   1 +
 .../widgets/components/WidgetTextarea.test.ts |  32 ++++
 .../widgets/components/WidgetTextarea.vue     |  14 +-
 .../components/WidgetToggleSwitch.test.ts     |  42 ++++
 .../widgets/components/WidgetToggleSwitch.vue |  32 +++-
 .../components/WidgetWithControl.test.ts      |  87 ++++++++-
 .../widgets/components/WidgetWithControl.vue  |  14 +-
 .../form/dropdown/FormDropdown.test.ts        |  25 +++
 .../components/form/dropdown/FormDropdown.vue |   8 +-
 .../form/dropdown/FormDropdownInput.vue       |   1 +
 .../layout/WidgetLayoutField.test.ts          |  29 ++-
 .../components/layout/WidgetLayoutField.vue   |  36 +++-
 .../widgets/utils/linkedWidgetDisplay.test.ts | 179 ++++++++++++++++++
 .../widgets/utils/linkedWidgetDisplay.ts      |  60 ++++++
 src/types/simplifiedWidget.ts                 |   4 +
 tools/devtools/dev_nodes.py                   |   4 +
 tools/devtools/nodes/__init__.py              |   4 +
 tools/devtools/nodes/inputs.py                | 113 +++++++++++
 33 files changed, 1357 insertions(+), 248 deletions(-)
 create mode 100644 browser_tests/assets/vueNodes/linked-standard-widgets.json
 create mode 100644 browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
 create mode 100644 src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
 create mode 100644 src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
 create mode 100644 src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts

diff --git a/browser_tests/assets/vueNodes/linked-standard-widgets.json b/browser_tests/assets/vueNodes/linked-standard-widgets.json
new file mode 100644
index 00000000000..a85a0299345
--- /dev/null
+++ b/browser_tests/assets/vueNodes/linked-standard-widgets.json
@@ -0,0 +1,134 @@
+{
+  "id": "bc8526ee-e7ce-4b81-9a55-12a34d43cc3a",
+  "revision": 0,
+  "last_node_id": 2,
+  "last_link_id": 9,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "DevToolsLinkedStandardWidgetSource",
+      "pos": [-1600, 100],
+      "size": [360, 270],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        { "name": "plain_text", "type": "STRING", "links": [1] },
+        { "name": "integer", "type": "INT", "links": [2] },
+        { "name": "number", "type": "FLOAT", "links": [3] },
+        { "name": "slider", "type": "FLOAT", "links": [4] },
+        { "name": "switch", "type": "BOOLEAN", "links": [5] },
+        { "name": "labeled_toggle", "type": "BOOLEAN", "links": [6] },
+        { "name": "select", "type": "COMBO", "links": [7] },
+        { "name": "color", "type": "COLOR", "links": [8] },
+        { "name": "textarea", "type": "STRING", "links": [9] }
+      ],
+      "properties": {
+        "Node name for S&R": "DevToolsLinkedStandardWidgetSource"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 2,
+      "type": "DevToolsLinkedStandardWidgets",
+      "pos": [200, 100],
+      "size": [560, 620],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "plain_text",
+          "type": "STRING",
+          "widget": { "name": "plain_text" },
+          "link": 1
+        },
+        {
+          "name": "integer",
+          "type": "INT",
+          "widget": { "name": "integer" },
+          "link": 2
+        },
+        {
+          "name": "number",
+          "type": "FLOAT",
+          "widget": { "name": "number" },
+          "link": 3
+        },
+        {
+          "name": "slider",
+          "type": "FLOAT",
+          "widget": { "name": "slider" },
+          "link": 4
+        },
+        {
+          "name": "switch",
+          "type": "BOOLEAN",
+          "widget": { "name": "switch" },
+          "link": 5
+        },
+        {
+          "name": "labeled_toggle",
+          "type": "BOOLEAN",
+          "widget": { "name": "labeled_toggle" },
+          "link": 6
+        },
+        {
+          "name": "select",
+          "type": "COMBO",
+          "widget": { "name": "select" },
+          "link": 7
+        },
+        {
+          "name": "color",
+          "type": "COLOR",
+          "widget": { "name": "color" },
+          "link": 8
+        },
+        {
+          "name": "textarea",
+          "type": "STRING",
+          "widget": { "name": "textarea" },
+          "link": 9
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "DevToolsLinkedStandardWidgets"
+      },
+      "widgets_values": [
+        "STALE PLAIN TEXT",
+        314,
+        9.875,
+        0.73,
+        true,
+        false,
+        "STALE SELECT VALUE",
+        "#22c55d",
+        "STALE MULTILINE PROMPT"
+      ]
+    }
+  ],
+  "links": [
+    [1, 1, 0, 2, 0, "STRING"],
+    [2, 1, 1, 2, 1, "INT"],
+    [3, 1, 2, 2, 2, "FLOAT"],
+    [4, 1, 3, 2, 3, "FLOAT"],
+    [5, 1, 4, 2, 4, "BOOLEAN"],
+    [6, 1, 5, 2, 5, "BOOLEAN"],
+    [7, 1, 6, 2, 6, "COMBO"],
+    [8, 1, 7, 2, 7, "COLOR"],
+    [9, 1, 8, 2, 8, "STRING"]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 1,
+      "offset": [0, 0]
+    },
+    "frontendVersion": "1.28.6"
+  },
+  "version": 0.4
+}
diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
new file mode 100644
index 00000000000..8b4830fc1a3
--- /dev/null
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -0,0 +1,149 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
+
+const TARGET_NODE_TYPE = 'DevToolsLinkedStandardWidgets'
+const TARGET_NODE_TITLE = 'Linked Standard Widgets'
+const WIDGET_NAMES = [
+  'plain_text',
+  'integer',
+  'number',
+  'slider',
+  'switch',
+  'labeled_toggle',
+  'select',
+  'color',
+  'textarea'
+] as const
+
+test.describe(
+  'Linked standard Vue widgets',
+  { tag: ['@vue-nodes', '@widget', '@node', '@screenshot'] },
+  () => {
+    test('preserves each control surface while making stale values inert', async ({
+      comfyPage
+    }) => {
+      await comfyPage.page.setViewportSize({ width: 1280, height: 900 })
+      await comfyPage.workflow.loadWorkflow('vueNodes/linked-standard-widgets')
+
+      const [targetNodeRef] =
+        await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
+      if (!targetNodeRef) throw new Error('Target DevTools node was not loaded')
+      await targetNodeRef.centerOnNode()
+
+      const targetNode = comfyPage.vueNodes
+        .getNodeByTitle(TARGET_NODE_TITLE)
+        .first()
+      await expect(targetNode).toBeVisible()
+
+      const statuses = targetNode.getByTestId(TestIds.widgets.linkedPlaceholder)
+      const linkedContent = targetNode.getByTestId(
+        TestIds.widgets.linkedContent
+      )
+      await expect(statuses).toHaveCount(WIDGET_NAMES.length)
+      await expect(linkedContent).toHaveCount(WIDGET_NAMES.length)
+
+      for (const name of WIDGET_NAMES) {
+        await expect(
+          targetNode.getByRole('status', {
+            name: `${name}: Linked input`
+          })
+        ).toBeVisible()
+      }
+
+      for (let index = 0; index < WIDGET_NAMES.length; index++) {
+        await expect(linkedContent.nth(index)).toHaveAttribute('inert', '')
+        await expect(linkedContent.nth(index)).toHaveAttribute(
+          'aria-hidden',
+          'true'
+        )
+      }
+
+      const interactive = targetNode.locator(
+        `[data-testid="${TestIds.widgets.linkedContent}"]:is(input, textarea, button, [role="slider"]), ` +
+          `[data-testid="${TestIds.widgets.linkedContent}"] :is(input, textarea, button, [role="slider"])`
+      )
+      const interactiveCount = await interactive.count()
+      expect(interactiveCount).toBeGreaterThan(WIDGET_NAMES.length)
+
+      const disabled = await interactive.evaluateAll((elements) =>
+        elements.map((element) => {
+          if (
+            element instanceof HTMLButtonElement ||
+            element instanceof HTMLInputElement ||
+            element instanceof HTMLTextAreaElement
+          ) {
+            return element.disabled
+          }
+          return (
+            element.getAttribute('aria-disabled') === 'true' ||
+            element.hasAttribute('data-disabled')
+          )
+        })
+      )
+      expect(disabled.every(Boolean)).toBe(true)
+
+      for (let index = 0; index < interactiveCount; index++) {
+        const control = interactive.nth(index)
+        await expect(control).toBeHidden()
+        await control.evaluate((element) => {
+          if (element instanceof HTMLElement) element.focus()
+        })
+        expect(
+          await control.evaluate(
+            (element) => document.activeElement === element
+          )
+        ).toBe(false)
+      }
+
+      await expect(
+        targetNode.getByText('STALE SELECT VALUE', { exact: true })
+      ).toBeHidden()
+      await expect(
+        targetNode.getByText('STALE ON', { exact: true })
+      ).toBeHidden()
+      await expect(
+        targetNode.getByText('STALE OFF', { exact: true })
+      ).toBeHidden()
+      await expect(
+        targetNode.getByText('#22c55d', { exact: true })
+      ).toBeHidden()
+
+      const widgetRefs = await Promise.all(
+        WIDGET_NAMES.map((name) => targetNodeRef.getWidgetByName(name))
+      )
+      const valuesBefore = await Promise.all(
+        widgetRefs.map((widget) => widget.getValue())
+      )
+
+      for (let index = 0; index < WIDGET_NAMES.length; index++) {
+        await statuses.nth(index).click()
+      }
+      await comfyPage.page.keyboard.press('Space')
+      await comfyPage.page.keyboard.press('ArrowUp')
+      await comfyPage.page.keyboard.press('Enter')
+
+      for (let index = 0; index < WIDGET_NAMES.length + 2; index++) {
+        await comfyPage.page.keyboard.press('Tab')
+        expect(
+          await targetNode.evaluate(
+            (node) =>
+              node.querySelector(
+                '[data-testid="linked-widget-content"]:focus-within'
+              ) !== null
+          )
+        ).toBe(false)
+      }
+
+      await expect
+        .poll(() => Promise.all(widgetRefs.map((widget) => widget.getValue())))
+        .toStrictEqual(valuesBefore)
+
+      await comfyPage.nextFrame()
+      await comfyPage.nextFrame()
+      await expect(targetNode).toHaveScreenshot('linked-standard-widgets.png')
+    })
+  }
+)
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 10fc410e265..94a572fec86 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -1,27 +1,49 @@
-import { render } from '@testing-library/vue'
+import { render, screen } from '@testing-library/vue'
 import { fromAny } from '@total-typescript/shoehorn'
-import { describe, expect, it, vi } from 'vitest'
+import PrimeVue from 'primevue/config'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createI18n } from 'vue-i18n'
 
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
+import type * as WidgetRegistry from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
 import { useWidgetValueStore } from '@/stores/widgetValueStore'
+import { toLinkId } from '@/types/linkId'
 import { widgetId } from '@/types/widgetId'
 import WidgetItem from './WidgetItem.vue'
 import { toNodeId } from '@/types/nodeId'
 
-const { mockGetInputSpecForWidget, StubWidgetComponent } = vi.hoisted(() => ({
+const {
+  mockFromLGraphNode,
+  mockGetInputSpecForWidget,
+  mockIsAssetAPIEnabled,
+  mockShouldUseAssetBrowser,
+  StubWidgetComponent
+} = vi.hoisted(() => ({
+  mockFromLGraphNode: vi.fn<() => { isCoreNode: boolean; name: string } | null>(
+    () => null
+  ),
   mockGetInputSpecForWidget: vi.fn(),
+  mockIsAssetAPIEnabled: vi.fn(() => false),
+  mockShouldUseAssetBrowser: vi.fn(() => false),
   StubWidgetComponent: {
     name: 'StubWidget',
     props: ['widget', 'modelValue', 'nodeId', 'nodeType'],
     template:
-      '<div class="stub-widget" :data-widget-options="JSON.stringify(widget?.options)" :data-widget-type="widget?.type" :data-widget-name="widget?.name" :data-widget-value="String(widget?.value)" />'
+      '<div class="stub-widget" :data-linked-display="widget?.linkedDisplay" :data-widget-options="JSON.stringify(widget?.options)" :data-widget-type="widget?.type" :data-widget-name="widget?.name" :data-widget-value="String(widget?.value)" />'
+  }
+}))
+
+vi.mock('@/platform/assets/services/assetService', () => ({
+  assetService: {
+    isAssetAPIEnabled: mockIsAssetAPIEnabled,
+    shouldUseAssetBrowser: mockShouldUseAssetBrowser
   }
 }))
 
 vi.mock('@/stores/nodeDefStore', () => ({
   useNodeDefStore: () => ({
+    fromLGraphNode: mockFromLGraphNode,
     getInputSpecForWidget: mockGetInputSpecForWidget
   })
 }))
@@ -45,10 +67,17 @@ vi.mock('@/composables/graph/useGraphNodeManager', () => ({
 
 vi.mock(
   '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry',
-  () => ({
-    getComponent: () => StubWidgetComponent,
-    shouldExpand: () => false
-  })
+  async (importOriginal) => {
+    const original = await importOriginal<typeof WidgetRegistry>()
+    const { default: WidgetInputText } =
+      await import('@/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue')
+    return {
+      ...original,
+      getComponent: (type: string) =>
+        type === 'text' ? WidgetInputText : StubWidgetComponent,
+      shouldExpand: () => false
+    }
+  }
 )
 
 vi.mock(
@@ -70,7 +99,7 @@ const i18n = createI18n({
   }
 })
 
-function createMockNode(overrides: Partial<LGraphNode> = {}): LGraphNode {
+function createMockNode(overrides: Record<string, unknown> = {}): LGraphNode {
   return fromAny<LGraphNode, unknown>({
     id: 1,
     type: 'TestNode',
@@ -100,7 +129,7 @@ function renderWidgetItem(
   return render(WidgetItem, {
     props: { widget, node },
     global: {
-      plugins: [i18n],
+      plugins: [i18n, PrimeVue],
       stubs: {
         EditableText: { template: '<span />' },
         WidgetActions: { template: '<span />' }
@@ -115,6 +144,7 @@ function getStubWidget(container: Element) {
   if (!el) throw new Error('stub-widget not found')
   return {
     options: JSON.parse(el.getAttribute('data-widget-options') ?? 'null'),
+    linkedDisplay: el.getAttribute('data-linked-display'),
     type: el.getAttribute('data-widget-type'),
     name: el.getAttribute('data-widget-name'),
     value: el.getAttribute('data-widget-value')
@@ -122,6 +152,12 @@ function getStubWidget(container: Element) {
 }
 
 describe('WidgetItem', () => {
+  beforeEach(() => {
+    mockIsAssetAPIEnabled.mockReturnValue(false)
+    mockShouldUseAssetBrowser.mockReturnValue(false)
+    mockFromLGraphNode.mockReturnValue(null)
+  })
+
   describe('widget state rendering', () => {
     it('passes options from a regular widget to the widget component', () => {
       const widget = createMockWidget({
@@ -197,5 +233,120 @@ describe('WidgetItem', () => {
 
       expect(stub.value).toBe('model_a.safetensors')
     })
+
+    it('renders a supported linked text status in Parameters', () => {
+      const widget = createMockWidget({
+        name: 'prompt',
+        type: 'text',
+        value: 'STALE PARAMETER TEXT'
+      })
+      const node = createMockNode({
+        inputs: [
+          {
+            name: 'prompt',
+            type: 'STRING',
+            link: toLinkId(1),
+            boundingRect: [0, 0, 0, 0],
+            widget: { name: 'prompt' }
+          }
+        ]
+      })
+
+      renderWidgetItem(widget, node)
+
+      const content = screen.getByTestId('linked-widget-content')
+      const input = screen.getByRole('textbox', { hidden: true })
+      expect(content).toHaveAttribute('inert')
+      expect(content).toHaveAttribute('aria-hidden', 'true')
+      expect(input).toBeDisabled()
+      expect(screen.queryByRole('textbox')).toBeNull()
+      expect(
+        screen.getByRole('status', { name: 'prompt: Linked input' })
+      ).toBeVisible()
+    })
+
+    it('uses the bounded linked resolver for ordinary and upload combos', () => {
+      const widget = createMockWidget({ name: 'option', type: 'COMBO' })
+      const node = createMockNode({
+        inputs: [
+          {
+            name: 'option',
+            type: 'COMBO',
+            link: toLinkId(1),
+            boundingRect: [0, 0, 0, 0],
+            widget: { name: 'option' }
+          }
+        ]
+      })
+      const { container, unmount } = renderWidgetItem(widget, node)
+
+      expect(getStubWidget(container).linkedDisplay).toBe('control')
+      unmount()
+
+      mockGetInputSpecForWidget.mockReturnValue({
+        type: 'COMBO',
+        name: 'option',
+        image_upload: true
+      })
+      const upload = renderWidgetItem(widget, node)
+
+      expect(getStubWidget(upload.container).linkedDisplay).toBeNull()
+      expect(getStubWidget(upload.container).options.disabled).toBe(true)
+    })
+
+    it('uses the linked presentation for an exact core media selector', () => {
+      mockGetInputSpecForWidget.mockReturnValue({
+        type: 'COMBO',
+        name: 'image',
+        image_upload: true
+      })
+      mockFromLGraphNode.mockReturnValue({
+        name: 'LoadImage',
+        isCoreNode: true
+      })
+      const widget = createMockWidget({ name: 'image', type: 'asset' })
+      const node = createMockNode({
+        type: 'LoadImage',
+        inputs: [
+          {
+            name: 'image',
+            type: 'COMBO',
+            link: toLinkId(1),
+            boundingRect: [0, 0, 0, 0],
+            widget: { name: 'image' }
+          }
+        ]
+      })
+
+      const { container } = renderWidgetItem(widget, node)
+      const stub = getStubWidget(container)
+
+      expect(stub.linkedDisplay).toBe('control')
+      expect(stub.options.disabled).toBe(true)
+    })
+
+    it('does not add linked presentation to a special widget', () => {
+      const widget = createMockWidget({
+        name: 'gradient',
+        type: 'gradientslider'
+      })
+      const node = createMockNode({
+        inputs: [
+          {
+            name: 'gradient',
+            type: 'FLOAT',
+            link: toLinkId(1),
+            boundingRect: [0, 0, 0, 0],
+            widget: { name: 'gradient' }
+          }
+        ]
+      })
+      const { container } = renderWidgetItem(widget, node)
+      const stub = getStubWidget(container)
+
+      expect(stub.linkedDisplay).toBeNull()
+      expect(stub.options.disabled).toBe(true)
+      expect(screen.queryByRole('status')).toBeNull()
+    })
   })
 })
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.vue b/src/components/rightSidePanel/parameters/WidgetItem.vue
index 643edb4a858..63a5dde944b 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.vue
+++ b/src/components/rightSidePanel/parameters/WidgetItem.vue
@@ -8,12 +8,14 @@ import { useVueNodeLifecycle } from '@/composables/graph/useVueNodeLifecycle'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
+import { assetService } from '@/platform/assets/services/assetService'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
 import {
   getComponent,
   shouldExpand
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveLinkedWidgetDisplay } from '@/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay'
 import { useNodeDefStore } from '@/stores/nodeDefStore'
 import {
   stripGraphPrefix,
@@ -88,14 +90,27 @@ const simplifiedWidget = computed((): SimplifiedWidget => {
   const widgetType = widgetState?.type ?? widget.type
 
   const baseOptions = widgetState?.options ?? widget.options
+  const spec = nodeDefStore.getInputSpecForWidget(node, widgetName)
+  const nodeDef = nodeDefStore.fromLGraphNode(node)
+  const linkedDisplay = resolveLinkedWidgetDisplay(
+    { name: widgetName, type: widgetType, spec },
+    baseOptions,
+    {
+      assetApiEnabled: assetService.isAssetAPIEnabled(),
+      coreNodeType: nodeDef?.isCoreNode ? nodeDef.name : undefined,
+      linked: isLinked.value,
+      useAssetBrowser: assetService.shouldUseAssetBrowser(node.type, widgetName)
+    }
+  )
   const disabled = isLinked.value || !!widget.disabled || undefined
   return {
     name: widgetName,
     type: widgetType,
     value: widgetState?.value ?? widget.value,
     label: widgetState?.label ?? widget.label,
+    linkedDisplay,
     options: { ...baseOptions, disabled },
-    spec: nodeDefStore.getInputSpecForWidget(node, widgetName),
+    spec,
     controlWidget: getControlWidget(widget)
   }
 })
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
index 29ac72e0e8d..f562eb4167a 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
@@ -1,7 +1,7 @@
 /* eslint-disable testing-library/no-container */
 /* eslint-disable testing-library/no-node-access */
 import { createTestingPinia } from '@pinia/testing'
-import { render, screen, within } from '@testing-library/vue'
+import { render, screen } from '@testing-library/vue'
 import { setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
@@ -36,7 +36,7 @@ const WidgetStub = {
   name: 'WidgetStub',
   props: ['widget', 'nodeId', 'nodeType', 'modelValue'],
   template:
-    '<button class="widget-stub" :data-node-type="nodeType" :disabled="widget.options?.disabled">{{ modelValue }}</button>'
+    '<button class="widget-stub" :data-linked-display="widget.linkedDisplay" :data-node-type="nodeType" :disabled="widget.options?.disabled">{{ modelValue }}</button>'
 }
 
 vi.mock(
@@ -353,7 +353,7 @@ describe('NodeWidgets', () => {
     expect(ids).toStrictEqual([seedAEntityId, seedBEntityId])
   })
 
-  it('keeps linked content mounted but inert and hidden from accessibility', () => {
+  it('passes linked presentation state to the mounted standard widget', () => {
     const linkedWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'prompt')
     const nodeData = createMockNodeData('TestNode', [
       createMockWidget({
@@ -376,76 +376,10 @@ describe('NodeWidgets', () => {
       })
     })
 
-    const linkedContent = screen.getByTestId('linked-widget-content')
-    expect(linkedContent).toHaveAttribute('inert')
-    expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
-    expect(container.querySelector('.widget-stub')).not.toBeNull()
-    expect(container.querySelector('.widget-stub')).toBeDisabled()
-    expect(within(linkedContent).queryByRole('button')).toBeNull()
-    expect(
-      screen.getByRole('img', { name: 'prompt: Linked input' })
-    ).toBeVisible()
-    expect(
-      screen.getByTestId('linked-widget-placeholder')
-    ).not.toHaveTextContent('stale local prompt')
-  })
-
-  it('places indicators on unlabeled switches and full labeled controls', () => {
-    const labeledWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'labeled')
-    const nodeData = createMockNodeData('TestNode', [
-      createMockWidget({
-        name: 'unlabeled',
-        type: 'boolean',
-        slotMetadata: {
-          index: 0,
-          linked: true,
-          type: 'BOOLEAN'
-        }
-      }),
-      createMockWidget({
-        widgetId: labeledWidgetId,
-        name: 'labeled',
-        type: 'toggle',
-        slotMetadata: {
-          index: 1,
-          linked: true,
-          type: 'BOOLEAN'
-        }
-      })
-    ])
-
-    renderComponent(nodeData, () => {
-      useWidgetValueStore().registerWidget(labeledWidgetId, {
-        type: 'toggle',
-        value: false,
-        options: { off: 'No', on: 'Yes' }
-      })
-    })
-
-    const placeholders = screen.getAllByTestId('linked-widget-placeholder')
-    expect(placeholders[0]).toHaveAttribute('data-linked-display', 'switch')
-    expect(placeholders[1]).toHaveAttribute('data-linked-display', 'control')
-  })
-
-  it('keeps the expanding textarea component mounted while linked', () => {
-    const nodeData = createMockNodeData('CLIPTextEncode', [
-      createMockWidget({
-        name: 'text',
-        type: 'customtext',
-        slotMetadata: {
-          index: 1,
-          linked: true,
-          type: 'STRING'
-        }
-      })
-    ])
-
-    const { container } = renderComponent(nodeData)
-
-    expect(container.querySelector('.widget-stub')).not.toBeNull()
-    expect(screen.getByTestId('linked-widget-placeholder')).toHaveAttribute(
-      'data-linked-display',
-      'expanding'
-    )
+    const control = container.querySelector('.widget-stub')
+    expect(control).not.toBeNull()
+    expect(control).toBeDisabled()
+    expect(control).toHaveAttribute('data-linked-display', 'control')
+    expect(screen.queryByTestId('linked-widget-placeholder')).toBeNull()
   })
 })
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
index f720c83b7e4..17d6c02bc29 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.vue
@@ -53,14 +53,7 @@
           />
         </div>
         <!-- Widget Component -->
-        <div
-          class="contents"
-          :aria-hidden="widget.linkedDisplay ? 'true' : undefined"
-          :inert="widget.linkedDisplay ? true : undefined"
-          :data-testid="
-            widget.linkedDisplay ? 'linked-widget-content' : undefined
-          "
-        >
+        <div class="contents" @contextmenu="widget.handleContextMenu">
           <AppInput
             :widget-id="widget.widgetId"
             :name="widget.name"
@@ -84,38 +77,9 @@
                 )
               "
               @update:model-value="widget.updateHandler"
-              @contextmenu="widget.handleContextMenu"
             />
           </AppInput>
         </div>
-        <div
-          v-if="widget.linkedDisplay"
-          data-testid="linked-widget-placeholder"
-          :data-linked-display="widget.linkedDisplay"
-          role="img"
-          :aria-label="`${widget.simplified.label || widget.simplified.name}: ${st(
-            'widgets.linkedInput',
-            'Linked input'
-          )}`"
-          :title="st('widgets.linkedInput', 'Linked input')"
-          :class="
-            cn(
-              'pointer-events-auto z-20 row-start-1 flex cursor-default items-center justify-center overflow-hidden bg-component-node-widget-background text-component-node-foreground-secondary select-none',
-              widget.simplified.borderStyle,
-              widget.linkedDisplay === 'expanding'
-                ? 'col-span-2 col-start-2 size-full rounded-lg'
-                : widget.linkedDisplay === 'switch'
-                  ? 'col-start-3 h-6 w-10 self-center justify-self-end rounded-full'
-                  : 'col-start-3 rounded-md'
-            )
-          "
-          @pointerdown.stop
-          @pointermove.stop
-          @pointerup.stop
-          @contextmenu="widget.handleContextMenu"
-        >
-          <i class="icon-[lucide--link] size-4" aria-hidden="true" />
-        </div>
       </div>
     </template>
   </div>
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index acf9d66b285..94bd5439516 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -86,10 +86,19 @@ const noopUi = {
 }
 
 function processWidgets(widgets: SafeWidgetData[], ui: typeof noopUi = noopUi) {
+  return processNodeWidgets(widgets, 'TestNode', false, ui)
+}
+
+function processNodeWidgets(
+  widgets: SafeWidgetData[],
+  nodeType: string,
+  isCoreNode: boolean,
+  ui: typeof noopUi = noopUi
+) {
   return computeProcessedWidgets({
     nodeData: {
       id: NODE_ID,
-      type: 'TestNode',
+      type: nodeType,
       widgets,
       title: 'Test',
       mode: 0,
@@ -98,6 +107,7 @@ function processWidgets(widgets: SafeWidgetData[], ui: typeof noopUi = noopUi) {
       inputs: [],
       outputs: []
     },
+    coreNodeType: isCoreNode ? nodeType : undefined,
     graphId: GRAPH_ID,
     showAdvanced: false,
     isGraphReady: false,
@@ -762,7 +772,6 @@ describe('computeProcessedWidgets linked presentation', () => {
   }
 
   beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
     isAssetAPIEnabled.mockReturnValue(false)
     shouldUseAssetBrowser.mockReturnValue(false)
     showNodeOptions.mockClear()
@@ -795,39 +804,6 @@ describe('computeProcessedWidgets linked presentation', () => {
     })
   })
 
-  it.for([
-    'text',
-    'string',
-    'STRING',
-    'int',
-    'INT',
-    'float',
-    'FLOAT',
-    'number',
-    'slider',
-    'boolean',
-    'BOOLEAN',
-    'toggle',
-    'combo',
-    'COMBO',
-    'color',
-    'COLOR'
-  ])('uses the linked control display for the registered %s type', (type) => {
-    const widget = createMockWidget({
-      type,
-      slotMetadata: linkedSlot
-    })
-
-    const [processed] = processWidgets([widget])
-
-    expect(processed.linkedDisplay).toBe(
-      type === 'boolean' || type === 'BOOLEAN' || type === 'toggle'
-        ? 'switch'
-        : 'control'
-    )
-    expect(processed.simplified.options?.disabled).toBe(true)
-  })
-
   it('restores the standard widget state after disconnect', () => {
     const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
     useWidgetValueStore().registerWidget(id, {
@@ -883,19 +859,6 @@ describe('computeProcessedWidgets linked presentation', () => {
     expect(processWidgets([toggleWidget])[0].linkedDisplay).toBe('control')
   })
 
-  it.for(['textarea', 'TEXTAREA', 'multiline', 'customtext'])(
-    'uses the expanding linked display for %s',
-    (type) => {
-      const widget = createMockWidget({
-        name: 'text',
-        type,
-        slotMetadata: linkedSlot
-      })
-
-      expect(processWidgets([widget])[0].linkedDisplay).toBe('expanding')
-    }
-  )
-
   it.for([
     ['String', false, WidgetLegacy],
     ['CoMbO', true, WidgetDOM]
@@ -941,6 +904,20 @@ describe('computeProcessedWidgets linked presentation', () => {
     expect(processed.simplified.options?.disabled).toBe(true)
   })
 
+  it('hides and disables a linked core media selector', () => {
+    const widget = createMockWidget({
+      name: 'image',
+      type: 'asset',
+      spec: { type: 'COMBO', name: 'image', image_upload: true },
+      slotMetadata: linkedSlot
+    })
+
+    const [processed] = processNodeWidgets([widget], 'LoadImage', true)
+
+    expect(processed.linkedDisplay).toBe('control')
+    expect(processed.simplified.options?.disabled).toBe(true)
+  })
+
   it('keeps an asset-browser combo rendered while hiding an ordinary combo', () => {
     shouldUseAssetBrowser.mockReturnValue(true)
     const widget = createMockWidget({
@@ -955,24 +932,21 @@ describe('computeProcessedWidgets linked presentation', () => {
     expect(processWidgets([widget])[0].linkedDisplay).toBe('control')
   })
 
-  it.for(['range', 'curve', 'imagecrop', 'boundingbox', 'gradientslider'])(
-    'keeps the upstream-relaying %s widget rendered',
-    (type) => {
-      const widget = createMockWidget({
-        type,
-        slotMetadata: linkedSlot
-      })
+  it('keeps upstream metadata for a linked relay widget', () => {
+    const widget = createMockWidget({
+      type: 'range',
+      slotMetadata: linkedSlot
+    })
 
-      const [processed] = processWidgets([widget])
+    const [processed] = processWidgets([widget])
 
-      expect(processed.linkedDisplay).toBeUndefined()
-      expect(processed.simplified.options?.disabled).toBe(true)
-      expect(processed.simplified.linkedUpstream).toEqual({
-        nodeId: toNodeId(2),
-        outputName: 'value'
-      })
-    }
-  )
+    expect(processed.linkedDisplay).toBeUndefined()
+    expect(processed.simplified.options?.disabled).toBe(true)
+    expect(processed.simplified.linkedUpstream).toEqual({
+      nodeId: toNodeId(2),
+      outputName: 'value'
+    })
+  })
 
   it('opens only node actions for a hidden linked widget', () => {
     const handleNodeRightClick = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
index d8c347fdc2a..1c7234646d0 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
@@ -22,11 +22,10 @@ import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetD
 import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
 import {
   getComponent,
-  getLinkedWidgetFamily,
   shouldExpand,
   shouldRenderAsVue
 } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
-import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
+import { resolveLinkedWidgetDisplay } from '@/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay'
 import { nodeTypeValidForApp } from '@/stores/appModeStore'
 import {
   stripGraphPrefix,
@@ -35,6 +34,7 @@ import {
 import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
 import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore'
 import { useExecutionErrorStore } from '@/stores/executionErrorStore'
+import { useNodeDefStore } from '@/stores/nodeDefStore'
 import {
   createNodeExecutionId,
   createNodeLocatorId
@@ -51,6 +51,7 @@ import {
 } from '@/utils/graphTraversalUtil'
 import type { LGraph } from '@/lib/litegraph/src/litegraph'
 import type {
+  LinkedWidgetDisplay,
   LinkedUpstreamInfo,
   SimplifiedWidget,
   WidgetValue
@@ -69,7 +70,7 @@ interface ProcessedWidget {
   hasError: boolean
   hidden: boolean
   id?: string
-  linkedDisplay?: 'control' | 'expanding' | 'switch'
+  linkedDisplay?: LinkedWidgetDisplay
   widgetId?: WidgetId
   name: string
   renderKey: string
@@ -83,33 +84,6 @@ interface ProcessedWidget {
   slotMetadata?: WidgetSlotMetadata
 }
 
-function getLinkedDisplay(
-  widget: SafeWidgetData,
-  options: IWidgetOptions,
-  nodeType: string
-): ProcessedWidget['linkedDisplay'] {
-  if (!widget.slotMetadata?.linked) return undefined
-
-  const family = getLinkedWidgetFamily(widget.type)
-  if (!family) return undefined
-
-  if (family === 'combo') {
-    const mode = resolveWidgetSelectMode(widget, {
-      assetApiEnabled: assetService.isAssetAPIEnabled(),
-      useAssetBrowser: assetService.shouldUseAssetBrowser(nodeType, widget.name)
-    })
-    if (mode.isDropdownUIWidget) return undefined
-  }
-
-  if (family === 'textarea') return 'expanding'
-
-  if (family === 'boolean' && options.on == null && options.off == null) {
-    return 'switch'
-  }
-
-  return 'control'
-}
-
 interface WidgetUiCallbacks {
   getTooltipConfig: (widget: SafeWidgetData, fullVal?: string) => TooltipOptions
   handleNodeRightClick: (e: PointerEvent, nodeId: NodeId) => void
@@ -117,6 +91,7 @@ interface WidgetUiCallbacks {
 
 interface ComputeProcessedWidgetsOptions {
   nodeData: VueNodeData | undefined
+  coreNodeType?: string
   graphId: string | undefined
   showAdvanced: boolean
   isGraphReady: boolean
@@ -253,6 +228,7 @@ export function isWidgetVisible(
 
 export function computeProcessedWidgets({
   nodeData,
+  coreNodeType,
   graphId,
   showAdvanced,
   isGraphReady,
@@ -361,7 +337,15 @@ export function computeProcessedWidgets({
 
     const value = widgetState?.value as WidgetValue
 
-    const linkedDisplay = getLinkedDisplay(widget, mergedOptions, nodeData.type)
+    const linkedDisplay = resolveLinkedWidgetDisplay(widget, mergedOptions, {
+      assetApiEnabled: assetService.isAssetAPIEnabled(),
+      coreNodeType,
+      linked: Boolean(widget.slotMetadata?.linked),
+      useAssetBrowser: assetService.shouldUseAssetBrowser(
+        nodeData.type,
+        widget.name
+      )
+    })
     const isDisabled = slotMetadata?.linked || widgetState?.disabled
     const widgetOptions = isDisabled
       ? { ...mergedOptions, disabled: true }
@@ -394,6 +378,7 @@ export function computeProcessedWidgets({
       callback: widget.callback,
       controlWidget: widget.controlWidget,
       label: widgetState?.label,
+      linkedDisplay,
       linkedUpstream,
       nodeLocatorId,
       options: widgetOptions,
@@ -469,6 +454,7 @@ export function useProcessedWidgets(
 ) {
   const canvasStore = useCanvasStore()
   const settingStore = useSettingStore()
+  const nodeDefStore = useNodeDefStore()
   const { isSelectInputsMode } = useAppMode()
   const { handleNodeRightClick } = useNodeEventHandlers()
 
@@ -499,16 +485,21 @@ export function useProcessedWidgets(
     )
   })
 
-  const processedWidgets = computed((): ProcessedWidget[] =>
-    computeProcessedWidgets({
-      nodeData: nodeDataGetter(),
+  const processedWidgets = computed((): ProcessedWidget[] => {
+    const nodeData = nodeDataGetter()
+    const nodeDef = nodeData
+      ? nodeDefStore.nodeDefsByName[nodeData.type]
+      : undefined
+    return computeProcessedWidgets({
+      nodeData,
+      coreNodeType: nodeDef?.isCoreNode ? nodeDef.name : undefined,
       graphId: canvasStore.canvas?.graph?.rootGraph.id,
       showAdvanced: showAdvanced.value,
       isGraphReady: app.isGraphReady,
       rootGraph: app.isGraphReady ? app.rootGraph : null,
       ui
     })
-  )
+  })
 
   const visibleWidgets = computed(() =>
     processedWidgets.value.filter((w) => w.visible)
diff --git a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
new file mode 100644
index 00000000000..e151359034c
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
@@ -0,0 +1,56 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import { st } from '@/i18n'
+import type {
+  LinkedWidgetDisplay,
+  SimplifiedWidget
+} from '@/types/simplifiedWidget'
+import { cn } from '@comfyorg/tailwind-utils'
+
+const {
+  display,
+  widget,
+  rounded = 'md'
+} = defineProps<{
+  display: LinkedWidgetDisplay
+  widget: Pick<SimplifiedWidget, 'label' | 'name'>
+  rounded?: 'md' | 'lg'
+}>()
+
+const linkedLabel = st('widgets.linkedInput', 'Linked input')
+const accessibleName = computed(
+  () => `${widget.label || widget.name}: ${linkedLabel}`
+)
+</script>
+
+<template>
+  <div
+    data-testid="linked-widget-placeholder"
+    :data-linked-display="display"
+    role="status"
+    :aria-label="accessibleName"
+    :title="linkedLabel"
+    :class="
+      cn(
+        'pointer-events-auto absolute z-20 flex cursor-default items-center overflow-hidden bg-component-node-widget-background/40 select-none',
+        display === 'switch'
+          ? 'top-1 right-1 h-6 w-10 justify-center rounded-full'
+          : display === 'expanding'
+            ? 'inset-0 justify-start rounded-lg px-3'
+            : cn(
+                'inset-0 justify-start px-3',
+                rounded === 'lg' ? 'rounded-lg' : 'rounded-md'
+              )
+      )
+    "
+    @pointerdown.stop.prevent
+    @pointermove.stop
+    @pointerup.stop
+  >
+    <i
+      class="icon-[lucide--link] size-4 text-component-node-foreground-secondary opacity-40"
+      aria-hidden="true"
+    />
+  </div>
+</template>
diff --git a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
index cc470ad064e..869ef182a39 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
@@ -83,5 +83,20 @@ describe('ValueControlButton', () => {
       await user.click(screen.getByRole('button'))
       expect(onClick).toHaveBeenCalledTimes(1)
     })
+
+    it('cannot be activated when disabled', async () => {
+      const onClick = vi.fn()
+      render(ValueControlButton, {
+        global: { plugins: [i18n] },
+        props: { mode: 'randomize', disabled: true },
+        attrs: { onClick }
+      })
+      const user = userEvent.setup()
+      const button = screen.getByRole('button')
+
+      expect(button).toBeDisabled()
+      await user.click(button)
+      expect(onClick).not.toHaveBeenCalled()
+    })
   })
 })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
index 0abffea10d8..4963ee50a0a 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
@@ -4,9 +4,14 @@ import { useI18n } from 'vue-i18n'
 import type { ControlOptions } from '@/types/simplifiedWidget'
 import { cn } from '@comfyorg/tailwind-utils'
 
-const { mode, variant = 'badge' } = defineProps<{
+const {
+  mode,
+  variant = 'badge',
+  disabled = false
+} = defineProps<{
   mode: ControlOptions
   variant?: 'badge' | 'button'
+  disabled?: boolean
 }>()
 
 const { t } = useI18n()
@@ -30,10 +35,11 @@ const textMap: Record<ControlOptions, string | null> = {
   <button
     data-testid="value-control"
     type="button"
+    :disabled
     :aria-label="t('widgets.valueControl.' + mode)"
     :class="
       cn(
-        'flex shrink-0 cursor-pointer items-center justify-center border-none focus-visible:ring-2 focus-visible:ring-primary-background focus-visible:ring-offset-1 focus-visible:outline-none',
+        'flex shrink-0 cursor-pointer items-center justify-center border-none focus-visible:ring-2 focus-visible:ring-primary-background focus-visible:ring-offset-1 focus-visible:outline-none disabled:cursor-default disabled:opacity-50',
         variant === 'badge' ? 'h-4.5 w-8 rounded-full' : 'size-6 rounded-sm',
         mode !== 'fixed'
           ? 'bg-primary-background/30 hover:bg-primary-background-hover/30'
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
index f032ac4334a..4e619e4d2b4 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
@@ -1,5 +1,5 @@
 <template>
-  <WidgetLayoutField :widget="widget">
+  <WidgetLayoutField :widget="widget" linked-status-rounded="lg">
     <ColorPicker
       v-model="localValue"
       :disabled="Boolean(widget.options?.disabled)"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
index e8855d7dd22..50f8cdb91c8 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
@@ -168,6 +168,34 @@ describe('WidgetInputText Value Binding', () => {
       const textarea = container.querySelector('textarea')
       expect(textarea).not.toBeInTheDocument()
     })
+
+    it('restores the same text control after a link is removed', async () => {
+      const widget = createInputTextWidget('stale prompt', {
+        disabled: true
+      })
+      widget.linkedDisplay = 'control'
+      const { rerender } = renderComponent(widget, 'stale prompt')
+
+      const linkedInput = screen.getByRole('textbox', { hidden: true })
+      expect(linkedInput).toBeDisabled()
+      expect(screen.queryByRole('textbox')).toBeNull()
+      expect(screen.getByTestId('linked-widget-content')).toHaveAttribute(
+        'inert'
+      )
+      expect(
+        screen.getByRole('status', { name: 'test_input: Linked input' })
+      ).toBeVisible()
+
+      await rerender({
+        widget: createInputTextWidget('stale prompt'),
+        modelValue: 'stale prompt'
+      })
+
+      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.getByRole('textbox')).toBeVisible()
+      expect(screen.getByRole('textbox')).toBeEnabled()
+      expect(screen.getByRole('textbox')).toHaveValue('stale prompt')
+    })
   })
 
   describe('Edge Cases', () => {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
index c2000d475b0..f97f66c3786 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
@@ -66,6 +66,7 @@ const isReadOnly = computed(() =>
 const layoutWidget = computed(() => ({
   name: widget.name,
   label: widget.label,
+  linkedDisplay: widget.linkedDisplay,
   borderStyle: cn(
     widget.borderStyle,
     invalid && 'border border-destructive-background'
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
index d345d628f88..60960ac1b46 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
@@ -1,7 +1,8 @@
 import { fromPartial } from '@total-typescript/shoehorn'
 
 import { createTestingPinia } from '@pinia/testing'
-import { render, screen } from '@testing-library/vue'
+import { render, screen, waitFor, within } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
 import PrimeVue from 'primevue/config'
 import { computed, nextTick, ref } from 'vue'
 import type { Ref } from 'vue'
@@ -38,7 +39,10 @@ vi.mock('@/scripts/api', () => ({
     fetchApi: vi.fn(),
     apiURL: vi.fn((url: string) => url),
     addEventListener: vi.fn(),
-    removeEventListener: vi.fn()
+    removeEventListener: vi.fn(),
+    getServerFeature: vi.fn(
+      (_name: string, defaultValue: unknown) => defaultValue
+    )
   }
 }))
 
@@ -214,6 +218,52 @@ describe('WidgetSelectDropdown', () => {
     expect(screen.getByText('model_a.safetensors')).toBeDefined()
   })
 
+  it('closes an open core selector when it becomes linked', async () => {
+    mockItemsRef.value = [
+      { id: 'input-0', name: 'stale.png', label: 'stale.png' }
+    ]
+    mockSelectedSetRef.value = new Set(['input-0'])
+    const widget = createMockWidget<string | undefined>({
+      value: 'stale.png',
+      name: 'image',
+      type: 'asset',
+      options: {
+        values: ['stale.png']
+      }
+    })
+    const { rerender } = renderComponent(widget, 'stale.png')
+    const user = userEvent.setup()
+
+    await user.click(screen.getByRole('button', { name: 'stale.png' }))
+    expect(await screen.findByTestId('form-dropdown-menu')).toBeVisible()
+
+    const linkedWidget: SimplifiedWidget<string | undefined> = {
+      ...widget,
+      linkedDisplay: 'control',
+      options: { ...widget.options, disabled: true }
+    }
+    await rerender({ widget: linkedWidget, modelValue: 'stale.png' })
+
+    await waitFor(() =>
+      expect(screen.queryByTestId('form-dropdown-menu')).not.toBeInTheDocument()
+    )
+
+    const content = screen.getByTestId('linked-widget-content')
+    expect(content).toHaveAttribute('inert')
+    expect(content).toHaveAttribute('aria-hidden', 'true')
+    expect(
+      screen.queryByRole('button', { name: 'stale.png' })
+    ).not.toBeInTheDocument()
+    expect(
+      screen.getByRole('status', { name: 'image: Linked input' })
+    ).toBeVisible()
+    for (const button of within(content).getAllByRole('button', {
+      hidden: true
+    })) {
+      expect(button).toBeDisabled()
+    }
+  })
+
   describe('composable wiring', () => {
     const items: FormDropdownItem[] = [
       { id: 'input-0', name: 'cat.png', label: 'cat.png' },
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
index ade6869453b..3d01964e74b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
@@ -200,6 +200,7 @@ async function updateFiles(files: File[]) {
       :show-base-model-filter
       :base-model-options
       :is-uploading
+      :close-on-disable="Boolean(widget.linkedDisplay)"
       v-bind="combinedProps"
       :loading-more="outputMediaAssets.isLoadingMore.value"
       class="w-full"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
index 27c49811b8e..61d8df55db0 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
@@ -174,6 +174,38 @@ describe('WidgetTextarea Value Binding', () => {
       expect(textarea.value).toBe('initial content')
     })
 
+    it('restores the textarea after a link is removed', async () => {
+      const widget = createTextareaWidget('stale multiline', {
+        disabled: true
+      })
+      widget.linkedDisplay = 'expanding'
+      const { rerender } = renderComponent(widget, 'stale multiline')
+      const textarea = screen.getByTestId('linked-widget-content')
+
+      expect(textarea).toBeDisabled()
+      expect(textarea).toHaveAttribute('inert')
+      expect(textarea).toHaveAttribute('aria-hidden', 'true')
+      expect(screen.queryByRole('textbox')).toBeNull()
+      textarea.focus()
+      expect(textarea).not.toHaveFocus()
+      expect(
+        screen.getByRole('status', {
+          name: 'test_textarea: Linked input'
+        })
+      ).toBeVisible()
+      expect(screen.queryByRole('button')).toBeNull()
+
+      await rerender({
+        widget: createTextareaWidget('stale multiline'),
+        modelValue: 'stale multiline'
+      })
+
+      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.getByRole('textbox')).toBeVisible()
+      expect(screen.getByRole('textbox')).toBeEnabled()
+      expect(screen.getByRole('textbox')).toHaveValue('stale multiline')
+    })
+
     it('uses widget name as placeholder when no placeholder provided', () => {
       const widget = createTextareaWidget('test')
       const { container } = renderComponent(widget, 'test')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
index 70501679199..9454e71e6b0 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
@@ -2,7 +2,8 @@
   <div
     :class="
       cn(
-        'group relative rounded-lg transition-all focus-within:ring focus-within:ring-component-node-widget-background-highlighted hover:bg-component-node-widget-background-hovered',
+        'group relative rounded-lg transition-all focus-within:ring focus-within:ring-component-node-widget-background-highlighted',
+        !isLinked && 'hover:bg-component-node-widget-background-hovered',
         widget.borderStyle
       )
     "
@@ -24,12 +25,18 @@
           WidgetInputBaseClass,
           'size-full resize-none text-(length:--comfy-textarea-font-size) leading-normal',
           !hideLayoutField && 'pt-5',
+          isLinked && 'invisible',
           // Avoid overflow-auto when idle to prevent per-textarea compositing layers.
           'overflow-hidden hover:overflow-auto focus:overflow-auto'
         )
       "
       :placeholder
       :readonly="isReadOnly"
+      :disabled="Boolean(widget.options?.disabled)"
+      :aria-hidden="isLinked ? 'true' : undefined"
+      :inert="isLinked ? true : undefined"
+      :tabindex="isLinked ? -1 : undefined"
+      :data-testid="isLinked ? 'linked-widget-content' : undefined"
       data-capture-wheel="true"
       @pointerdown.capture.stop="trackFocus"
       @pointermove.capture.stop
@@ -37,7 +44,7 @@
       @contextmenu.capture="handleContextMenu"
     />
     <Button
-      v-if="isReadOnly"
+      v-if="isReadOnly && !isLinked"
       variant="textonly"
       size="icon"
       class="invisible absolute top-1.5 right-1.5 z-10 group-focus-within:visible group-hover:visible hover:bg-base-foreground/10"
@@ -48,6 +55,7 @@
     >
       <i class="icon-[lucide--copy] size-4 text-component-node-foreground" />
     </Button>
+    <LinkedWidgetStatus v-if="isLinked" display="expanding" :widget />
   </div>
 </template>
 
@@ -67,6 +75,7 @@ import {
 } from '@/utils/widgetPropFilter'
 
 import { WidgetInputBaseClass } from './layout'
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
 
 const { widget, placeholder = '' } = defineProps<{
   widget: SimplifiedWidget<string>
@@ -95,6 +104,7 @@ const id = useId()
 const isReadOnly = computed(() =>
   Boolean(widget.options?.read_only || widget.options?.disabled)
 )
+const isLinked = computed(() => widget.linkedDisplay === 'expanding')
 
 function handleContextMenu(e: MouseEvent) {
   if (isNodeOptionsOpen() || isFocused.value) {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
index e677cd2d1d3..2f76fc3a07b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
@@ -328,6 +328,48 @@ describe('WidgetToggleSwitch Value Binding', () => {
       expect(control).not.toBeChecked()
     })
 
+    it('exposes a linked status on the implicit switch surface', () => {
+      const widget = createToggleWidget(false, { disabled: true })
+      widget.linkedDisplay = 'switch'
+      mountComponent(widget, false)
+
+      const content = screen.getByTestId('linked-widget-content')
+      const control = screen.getByRole('switch', { hidden: true })
+      expect(content).toHaveAttribute('inert')
+      expect(content).toHaveAttribute('aria-hidden', 'true')
+      expect(control).toBeDisabled()
+      expect(screen.queryByRole('switch')).toBeNull()
+      control.focus()
+      expect(control).not.toHaveFocus()
+      expect(
+        screen.getByRole('status', {
+          name: 'test_toggle: Linked input'
+        })
+      ).toHaveAttribute('data-linked-display', 'switch')
+    })
+
+    it('keeps labeled linked toggles disabled behind one control status', () => {
+      const widget = createToggleWidget(false, {
+        disabled: true,
+        on: 'enabled',
+        off: 'disabled'
+      })
+      widget.linkedDisplay = 'control'
+      mountComponent(widget, false)
+
+      const content = screen.getByTestId('linked-widget-content')
+      const controls = screen.getAllByRole('button', { hidden: true })
+      expect(content).toHaveAttribute('inert')
+      expect(content).toHaveAttribute('aria-hidden', 'true')
+      expect(screen.queryByRole('button')).toBeNull()
+      for (const control of controls) expect(control).toBeDisabled()
+      expect(
+        screen.getByRole('status', {
+          name: 'test_toggle: Linked input'
+        })
+      ).toHaveAttribute('data-linked-display', 'control')
+    })
+
     it('does not emit when clicking already-selected option', async () => {
       const widget = createToggleWidget(false, { on: 'yes', off: 'no' })
       const onModelUpdate = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
index 365e7bebbe0..6b56cc77335 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
@@ -1,5 +1,10 @@
 <template>
-  <WidgetLayoutField v-slot="{ borderStyle }" :widget :no-border="!hasLabels">
+  <WidgetLayoutField
+    v-slot="{ borderStyle }"
+    :widget
+    :no-border="!hasLabels"
+    :show-linked-status="hasLabels"
+  >
     <ToggleGroup
       v-if="hasLabels"
       type="single"
@@ -25,18 +30,27 @@
       v-else
       :class="
         cn(
-          '-m-1 flex w-fit items-center gap-2 rounded-full p-1',
+          'relative -m-1 flex w-fit items-center gap-2 rounded-full p-1',
           hideLayoutField || 'ml-auto',
           borderStyle
         )
       "
     >
-      <Switch
-        v-model="modelValue"
-        :disabled="Boolean(widget.options?.disabled)"
-        :readonly="Boolean(widget.options?.read_only)"
-        :aria-label="widget.name"
-      />
+      <div
+        class="contents"
+        :class="isLinkedSwitch && 'invisible'"
+        :aria-hidden="isLinkedSwitch ? 'true' : undefined"
+        :inert="isLinkedSwitch ? true : undefined"
+        :data-testid="isLinkedSwitch ? 'linked-widget-content' : undefined"
+      >
+        <Switch
+          v-model="modelValue"
+          :disabled="Boolean(widget.options?.disabled)"
+          :readonly="Boolean(widget.options?.read_only)"
+          :aria-label="widget.name"
+        />
+      </div>
+      <LinkedWidgetStatus v-if="isLinkedSwitch" display="switch" :widget />
     </div>
   </WidgetLayoutField>
 </template>
@@ -53,6 +67,7 @@ import { useHideLayoutField } from '@/types/widgetTypes'
 import { cn } from '@comfyorg/tailwind-utils'
 
 import { WidgetInputBaseClass } from './layout'
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
 import WidgetLayoutField from './layout/WidgetLayoutField.vue'
 
 const { widget } = defineProps<{
@@ -67,6 +82,7 @@ const { t } = useI18n()
 const hasLabels = computed(() => {
   return widget.options?.on != null || widget.options?.off != null
 })
+const isLinkedSwitch = computed(() => widget.linkedDisplay === 'switch')
 
 function handleOptionChange(value: string | undefined) {
   if (value) {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
index 4e66ae4ba4a..b4e02dce0e8 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
@@ -1,7 +1,10 @@
-import { render, screen } from '@testing-library/vue'
+import { createTestingPinia } from '@pinia/testing'
+import { fireEvent, render, screen, waitFor } from '@testing-library/vue'
 import userEvent from '@testing-library/user-event'
+import PrimeVue from 'primevue/config'
 import { describe, expect, it, vi } from 'vitest'
-import { defineComponent, nextTick } from 'vue'
+import { defineComponent, nextTick, ref } from 'vue'
+import { createI18n } from 'vue-i18n'
 
 import type {
   SafeControlWidget,
@@ -10,6 +13,7 @@ import type {
 } from '@/types/simplifiedWidget'
 
 import WidgetWithControl from './WidgetWithControl.vue'
+import ValueControlPopover from './ValueControlPopover.vue'
 import { createMockWidget } from './widgetTestUtils'
 
 const PopoverStub = defineComponent({
@@ -24,9 +28,12 @@ const PopoverStub = defineComponent({
 
 const ValueControlButtonStub = defineComponent({
   name: 'ValueControlButton',
-  props: { mode: { type: String, default: '' } },
+  props: {
+    disabled: { type: Boolean, default: false },
+    mode: { type: String, default: '' }
+  },
   template:
-    '<button data-testid="control-button" :data-mode="mode">{{ mode }}</button>'
+    '<button data-testid="control-button" :data-mode="mode" :disabled>{{ mode }}</button>'
 })
 
 const ValueControlPopoverStub = defineComponent({
@@ -43,6 +50,23 @@ const ValueControlPopoverStub = defineComponent({
   `
 })
 
+const PortaledPopoverStub = defineComponent({
+  name: 'Popover',
+  components: { ValueControlPopover },
+  setup() {
+    const open = ref(false)
+    return { open }
+  },
+  template: `
+    <span @click.capture="open = true">
+      <slot name="button" />
+    </span>
+    <Teleport v-if="open" to="body">
+      <ValueControlPopover model-value="randomize" />
+    </Teleport>
+  `
+})
+
 const RenderedComponent = defineComponent({
   name: 'RenderedComponent',
   props: {
@@ -58,6 +82,12 @@ const RenderedComponent = defineComponent({
   `
 })
 
+const i18n = createI18n({
+  legacy: false,
+  locale: 'en',
+  messages: { en: {} }
+})
+
 const makeControlWidget = (
   update: (value: WidgetValue) => void = () => {},
   initial = 'randomize'
@@ -87,6 +117,15 @@ const mount = (widget: SimplifiedControlWidget, modelValue = 0) =>
     props: { widget, modelValue, component: RenderedComponent }
   })
 
+const mountWithPortal = (widget: SimplifiedControlWidget, modelValue = 0) =>
+  render(WidgetWithControl, {
+    global: {
+      plugins: [createTestingPinia(), i18n, PrimeVue],
+      stubs: { Popover: PortaledPopoverStub }
+    },
+    props: { widget, modelValue, component: RenderedComponent }
+  })
+
 describe('WidgetWithControl', () => {
   it('renders the passed component with widget and modelValue', () => {
     mount(makeControlWidget(), 42)
@@ -119,4 +158,44 @@ describe('WidgetWithControl', () => {
     mount(makeControlWidget(update, 'randomize'))
     expect(update).not.toHaveBeenCalled()
   })
+
+  it('disables the value control with the wrapped widget', () => {
+    const widget = makeControlWidget()
+    widget.options = { disabled: true }
+    mount(widget)
+
+    expect(screen.getByTestId('control-button')).toBeDisabled()
+  })
+
+  it('unmounts an open value-control portal when linked', async () => {
+    const update = vi.fn<(value: WidgetValue) => void>()
+    const widget = makeControlWidget(update, 'randomize')
+    const { rerender } = mountWithPortal(widget)
+
+    // eslint-disable-next-line testing-library/prefer-user-event
+    await fireEvent.click(await screen.findByTestId('value-control'))
+    expect(await screen.findAllByRole('radio')).toHaveLength(4)
+
+    const linkedWidget: SimplifiedControlWidget = {
+      ...widget,
+      linkedDisplay: 'control',
+      options: { ...widget.options, disabled: true }
+    }
+    update.mockClear()
+    await rerender({
+      widget: linkedWidget,
+      modelValue: 0,
+      component: RenderedComponent
+    })
+
+    await waitFor(() => expect(screen.queryAllByRole('radio')).toHaveLength(0))
+    const linkedButton = screen.getByTestId('value-control')
+    expect(linkedButton).toBeDisabled()
+    linkedButton.focus()
+    expect(linkedButton).not.toHaveFocus()
+    const user = userEvent.setup()
+    await user.click(linkedButton)
+    await user.keyboard('{Enter}')
+    expect(update).not.toHaveBeenCalled()
+  })
 })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
index 13e35d916da..37fd480165e 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
@@ -28,12 +28,22 @@ watch(controlModel, props.widget.controlWidget.update)
 <template>
   <div class="relative grid grid-cols-subgrid">
     <component :is="component" v-bind="$attrs" v-model="modelValue" :widget>
-      <Popover>
+      <Popover v-if="!widget.linkedDisplay">
         <template #button>
-          <ValueControlButton :mode="controlModel" class="mr-1 self-center" />
+          <ValueControlButton
+            :mode="controlModel"
+            :disabled="Boolean(widget.options?.disabled)"
+            class="mr-1 self-center"
+          />
         </template>
         <ValueControlPopover v-model="controlModel" />
       </Popover>
+      <ValueControlButton
+        v-else
+        :mode="controlModel"
+        disabled
+        class="mr-1 self-center"
+      />
     </component>
   </div>
 </template>
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
index 01115dc8fb0..bafe1d33cdc 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
@@ -81,6 +81,8 @@ const MockPopover = {
 }
 
 interface MountDropdownOptions {
+  closeOnDisable?: boolean
+  disabled?: boolean
   searcher?: (
     query: string,
     items: FormDropdownItem[],
@@ -105,6 +107,8 @@ function mountDropdown(
   const result = render(FormDropdown, {
     props: {
       items,
+      closeOnDisable: options.closeOnDisable,
+      disabled: options.disabled,
       multiple: options.multiple,
       selected: options.selected,
       searcher: options.searcher,
@@ -457,6 +461,27 @@ describe('FormDropdown', () => {
     expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
   })
 
+  it('closes when a linked display disables the dropdown', async () => {
+    const onUpdateIsOpen = vi.fn()
+    const items = [createItem('1', 'alpha')]
+    const { rerender, user } = mountDropdown(items, {
+      closeOnDisable: true,
+      onUpdateIsOpen
+    })
+    await openDropdown(user)
+
+    expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+
+    await rerender({
+      items,
+      closeOnDisable: true,
+      disabled: true,
+      'onUpdate:isOpen': onUpdateIsOpen
+    })
+
+    expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
+  })
+
   it('stays open on a pointerdown inside the menu', async () => {
     const onUpdateIsOpen = vi.fn()
     const { user } = mountDropdown([createItem('1', 'alpha')], {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
index 81136a03c7f..d6daad30cae 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
@@ -7,7 +7,7 @@ import {
 } from '@vueuse/core'
 import Popover from 'primevue/popover'
 import type { ComponentPublicInstance } from 'vue'
-import { computed, ref, useTemplateRef } from 'vue'
+import { computed, ref, useTemplateRef, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 
 import { useToastStore } from '@/platform/updates/common/toastStore'
@@ -41,6 +41,7 @@ interface Props {
 
   uploadable?: boolean
   disabled?: boolean
+  closeOnDisable?: boolean
   accept?: string
   filterOptions?: FilterOption[]
   sortOptions?: SortOption[]
@@ -69,6 +70,7 @@ const {
   multiple = false,
   uploadable = false,
   disabled = false,
+  closeOnDisable = false,
   accept,
   filterOptions = [],
   sortOptions = getDefaultSortOptions(),
@@ -216,6 +218,10 @@ const closeDropdown = ({ restoreFocus = false } = {}) => {
   if (restoreFocus) focusTrigger()
 }
 
+watch([() => disabled, () => closeOnDisable], ([isDisabled, shouldClose]) => {
+  if (isDisabled && shouldClose) closeDropdown()
+})
+
 /**
  * Dismiss on `pointerdown` rather than PrimeVue's default `click` (mouseup) so
  * the dropdown closes the instant an outside press lands, and a focused inner
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
index 66486215045..248134d9e11 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
@@ -78,6 +78,7 @@ defineExpose({ focus, showPicker })
   >
     <button
       ref="buttonRef"
+      :disabled="disabled"
       :class="
         cn(
           theButtonStyle,
diff --git a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
index 53bb79cf0c4..05682c4591c 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
@@ -9,7 +9,7 @@ import WidgetLayoutField from './WidgetLayoutField.vue'
 
 type WidgetShape = Pick<
   SimplifiedWidget<string>,
-  'name' | 'label' | 'borderStyle'
+  'name' | 'label' | 'borderStyle' | 'linkedDisplay'
 >
 
 function renderField(
@@ -96,6 +96,33 @@ describe('WidgetLayoutField', () => {
       const el = screen.getByTestId('slot-border')
       expect(el.dataset.border).toContain('custom-border')
     })
+
+    it('preserves linked content in place while exposing only its status', async () => {
+      const { rerender } = render(WidgetLayoutField, {
+        props: {
+          widget: { name: 'prompt', linkedDisplay: 'control' }
+        },
+        slots: {
+          default:
+            '<button data-testid="linked-control" disabled>stale prompt</button>'
+        }
+      })
+
+      const content = screen.getByTestId('linked-widget-content')
+      const control = screen.getByRole('button', { hidden: true })
+      expect(content).toHaveAttribute('inert')
+      expect(content).toHaveAttribute('aria-hidden', 'true')
+      expect(control).toBeDisabled()
+      expect(screen.queryByRole('button')).toBeNull()
+      expect(
+        screen.getByRole('status', { name: 'prompt: Linked input' })
+      ).toBeVisible()
+
+      await rerender({ widget: { name: 'prompt' } })
+
+      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.getByRole('button', { name: 'stale prompt' })).toBeVisible()
+    })
   })
 
   // user-event models clicks/keyboard but not raw pointerdown/move/up.
diff --git a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
index d7824b8e482..32b37bbcaf9 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
@@ -5,13 +5,22 @@ import type { SimplifiedWidget } from '@/types/simplifiedWidget'
 import { useHideLayoutField } from '@/types/widgetTypes'
 import { cn } from '@comfyorg/tailwind-utils'
 
-const { widget, rootClass } = defineProps<{
+import LinkedWidgetStatus from '../LinkedWidgetStatus.vue'
+
+const {
+  widget,
+  rootClass,
+  linkedStatusRounded = 'md',
+  showLinkedStatus = true
+} = defineProps<{
   widget: Pick<
     SimplifiedWidget<string | number | undefined>,
-    'name' | 'label' | 'borderStyle'
+    'name' | 'label' | 'borderStyle' | 'linkedDisplay'
   >
   rootClass?: string
   noBorder?: boolean
+  linkedStatusRounded?: 'md' | 'lg'
+  showLinkedStatus?: boolean
 }>()
 
 const hideLayoutField = useHideLayoutField()
@@ -21,6 +30,11 @@ const borderStyle = computed(() =>
     widget.borderStyle
   )
 )
+const linkedDisplay = computed(() =>
+  showLinkedStatus && widget.linkedDisplay === 'control'
+    ? widget.linkedDisplay
+    : undefined
+)
 </script>
 
 <template>
@@ -46,7 +60,7 @@ const borderStyle = computed(() =>
       <div
         :class="
           cn(
-            'min-w-0 cursor-default rounded-md transition-all',
+            'relative min-w-0 cursor-default rounded-md transition-all',
             !noBorder && borderStyle
           )
         "
@@ -54,7 +68,21 @@ const borderStyle = computed(() =>
         @pointermove.stop
         @pointerup.stop
       >
-        <slot :border-style />
+        <div
+          class="contents"
+          :class="linkedDisplay && 'invisible'"
+          :aria-hidden="linkedDisplay ? 'true' : undefined"
+          :inert="linkedDisplay ? true : undefined"
+          :data-testid="linkedDisplay ? 'linked-widget-content' : undefined"
+        >
+          <slot :border-style />
+        </div>
+        <LinkedWidgetStatus
+          v-if="linkedDisplay"
+          :display="linkedDisplay"
+          :widget
+          :rounded="linkedStatusRounded"
+        />
       </div>
     </div>
   </div>
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
new file mode 100644
index 00000000000..92f1b7f3598
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
@@ -0,0 +1,179 @@
+import { describe, expect, it } from 'vitest'
+
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+
+import { resolveLinkedWidgetDisplay } from './linkedWidgetDisplay'
+
+const linkedContext = {
+  assetApiEnabled: false,
+  linked: true,
+  useAssetBrowser: false
+}
+
+describe('resolveLinkedWidgetDisplay', () => {
+  it.for([
+    ['text', 'control'],
+    ['string', 'control'],
+    ['STRING', 'control'],
+    ['int', 'control'],
+    ['INT', 'control'],
+    ['float', 'control'],
+    ['FLOAT', 'control'],
+    ['number', 'control'],
+    ['slider', 'control'],
+    ['boolean', 'switch'],
+    ['BOOLEAN', 'switch'],
+    ['toggle', 'switch'],
+    ['combo', 'control'],
+    ['COMBO', 'control'],
+    ['color', 'control'],
+    ['COLOR', 'control'],
+    ['textarea', 'expanding'],
+    ['TEXTAREA', 'expanding'],
+    ['multiline', 'expanding'],
+    ['customtext', 'expanding']
+  ] as const)('maps the registered %s type to %s', ([type, display]) => {
+    expect(
+      resolveLinkedWidgetDisplay(
+        { name: 'value', type },
+        undefined,
+        linkedContext
+      )
+    ).toBe(display)
+  })
+
+  it.for([
+    'String',
+    'CoMbO',
+    'asset',
+    'gradientslider',
+    'range',
+    'curve',
+    'imagecrop',
+    'boundingbox',
+    'chart',
+    'galleria',
+    'colors',
+    'audiorecord',
+    'markdown',
+    'load3D',
+    'painter',
+    'imagecompare',
+    'boundingboxes',
+    'videoedit',
+    'legacy',
+    'custom_widget'
+  ])('leaves the linked %s type rendered', (type) => {
+    expect(
+      resolveLinkedWidgetDisplay(
+        { name: 'value', type },
+        undefined,
+        linkedContext
+      )
+    ).toBeUndefined()
+  })
+
+  it('leaves upload and asset-browser combos rendered', () => {
+    expect(
+      resolveLinkedWidgetDisplay(
+        {
+          name: 'image',
+          type: 'COMBO',
+          spec: { type: 'COMBO', name: 'image', image_upload: true }
+        },
+        undefined,
+        linkedContext
+      )
+    ).toBeUndefined()
+    expect(
+      resolveLinkedWidgetDisplay(
+        { name: 'ckpt_name', type: 'COMBO' },
+        undefined,
+        { ...linkedContext, useAssetBrowser: true }
+      )
+    ).toBeUndefined()
+  })
+
+  it.for([
+    {
+      nodeType: 'LoadImage',
+      name: 'image',
+      type: 'asset',
+      spec: { type: 'COMBO', name: 'image', image_upload: true }
+    },
+    {
+      nodeType: 'LoadVideo',
+      name: 'file',
+      type: 'COMBO',
+      spec: { type: 'COMBO', name: 'file', video_upload: true }
+    },
+    {
+      nodeType: 'LoadAudio',
+      name: 'audio',
+      type: 'combo',
+      spec: { type: 'COMBO', name: 'audio', audio_upload: true }
+    }
+  ] satisfies Array<{
+    nodeType: string
+    name: string
+    type: string
+    spec: InputSpec
+  }>)(
+    'includes the linked core $nodeType $name selector',
+    ({ nodeType, name, type, spec }) => {
+      expect(
+        resolveLinkedWidgetDisplay({ name, type, spec }, undefined, {
+          ...linkedContext,
+          assetApiEnabled: type === 'asset',
+          coreNodeType: nodeType,
+          useAssetBrowser: type === 'asset'
+        })
+      ).toBe('control')
+    }
+  )
+
+  it.for([
+    {
+      label: 'custom node with a core type name',
+      widget: {
+        name: 'image',
+        type: 'COMBO',
+        spec: { type: 'COMBO', name: 'image', image_upload: true }
+      },
+      coreNodeType: undefined
+    },
+    {
+      label: 'core node with the wrong widget name',
+      widget: {
+        name: 'custom_image',
+        type: 'COMBO',
+        spec: {
+          type: 'COMBO',
+          name: 'custom_image',
+          image_upload: true
+        }
+      },
+      coreNodeType: 'LoadImage'
+    },
+    {
+      label: 'core node with an unregistered mixed-case widget',
+      widget: {
+        name: 'image',
+        type: 'CoMbO',
+        spec: { type: 'COMBO', name: 'image', image_upload: true }
+      },
+      coreNodeType: 'LoadImage'
+    }
+  ] satisfies Array<{
+    label: string
+    widget: { name: string; type: string; spec: InputSpec }
+    coreNodeType: string | undefined
+  }>)('excludes a $label', ({ widget, coreNodeType }) => {
+    expect(
+      resolveLinkedWidgetDisplay(widget, undefined, {
+        ...linkedContext,
+        coreNodeType
+      })
+    ).toBeUndefined()
+  })
+})
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
new file mode 100644
index 00000000000..f4c58ed08ee
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
@@ -0,0 +1,60 @@
+import type { IWidgetOptions } from '@/lib/litegraph/src/types/widgets'
+import { getLinkedWidgetFamily } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { LinkedWidgetDisplay } from '@/types/simplifiedWidget'
+
+interface LinkedWidgetDisplayWidget {
+  name: string
+  type: string
+  spec?: InputSpec
+}
+
+interface LinkedWidgetDisplayContext {
+  assetApiEnabled: boolean
+  coreNodeType?: string
+  linked: boolean
+  useAssetBrowser: boolean
+}
+
+const CORE_MEDIA_SELECTOR_WIDGETS = new Map([
+  ['LoadImage', 'image'],
+  ['LoadVideo', 'file'],
+  ['LoadAudio', 'audio']
+])
+
+function isCoreMediaSelector(
+  widget: LinkedWidgetDisplayWidget,
+  context: LinkedWidgetDisplayContext
+): boolean {
+  return (
+    CORE_MEDIA_SELECTOR_WIDGETS.get(context.coreNodeType ?? '') ===
+      widget.name &&
+    (widget.type === 'asset' || getLinkedWidgetFamily(widget.type) === 'combo')
+  )
+}
+
+export function resolveLinkedWidgetDisplay(
+  widget: LinkedWidgetDisplayWidget,
+  options: IWidgetOptions | undefined,
+  context: LinkedWidgetDisplayContext
+): LinkedWidgetDisplay | undefined {
+  if (!context.linked) return undefined
+
+  const family = getLinkedWidgetFamily(widget.type)
+  if (isCoreMediaSelector(widget, context)) return 'control'
+  if (!family) return undefined
+
+  if (family === 'combo') {
+    const mode = resolveWidgetSelectMode(widget, context)
+    if (mode.isDropdownUIWidget) return undefined
+  }
+
+  if (family === 'textarea') return 'expanding'
+
+  if (family === 'boolean' && options?.on == null && options?.off == null) {
+    return 'switch'
+  }
+
+  return 'control'
+}
diff --git a/src/types/simplifiedWidget.ts b/src/types/simplifiedWidget.ts
index 54682225769..30152e15239 100644
--- a/src/types/simplifiedWidget.ts
+++ b/src/types/simplifiedWidget.ts
@@ -45,6 +45,8 @@ export interface LinkedUpstreamInfo {
   outputName?: string
 }
 
+export type LinkedWidgetDisplay = 'control' | 'expanding' | 'switch'
+
 export interface SimplifiedWidget<
   T extends WidgetValue = WidgetValue,
   O extends IWidgetOptions = IWidgetOptions
@@ -89,6 +91,8 @@ export interface SimplifiedWidget<
   controlWidget?: SafeControlWidget
 
   linkedUpstream?: LinkedUpstreamInfo
+
+  linkedDisplay?: LinkedWidgetDisplay
 }
 
 export interface SimplifiedControlWidget<
diff --git a/tools/devtools/dev_nodes.py b/tools/devtools/dev_nodes.py
index 660518d846b..31763cdfa46 100644
--- a/tools/devtools/dev_nodes.py
+++ b/tools/devtools/dev_nodes.py
@@ -7,6 +7,8 @@
     ErrorRaiseNodeWithMessage,
     ExperimentalNode,
     LoadAnimatedImageTest,
+    LinkedStandardWidgetSource,
+    LinkedStandardWidgets,
     LongComboDropdown,
     MultiSelectNode,
     NodeWithBooleanInput,
@@ -40,6 +42,8 @@
     "ErrorRaiseNodeWithMessage",
     "ExperimentalNode",
     "LoadAnimatedImageTest",
+    "LinkedStandardWidgetSource",
+    "LinkedStandardWidgets",
     "LongComboDropdown",
     "MultiSelectNode",
     "NodeWithBooleanInput",
diff --git a/tools/devtools/nodes/__init__.py b/tools/devtools/nodes/__init__.py
index f0ac2d8ee8f..8e26c78df8c 100644
--- a/tools/devtools/nodes/__init__.py
+++ b/tools/devtools/nodes/__init__.py
@@ -9,6 +9,8 @@
     NODE_DISPLAY_NAME_MAPPINGS as errors_display_name_mappings,
 )
 from .inputs import (
+    LinkedStandardWidgetSource,
+    LinkedStandardWidgets,
     LongComboDropdown,
     NodeWithBooleanInput,
     NodeWithDefaultInput,
@@ -66,6 +68,8 @@
     "ErrorRaiseNodeWithMessage",
     "ExperimentalNode",
     "LoadAnimatedImageTest",
+    "LinkedStandardWidgetSource",
+    "LinkedStandardWidgets",
     "LongComboDropdown",
     "MultiSelectNode",
     "NodeWithBooleanInput",
diff --git a/tools/devtools/nodes/inputs.py b/tools/devtools/nodes/inputs.py
index a219865dcd1..ebe7ed1b46d 100644
--- a/tools/devtools/nodes/inputs.py
+++ b/tools/devtools/nodes/inputs.py
@@ -243,6 +243,113 @@ def execute(self, value):
         return (value,)
 
 
+class LinkedStandardWidgetSource:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = (
+        "STRING",
+        "INT",
+        "FLOAT",
+        "FLOAT",
+        "BOOLEAN",
+        "BOOLEAN",
+        "COMBO",
+        "COLOR",
+        "STRING",
+    )
+    RETURN_NAMES = (
+        "plain_text",
+        "integer",
+        "number",
+        "slider",
+        "switch",
+        "labeled_toggle",
+        "select",
+        "color",
+        "textarea",
+    )
+    FUNCTION = "source_values"
+    CATEGORY = "DevTools"
+
+    def source_values(self):
+        return (
+            "upstream text",
+            1,
+            2.5,
+            0.5,
+            False,
+            True,
+            "Option 1",
+            "#ffffff",
+            "upstream multiline text",
+        )
+
+
+class LinkedStandardWidgets:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "plain_text": (
+                    "STRING",
+                    {"default": "STALE PLAIN TEXT"},
+                ),
+                "integer": (
+                    "INT",
+                    {"default": 314, "min": 0, "max": 1_000, "step": 1},
+                ),
+                "number": (
+                    "FLOAT",
+                    {"default": 9.875, "min": 0, "max": 10, "step": 0.125},
+                ),
+                "slider": (
+                    "FLOAT",
+                    {
+                        "default": 0.73,
+                        "display": "slider",
+                        "min": 0,
+                        "max": 1,
+                        "step": 0.01,
+                    },
+                ),
+                "switch": ("BOOLEAN", {"default": True}),
+                "labeled_toggle": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "label_on": "STALE ON",
+                        "label_off": "STALE OFF",
+                    },
+                ),
+                "select": (
+                    "COMBO",
+                    {
+                        "default": "STALE SELECT VALUE",
+                        "options": ["Option 1", "STALE SELECT VALUE"],
+                    },
+                ),
+                "color": ("COLOR", {"default": "#22c55d"}),
+                "textarea": (
+                    "STRING",
+                    {
+                        "default": "STALE MULTILINE PROMPT",
+                        "multiline": True,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    FUNCTION = "inspect"
+    CATEGORY = "DevTools"
+
+    def inspect(self, **_inputs):
+        return ()
+
+
 class NodeWithSeedInput:
     @classmethod
     def INPUT_TYPES(cls):
@@ -422,6 +529,8 @@ def noop(self):
     "DevToolsNodeWithUnionInput": NodeWithUnionInput,
     "DevToolsNodeWithBooleanInput": NodeWithBooleanInput,
     "DevToolsSimpleSlider": SimpleSlider,
+    "DevToolsLinkedStandardWidgetSource": LinkedStandardWidgetSource,
+    "DevToolsLinkedStandardWidgets": LinkedStandardWidgets,
     "DevToolsNodeWithSeedInput": NodeWithSeedInput,
     "DevToolsNodeWithValidation": NodeWithValidation,
     "DevToolsNodeWithV2ComboInput": NodeWithV2ComboInput,
@@ -444,6 +553,8 @@ def noop(self):
     "DevToolsNodeWithUnionInput": "Node With Union Input",
     "DevToolsNodeWithBooleanInput": "Node With Boolean Input",
     "DevToolsSimpleSlider": "Simple Slider",
+    "DevToolsLinkedStandardWidgetSource": "Linked Standard Widget Source",
+    "DevToolsLinkedStandardWidgets": "Linked Standard Widgets",
     "DevToolsNodeWithSeedInput": "Node With Seed Input",
     "DevToolsNodeWithValidation": "Node With Validation",
     "DevToolsNodeWithV2ComboInput": "Node With V2 Combo Input",
@@ -465,6 +576,8 @@ def noop(self):
     "NodeWithStringInput",
     "NodeWithUnionInput",
     "NodeWithBooleanInput",
+    "LinkedStandardWidgetSource",
+    "LinkedStandardWidgets",
     "SimpleSlider",
     "NodeWithSeedInput",
     "NodeWithValidation",

From 309b5c5b1fa15acdbfac55098c96f87ddf49cd0d Mon Sep 17 00:00:00 2001
From: github-actions <github-actions@github.com>
Date: Mon, 10 Aug 2026 03:41:50 +0000
Subject: [PATCH 04/18] [automated] Update test expectations

---
 .../linked-standard-widgets-chromium-linux.png  | Bin 0 -> 17764 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png

diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png
new file mode 100644
index 0000000000000000000000000000000000000000..67f304fad8d3153eef32e1fcd5efab0166febeb2
GIT binary patch
literal 17764
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

literal 0
HcmV?d00001


From 9c6188b1cde8e7fd1a8c96358697bb1507789ac8 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 12:57:56 +0900
Subject: [PATCH 05/18] test: harden linked widget regression coverage

---
 .../widgets/int/integerWidget.spec.ts         |  2 +-
 .../linked/linkedStandardWidgets.spec.ts      | 31 +++++++------------
 .../text/multilineStringWidget.spec.ts        |  2 +-
 .../parameters/WidgetItem.test.ts             |  5 ++-
 .../form/dropdown/FormDropdown.test.ts        | 17 ++++++++++
 5 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
index 1ca97d9dabc..ac618bf12ce 100644
--- a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
@@ -53,7 +53,7 @@ test.describe('Vue Integer Widget', { tag: '@vue-nodes' }, () => {
     await expect(controls.input).toHaveValue(initialValue.toString())
     await expect
       .poll(async () => (await samplerNode.boundingBox())?.height)
-      .toBe(nodeBounds.height)
+      .toBeCloseTo(nodeBounds.height, 0)
   })
 
   test('displays control widgets with default state', async ({ comfyPage }) => {
diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
index 8b4830fc1a3..4dd41727576 100644
--- a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -98,18 +98,16 @@ test.describe(
         ).toBe(false)
       }
 
-      await expect(
-        targetNode.getByText('STALE SELECT VALUE', { exact: true })
-      ).toBeHidden()
-      await expect(
-        targetNode.getByText('STALE ON', { exact: true })
-      ).toBeHidden()
-      await expect(
-        targetNode.getByText('STALE OFF', { exact: true })
-      ).toBeHidden()
-      await expect(
-        targetNode.getByText('#22c55d', { exact: true })
-      ).toBeHidden()
+      for (const text of [
+        'STALE SELECT VALUE',
+        'STALE ON',
+        'STALE OFF',
+        '#22c55d'
+      ]) {
+        const staleValue = targetNode.getByText(text, { exact: true })
+        await expect(staleValue).toBeAttached()
+        await expect(staleValue).toBeHidden()
+      }
 
       const widgetRefs = await Promise.all(
         WIDGET_NAMES.map((name) => targetNodeRef.getWidgetByName(name))
@@ -127,14 +125,7 @@ test.describe(
 
       for (let index = 0; index < WIDGET_NAMES.length + 2; index++) {
         await comfyPage.page.keyboard.press('Tab')
-        expect(
-          await targetNode.evaluate(
-            (node) =>
-              node.querySelector(
-                '[data-testid="linked-widget-content"]:focus-within'
-              ) !== null
-          )
-        ).toBe(false)
+        await expect(linkedContent.locator(':focus-within')).toHaveCount(0)
       }
 
       await expect
diff --git a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
index e793de778d1..0437c8a16ba 100644
--- a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
@@ -93,7 +93,7 @@ test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
     await expect(restoredTextarea).toHaveValue('restored local prompt')
     await expect
       .poll(async () => (await clipNode.boundingBox())?.height)
-      .toBe(nodeBounds.height)
+      .toBeCloseTo(nodeBounds.height, 0)
   })
 
   test('should use native context menu when focused', async ({ comfyPage }) => {
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 94a572fec86..024a56ad48d 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -99,7 +99,9 @@ const i18n = createI18n({
   }
 })
 
-function createMockNode(overrides: Record<string, unknown> = {}): LGraphNode {
+function createMockNode(
+  overrides: Partial<Record<keyof LGraphNode, unknown>> = {}
+): LGraphNode {
   return fromAny<LGraphNode, unknown>({
     id: 1,
     type: 'TestNode',
@@ -156,6 +158,7 @@ describe('WidgetItem', () => {
     mockIsAssetAPIEnabled.mockReturnValue(false)
     mockShouldUseAssetBrowser.mockReturnValue(false)
     mockFromLGraphNode.mockReturnValue(null)
+    mockGetInputSpecForWidget.mockReset()
   })
 
   describe('widget state rendering', () => {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
index bafe1d33cdc..647a0aaa52b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
@@ -482,6 +482,23 @@ describe('FormDropdown', () => {
     expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
   })
 
+  it('stays open when disabled without closeOnDisable', async () => {
+    const onUpdateIsOpen = vi.fn()
+    const items = [createItem('1', 'alpha')]
+    const { rerender, user } = mountDropdown(items, { onUpdateIsOpen })
+    await openDropdown(user)
+
+    expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+
+    await rerender({
+      items,
+      disabled: true,
+      'onUpdate:isOpen': onUpdateIsOpen
+    })
+
+    expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+  })
+
   it('stays open on a pointerdown inside the menu', async () => {
     const onUpdateIsOpen = vi.fn()
     const { user } = mountDropdown([createItem('1', 'alpha')], {

From 5edf757c798a485a1e505678b28096b4d527dbb4 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 13:09:36 +0900
Subject: [PATCH 06/18] test: cover direct linked widget focus

---
 .../vueNodes/widgets/linked/linkedStandardWidgets.spec.ts    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
index 4dd41727576..48cb9b990a8 100644
--- a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -42,6 +42,9 @@ test.describe(
       const linkedContent = targetNode.getByTestId(
         TestIds.widgets.linkedContent
       )
+      const focusedLinkedContent = targetNode.locator(
+        `[data-testid="${TestIds.widgets.linkedContent}"]:focus-within`
+      )
       await expect(statuses).toHaveCount(WIDGET_NAMES.length)
       await expect(linkedContent).toHaveCount(WIDGET_NAMES.length)
 
@@ -125,7 +128,7 @@ test.describe(
 
       for (let index = 0; index < WIDGET_NAMES.length + 2; index++) {
         await comfyPage.page.keyboard.press('Tab')
-        await expect(linkedContent.locator(':focus-within')).toHaveCount(0)
+        await expect(focusedLinkedContent).toHaveCount(0)
       }
 
       await expect

From 92783aa4e6251ce6682788609a6b0cd897721894 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 13:51:03 +0900
Subject: [PATCH 07/18] fix: retain promoted widget actions when linked

---
 .../fixtures/utils/promotedMissingModel.ts    | 21 +++++++++++-------
 .../tests/subgraph/subgraphNested.spec.ts     | 22 +++++++++++++------
 .../tests/subgraph/subgraphPromotion.spec.ts  | 16 +++++++++-----
 .../subgraph/subgraphPromotionDom.spec.ts     | 12 ++++++----
 .../subgraph/subgraphSerialization.spec.ts    | 13 +++++++----
 .../tests/subgraph/subgraphSlots.spec.ts      | 16 +++++++++-----
 .../vueNodes/widgets/advancedWidgets.spec.ts  |  5 ++++-
 .../composables/useProcessedWidgets.test.ts   |  5 +++--
 .../composables/useProcessedWidgets.ts        |  4 ----
 9 files changed, 73 insertions(+), 41 deletions(-)

diff --git a/browser_tests/fixtures/utils/promotedMissingModel.ts b/browser_tests/fixtures/utils/promotedMissingModel.ts
index 1984e118701..9e0d5a24494 100644
--- a/browser_tests/fixtures/utils/promotedMissingModel.ts
+++ b/browser_tests/fixtures/utils/promotedMissingModel.ts
@@ -235,18 +235,23 @@ export async function expectResolvedPromotedModelSuppressesStaleInteriorErrors(
     const node = comfyPage.vueNodes.getNodeByTitle(step.nodeTitle)
     await expect(node).toBeVisible()
 
-    const staleCombo = node.getByRole('combobox', {
-      name: PROMOTED_MODEL_WIDGET_NAME,
+    const linkedStatus = node.getByRole('status', {
+      name: `${PROMOTED_MODEL_WIDGET_NAME}: Linked input`,
       exact: true
     })
     await expect(
-      staleCombo,
-      `${step.nodeTitle} should expose the stale linked interior widget`
-    ).toBeDisabled()
+      linkedStatus,
+      `${step.nodeTitle} should expose the linked interior status`
+    ).toBeVisible()
+    const staleValue = node.getByText(staleModelName, { exact: true })
     await expect(
-      staleCombo,
-      `${step.nodeTitle} should keep the stale interior value`
-    ).toContainText(staleModelName)
+      staleValue,
+      `${step.nodeTitle} should retain the stale interior value`
+    ).toBeAttached()
+    await expect(
+      staleValue,
+      `${step.nodeTitle} should hide the stale interior value`
+    ).toBeHidden()
     await expectNoMissingModelUi(comfyPage)
   }
 }
diff --git a/browser_tests/tests/subgraph/subgraphNested.spec.ts b/browser_tests/tests/subgraph/subgraphNested.spec.ts
index 7b30330e96a..0b6450cfd8a 100644
--- a/browser_tests/tests/subgraph/subgraphNested.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphNested.spec.ts
@@ -64,13 +64,21 @@ test.describe('Nested Subgraphs', { tag: ['@subgraph'] }, () => {
         await comfyExpect(innerNode).toBeVisible()
 
         const innerTextboxes = innerNode.getByRole('textbox')
-        await comfyExpect(innerTextboxes).toHaveCount(2)
-        const innerValues = await innerTextboxes.evaluateAll<
-          string[],
-          HTMLInputElement
-        >((boxes) => boxes.map((b) => b.value))
-        comfyExpect(innerValues).toContain('11111111111')
-        comfyExpect(innerValues).toContain('22222222222')
+        await comfyExpect(innerTextboxes).toHaveCount(1)
+        await comfyExpect(innerTextboxes).toHaveValue('11111111111')
+
+        await comfyExpect(
+          innerNode.getByRole('status', {
+            name: 'text_1: Linked input',
+            exact: true
+          })
+        ).toBeVisible()
+        const linkedTextbox = innerNode.getByTestId(
+          TestIds.widgets.linkedContent
+        )
+        await comfyExpect(linkedTextbox).toHaveCount(1)
+        await comfyExpect(linkedTextbox).toHaveValue('22222222222')
+        await comfyExpect(linkedTextbox).toBeHidden()
       })
     }
   )
diff --git a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
index b7ebc8fea3d..976eb3dcdf3 100644
--- a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
@@ -377,12 +377,18 @@ test.describe(
             .toEqual(expect.arrayContaining(['string_a', 'value']))
 
           const subgraphNode = comfyPage.vueNodes.getNodeLocator('5')
-          const linkedTextarea = subgraphNode.getByRole('textbox', {
-            name: 'string_a',
-            exact: true
-          })
-          await expect(linkedTextarea).toBeVisible()
+          await expect(
+            subgraphNode.getByRole('status', {
+              name: 'string_a: Linked input',
+              exact: true
+            })
+          ).toBeVisible()
+          const linkedTextarea = subgraphNode.getByTestId(
+            TestIds.widgets.linkedContent
+          )
+          await expect(linkedTextarea).toHaveCount(1)
           await expect(linkedTextarea).toBeDisabled()
+          await expect(linkedTextarea).toBeHidden()
 
           const allTextareas = subgraphNode.getByRole('textbox')
           await expect(allTextareas.first()).toBeVisible()
diff --git a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
index eb44157d899..ea2ddcd725f 100644
--- a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
@@ -152,10 +152,14 @@ test.describe(
 
           await openSubgraphById(comfyPage, '11')
 
-          const interiorTextareas = comfyPage.page
-            .locator('[data-node-id]')
-            .getByRole('textbox')
-          await expect(interiorTextareas).toHaveCount(2)
+          const interiorNodes = comfyPage.page.locator('[data-node-id]')
+          await expect(interiorNodes.getByRole('textbox')).toHaveCount(0)
+          await expect(
+            interiorNodes.getByRole('status', {
+              name: 'text: Linked input',
+              exact: true
+            })
+          ).toHaveCount(2)
 
           await comfyPage.subgraph.exitViaBreadcrumb()
 
diff --git a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
index ebaae234d91..880364faed2 100644
--- a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
@@ -733,11 +733,16 @@ test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
         const outerNode = comfyPage.vueNodes.getNodeLocator('5')
         await expect(outerNode).toBeVisible()
 
-        const textarea = outerNode
-          .getByRole('textbox', { name: 'string_a' })
-          .first()
-        await expect(textarea).toBeVisible()
+        await expect(
+          outerNode.getByRole('status', {
+            name: 'string_a: Linked input',
+            exact: true
+          })
+        ).toBeVisible()
+        const textarea = outerNode.getByTestId(TestIds.widgets.linkedContent)
+        await expect(textarea).toHaveCount(1)
         await expect(textarea).toBeDisabled()
+        await expect(textarea).toBeHidden()
       })
 
       test('No legacy-prefixed or disconnected widgets remain on the node', async ({
diff --git a/browser_tests/tests/subgraph/subgraphSlots.spec.ts b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
index a10b9cbfd17..43034acbf4d 100644
--- a/browser_tests/tests/subgraph/subgraphSlots.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
@@ -419,9 +419,12 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
       const subgraphNode = comfyPage.vueNodes.getNodeLocator('19')
       await expect(subgraphNode).toBeVisible()
 
-      const seedWidget = subgraphNode.getByLabel('seed', { exact: true })
-      await expect(seedWidget).toBeVisible()
-      await SubgraphHelper.expectWidgetBelowHeader(subgraphNode, seedWidget)
+      const seedStatus = subgraphNode.getByRole('status', {
+        name: 'renamed_seed: Linked input',
+        exact: true
+      })
+      await expect(seedStatus).toBeVisible()
+      await SubgraphHelper.expectWidgetBelowHeader(subgraphNode, seedStatus)
 
       await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
 
@@ -475,16 +478,17 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
         )
         .toBe(RENAMED_LABEL)
 
-      const seedWidgetAfter = subgraphNodeAfter.getByLabel('seed', {
+      const seedStatusAfter = subgraphNodeAfter.getByRole('status', {
+        name: `${RENAMED_LABEL}: Linked input`,
         exact: true
       })
-      await expect(seedWidgetAfter).toBeVisible()
+      await expect(seedStatusAfter).toBeVisible()
       await expect(
         subgraphNodeAfter.getByText(RENAMED_LABEL, { exact: true })
       ).toBeVisible()
       await SubgraphHelper.expectWidgetBelowHeader(
         subgraphNodeAfter,
-        seedWidgetAfter
+        seedStatusAfter
       )
     })
   })
diff --git a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
index 6452587bd71..8546ac7048f 100644
--- a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
@@ -124,7 +124,10 @@ test.describe('Advanced Widget Visibility', { tag: '@vue-nodes' }, () => {
 
     await node.getByText(HIDE_ADVANCED_INPUTS).click()
 
-    await expect(maxShiftWidget).toBeVisible()
+    await expect(
+      node.getByRole('status', { name: 'max_shift: Linked input' })
+    ).toBeVisible()
+    await expect(maxShiftWidget).toBeHidden()
     await expect(baseShiftWidget).toBeHidden()
   })
 
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index 94bd5439516..deb490218ab 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -948,7 +948,7 @@ describe('computeProcessedWidgets linked presentation', () => {
     })
   })
 
-  it('opens only node actions for a hidden linked widget', () => {
+  it('retains widget actions for a hidden linked widget', () => {
     const handleNodeRightClick = vi.fn()
     const event = fromAny<PointerEvent, unknown>({
       preventDefault: vi.fn(),
@@ -956,6 +956,7 @@ describe('computeProcessedWidgets linked presentation', () => {
     })
     const widget = createMockWidget({
       name: 'prompt',
+      nodeId: NODE_ID,
       type: 'text',
       slotMetadata: linkedSlot
     })
@@ -966,7 +967,7 @@ describe('computeProcessedWidgets linked presentation', () => {
     })[0].handleContextMenu(event)
 
     expect(handleNodeRightClick).toHaveBeenCalledWith(event, NODE_ID)
-    expect(showNodeOptions).toHaveBeenCalledWith(event)
+    expect(showNodeOptions).toHaveBeenCalledWith(event, 'prompt', NODE_ID)
   })
 
   it('retains widget actions when the widget is unlinked', () => {
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
index 1c7234646d0..f16cc7e85cf 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts
@@ -404,10 +404,6 @@ export function computeProcessedWidgets({
       e.preventDefault()
       e.stopPropagation()
       if (nodeId !== undefined) ui.handleNodeRightClick(e, nodeId)
-      if (linkedDisplay) {
-        showNodeOptions(e)
-        return
-      }
       showNodeOptions(
         e,
         widget.name,

From 711cd324f1338da309e173188d14c461caf6da0b Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 10 Aug 2026 18:41:44 +0900
Subject: [PATCH 08/18] test: split linked widget browser coverage

---
 .../linked/linkedStandardWidgets.spec.ts      | 133 +++++++++++-------
 1 file changed, 82 insertions(+), 51 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
index 48cb9b990a8..4ef493c05b2 100644
--- a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -20,42 +20,60 @@ const WIDGET_NAMES = [
 
 test.describe(
   'Linked standard Vue widgets',
-  { tag: ['@vue-nodes', '@widget', '@node', '@screenshot'] },
+  { tag: ['@vue-nodes', '@widget', '@node'] },
   () => {
-    test('preserves each control surface while making stale values inert', async ({
-      comfyPage
-    }) => {
+    test.beforeEach(async ({ comfyPage }) => {
       await comfyPage.page.setViewportSize({ width: 1280, height: 900 })
       await comfyPage.workflow.loadWorkflow('vueNodes/linked-standard-widgets')
+    })
 
-      const [targetNodeRef] =
-        await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
-      if (!targetNodeRef) throw new Error('Target DevTools node was not loaded')
-      await targetNodeRef.centerOnNode()
+    test(
+      'renders each linked control surface',
+      { tag: '@screenshot' },
+      async ({ comfyPage }) => {
+        const [targetNodeRef] =
+          await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
+        if (!targetNodeRef)
+          throw new Error('Target DevTools node was not loaded')
+        await targetNodeRef.centerOnNode()
+
+        const targetNode = comfyPage.vueNodes
+          .getNodeByTitle(TARGET_NODE_TITLE)
+          .first()
+        await expect(targetNode).toBeVisible()
+
+        const statuses = targetNode.getByTestId(
+          TestIds.widgets.linkedPlaceholder
+        )
+        await expect(statuses).toHaveCount(WIDGET_NAMES.length)
+
+        for (const name of WIDGET_NAMES) {
+          await expect(
+            targetNode.getByRole('status', {
+              name: `${name}: Linked input`
+            })
+          ).toBeVisible()
+        }
+
+        await comfyPage.nextFrame()
+        await comfyPage.nextFrame()
+        await expect(targetNode).toHaveScreenshot('linked-standard-widgets.png')
+      }
+    )
 
+    test('keeps linked controls inaccessible to focus', async ({
+      comfyPage
+    }) => {
       const targetNode = comfyPage.vueNodes
         .getNodeByTitle(TARGET_NODE_TITLE)
         .first()
       await expect(targetNode).toBeVisible()
 
-      const statuses = targetNode.getByTestId(TestIds.widgets.linkedPlaceholder)
       const linkedContent = targetNode.getByTestId(
         TestIds.widgets.linkedContent
       )
-      const focusedLinkedContent = targetNode.locator(
-        `[data-testid="${TestIds.widgets.linkedContent}"]:focus-within`
-      )
-      await expect(statuses).toHaveCount(WIDGET_NAMES.length)
       await expect(linkedContent).toHaveCount(WIDGET_NAMES.length)
 
-      for (const name of WIDGET_NAMES) {
-        await expect(
-          targetNode.getByRole('status', {
-            name: `${name}: Linked input`
-          })
-        ).toBeVisible()
-      }
-
       for (let index = 0; index < WIDGET_NAMES.length; index++) {
         await expect(linkedContent.nth(index)).toHaveAttribute('inert', '')
         await expect(linkedContent.nth(index)).toHaveAttribute(
@@ -71,35 +89,47 @@ test.describe(
       const interactiveCount = await interactive.count()
       expect(interactiveCount).toBeGreaterThan(WIDGET_NAMES.length)
 
-      const disabled = await interactive.evaluateAll((elements) =>
+      const controlStates = await interactive.evaluateAll((elements) =>
         elements.map((element) => {
-          if (
+          const disabled =
             element instanceof HTMLButtonElement ||
             element instanceof HTMLInputElement ||
             element instanceof HTMLTextAreaElement
-          ) {
-            return element.disabled
+              ? element.disabled
+              : element.getAttribute('aria-disabled') === 'true' ||
+                element.hasAttribute('data-disabled')
+
+          if (element instanceof HTMLElement) element.focus()
+
+          return {
+            disabled,
+            focused: document.activeElement === element
           }
-          return (
-            element.getAttribute('aria-disabled') === 'true' ||
-            element.hasAttribute('data-disabled')
-          )
         })
       )
-      expect(disabled.every(Boolean)).toBe(true)
+      expect(controlStates.every(({ disabled }) => disabled)).toBe(true)
+      expect(controlStates.every(({ focused }) => !focused)).toBe(true)
 
       for (let index = 0; index < interactiveCount; index++) {
-        const control = interactive.nth(index)
-        await expect(control).toBeHidden()
-        await control.evaluate((element) => {
-          if (element instanceof HTMLElement) element.focus()
-        })
-        expect(
-          await control.evaluate(
-            (element) => document.activeElement === element
-          )
-        ).toBe(false)
+        await expect(interactive.nth(index)).toBeHidden()
       }
+    })
+
+    test('ignores pointer and keyboard input on linked controls', async ({
+      comfyPage
+    }) => {
+      const [targetNodeRef] =
+        await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
+      if (!targetNodeRef) throw new Error('Target DevTools node was not loaded')
+
+      const targetNode = comfyPage.vueNodes
+        .getNodeByTitle(TARGET_NODE_TITLE)
+        .first()
+      await expect(targetNode).toBeVisible()
+
+      const focusedLinkedContent = targetNode.locator(
+        `[data-testid="${TestIds.widgets.linkedContent}"]:focus-within`
+      )
 
       for (const text of [
         'STALE SELECT VALUE',
@@ -119,25 +149,26 @@ test.describe(
         widgetRefs.map((widget) => widget.getValue())
       )
 
-      for (let index = 0; index < WIDGET_NAMES.length; index++) {
-        await statuses.nth(index).click()
-      }
+      await targetNode
+        .getByRole('status', { name: 'switch: Linked input' })
+        .click()
       await comfyPage.page.keyboard.press('Space')
+
+      await targetNode
+        .getByRole('status', { name: 'select: Linked input' })
+        .click()
       await comfyPage.page.keyboard.press('ArrowUp')
       await comfyPage.page.keyboard.press('Enter')
 
-      for (let index = 0; index < WIDGET_NAMES.length + 2; index++) {
-        await comfyPage.page.keyboard.press('Tab')
-        await expect(focusedLinkedContent).toHaveCount(0)
-      }
+      await targetNode
+        .getByRole('status', { name: 'textarea: Linked input' })
+        .click()
+      await comfyPage.page.keyboard.type('ignored input')
+      await expect(focusedLinkedContent).toHaveCount(0)
 
       await expect
         .poll(() => Promise.all(widgetRefs.map((widget) => widget.getValue())))
         .toStrictEqual(valuesBefore)
-
-      await comfyPage.nextFrame()
-      await comfyPage.nextFrame()
-      await expect(targetNode).toHaveScreenshot('linked-standard-widgets.png')
     })
   }
 )

From 2c177e598665f6ba2ed46e10ca0d6deb59cee0b2 Mon Sep 17 00:00:00 2001
From: github-actions <github-actions@github.com>
Date: Mon, 10 Aug 2026 10:10:44 +0000
Subject: [PATCH 09/18] [automated] Update test expectations

---
 ...linked-standard-widgets-chromium-linux.png | Bin 17764 -> 17107 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png
index 67f304fad8d3153eef32e1fcd5efab0166febeb2..3489e0af2f61c25fe88d54b7b8f29eeb7a75b822 100644
GIT binary patch
literal 17107
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%0DL_S~I2eWfO>pJrWtV796?-
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

literal 17764
zcmeIaXIN8fzx6w@U|9%?4UkT#f@tVSQxFom^d6J|(tB^RSbzu!gc@lJNkqDI=_t~h
zgx;kSdPn+u>w4C+pJ(s=Ug!OAKAh{k`-AgBYG#r-?(zSPanBG{Ww|StX)Z$$bOni!
zQG=i}_rbr{7test<b2t^3qe;Qq|74?_oU@9ix~ac<h8?GU4e48KE}R_?xZTF@xg@;
z5)wZDVc+p3LHZ+8J(2%vbBkrC$kMh?Y;0BeUW&__M-Q@JiQpqTc6Wn`sTxD>fAx$j
zr9I=N?;ac@nyyFziYz2vSJclUfZ1|WE7pcy+eb3Z!eUKMpJ0|duYEf2u^U%XRb|k_
zUo@0s`T(nF7TRE0(Ciw0WCFK<pmt3)nA-CVcV_x{bM+COom2CoA$TG;!+azuR9C_n
z7>@k%M4m2DN#(t}m_%l{3*k2$=gw8=`$5$2?3#Nz+#5QI7|x>Oe1A03{I<n8=o5(=
zYjj^0UT%GxXKtC!lLl!kzFv2hXQZ@cTJx?pz56Ee3iQ$=l0&!L5id4a<8zpDf&Sa=
zd$^$4oc?xZQUzb%nqFD*40RP2kE8Da6#f0ZRfpqV;o;$K6D|Y9o(!MlWEu!^V%6;-
z5Gct4D=I49CMITQXY-bn5EbsA&#92E&Ny&I(vr(%*~({hOQ#-NYnsm1o^Hn9ym|BC
zTGdv)Nz=H`p5d=Y@uktS$Y!h%Ut4<`Kp{Cg*b9s8Y6!i}8mvh4M8I3rR8_yXxAnB8
zcZqLD&V1uVc{~|LYVM4CtsN7){Q4m%K`6D0J-`{xz|YSQ!xsA<dqy<%3=h8@HizTS
zShQeRu>uoU!o%g>&{|l(7%Vhx>rR)$ixD8`lPtRG9(_dH;Mm|`!VNLCGc9$=aVd)O
z=hcwNkfG<@iAEL97Go7IcZ6(@ju}qur)H2VG$QujU!F6$Pt|T6MX}L7ak4_>GygKV
z-n*-uvGv{mY?EVzG<JiFn|pa_t;;$p1HR6I^4(eN!<(8q-Ybl!>TK%Wdpq)*oAt!1
zYvn`96ucLD&B()Zf7A4sc$Px!`^S;l&&3&5ov9>{1kaebI6S(z8qZ1@a<uAJ+h!gA
zOteVC3m4s8ePwAtfhJkhMZVG%4Sh>l)#N+!Jxx8`yp3$O7}3w|uc#2^al039g>-P(
zy>&^DIx@!M<8Qa`jn;VXNK=U8>`uFQYjkvVGdt>kJ)WkfrnOJg<i`cDjn_Bt_U9TV
z4psV&ReVlM!zvHZO4J|K3PbJDGVKf}>lZ>2J32bB;cP|w*Kaq<+x_UDte@{pZX5q(
zJp>P~e<1J<cPCbI5T8Ea$liw?Gm9?grsj!BiV0ZC<~?!WUT|lO94oA-@SJ^p)6f0T
zCUX<^LC|K@eZ;10XM6i-W6X`6jjh<3y~d)4joK_}yP(ARqo$_j@wDV|^vp-GYC?Cx
z^L<Ai!<a#Wla+aAQn@=3L#EeiLL4>aP?zPL4L3W`=&2dl=AEcHULGoPTODK~jt>k7
zwFSpete1EBbXpdCopP{X-13dRd6TuFp`L|BKtP~CN3kY{R#noF&xdrMqIY!E0Hw{I
z%5*=<ake!!GsB8-J3lu!)}!IwJ7$lY(SeXHE;>UQX~$Wu>pH&`a@c#kjyf^5jNmj(
z3-c7P8H}ucn$jxk)qf?}k(us;^APqzrQ2GK_pCg)3U1f_XjnGu)6~3>;;q)0zx`0L
z*`$S?xIL?hIv~Vz6QdftBsczm#ciKh4dmtK=Xd#*Z_mMR?1Jl1uSfHHU0vNnxro-Y
z`CaT6Vhq(hXJ%)Qn|S?nPk7Ablsn8<%gy6d1a_*;Jj-Re^D5Wq>FMLT?jHunT+Xbm
zt=)*zpV`PQ8|N}fgy(&7CaQUODww28xW<bZ^3g4ZoUSuy<?FFNVCm~R-W$`_)_=G{
zY(1HBRG!gfNl$Nj!w{d@pqZ^@0ok8T7V+9eo$R3aRMZDxhC2dq7bfxH{#^apjSCFE
zAMibhlvd${Wx|}&iP>q#9XqlsSCCIO_fA)8%Uj#<98s21i)V=sP`>-7$nzF#0q*C|
zpFcgSXLw)Jh~-0_s+<zz^lhUE896!2r-uxu(q=*9r{B*G2@}5ulha|O4kS-c*6{K1
z$jsWR(;DlT#Ye*mYut8RDzjk-t(Jfn{9K$5doo&iIT8+x;12{>+VFdR`{t58J&5Nf
zyA+(6EEBU+4WU=AT&eZk>HGfmkC|xi-p0m8^$ZpBvZP&AM>Cv6kC1!?BCEr>VulBf
zGMFQum0Y^O;C)|Il#4-%mzm_dy7P_{L86mMJbL>AM)sg_Kl+{;1*r$4$;-?{VqiTX
zt!+CZOn_*C!w)<{P#n(k`XK$dShNZFRs~N_FTSN4Fc&sDgP>vG&7RcO-%QU~s5=#D
z(4Q{h<Jn3$d3bDwN|g?*TILmN#dg$@8Imhr9ovrL;l<mEUCRt=vR$h+OZPJBnbOVa
z=;$z4J;h<tmXfFYT}ArJUK}EPLw9Cz;Gq{%u=eTe>yJ2fN!$&{%e{Rs=>)w=QWtK{
z5m~HaMi5X;*F`vb?|#03&yc_v1zjT##ASEntrc&J#cfYxGYBhYYaLx(@$?22KcpBL
z>tk-;Gx9#kMkR0G%ht}XnNRULF+AFgr{waYcQ+1-NJkDT`tY*wrtSs~4UdfMi64CM
zzP<lJPm~MR-k+n(Lc!MYLCK3_NJmFU*kT%J9EO2G6fKx&I){9X*e|<bP6K&+I{pa1
zbcqQY5apNWM$_V+tmx7#Oi<vhhF$x#T{=>{jd8{@MoAu(IHy+HO-SrVqb3$yD@&Y}
z7^RJdnp(QrycWMd@{y3u(XSLNQdRQw_IaN9>6825+Ca1vYV&@y#Y9_koB3(v<C>ga
z(Ip}4Zv)d-#79*;i9+VL{JMNOs9)W^%QIH&kRF#3n5Cq`sN_{qSo>+&b0IAlmxrOz
zASJ~M_dws(O^Y8B=p=m&5~IyecJ25gPUj_0x4wV>&K<7Ab}UOdT=)G?4f+U)gN4)6
z>NRBfdh6YMvHkt7h=_<bgX1;dQ?DUr8zY~czTTOm=2tD&aWou<!ke4gzB_k0i`1-`
z72m7g|54<3DC9FxzBRumxjWbr%|79?R-LO~dNh9<6{Cl?gwWB%cbRK0Q(r@}YrKbV
zD--(1YYzERqb~6sXOc|;O`{WW{MwxMI4x2mnumwSYj;`1Yc;7#u;c-4%C56%%@6%x
zingBo>h&)&_c{2`YCIOudM2E>RB6jxA|Nn{z)3Dys$%UiBHpQ8@z_!<t|H6Q+JKqm
z{)$m1)#B0;UN$Plu<~u@n(6wi_HksRl6VZ6@?z-shTAE=2klrsY;26Winid;-JR%x
z`NZAJrqHJ-+Zw4a8gQZhk&(Nz!&!aV@x1!G$!osamszerwp`~3j~V%-z-n8p#|?k)
zw)|rQYxxLLrS?AusXivpUIr_+??o8&lJdVh<hWL<pM}2n$OeM%KJ)WO{<nw6wvx}@
zkg4Cg0!6Z78-8S8#Fc+c;9=tvIS2K$9TlV~!lpw$eb#<}j^_&v<Ua#R<H}+rdW=oZ
za0-QWlSnCtxh0-cvu$VVq=IG|jk{WC)oeK;AVzIcFXc0wax>SUnO2>y7U%{fbx8vu
z6f<OfkAvf*UT&Hy2Njtm^fKZaLg-Boaoc?q2uDvE(`jAZOHv5I5@~xCnO;#bta`t<
zua7Q7=Jo5>26>zAVyk<H0#KdzTqG`7e0}CR--=7Q0k7C;l5-^uf$Q#FbXe!oR*SJA
za}*UdHIYb+RV*C(kqAL*?Gp!cLNy1YMcLZ91V?m%j-{og+3-U#v7?g<3~wSLtQx&n
z0_X2?8R)&4+s#sW;^yXNZmzu>C&d`4$Yv^!JPRRmmM3a!aX9zs#`mjvt2HMl7I%iM
zOIJqpnWNTy_QprPsY;59(j+8&99c;e5~|(md}_fM`z`rlsgT_;+HLUg@DQIG`>6t7
zFu6H<H*=uWI=a(sAg^-K(rT9HUH1ZR+HM4Vv7md^9vA#E$TZH>M7`$?9nZ~s+IA=u
z_pRvOp^wk12bN+RH{Hi7N+eS42-(GVzF2qWzK>Z`GcwZB(&NfdkjU_kZ@(w<q|n^i
zT0?f7AJX}TMlWR9sEuVi$52vMx{isfvk(>aOKpyq1H53Q;AwPUZ^2AWwU1Yc&EHOu
z;9zmj=t{D%9Jb#xe7F;DJyyZGWjrwE=3=m+rJ+SDw!WX)wCCd5V!p7rNN}3nIF0~@
zBt_Uk?aN$dzy;j&>KcPi>9!zJDY|95JedCNMMXuQ*x!?s<xHfdEs&W*&*R$j^0V8*
zp0(cI057_V|F#<m<jwETG{hQBTT~pa;l46Z8#RtnxS->-^*-ItTYKUrS&*;y0{-*o
zM;_dtORMpw1S>qkb1Rnx?&UYPJaqeXbxG|389BMBP$WT4Ldx7cqc}4+my@IUv^#>L
zW!GuGQ*v*akC1_~v^s34tz}l%a!s^BJJ0+GxgKqV&y=Ios|jtVYB7j1qC$$pCVZ@|
z6$uF0hsoq}!2{+q`J|8zSy<->h1$%FsD<UlxBT<40AKx5eg((o)Dv~NnVAw#v*rMM
z;pZj8W*#is9v;5F{x@U~)H&g=d-@V+CkG3r;f_C6*1WaVQ|h1PXXjoDdJMONolSsu
za*FT^^TSRNA;i2qS7ACMl({f1F!2@)=P`=m&Tf0{1ZA4Rl~M%krr>6VkLzNNLHSf(
z@<Wu*PKh?^xCBk8-dpXTdqkOCmcREcEuPIL-q*Y1tpFjQZJRJc47nRyo;@~+kO7m+
zBEzP(wsw46T&stZXwrtvXuO`S91Tew3O^T#7FL$+BWI9+d-VV_t0#&D*2Qabs-b<C
zRUwWng3QZD!lTN0$YwaH*}K-a;f21Jm+6zhwphJ~^Y+5Kt3EpUk*l?9MyL#xpiM!W
zVI56f5u&C%CpUNT!{xEDF>I<lE!~}^bx%A({_FLVXQ#7m+6WdX;VW12`>p{_3)por
z@Va*kVk1w#^jz55+(b98ehrDn?zCnoCy$R-5v_Q=1@1rScEC#~M)&vs79m!+*G}Y<
z^W8ffF!DOyI6ge%FJ)?qzah=S!qOJUQ#~8kxaM=pz!LR}-~GpA@X1E%iLQj&ZZ^N^
zptaV%b@vNyuXIH=qzA0Wjs`LoeLs6Q&-XkA-Su0S<euO0#A$V2scZ9E{D*{Isn#3V
zy7(b4qN~8!lO;co2Zx!s&hB)-q~6Bq4aCt0S0_4_^VoK;zJY-@cf;Kf%$5lpTV<3=
z3WcidKH=qSv8hsEh)>*2MpMc2EuZeMovvw)p!-!vozcRbYw^f*t`->b1@(+`<(NmO
zSbkSF31nu>5s6dt*c;p9r|O@Oyc*iLxMW$f-KB;!_R?*DpdvUwIyfw;UsZ=Y?%lgD
z?qW<PZU%Pej2~3)O1m~A#poI6>AN9_bUm~Hf>^I2MC5_Wj#4d&T*8f_^IXnDROpZM
zut>+^Tx;*YSwJ+x(e&;w`9?C%%08FC{)spPrBjB;V3;bGU@5QoqR&C3)U^wNrV~!r
zLYowI`5~z|^sVW9=EymYf$LYG1UhNgUw`fI!~I}>Id1TWu^&H7HWvK*dZHfRN>v|e
z*vWm1a1kPl8dp0|3<w90?!N2=NaVq|4ICYRr^v$Snyn!A^5x4pf>!sbC}|+>GX$r`
zE2Eunq*^<?TUj!Chz^x}wIUB^_9)26UO*qeJ!LXvaOz+|rVkI(WWEMdICB)D8^avm
zb~B>s=;YZI=$4>~ct#ot2T>H|eo_vGmn%-1PbV*v1{me@-XLekv_wU9r>xS86kvb9
z1l<y8bF0}}>C4tS-+1<zkAk5EwQW{Zo||j)o)qOZxnH_l8WM8JCM|mF&yJ9!r0(wS
zWuERA#W}?=n$W=dpMQ;?W$&o;KQ9@?JG$Iu{DKBG-VJ6&Hg-d|E}nB;smRVN)f!gF
zudrE)YiyLQtiKk~WD3cj%uEdS7MsW^1h(~!4BQTFn7Qa$>9aLA7iXitLhj|TfjK(z
zCMIW;D$@CRDR59#?TwEGNC#YIGsyFYO%&whXb97~ibx&|HPdEQRe3u*!ze>6p^tx3
zU&3kZana#tTJsFux_S{)=%s!hFqEy<WKX{?dsjI1-M_0%7G)k!`{=#wHZihkPf|-$
z(_`u@GUP)BIsG^7KiB-0yJPQaC5gM`6~24EXTF-5yP-Iu_J%jD#A*J`WK@*S^7~U8
zt>F6ZZ>lIQEw&+b;B!$ZZ4HeNYZ%TNnh3c~3+9jOZSv6lsq{-^EqSf2msxltnddsn
z-uyT|;WO{5`Qe7*<>lS-tlr%0>{K4&*xEgReqZungUP~Ub##9|#piuN8WZg$g^VML
ziIY73haQ_TG3teG!*Sx()sza7rwzPCcS902EN@DO%bA6FdV22Uv#>vse^*ejp+VE<
zPOB^@7cBJIP6v|G>*QOc<f0Ti_)EeI_bOW3wzhu5jdrJsCcl}Qnv!7#BXerzfTx$2
zxh1DRtmBpxjmWaAk5V#FFO@rsOHGZ9K?L;G{ECWJqJ8r{Y*No(5+26s;<oo<i|rbC
z`MegsDGc4w&NtFj)rs`rI;+c9!p*_)?bf-n5jyhV9ex5Kp0+$YTR~m{W`%deTvN`^
zk1ipDB6$RYVd-f2Rkt7O*KG38rADZl(f;v!MKbr|6%;OXjaO4BjP>;Q8|kSPKCAZ}
z8XO!{jZTqzTZ%7bY<7-P3^Kh?6(dJC{$^vtA><vfSAT2oTSc~63J)X;_BvrMt7PX3
zOT@Cc(?NUG#PLbVfRUf~X^j-4s;=(-?n5~_Sy|lYHp#;>V7N!!)>gN2b19$bWj(&E
zVpD#f3zpr-oE{TRN-v#e&o2t|$B{tqP4sG>$GXzFi_v2lTSjTv!7E8cwirPnw*Pg=
zX@0`*G{8citFzf9C$qt2XD2y1*+0j0364h-6pd0<&c1ADYMz1=%G<t8RT#7|YVK;v
zpiT(47nc@s5`*J~xuto#;X>oh2Ht#`_^B|1U>K?gEm&zVi}}1cA!Rh>P|1ohy&7@(
zQr#4KMijTC$)v>G!vzn9MQf(1E`WtaXic0h=T`RTM0jjWOfxN(b4-*bRG!Ac%MJ?F
zPz!CyH)0z5Q%di?<3X;@C1d22jM%*`^iPTHhX1H67#-pha@67pQh7`Ejc6qb89z{f
zUFpyQa$6oHD)-LlEJVdpBu6Uu>LM-)e_4h35)}5JFzHcK<d{M8auR1KDb$Q<e}1HS
zjzBx>`HloCGHE7<{ycZ)(%*-<$hlWfu0Z#%-x3%V78%PYfo>(XGc1v=b^mG7e9!#W
zZ-8kAA?!GP-hXZc&YLRz?8_voH9_jaw(ueT{EI?~ihv(zB??fHIc$M5`eQq3116+h
z-9M*JFOsYrF_OF=Qp;3(YPPTY7)qev!Y!HPdB7|*^z~UZp8|^jqvX_6n{h0k+DMp?
z%ps}!VwN*s)$N2J@G^+4d)RDbey~3u@F;)a_T}K~Ei=u{FI3zj(3q$RnF}u)>JD=4
zeA6>B_SPp^%sW&1@+3nW)YR3}c_a?j;>`zg{X;^~%uMR?M`o1J#kP~<Lk0QQLble6
ztBb2kYpJDC9cClrg*;a;E)TnC8`|XZhsvfGI?N|OyoV}(S2k2?v$XzE65Cs9XBSmX
zA!d)-z_1z`jsdT|HrTDEr8T$XiN}uFP862!PvI5z#=PvLrH>aDUN9az&8cx%TU%n{
z{`S%e)x_O6)%)&i)s+{5NpJ4=ITeYNy;ZBx1`yC*c$pHhSzSn>X=EfJDhgIX0bruT
zjxIjQ@``<<#*7A@-P{t!S?ID9XXrN3=g^@4R5vZ6oOp-N=B<zo7Y9d7_(-Yzly${7
zPY3Cqpo|pJkGKyD+nIb;{iEH*&#K4Ovi|6j_|!DNg*5kB{~isvTj9n(eKcX!Ud(0v
z<qb8*4?ySLR!1L*!6`$jtMlYJ$%CaIYk$!x%=q~6V@*xohYzX~tn6ux(^1}UFLGQf
z1{3Syi!;)N*@cDA<6PD9tM>b^)lTrTc=4W$4YakjJx*KSmMhltJ3g@cGHDN^87lBO
zyi@C=E?8kOtJ&A*d6pQ8I^3~C+oBZAp8@Y(G~api#?0wLQ!u)%+-W}5YZu!X6qGV<
z6oOAZor)jQY*2!gyiRLm;gf|kXZf8+vT=s|1V<Jc(+<J_#f+b;eMSOV$eQ=E7Qn&*
z84}RSR_gh}R}#aIxe$ebMYB?h%|&FW;QUi$-xXzB?PO`@ZEhYNo#71I4p+`d|MW@c
z3{r0#XEF0}WJkb70+k_V^C6$%&Ye5*(RF!wd5)sAg$l}1U|Kxnh(s$Q&BjU$V3er|
z?}U7P-c-ep+4it2<4|$kkCC6oYsRI6jaqHlijIes+E!c@xRwBn;uUcOmN+I3Q6oPK
z+gRRlSuD5$efw#M(TcJ&zz}2Fek(D)5A*xZYv`FMRx`aj;?x@PZx*?9cenNR<@h!{
ze%=r`;ZMTi1<uhJA~P0hBX{SF5Urw{o}Q+BA}xK=7M~v}3*8S9z$&&fY&z-h9`{eO
zoHo^`ZXE_69vp0wh_k502j05rGf52a@bG}6-N1r7^kdj6U$Vvz#d!5YPLB6sayqcM
zLUw`Z5<Q%E68|8Fx^4GD<T(r}l<>x4|F!0DMjEgZq=hj5LLpBvdN2UkeK463?eCqc
zI5_C+?3C(PbHS>?E!gtAGDzyCOwf;B;zu>pd}w6l<V<&85M-%`)n+`?u~g;coGv6e
zL(7h_7Xlvb+cENPd>T_DUmR!z2I2?!YRF;#42Q+SdquSw<c+?*zPE(j^nwo&nq<%|
z9+UX8tBCR_PN9IZTslBpf6xE;@&2`lwr1GC9TJ^lvXe*=|CmG>xa|XP0{Z2f!(I|8
zW{Vf4zoWuB!oPaMALX8fWLuV_K3`)#!)d-DW59xe>Zn-SsGZ4%I-YRT^O*vBtBcVM
zt9>o?Hr+slA2N0&8zO;Xq!|A`)X@@X3qAlZ{pDTIou=od3GFjiAw}M;CQo>jq9K<F
znY61&kq($a?#p;85c#eMvPC-9Q_(>)U){@q18%gQ3L}xSCEHDEXPOP#ya+j({<6$6
z^dwSwVLM6Z2v<!1&6|EVIY$Veb`}-4E$chz7Gc;tyg*6{JTi^Ha{z*-ufHFm2`I)*
zKr!NOlpEx^i_Ps(SV1pE@(ZI^cj}^5n$Hq7|MH~okXKem3w-*rVre9_{yTH(^_Mwa
zDy!KKPe~cC4~|F@@#_E4#(hgcNhw^6ik{vV1V<pjU>D%v<&BU@r;+F%8@nFSR22XA
z92*-Z<PSy84ZeAZF^BM^Rh0nv`!<E&kNgbf)Ras^rEv4(3YWkqfwy^$JWr1);3KoM
zu8B&u`cd_hFD!>uQK*4o&&hl{;}Tn)+LJi_JBOZ!<A*(|c=?Y**7{|(B7Uph3T>rs
zZ|GOnP|aH$n>#?@XWM1cfjur*4kVkq5gIlOB0isH<rByFRmZ=Sw0hCxke-h24)Acj
z!va=XIXWprre!0nhTBbt3?pUF_Y1e?^+6!BTT!9sGd+FCke!t!<}igDn{;3NPQsZx
z!wRyz)zNYjcQou4pJzmRV$_VPw6u?|E*7Tp>{*(O%hRW6H4491HBN^#JiqRL37{_B
z-be%t@FFuySiL-kx#<lZ(3Pcyg-8*P#14r}B|{q<3yT&>@54$*4vYO!r><t%%<9XR
zH~qG!r8j?!mTz^5A1VT(p<<W+mC)t4p+J075_tDt)KDGCM%_Yt=Z*^gX?WA5v$M1N
z^`m8O2uJ<)X*}``5CiX7yBh9km)pFCqF%d69fIXb9v-?VR4p#*M8j-(cH+NE;ai?%
ze#gO;gSVoo`RXZxy#oqy6nJF0uA$+qvoJbdrt)tk%zQ}4#JAs~f{GI)w2b>r_-w9~
zO-P7lK7!H2Udw7%Z=v6J6Q(7uEQvcW;Fsgn>@0pu9$6s|uJ@#|AS%2W?dxL&DO<go
zNDEcwzyRkJeyFZV%?Sa2X;w7!6BDSj#J82q`yb+SqL|(Tv)=05+$*@UvU2n0z5NlC
z9ZFl9onm-+<gRHp&_#BQpM-!5_H$HXVM!VyNu^obb`6V&P`GjB%07M+77iIxTEVd~
zk~8M0U2$Pyj#J-VZ2q}`N7#$t9Q*`Jl<re`9t+utm9BM1MLjJVa?Z?EQqV+9{_F5R
zJF-R_+g*De#iW}XC&MgZp$NZmSuS0g67i1-UyIs$al;+WXuFH0;4DQ;<rfuMskw3I
z$7=Jud^k&0{zjnWQ(jF?Q4!z$je(oaj(Uo3Tb8ygeyW|WP^2{DBfeV*J<o52pWH*v
zIdR;;lnY^{THCs|Jbl7?NpzCJ&Qb2=mfyqOiYWr8ZzVtBB2E)}p!0KHXO7H^pPZa5
zC@A>y<qPnV>Mwwogo;=q9b?)jg$|}Rg!eMfLLGw)Gfq__d+%a#-$-84QZN6U*I}5P
z5mGR`|N0N2o&EX^BxJ0?{LGm=S*lf6?ApL97<8Y_DWWI)`O|uXuTu~H72}Gu?#P^l
z%$g$U0D3(~`S+oni3BQ+7<hp{ji1)b?ft{^z;8>PcYXhF7La7X9tjzP+47@KyIIkb
z#9+lpqRRCUcd?X&`palwQ*Uv$kOfF)MqdvR+LwFGIbazg0)uqI+RdV8f?UU%KP$Z-
zeWL=nbLg91S*JViqa!&1@Ey+iY>a3>p}!T%X~;&M8x5efj)7w4hXe(hzf39h?44h#
zY33JF6}3_D@aG?jFCSZ1Bz!0>mCbqw)_Vj@tr*ul>)0^;pw>^Pa(Kk&t)wJV>So}4
z>Rm3b3QL9kpbHe<z<`f(%!w$`X=;4>{qvs#OTPuyhoBwN=;Dk@InTrFd!hGFT;tZf
z=SKhuz8rSpAYaRanthTp_0QZ~C3-&qfk%c%*x1<K+Ys%AUDr<9!8@xDf(B5YyD#qf
z!^VC9N4XpKf?rQdk21Uggx$;e0y<2(yK56DHMJ@S6LmLjH<aJ0;)<oE*u%Ba?%v`@
zmTy;AS4V8COR};Yjg3`ZbM-4-TQKj^(wID|3M{0VQzGB4#x({3QLz4-05?;;i*bP`
zaM%@_9PY9<D9Fmn!pfFi592yI%)63DN|y2}hV}NL%_{(g?>s9=aH1)UJ_9Vm&yk<l
zVp5=E7Jp9P!()HpgY%p=v26BAI9iR1eO4Ss3UGsd;{I82a5Z%o6hyPD<Qf*4HN2js
z<N@h$+FC5P1xVWzRE)-)y7EGdRiB#yI8fLyFvNNxo<z<k@+o=Yv*UyQ{{EnYgR?3U
zX<b<@nL{pnhIHChH)C&-O_0>N#7Wb%FlzlJz-S=A&wP9gpFW+GlY4-*6r*p+2&wy8
z;@K0?cmk}oscC~^IG{W*lQ(n^B?JZgyStfUmBdm8EB7X+rdT(x;d2~f<1-}Oe5!kq
z1li#w-fhon#~FYGYA4n<+;JZc#`pZLk_Ek?lPm!9ug}cWn!ZFkx+qdGe)w#x)fgEW
z2?`5?nKbWg^rV!0?(+{D&0$YfRPq7pg(H#tf`TdX=`<1b#D#@*ntc%+b!C74htx*V
z8)f-N9r3(IRn8j(e35w<vc0&Zgx9b_qfl<{Q=@E?Z8;$IX_H?X6!_?Hg<twcM%XQI
zlE>@yCVCaS7-=LBQdP2G7GQYKLf%=lu9Y?KJLi{TGSuu41rK7_j$K_`VtXbd4b@Vq
zMD*0!Ooz&1Ovc8<i;53_$@b<x0ICxEdrSGXOf4{mf<Hfg4;S*)*VWa%t8ZoHyOXVL
zF8cc)N}!oS3jNqd2vTKgkJ<uF@9#k<pd4rN^6qi+M5!UU*s-A-2cr2EaZHDX;fM~V
z7K1k(W)Ho8G%JQ1+#5)_uo{0^Hj9s1C;FM_(BQD=BT5AQ-X4WPMX#%ZiL|d#iiT^n
z(OoCwgKq|a`67`Uo3m}R4oHWMqAu@-<_deLP5_N|@ONH@D@7aPadTGxw7b64d~HnO
zVcLkzN!VG|aF~UeCBJZjo)Y^tN-|PYvJH00V{Dw!87eA@g-Tpb^cS9J{1B{+-UGdc
z?J<9Iw7QpHwYiugz6Y+qJPZaiQM0eLYkeL1PI{jbp_R=V_2cXBqC9<F!Rg&hmtZ_@
zr13t9arruU>gf&lq)uAWE9O(K+6qqvh}mZ#+puh-)+}DNrR8NZwBci}9yq*zerLaU
zwBh+vmfu#mXY($1P;tIEI+-kQFcIWDKyRyn*NlcxTPLJ1hLE&_CmQBCQs0c8`fM%e
zHM&|=B}V-<QTiMr*lv9{YqX6V=#)FNtpEzY#XyA!HvwjN@h;=Lf)BhInq<0R+KfPY
zxkc3$40eJh>g(&__qB9%5?(c(^_P0CT&t9#{^SWGN!`0>MYii9KQ#R)kyB_iS|%~u
zz>hx;6?Xn*1H#O8u9nUC*3lm#P#wo5GAxIDrv>+_Cv6<lLrAB0TeKyq;?gHw1xvOq
z1K%2z+FlNUs|g8SRo4&@#6t%oUaL}B%c2bed7(UG<lhHla*H?rMsdG9FKu^Vx(p~Q
zR<b`j1TFS#+mbzK+0m>33@yg5w&S#`<(`uI$J}XLfEd{uE0sX}XLjA3401I2IFBah
z6pE39BJT!>v-`)e{4&fr^JwTYKpI@QJFV7&w{P6g$?aF=xIsn=1gq&H?oJcY*;C9G
z$#P8m7U^efEOi#bfh6!1?x~@n4F}cY;^G?_<|j{{+|%|Dqu)C`rh)3d(_)<8gPO?m
zxayxWpSb71R_@fa3o00v14_yaW+(rr@!wl~RKxSk%uMXaczMZ<+1XizIBsmku@$cv
z>ggn5jwgeH&kw{F$;pO8`XE^V)`XMw3dAVw$`+kjS~?es@;(TbJQ@H63DnMccz<!Z
zM>MV>F!Z)ck}!53xx2WS6=(Bv1(Epiy&j~5y=l4qprAD2Xk~)3oAB~G*use%S?r0@
zzIp%t%Fd2UZtm^(K6^I$WrNnGb8~Ybttu%gQTUL9s$J~|y^qzC0E&o~N`*U>V>MuP
z0a(QQOGpe@*ODt7Uc7j*OW~x{9HpS3K<g?8qoJmwi{9iYQjn+`Lf7QgT2MejQN5AL
z+acXAoPpWS9~R~9+7Ha2Xf+-HO)Z$nYK>J!jiK5~5yk4pzBl2NUhD@N=}=(p?R{#Z
zsToVD=Ndc>Qa!e@&KJYg|7ONru@2Y+67OWgO^eEk3c%Mr4hC!F5(TY4*-t(;^ce%W
zw>*mX<7t7McAk#I?r3@I>(^tc<r$@od_9drlI=$#$!`EnAYjyr8n_=Bfr8O#XVQa+
zCc4muGyibtj72o?7Kgt6&&B{j7}3zu#x!A`jp*xbuMnzhc9$j)$}foSR<`3XL%&Cl
zP9l805v55F-A>BQQ={_AGs?8>cm;-ftKogT4PSp6`ORlwi8%pQUhx=GTWTKvdkuj-
zso6VbXwDFIJ^I?CLT6BEriAiCf#Jb760D8_f`W^7LM|qa#SC+5`iX*)lp~I4&Jc7S
z;&-{ynE2S(_;}C+Y$0O0A7|8ePwuqHfi9hsj;S^<1EvZ^&O?;a803L0QFDi%GTG1&
z&N9oz+ttMzX(>IyQS#Wq!GSIE{a7O6D?k8zbj~VnUCXKev7W4efkZLcIdXjaVe5#}
zSi*yq;O@Dm$&Ukl{pX~autJ!ScR@j(Eoq<AnD*sbh230A>WS+IqV<y>{~86_&7Ai7
z&Pe@tsbOc;sBPI3=1gyl<PqzKFOvv6)LNP}uW79qpTFeFcwe?QNb=`0&($w8$dY4H
zQ&WBHu{5t`($5F_8M6J!U_Tr_)Py~FHrHafLN3SbNz<Z!8d(cMm*QfL&aj@zF!rgM
zUdM+Z;5p#}1Y4a=FmVMyL2a9AbPHxO>KQ0(Ma18$<nbDqn=|7{R$S`Ot+wBIuJ2XZ
z-v7xUbJm^`^4gO~GIUj}EUT_IEY;N3Zjl`VN1+w-S4}1d22r#!ttGQ<aV^tXSy^}m
zyN7NyCAqoP#W-|*&`u#R+i7g#+WafvtrjLo5f~Wg8eCmj`EW};B;CY>&M5x|GQ|Ch
z<Z`X|{$+quqjm5-+xw!d;hjn1UVZ)lId)_zGOQ(R{iedu-qse)RC%3UxwY{>4<B^Y
z)Gb+&U)1+ncL)5o8h=i-)YJlrN_-tt#id5>Gf~y%%Bdool@qm_t=V3?qqSap;%Z#g
zpd{ckxIUYDJkrmjzgp?Gx8JXI>CO=IbrE$Tv-a(0bHIbQt{d~yw2gD5K5Av@?<J{I
zRBY4EX(gUlOKvu(R_ry;H}3E2>nGnoCghsiZM%z6YV(b;m@gV}4$S<358`>x{m4I^
zZCKvL+>(npaUeVzUA4qAw{GuHzQ($Y070EvF5g<KJ^fsKC;#Bt`{RS*zGh<+AD?RP
zz-4tNR4W?pQ7r-TEQV@@RKrexTutq9t6z+_sLR22>&?5i`ko^czUvXw)BYAhmgRhu
zh{r*Ysk=HH`CLEf!I-TZa1jIZra1Dtsba)g<a>K`1%iv`(phS;-u$>^*J)ZRG8j{l
zR^~%_oL`*$iGs6>i%KphiE)$;&fnRPngYfnex#$JK^4J{UVgI_4sn~wo(XyAWh4jB
z6%Z54-?;{TbpL;fI{!Z(Z%$o6lW<f1zmadwmn2DJB=!JPdXb>~B=9a3nP+v4s&Ep5
z4Wu|;6<)At`1$J)x8t0h&(<B3&*~5eI4!o!e$`=$X??)-gD>j8Rk6C7l9#u-TmfSD
zC`B0hSN-MHf6g+o!+pK(uH)tDnHB*tkHCsq_~fMcKSh>cWSQ&eSgUe!9<J6CEtm;+
zwVtTKxwkYozX~(3`Fq;=I=zwje7*Hom1Rp+ON)z^ywY3lSPV`6i@|fvGi8y~{cbiR
z$MLJi^4DSp82o=FNB8b9Oq}XyYR-mSXJ=JT5p_2v$ZuKfwLTKeK}`$~1BAsJ;8oZS
z#+kKyJzT#zay3la^Yixt9Y^loxOJ<4U;uQo7b|fZSsU)KRJJqMX&}a;508E^_4l&y
z99Umhfk_hx{6s}XafMO)`@jEw#Bls0a#`GM^$1i8dj`LK>lw)|OLeuoe*^RC-=~un
zk^F(Xc4I?B#J$6kK-PcIB60C*&u6d}7;E?7pgUK%r5JfedU}20cOh<wvEy4<1zEl!
zD9hgU+nNmpu&BzJxIE<a4>;trP5O(I3tva{tj13LSyrY(KumzjLsM~J+q1GIt3~e`
zWe={KY3O~`w_ol5F>_F^fRkEDm%=<?#k!>8$5ea|3X7wZcTWyiqy5}W&FGc>W&s8p
zySqE|qT6b&iS0+;!nD{5x4zcc{r&ynsqe0pV3|pg)jPnjxVg9>Eka`C0Wjjg|0^(x
zH~Dv9WNNJxlmImLZV!{q$_l6)7aA&b#Vn5<e(aUP?t)VYXJu_@i_e%#m46+Y>N9s2
zI6ys1(z~T~aT0C&QP(<`U#eVj@qF0W)WrHaDCkJd7V{rS9V3h3=M(s86Z{nZ_$NMM
zJ0@D?SD*Yi@$r}Xv#@Y;#qCY&M<cC3{tly|6VOCl9dbHd?ONvI<lJ9Lv_lH<+|k$P
z729kc=ga7#-5*;kIse(R1f&W&s_c*dE#UmJa1%ivA!ioA*5TbO>ml01WB-0^$yFQ7
zPl}8AcDH0-m;X)O>%OA2zqJTwAo)Ceekm!7k1x6Zxegsh3*w_rFy;cQnWl=E8%Lkv
z<dy7N+IgUM!Po&#i5M+olS4`inPT3lcKR9`=Ke}5e^Mn7MY?+Y2JAT2k<Wc(cyjU?
z7Iv4LTk-2OJic*97C`s_NwhNKEL&8VK3Qt9yI5ZS9Q3k*JBq(JCG=l8J1eE^ucWf!
zx<feVe3*odYH9wAD*sPeQb*{JwIJTMk@3{T;w-dq`!iegC7vk$icj|fq~87}GHF)S
z@SH6e`W~%zH$sUm)J*y96s3H~rwx2F$UkAZx3XIlZ;;fr!(zGFsGq!UG6`BGX$A1U
z8Oat7)xFv-d3)<;H6%&*C#&ZkGpDJrjFxH*A3~dr11fKfdBiIHgc3Xrwl~f}<#6gy
zntxOdo6+1>I;Qc79$E;q=*&O=tg|d44PZ(mse5jmGYyNhrTtYO$?cEm+>e})ynp{s
z5{LkX5}E%UY&r`WY>B{#t{}nwBZ!lW%iy!|x22uHFOxEG5jcFfXN(052?>yKRFUse
z;=}@xC=O<9Y>|11N0AOUXrI!&UszoYX_9pKExhil3_L256CV|I4J@kS|0M-2NN!-Z
z`Aa23od1L`;Owj|hd-KlDd<`d>%IdgQ1W-Zu-js9_*eh%@#pWL2S!gzla!F~%~sIN
z$yNY=L&|jXSV4h~yz-nH_pLSwjbAV*sr>^f^xNAg2Dpk#KH;gn9!OgExL4>$_7;M6
zmOwokv>8lQmA}YN3>H7D5B%-+;^I=x`nGzsZ0h^f*iV*2r7rWGboDGO1v&=$3t&gf
zf2KTuv&-ZE>UY?0;o*=01;dk9XzgE^M~q$t2=iXeX@K#4=j9(ESMKyHRA}IjT&DlB
z-5vY={T3+9&|T#27U~FIsjBlqEt|?x3~mBrd3UfEi^gDHSX+z5$_mg2_jGqpDy=_U
zfFjLaKv{nQnC^GK0L-MlJE8H-n>WjdM2mdb#B&5o@K}nT`fc(<@8nG%d`^r*Wm;Mq
zfNh9403Yedhwu^JXP{!mK$wX<d`Ut*-Ch{@UCBdPY*JUs^|wB2zt01$Bk~hcfyG)~
zT*MG4FR^DPp~HHYmSRY0pzkJ`myto;)`BCG^>SvGz5U}x!25geJ9-$X85}M1p}_m)
z;Kg*IY2j1SwYYoLE2I1UExg!gYhT!Up1}3v=+;euCH-eZqqY}`y9OyfS7M9a3_e<J
ztHJMi&&F!+EtmW4nY)6<!qIL=87??>g~4XjC*p=QSX+xhZ-gri{7&1oFJ>irlp#NG
zQ7x(*wBh7PMhoaAF#(_v)2fmY!!ht)&&-Yu_whOAb15lWt0w*{_>L5i=Tw(x>zLWu
z2enb}upIi2F_m2W_2_RFi+YYj2}vHAgUeoaqOy6?@`jMr&&tJTW7U&8%?e_+Zbn8a
zzBW0a_ZAVg6#2=n!{x#K$SjtnMN1`O;;5|2Q-*9R$XM$fVFxZI#?5B~963PBS1;OE
zUxV5~rRym?cw!-%M08dC0`#^(vU$H@aFiRje;@kv0K{-VYYrY~UmCDp#4RzEsQ!UC
z^U{Dy_j$%OL^&K=?EX7`1Yq%ljPGP6pxDOtG*yvC-V4&1LGLyjd*BLMZOIkc)VXg7
zB?^QN;jm=9<!4_$Va0~A!@?yt6ovqapL^VykMrfu!zyh`^0@5WZ8-<Mt$BBE$ItT_
zx)pB+i=2Bhg)))71m&Hd`zJ&BMN<;mXfZ$mu?Z~~AjLFZO9U=s&?!cmv86Jh<5s^Y
z;O{Yd+U9UwekX$SahwnPKNJrli_|DgKuht^M^GQdo=bN^IHJL<6nS0!b%U`<x<8sJ
z9D>Rfnwm-~N8Ao<&jE(S=*C8k;?sapUxr-=BTK^F=z`C}Cb`WlP@Mrb%rrbr(^Ufj
zy)2*J1CLPX+Rr}8A6B;jEOXf}#1E9R0;d1-<;)vywyyEC1p|YY#wXnD!or81Nx+T4
zWRrN2)KvS~vq=ot)ng3|p_N#J!fQUB(9qDaKFudj0<T~HEW^yi%gxCNfIcWmq^Z6j
zIDEzJf-Atx7}r!|c9Ssp15|z(=;(@uth4P<$p|(ZSFf%2;bzem&z}R_ZR9vxI$|3x
z^9~z#et%z$EAY#;A(thdaL22`J)Aa4%H|w5QaqC~S4g1W8U+p;1`7%vgkXVAmQ{)h
zUn2`t6HpSSHBvJW6BF|W?Nk8NSu-uFeS9$do(dN0^R-nd4UHS2vaAIX5}lt0=A$q4
z(3@L&L3Lm3SNy(=S{CSW&tayXdvIr750{zo*ARo-4|Gp<*mCN}@#u?+!fC=A;CIyB
z?xju&_mp0MxXA`=V-4Y%s62i_2{x0!_<ZMPN&h+-VLF6D{J86hcXpfRy?O_1959T4
z+{O<NlU^WwPj9#AU}i@FeabW}x{S=aMg2<OsfmtVB^ekD-7?p3>lmJZfB?<d*cO>D
zl49I8T6sFY%Reqv&*By0wek#}>OQ>|`Xqzi-rXHdaPai<Gy@3dQzjN%z%G5VT2`Iq
zrbT+7AuHR|Xl6HOFN~XYXEa_H*0!O5R8`ySG}?A9!ypI_(kM4e2;%UUI`cn=|9KAn
zfA~K5oMq?->bO6hT}ja6G~@fA?Qy@sg#reQ-Nq-@@a+sxx$*ZW0efmyDr)>ezfD{F
z&gCEgs92&9PoGA$Y0^hD9sAajf+F+M9Yk#GO}Om*mdm0F7?YnDB-~J(o;K-zp$PWS
znEY#2XikreMl#wc1G)<mxuP=AY$z;L3&E>$<bax9une<9pP*TE3n<fVHSkLKG_90b
z4ZLcn0#T%;m8JYoJ0`b#FSOygAl9^3`7Fe!khLA<9{I%-u-Ou;&qQZ_LH?Myn72G;
zSpKa1>}bEGO4t#)O1U*%%J?z(_BJ^ugqmWDcZ8swa)$b1t|~`wPtV=YEc&f&t*vcs
zpnL@j2m4x*er;U9xt@i%xdt4c2K>G00E`(e=)#{m{KEbP;w0*k*guKkGqVT?iuSpI
z08eUVrCcI|TggM(kOd2v%CYpx;-V#17PBFhQBSS%)klKCiW-7?<j-Roo=07t15|HV
z42;ghbi2E|uHxZe7Y21;G=_z^X4|5};A3fN-+nj*nLUp^TK@-O%kBv1FpI^eA+>L}
zpfNFWpqukO>nGEyuuN|c_cNPx76m)1Osno)y@(bBNn?T{TmC=>czz%FU`LkohQ?}4
z9YH-Gl;<;gGV$zqaK@WS9>>QZB!IM?c(jLh_9(u-D>$go>p&9-9t);7&q8$xR^Gf1
zPuJJMqkH=FnOI6>!NWYEGZ2;Yid`N}L{o6E96tm(e&%gF^RGps|ELuGU-^;kqyYm2
zog@CdU%>yBPr(12^uJyW#@vyZpLaSybIXvOSA!#&NuarA<5yIdap%Am!-VXwC1g06
z-=98&>PB&oze3XfXt)LF?*ZYG+i*8{{Pkjb_A+b&gOt8@0eY!y7C{y#_r>yKatr!(
z!<1Q(*@Hy>fM*vVonlOj`(py4l_fpu8GmH4GaItEVe0J=?6gOb1~~H{xZc+ly{E*$
zD9-qVkFAKL{ps5PO|A_FH|g^lBpeH1JZSjj!5tlR3cQC7c9x6|TG|fOFWoPSE1?1V
z)_uSL3z{FjVE?48R<54M&w6o5iMfq}-s?~W?pvWJIoa7GmL;~s#Sf@1U-`MU1TwI~
z$d2fjCJQ@kcKLZo7CpEXu6sH3wY6a7Nfq972}FMZ*FW<lCZ-pFO%7o1PhClo?aJF+
z{j#dllMC9SqUh$%r5)l3%VcE3<j48hS-)P}vEdS{Rge#wn53tJ0(09dBhV!K`IFyz
zi=Xv0zLx~Ia{xCy@S^{ODlInp^kMC7!bKfx!NeXSf1-N2Yy7<ukc%SmCQT6(WaPGE
zg}SoqqLmdu!sg7Kwm=VeT;!nX<mBYSYApy?*9Y=z(<bKb-3kwqexv{@5!|<2gtrLU
z714mg*}Cl<xLBzqiHU%nXj{la5R=HAg^crHO6aSr3*C|j$3K5dep%U`klm3MiY5iY
z)+8G|>;I%R-CfMKL}wd|(_kwp(f(urxFG1!Q79^oIy9|-4CUwDD6%VESG~brrp{!$
zYEYl8k6KT(qwgI3%yc6uvI0S$ATKWu`vd(w@8iejReNArM>(SGUwC^f*7^!+GT~2B
z8$d^7D&$k2C7;9Td8p2X?WUTsH#b$%H;J0GdUjj78{~oSq7cuzG3}4-At<l>1wULu
zkPE;V|CvWwkL8bRw@bi65M(cW12oay>=CVOK70b#A>&mHXNWuZy{G&S9$ZVh*z6>3
t06#sM0JlgvJ#CF=90MPa{uI5lkOgJqWlW+tFZc|Ee4;Fq_t^ON{{^KT4XpqG


From c04848d0603ede8ea62e3fbb5c97637ca4034c57 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Tue, 11 Aug 2026 13:50:29 +0900
Subject: [PATCH 10/18] fix: harden linked widget interactions

---
 .../linked/linkedStandardWidgets.spec.ts      |  1 +
 .../vueNodes/components/NodeWidgets.test.ts   | 42 ++++++++++++++++++-
 .../components/WidgetSelectDropdown.test.ts   |  6 +++
 .../widgets/components/WidgetTextarea.test.ts | 11 +++++
 .../widgets/components/WidgetTextarea.vue     |  2 +-
 5 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
index 4ef493c05b2..01e126f2a0c 100644
--- a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -166,6 +166,7 @@ test.describe(
       await comfyPage.page.keyboard.type('ignored input')
       await expect(focusedLinkedContent).toHaveCount(0)
 
+      await comfyPage.nextFrame()
       await expect
         .poll(() => Promise.all(widgetRefs.map((widget) => widget.getValue())))
         .toStrictEqual(valuesBefore)
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
index f562eb4167a..3f054f1e03b 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
@@ -1,7 +1,7 @@
 /* eslint-disable testing-library/no-container */
 /* eslint-disable testing-library/no-node-access */
 import { createTestingPinia } from '@pinia/testing'
-import { render, screen } from '@testing-library/vue'
+import { fireEvent, render, screen } from '@testing-library/vue'
 import { setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
@@ -19,6 +19,11 @@ import { createNodeExecutionId } from '@/types/nodeIdentification'
 import { widgetId } from '@/types/widgetId'
 
 const GRAPH_ID = 'graph-test'
+const mockShowNodeOptions = vi.hoisted(() => vi.fn())
+
+vi.mock('@/composables/graph/useMoreOptionsMenu', () => ({
+  showNodeOptions: mockShowNodeOptions
+}))
 
 vi.mock('@/renderer/core/canvas/canvasStore', () => ({
   useCanvasStore: () => ({
@@ -382,4 +387,39 @@ describe('NodeWidgets', () => {
     expect(control).toHaveAttribute('data-linked-display', 'control')
     expect(screen.queryByTestId('linked-widget-placeholder')).toBeNull()
   })
+
+  it('dispatches context menu actions from a mounted linked widget', async () => {
+    const linkedWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'prompt')
+    const nodeData = createMockNodeData('TestNode', [
+      createMockWidget({
+        widgetId: linkedWidgetId,
+        name: 'prompt',
+        nodeId: toNodeId('test_node'),
+        type: 'text',
+        slotMetadata: {
+          index: 0,
+          linked: true,
+          type: 'STRING'
+        }
+      })
+    ])
+
+    const { container } = renderComponent(nodeData, () => {
+      useWidgetValueStore().registerWidget(linkedWidgetId, {
+        type: 'text',
+        value: 'stale local prompt',
+        options: {}
+      })
+    })
+
+    const control = container.querySelector('.widget-stub')
+    expect(control).not.toBeNull()
+    await fireEvent.contextMenu(control!)
+
+    expect(mockShowNodeOptions).toHaveBeenCalledWith(
+      expect.any(MouseEvent),
+      'prompt',
+      toNodeId('test_node')
+    )
+  })
 })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
index 60960ac1b46..7244dd8fe98 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
@@ -15,6 +15,12 @@ import WidgetSelectDropdown from '@/renderer/extensions/vueNodes/widgets/compone
 import type { SimplifiedWidget } from '@/types/simplifiedWidget'
 import { createMockWidget } from './widgetTestUtils'
 
+vi.mock('@/composables/useFeatureFlags', () => ({
+  useFeatureFlags: () => ({
+    flags: { modelUploadButtonEnabled: false }
+  })
+}))
+
 const mockCheckState = vi.hoisted(() => vi.fn())
 const mockAssetsData = vi.hoisted(() => ({ items: [] as AssetItem[] }))
 
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
index 61d8df55db0..7d8c02bb97a 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
@@ -174,6 +174,17 @@ describe('WidgetTextarea Value Binding', () => {
       expect(textarea.value).toBe('initial content')
     })
 
+    it('keeps an unlinked disabled textarea readonly without disabling it', () => {
+      const widget = createTextareaWidget('readable content', {
+        disabled: true
+      })
+      renderComponent(widget, 'readable content')
+
+      const textarea = screen.getByRole('textbox')
+      expect(textarea).toHaveAttribute('readonly')
+      expect(textarea).toBeEnabled()
+    })
+
     it('restores the textarea after a link is removed', async () => {
       const widget = createTextareaWidget('stale multiline', {
         disabled: true
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
index 9454e71e6b0..cd85e249dee 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
@@ -32,7 +32,7 @@
       "
       :placeholder
       :readonly="isReadOnly"
-      :disabled="Boolean(widget.options?.disabled)"
+      :disabled="isLinked || undefined"
       :aria-hidden="isLinked ? 'true' : undefined"
       :inert="isLinked ? true : undefined"
       :tabindex="isLinked ? -1 : undefined"

From 2ecc0676ea0525564aa5f2bd4a9680cb591107bc Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Tue, 11 Aug 2026 16:49:38 +0900
Subject: [PATCH 11/18] fix: close linked widget menus on mount

---
 .../widgets/components/WidgetWithControl.test.ts   |  7 +++----
 .../components/form/dropdown/FormDropdown.test.ts  | 14 ++++++++++++++
 .../components/form/dropdown/FormDropdown.vue      | 12 ++++++++----
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
index b4e02dce0e8..cb09ba7cf6c 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
@@ -1,5 +1,5 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fireEvent, render, screen, waitFor } from '@testing-library/vue'
+import { render, screen, waitFor } from '@testing-library/vue'
 import userEvent from '@testing-library/user-event'
 import PrimeVue from 'primevue/config'
 import { describe, expect, it, vi } from 'vitest'
@@ -171,9 +171,9 @@ describe('WidgetWithControl', () => {
     const update = vi.fn<(value: WidgetValue) => void>()
     const widget = makeControlWidget(update, 'randomize')
     const { rerender } = mountWithPortal(widget)
+    const user = userEvent.setup()
 
-    // eslint-disable-next-line testing-library/prefer-user-event
-    await fireEvent.click(await screen.findByTestId('value-control'))
+    await user.click(await screen.findByTestId('value-control'))
     expect(await screen.findAllByRole('radio')).toHaveLength(4)
 
     const linkedWidget: SimplifiedControlWidget = {
@@ -193,7 +193,6 @@ describe('WidgetWithControl', () => {
     expect(linkedButton).toBeDisabled()
     linkedButton.focus()
     expect(linkedButton).not.toHaveFocus()
-    const user = userEvent.setup()
     await user.click(linkedButton)
     await user.keyboard('{Enter}')
     expect(update).not.toHaveBeenCalled()
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
index 647a0aaa52b..87ff7e36af7 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
@@ -83,6 +83,7 @@ const MockPopover = {
 interface MountDropdownOptions {
   closeOnDisable?: boolean
   disabled?: boolean
+  isOpen?: boolean
   searcher?: (
     query: string,
     items: FormDropdownItem[],
@@ -109,6 +110,7 @@ function mountDropdown(
       items,
       closeOnDisable: options.closeOnDisable,
       disabled: options.disabled,
+      ...(options.isOpen === undefined ? {} : { isOpen: options.isOpen }),
       multiple: options.multiple,
       selected: options.selected,
       searcher: options.searcher,
@@ -482,6 +484,18 @@ describe('FormDropdown', () => {
     expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
   })
 
+  it('closes when mounted disabled with closeOnDisable', () => {
+    const onUpdateIsOpen = vi.fn()
+    mountDropdown([createItem('1', 'alpha')], {
+      closeOnDisable: true,
+      disabled: true,
+      isOpen: true,
+      onUpdateIsOpen
+    })
+
+    expect(onUpdateIsOpen).toHaveBeenCalledWith(false)
+  })
+
   it('stays open when disabled without closeOnDisable', async () => {
     const onUpdateIsOpen = vi.fn()
     const items = [createItem('1', 'alpha')]
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
index d6daad30cae..a65aa12a13b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
@@ -212,15 +212,19 @@ function focusTrigger() {
 const closeDropdown = ({ restoreFocus = false } = {}) => {
   if (popoverRef.value) {
     popoverRef.value.hide?.()
-    isOpen.value = false
   }
+  isOpen.value = false
 
   if (restoreFocus) focusTrigger()
 }
 
-watch([() => disabled, () => closeOnDisable], ([isDisabled, shouldClose]) => {
-  if (isDisabled && shouldClose) closeDropdown()
-})
+watch(
+  [() => disabled, () => closeOnDisable],
+  ([isDisabled, shouldClose]) => {
+    if (isDisabled && shouldClose) closeDropdown()
+  },
+  { immediate: true }
+)
 
 /**
  * Dismiss on `pointerdown` rather than PrimeVue's default `click` (mouseup) so

From 740dfd1b39949fe3f420a8f8b9ed27392b64379d Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 20:00:56 +0900
Subject: [PATCH 12/18] fix: address linked widget review regressions

---
 .../tests/subgraph/subgraphNested.spec.ts     |  2 +-
 .../tests/subgraph/subgraphPromotion.spec.ts  |  2 +-
 .../subgraph/subgraphPromotionDom.spec.ts     |  3 +-
 .../subgraph/subgraphSerialization.spec.ts    |  2 +-
 .../tests/subgraph/subgraphSlots.spec.ts      |  4 +-
 .../vueNodes/widgets/advancedWidgets.spec.ts  |  4 +-
 .../linked/linkedStandardWidgets.spec.ts      |  8 +--
 .../parameters/WidgetItem.test.ts             |  4 +-
 .../vueNodes/components/NodeWidgets.test.ts   | 12 +++-
 .../components/LinkedWidgetStatus.test.ts     | 72 +++++++++++++++++++
 .../widgets/components/LinkedWidgetStatus.vue | 11 ++-
 .../components/ValueControlButton.test.ts     | 15 ----
 .../widgets/components/ValueControlButton.vue |  8 +--
 .../components/WidgetInputText.test.ts        |  4 +-
 .../components/WidgetSelectDropdown.test.ts   |  2 +-
 .../widgets/components/WidgetTextarea.test.ts |  8 +--
 .../widgets/components/WidgetTextarea.vue     |  2 +-
 .../components/WidgetToggleSwitch.test.ts     |  4 +-
 .../widgets/components/WidgetToggleSwitch.vue |  3 +-
 .../layout/WidgetLayoutField.test.ts          |  4 +-
 .../components/layout/WidgetLayoutField.vue   |  3 +-
 21 files changed, 115 insertions(+), 62 deletions(-)
 create mode 100644 src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts

diff --git a/browser_tests/tests/subgraph/subgraphNested.spec.ts b/browser_tests/tests/subgraph/subgraphNested.spec.ts
index 0b6450cfd8a..ec894f134f0 100644
--- a/browser_tests/tests/subgraph/subgraphNested.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphNested.spec.ts
@@ -68,7 +68,7 @@ test.describe('Nested Subgraphs', { tag: ['@subgraph'] }, () => {
         await comfyExpect(innerTextboxes).toHaveValue('11111111111')
 
         await comfyExpect(
-          innerNode.getByRole('status', {
+          innerNode.getByRole('img', {
             name: 'text_1: Linked input',
             exact: true
           })
diff --git a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
index 976eb3dcdf3..d9dae3f6ecf 100644
--- a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
@@ -378,7 +378,7 @@ test.describe(
 
           const subgraphNode = comfyPage.vueNodes.getNodeLocator('5')
           await expect(
-            subgraphNode.getByRole('status', {
+            subgraphNode.getByRole('img', {
               name: 'string_a: Linked input',
               exact: true
             })
diff --git a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
index ea2ddcd725f..e894afa4a53 100644
--- a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
@@ -153,9 +153,10 @@ test.describe(
           await openSubgraphById(comfyPage, '11')
 
           const interiorNodes = comfyPage.page.locator('[data-node-id]')
+          await expect(interiorNodes.locator('textarea')).toHaveCount(2)
           await expect(interiorNodes.getByRole('textbox')).toHaveCount(0)
           await expect(
-            interiorNodes.getByRole('status', {
+            interiorNodes.getByRole('img', {
               name: 'text: Linked input',
               exact: true
             })
diff --git a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
index 880364faed2..127bc57b92c 100644
--- a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
@@ -734,7 +734,7 @@ test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
         await expect(outerNode).toBeVisible()
 
         await expect(
-          outerNode.getByRole('status', {
+          outerNode.getByRole('img', {
             name: 'string_a: Linked input',
             exact: true
           })
diff --git a/browser_tests/tests/subgraph/subgraphSlots.spec.ts b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
index 43034acbf4d..a5bdb8de864 100644
--- a/browser_tests/tests/subgraph/subgraphSlots.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
@@ -419,7 +419,7 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
       const subgraphNode = comfyPage.vueNodes.getNodeLocator('19')
       await expect(subgraphNode).toBeVisible()
 
-      const seedStatus = subgraphNode.getByRole('status', {
+      const seedStatus = subgraphNode.getByRole('img', {
         name: 'renamed_seed: Linked input',
         exact: true
       })
@@ -478,7 +478,7 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
         )
         .toBe(RENAMED_LABEL)
 
-      const seedStatusAfter = subgraphNodeAfter.getByRole('status', {
+      const seedStatusAfter = subgraphNodeAfter.getByRole('img', {
         name: `${RENAMED_LABEL}: Linked input`,
         exact: true
       })
diff --git a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
index 8546ac7048f..88a7a7e1d9e 100644
--- a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
@@ -87,7 +87,7 @@ test.describe('Advanced Widget Visibility', { tag: '@vue-nodes' }, () => {
     await expect(widgets).toHaveCount(2)
   })
 
-  test('should keep connected advanced widgets visible when advanced inputs are hidden', async ({
+  test('should show linked status for connected advanced widgets when advanced inputs are hidden', async ({
     comfyPage
   }) => {
     const node = getNode(comfyPage)
@@ -125,7 +125,7 @@ test.describe('Advanced Widget Visibility', { tag: '@vue-nodes' }, () => {
     await node.getByText(HIDE_ADVANCED_INPUTS).click()
 
     await expect(
-      node.getByRole('status', { name: 'max_shift: Linked input' })
+      node.getByRole('img', { name: 'max_shift: Linked input' })
     ).toBeVisible()
     await expect(maxShiftWidget).toBeHidden()
     await expect(baseShiftWidget).toBeHidden()
diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
index 01e126f2a0c..1534ec6ca1e 100644
--- a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -49,7 +49,7 @@ test.describe(
 
         for (const name of WIDGET_NAMES) {
           await expect(
-            targetNode.getByRole('status', {
+            targetNode.getByRole('img', {
               name: `${name}: Linked input`
             })
           ).toBeVisible()
@@ -150,18 +150,18 @@ test.describe(
       )
 
       await targetNode
-        .getByRole('status', { name: 'switch: Linked input' })
+        .getByRole('img', { name: 'switch: Linked input' })
         .click()
       await comfyPage.page.keyboard.press('Space')
 
       await targetNode
-        .getByRole('status', { name: 'select: Linked input' })
+        .getByRole('img', { name: 'select: Linked input' })
         .click()
       await comfyPage.page.keyboard.press('ArrowUp')
       await comfyPage.page.keyboard.press('Enter')
 
       await targetNode
-        .getByRole('status', { name: 'textarea: Linked input' })
+        .getByRole('img', { name: 'textarea: Linked input' })
         .click()
       await comfyPage.page.keyboard.type('ignored input')
       await expect(focusedLinkedContent).toHaveCount(0)
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 024a56ad48d..5676b4a5726 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -264,7 +264,7 @@ describe('WidgetItem', () => {
       expect(input).toBeDisabled()
       expect(screen.queryByRole('textbox')).toBeNull()
       expect(
-        screen.getByRole('status', { name: 'prompt: Linked input' })
+        screen.getByRole('img', { name: 'prompt: Linked input' })
       ).toBeVisible()
     })
 
@@ -349,7 +349,7 @@ describe('WidgetItem', () => {
 
       expect(stub.linkedDisplay).toBeNull()
       expect(stub.options.disabled).toBe(true)
-      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.queryByTestId('linked-widget-placeholder')).toBeNull()
     })
   })
 })
diff --git a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
index 3f054f1e03b..9230eef810e 100644
--- a/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/components/NodeWidgets.test.ts
@@ -41,7 +41,7 @@ const WidgetStub = {
   name: 'WidgetStub',
   props: ['widget', 'nodeId', 'nodeType', 'modelValue'],
   template:
-    '<button class="widget-stub" :data-linked-display="widget.linkedDisplay" :data-node-type="nodeType" :disabled="widget.options?.disabled">{{ modelValue }}</button>'
+    '<button class="widget-stub" :data-linked-display="widget.linkedDisplay" :data-node-type="nodeType" :disabled="widget.options?.disabled" :inert="widget.linkedDisplay ? true : undefined">{{ modelValue }}</button>'
 }
 
 vi.mock(
@@ -388,7 +388,7 @@ describe('NodeWidgets', () => {
     expect(screen.queryByTestId('linked-widget-placeholder')).toBeNull()
   })
 
-  it('dispatches context menu actions from a mounted linked widget', async () => {
+  it('dispatches context menu actions around an inert linked widget', async () => {
     const linkedWidgetId = widgetId(GRAPH_ID, toNodeId('test_node'), 'prompt')
     const nodeData = createMockNodeData('TestNode', [
       createMockWidget({
@@ -414,7 +414,13 @@ describe('NodeWidgets', () => {
 
     const control = container.querySelector('.widget-stub')
     expect(control).not.toBeNull()
-    await fireEvent.contextMenu(control!)
+    expect(control).toHaveAttribute('inert')
+
+    const contextMenuSurface = container.querySelector(
+      '.lg-node-widget > .contents'
+    )
+    expect(contextMenuSurface).not.toBeNull()
+    await fireEvent.contextMenu(contextMenuSurface!)
 
     expect(mockShowNodeOptions).toHaveBeenCalledWith(
       expect.any(MouseEvent),
diff --git a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts
new file mode 100644
index 00000000000..056e5946ab7
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts
@@ -0,0 +1,72 @@
+import { render, screen } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick } from 'vue'
+
+import { i18n } from '@/i18n'
+
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
+
+const originalLocale = i18n.global.locale.value
+const originalFrenchMessages = i18n.global.getLocaleMessage('fr')
+
+afterEach(() => {
+  i18n.global.locale.value = originalLocale
+  i18n.global.setLocaleMessage('fr', originalFrenchMessages)
+})
+
+describe('LinkedWidgetStatus', () => {
+  it('exposes the linked state as a named image', () => {
+    render(LinkedWidgetStatus, {
+      props: {
+        display: 'control',
+        widget: { name: 'prompt', label: 'Prompt' }
+      }
+    })
+
+    expect(
+      screen.getByRole('img', { name: 'Prompt: Linked input' })
+    ).toBeVisible()
+  })
+
+  it('allows pointer gestures to bubble to the canvas surface', async () => {
+    const onPointerdown = vi.fn()
+    const Harness = defineComponent({
+      components: { LinkedWidgetStatus },
+      setup: () => ({ onPointerdown }),
+      template: `
+        <div @pointerdown="onPointerdown">
+          <LinkedWidgetStatus
+            display="control"
+            :widget="{ name: 'prompt' }"
+          />
+        </div>
+      `
+    })
+    render(Harness)
+    const user = userEvent.setup()
+
+    await user.pointer({ keys: '[MouseLeft]', target: screen.getByRole('img') })
+
+    expect(onPointerdown).toHaveBeenCalledTimes(1)
+  })
+
+  it('updates its accessible name when the locale changes', async () => {
+    render(LinkedWidgetStatus, {
+      props: {
+        display: 'control',
+        widget: { name: 'prompt' }
+      }
+    })
+    i18n.global.mergeLocaleMessage('fr', {
+      widgets: { linkedInput: 'Entrée liée' }
+    })
+    i18n.global.locale.value = 'fr'
+
+    await nextTick()
+
+    expect(
+      screen.getByRole('img', { name: 'prompt: Entrée liée' })
+    ).toBeVisible()
+  })
+})
diff --git a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
index e151359034c..abae29536a0 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
@@ -18,9 +18,9 @@ const {
   rounded?: 'md' | 'lg'
 }>()
 
-const linkedLabel = st('widgets.linkedInput', 'Linked input')
+const linkedLabel = computed(() => st('widgets.linkedInput', 'Linked input'))
 const accessibleName = computed(
-  () => `${widget.label || widget.name}: ${linkedLabel}`
+  () => `${widget.label || widget.name}: ${linkedLabel.value}`
 )
 </script>
 
@@ -28,12 +28,12 @@ const accessibleName = computed(
   <div
     data-testid="linked-widget-placeholder"
     :data-linked-display="display"
-    role="status"
+    role="img"
     :aria-label="accessibleName"
     :title="linkedLabel"
     :class="
       cn(
-        'pointer-events-auto absolute z-20 flex cursor-default items-center overflow-hidden bg-component-node-widget-background/40 select-none',
+        'absolute z-20 flex cursor-default items-center overflow-hidden bg-component-node-widget-background/40 select-none',
         display === 'switch'
           ? 'top-1 right-1 h-6 w-10 justify-center rounded-full'
           : display === 'expanding'
@@ -44,9 +44,6 @@ const accessibleName = computed(
               )
       )
     "
-    @pointerdown.stop.prevent
-    @pointermove.stop
-    @pointerup.stop
   >
     <i
       class="icon-[lucide--link] size-4 text-component-node-foreground-secondary opacity-40"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
index 869ef182a39..cc470ad064e 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.test.ts
@@ -83,20 +83,5 @@ describe('ValueControlButton', () => {
       await user.click(screen.getByRole('button'))
       expect(onClick).toHaveBeenCalledTimes(1)
     })
-
-    it('cannot be activated when disabled', async () => {
-      const onClick = vi.fn()
-      render(ValueControlButton, {
-        global: { plugins: [i18n] },
-        props: { mode: 'randomize', disabled: true },
-        attrs: { onClick }
-      })
-      const user = userEvent.setup()
-      const button = screen.getByRole('button')
-
-      expect(button).toBeDisabled()
-      await user.click(button)
-      expect(onClick).not.toHaveBeenCalled()
-    })
   })
 })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
index 4963ee50a0a..c4b371e46b3 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
@@ -4,14 +4,9 @@ import { useI18n } from 'vue-i18n'
 import type { ControlOptions } from '@/types/simplifiedWidget'
 import { cn } from '@comfyorg/tailwind-utils'
 
-const {
-  mode,
-  variant = 'badge',
-  disabled = false
-} = defineProps<{
+const { mode, variant = 'badge' } = defineProps<{
   mode: ControlOptions
   variant?: 'badge' | 'button'
-  disabled?: boolean
 }>()
 
 const { t } = useI18n()
@@ -35,7 +30,6 @@ const textMap: Record<ControlOptions, string | null> = {
   <button
     data-testid="value-control"
     type="button"
-    :disabled
     :aria-label="t('widgets.valueControl.' + mode)"
     :class="
       cn(
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
index e1f1dc7ed50..da023918092 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
@@ -183,7 +183,7 @@ describe('WidgetInputText Value Binding', () => {
         'inert'
       )
       expect(
-        screen.getByRole('status', { name: 'test_input: Linked input' })
+        screen.getByRole('img', { name: 'test_input: Linked input' })
       ).toBeVisible()
 
       await rerender({
@@ -191,7 +191,7 @@ describe('WidgetInputText Value Binding', () => {
         modelValue: 'stale prompt'
       })
 
-      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.queryByRole('img')).toBeNull()
       expect(screen.getByRole('textbox')).toBeVisible()
       expect(screen.getByRole('textbox')).toBeEnabled()
       expect(screen.getByRole('textbox')).toHaveValue('stale prompt')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
index 54d1eba2146..b6bfbe24566 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
@@ -258,7 +258,7 @@ describe('WidgetSelectDropdown', () => {
       screen.queryByRole('button', { name: 'stale.png' })
     ).not.toBeInTheDocument()
     expect(
-      screen.getByRole('status', { name: 'image: Linked input' })
+      screen.getByRole('img', { name: 'image: Linked input' })
     ).toBeVisible()
     for (const button of within(content).getAllByRole('button', {
       hidden: true
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
index 6385a90ffe7..1bdda93aabe 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
@@ -174,7 +174,7 @@ describe('WidgetTextarea Value Binding', () => {
       expect(textarea.value).toBe('initial content')
     })
 
-    it('keeps an unlinked disabled textarea readonly without disabling it', () => {
+    it('keeps an unlinked disabled textarea disabled and readonly', () => {
       const widget = createTextareaWidget('readable content', {
         disabled: true
       })
@@ -182,7 +182,7 @@ describe('WidgetTextarea Value Binding', () => {
 
       const textarea = screen.getByRole('textbox')
       expect(textarea).toHaveAttribute('readonly')
-      expect(textarea).toBeEnabled()
+      expect(textarea).toBeDisabled()
     })
 
     it('restores the textarea after a link is removed', async () => {
@@ -200,7 +200,7 @@ describe('WidgetTextarea Value Binding', () => {
       textarea.focus()
       expect(textarea).not.toHaveFocus()
       expect(
-        screen.getByRole('status', {
+        screen.getByRole('img', {
           name: 'test_textarea: Linked input'
         })
       ).toBeVisible()
@@ -211,7 +211,7 @@ describe('WidgetTextarea Value Binding', () => {
         modelValue: 'stale multiline'
       })
 
-      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.queryByRole('img')).toBeNull()
       expect(screen.getByRole('textbox')).toBeVisible()
       expect(screen.getByRole('textbox')).toBeEnabled()
       expect(screen.getByRole('textbox')).toHaveValue('stale multiline')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
index d16c995dd06..4f79f933538 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
@@ -34,7 +34,7 @@
       "
       :placeholder
       :readonly="isReadOnly"
-      :disabled="isLinked || undefined"
+      :disabled="isLinked || filteredProps.disabled"
       :aria-hidden="isLinked ? 'true' : undefined"
       :inert="isLinked ? true : undefined"
       :tabindex="isLinked ? -1 : undefined"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
index 2f76fc3a07b..8bcadac8e17 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
@@ -342,7 +342,7 @@ describe('WidgetToggleSwitch Value Binding', () => {
       control.focus()
       expect(control).not.toHaveFocus()
       expect(
-        screen.getByRole('status', {
+        screen.getByRole('img', {
           name: 'test_toggle: Linked input'
         })
       ).toHaveAttribute('data-linked-display', 'switch')
@@ -364,7 +364,7 @@ describe('WidgetToggleSwitch Value Binding', () => {
       expect(screen.queryByRole('button')).toBeNull()
       for (const control of controls) expect(control).toBeDisabled()
       expect(
-        screen.getByRole('status', {
+        screen.getByRole('img', {
           name: 'test_toggle: Linked input'
         })
       ).toHaveAttribute('data-linked-display', 'control')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
index 6b56cc77335..1482244bd09 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
@@ -37,8 +37,7 @@
       "
     >
       <div
-        class="contents"
-        :class="isLinkedSwitch && 'invisible'"
+        :class="cn('contents', isLinkedSwitch && 'invisible')"
         :aria-hidden="isLinkedSwitch ? 'true' : undefined"
         :inert="isLinkedSwitch ? true : undefined"
         :data-testid="isLinkedSwitch ? 'linked-widget-content' : undefined"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
index 05682c4591c..bbb4970d59b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.test.ts
@@ -115,12 +115,12 @@ describe('WidgetLayoutField', () => {
       expect(control).toBeDisabled()
       expect(screen.queryByRole('button')).toBeNull()
       expect(
-        screen.getByRole('status', { name: 'prompt: Linked input' })
+        screen.getByRole('img', { name: 'prompt: Linked input' })
       ).toBeVisible()
 
       await rerender({ widget: { name: 'prompt' } })
 
-      expect(screen.queryByRole('status')).toBeNull()
+      expect(screen.queryByRole('img')).toBeNull()
       expect(screen.getByRole('button', { name: 'stale prompt' })).toBeVisible()
     })
   })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
index 32b37bbcaf9..ab4e07160dc 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
@@ -69,8 +69,7 @@ const linkedDisplay = computed(() =>
         @pointerup.stop
       >
         <div
-          class="contents"
-          :class="linkedDisplay && 'invisible'"
+          :class="cn('contents', linkedDisplay && 'invisible')"
           :aria-hidden="linkedDisplay ? 'true' : undefined"
           :inert="linkedDisplay ? true : undefined"
           :data-testid="linkedDisplay ? 'linked-widget-content' : undefined"

From e4ead19895de58a5e5f1ff031035d388333868c3 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 20:05:36 +0900
Subject: [PATCH 13/18] fix: cover remaining core image selectors

---
 .../parameters/WidgetItem.test.ts             | 63 ++++++++++---------
 .../composables/useProcessedWidgets.test.ts   | 25 ++++----
 .../widgets/utils/linkedWidgetDisplay.test.ts | 21 +++++++
 .../widgets/utils/linkedWidgetDisplay.ts      |  2 +
 4 files changed, 70 insertions(+), 41 deletions(-)

diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 5676b4a5726..a16c5666b12 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -297,36 +297,39 @@ describe('WidgetItem', () => {
       expect(getStubWidget(upload.container).options.disabled).toBe(true)
     })
 
-    it('uses the linked presentation for an exact core media selector', () => {
-      mockGetInputSpecForWidget.mockReturnValue({
-        type: 'COMBO',
-        name: 'image',
-        image_upload: true
-      })
-      mockFromLGraphNode.mockReturnValue({
-        name: 'LoadImage',
-        isCoreNode: true
-      })
-      const widget = createMockWidget({ name: 'image', type: 'asset' })
-      const node = createMockNode({
-        type: 'LoadImage',
-        inputs: [
-          {
-            name: 'image',
-            type: 'COMBO',
-            link: toLinkId(1),
-            boundingRect: [0, 0, 0, 0],
-            widget: { name: 'image' }
-          }
-        ]
-      })
-
-      const { container } = renderWidgetItem(widget, node)
-      const stub = getStubWidget(container)
-
-      expect(stub.linkedDisplay).toBe('control')
-      expect(stub.options.disabled).toBe(true)
-    })
+    it.for(['LoadImage', 'LoadImageMask', 'LoadImageOutput'])(
+      'uses the linked presentation for the exact core %s selector',
+      (nodeType) => {
+        mockGetInputSpecForWidget.mockReturnValue({
+          type: 'COMBO',
+          name: 'image',
+          image_upload: true
+        })
+        mockFromLGraphNode.mockReturnValue({
+          name: nodeType,
+          isCoreNode: true
+        })
+        const widget = createMockWidget({ name: 'image', type: 'asset' })
+        const node = createMockNode({
+          type: nodeType,
+          inputs: [
+            {
+              name: 'image',
+              type: 'COMBO',
+              link: toLinkId(1),
+              boundingRect: [0, 0, 0, 0],
+              widget: { name: 'image' }
+            }
+          ]
+        })
+
+        const { container } = renderWidgetItem(widget, node)
+        const stub = getStubWidget(container)
+
+        expect(stub.linkedDisplay).toBe('control')
+        expect(stub.options.disabled).toBe(true)
+      }
+    )
 
     it('does not add linked presentation to a special widget', () => {
       const widget = createMockWidget({
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index deb490218ab..8bf04f15293 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -904,19 +904,22 @@ describe('computeProcessedWidgets linked presentation', () => {
     expect(processed.simplified.options?.disabled).toBe(true)
   })
 
-  it('hides and disables a linked core media selector', () => {
-    const widget = createMockWidget({
-      name: 'image',
-      type: 'asset',
-      spec: { type: 'COMBO', name: 'image', image_upload: true },
-      slotMetadata: linkedSlot
-    })
+  it.for(['LoadImage', 'LoadImageMask', 'LoadImageOutput'])(
+    'hides and disables a linked core %s selector',
+    (nodeType) => {
+      const widget = createMockWidget({
+        name: 'image',
+        type: 'asset',
+        spec: { type: 'COMBO', name: 'image', image_upload: true },
+        slotMetadata: linkedSlot
+      })
 
-    const [processed] = processNodeWidgets([widget], 'LoadImage', true)
+      const [processed] = processNodeWidgets([widget], nodeType, true)
 
-    expect(processed.linkedDisplay).toBe('control')
-    expect(processed.simplified.options?.disabled).toBe(true)
-  })
+      expect(processed.linkedDisplay).toBe('control')
+      expect(processed.simplified.options?.disabled).toBe(true)
+    }
+  )
 
   it('keeps an asset-browser combo rendered while hiding an ordinary combo', () => {
     shouldUseAssetBrowser.mockReturnValue(true)
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
index 92f1b7f3598..cacbb28946b 100644
--- a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
@@ -101,6 +101,18 @@ describe('resolveLinkedWidgetDisplay', () => {
       type: 'asset',
       spec: { type: 'COMBO', name: 'image', image_upload: true }
     },
+    {
+      nodeType: 'LoadImageMask',
+      name: 'image',
+      type: 'COMBO',
+      spec: { type: 'COMBO', name: 'image', image_upload: true }
+    },
+    {
+      nodeType: 'LoadImageOutput',
+      name: 'image',
+      type: 'asset',
+      spec: { type: 'COMBO', name: 'image', image_upload: true }
+    },
     {
       nodeType: 'LoadVideo',
       name: 'file',
@@ -163,6 +175,15 @@ describe('resolveLinkedWidgetDisplay', () => {
         spec: { type: 'COMBO', name: 'image', image_upload: true }
       },
       coreNodeType: 'LoadImage'
+    },
+    {
+      label: 'out-of-scope core 3D loader',
+      widget: {
+        name: 'model_file',
+        type: 'load3D',
+        spec: { type: 'COMBO', name: 'model_file' }
+      },
+      coreNodeType: 'Load3D'
     }
   ] satisfies Array<{
     label: string
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
index f4c58ed08ee..01d3434b70d 100644
--- a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
@@ -19,6 +19,8 @@ interface LinkedWidgetDisplayContext {
 
 const CORE_MEDIA_SELECTOR_WIDGETS = new Map([
   ['LoadImage', 'image'],
+  ['LoadImageMask', 'image'],
+  ['LoadImageOutput', 'image'],
   ['LoadVideo', 'file'],
   ['LoadAudio', 'audio']
 ])

From 28768aa746f1615dde6d709adc4b78d74e278717 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 20:21:13 +0900
Subject: [PATCH 14/18] test: align promoted linked status role

---
 browser_tests/fixtures/utils/promotedMissingModel.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/browser_tests/fixtures/utils/promotedMissingModel.ts b/browser_tests/fixtures/utils/promotedMissingModel.ts
index 9e0d5a24494..9b13e1788ac 100644
--- a/browser_tests/fixtures/utils/promotedMissingModel.ts
+++ b/browser_tests/fixtures/utils/promotedMissingModel.ts
@@ -235,7 +235,7 @@ export async function expectResolvedPromotedModelSuppressesStaleInteriorErrors(
     const node = comfyPage.vueNodes.getNodeByTitle(step.nodeTitle)
     await expect(node).toBeVisible()
 
-    const linkedStatus = node.getByRole('status', {
+    const linkedStatus = node.getByRole('img', {
       name: `${PROMOTED_MODEL_WIDGET_NAME}: Linked input`,
       exact: true
     })

From b479990c871a83f9844d0d37c835063fd3a3b4a9 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 20:41:19 +0900
Subject: [PATCH 15/18] fix: address linked widget review feedback

---
 .../text/multilineStringWidget.spec.ts        |  1 +
 .../parameters/WidgetItem.test.ts             |  3 +-
 .../ui/color-picker/ColorPicker.test.ts       | 30 +++++++++++++++++++
 .../ui/color-picker/ColorPicker.vue           |  6 +++-
 .../components/WidgetToggleSwitch.test.ts     |  3 +-
 .../widgets/components/WidgetToggleSwitch.vue | 10 +++++--
 6 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
index 0437c8a16ba..578313c5b1f 100644
--- a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
@@ -65,6 +65,7 @@ test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
     await expect(placeholder).toHaveAccessibleName('text: Linked input')
     await expect(linkedContent).toHaveAttribute('inert', '')
     await expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
+    await expect(hiddenTextarea).toBeHidden()
     await expect(hiddenTextarea).toBeDisabled()
     await expect(clipNode.getByRole('textbox', { name: 'text' })).toHaveCount(0)
     await expect(hiddenTextarea).toHaveValue('stale local prompt')
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index a16c5666b12..79b2956e7e0 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -9,9 +9,10 @@ import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import type * as WidgetRegistry from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
 import { useWidgetValueStore } from '@/stores/widgetValueStore'
 import { toLinkId } from '@/types/linkId'
+import { toNodeId } from '@/types/nodeId'
 import { widgetId } from '@/types/widgetId'
+
 import WidgetItem from './WidgetItem.vue'
-import { toNodeId } from '@/types/nodeId'
 
 const {
   mockFromLGraphNode,
diff --git a/src/components/ui/color-picker/ColorPicker.test.ts b/src/components/ui/color-picker/ColorPicker.test.ts
index e1a9b5d82da..bec44b9c9e3 100644
--- a/src/components/ui/color-picker/ColorPicker.test.ts
+++ b/src/components/ui/color-picker/ColorPicker.test.ts
@@ -44,4 +44,34 @@ describe('ColorPicker', () => {
     })
     expect(trigger).toBeDisabled()
   })
+
+  it('does not reopen from a custom trigger when disabled', async () => {
+    const user = userEvent.setup()
+    const { rerender } = render(ColorPicker, {
+      global: { plugins: [i18n] },
+      props: { modelValue: '#112233' },
+      slots: {
+        trigger: '<button type="button">Custom trigger</button>'
+      }
+    })
+    const trigger = screen.getByRole('button', { name: 'Custom trigger' })
+
+    await user.click(trigger)
+    expect(
+      await screen.findByRole('textbox', { name: 'Hex' })
+    ).toBeInTheDocument()
+
+    await rerender({ disabled: true, modelValue: '#112233' })
+    await waitFor(() => {
+      expect(
+        screen.queryByRole('textbox', { name: 'Hex' })
+      ).not.toBeInTheDocument()
+    })
+
+    await user.click(trigger)
+
+    expect(
+      screen.queryByRole('textbox', { name: 'Hex' })
+    ).not.toBeInTheDocument()
+  })
 })
diff --git a/src/components/ui/color-picker/ColorPicker.vue b/src/components/ui/color-picker/ColorPicker.vue
index e92c7bcd336..057c3908785 100644
--- a/src/components/ui/color-picker/ColorPicker.vue
+++ b/src/components/ui/color-picker/ColorPicker.vue
@@ -70,6 +70,10 @@ const displayHex = computed(() => rgbToHex(baseRgb.value).toLowerCase())
 const isOpen = ref(false)
 const contentStyle = useModalLiftedZIndex(isOpen)
 
+function updateOpen(open: boolean) {
+  isOpen.value = open && !disabled
+}
+
 watch(
   () => disabled,
   (isDisabled) => {
@@ -79,7 +83,7 @@ watch(
 </script>
 
 <template>
-  <PopoverRoot v-model:open="isOpen">
+  <PopoverRoot :open="isOpen" @update:open="updateOpen">
     <PopoverTrigger as-child>
       <slot name="trigger">
         <button
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
index 8bcadac8e17..5956ff8e576 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
@@ -329,7 +329,7 @@ describe('WidgetToggleSwitch Value Binding', () => {
     })
 
     it('exposes a linked status on the implicit switch surface', () => {
-      const widget = createToggleWidget(false, { disabled: true })
+      const widget = createToggleWidget(false)
       widget.linkedDisplay = 'switch'
       mountComponent(widget, false)
 
@@ -350,7 +350,6 @@ describe('WidgetToggleSwitch Value Binding', () => {
 
     it('keeps labeled linked toggles disabled behind one control status', () => {
       const widget = createToggleWidget(false, {
-        disabled: true,
         on: 'enabled',
         off: 'disabled'
       })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
index 1482244bd09..0704f61e887 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
@@ -9,7 +9,13 @@
       v-if="hasLabels"
       type="single"
       :model-value="modelValue ? 'on' : 'off'"
-      :disabled="Boolean(widget.options?.read_only || widget.options?.disabled)"
+      :disabled="
+        Boolean(
+          widget.linkedDisplay ||
+          widget.options?.read_only ||
+          widget.options?.disabled
+        )
+      "
       :class="
         cn(
           WidgetInputBaseClass,
@@ -44,7 +50,7 @@
       >
         <Switch
           v-model="modelValue"
-          :disabled="Boolean(widget.options?.disabled)"
+          :disabled="isLinkedSwitch || Boolean(widget.options?.disabled)"
           :readonly="Boolean(widget.options?.read_only)"
           :aria-label="widget.name"
         />

From cd206f3dc49b758b9548dcf53aebd9491d9d5936 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 20:57:09 +0900
Subject: [PATCH 16/18] test: update linked widget hover snapshot

---
 ...cked-widget-hover-color-chromium-linux.png | Bin 5963 -> 4893 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png b/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png
index 2eb6df89275581d26530699216faa29b637be4d5..f460a7567ab20b301e4a52ae52a7c863f82a0ba8 100644
GIT binary patch
literal 4893
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

literal 5963
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
KE>|gI9{OLOBf8E2


From bec99656ec52b15090bcb590b20c2730104b4e25 Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 21:42:29 +0900
Subject: [PATCH 17/18] test: verify parameter widget restoration

---
 .../parameters/WidgetItem.test.ts             | 20 ++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 79b2956e7e0..58df1eb178b 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -1,4 +1,4 @@
-import { render, screen } from '@testing-library/vue'
+import { fireEvent, render, screen } from '@testing-library/vue'
 import { fromAny } from '@total-typescript/shoehorn'
 import PrimeVue from 'primevue/config'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -238,7 +238,7 @@ describe('WidgetItem', () => {
       expect(stub.value).toBe('model_a.safetensors')
     })
 
-    it('renders a supported linked text status in Parameters', () => {
+    it('restores a linked text control in Parameters after disconnect', async () => {
       const widget = createMockWidget({
         name: 'prompt',
         type: 'text',
@@ -256,7 +256,7 @@ describe('WidgetItem', () => {
         ]
       })
 
-      renderWidgetItem(widget, node)
+      const view = renderWidgetItem(widget, node)
 
       const content = screen.getByTestId('linked-widget-content')
       const input = screen.getByRole('textbox', { hidden: true })
@@ -267,6 +267,20 @@ describe('WidgetItem', () => {
       expect(
         screen.getByRole('img', { name: 'prompt: Linked input' })
       ).toBeVisible()
+
+      await view.rerender({ widget, node: createMockNode({ inputs: [] }) })
+
+      expect(screen.queryByRole('img')).toBeNull()
+      const restoredInput = screen.getByRole('textbox', { name: 'prompt' })
+      expect(restoredInput).toBeVisible()
+      expect(restoredInput).toBeEnabled()
+      expect(restoredInput).toHaveValue('STALE PARAMETER TEXT')
+
+      await fireEvent.update(restoredInput, 'restored parameter text')
+
+      expect(view.emitted()['update:widgetValue']).toContainEqual([
+        'restored parameter text'
+      ])
     })
 
     it('uses the bounded linked resolver for ordinary and upload combos', () => {

From 6f44e9ae6ddec08369c7dc6f160a80559781b95c Mon Sep 17 00:00:00 2001
From: jaeone94 <89377375+jaeone94@users.noreply.github.com>
Date: Mon, 17 Aug 2026 22:00:12 +0900
Subject: [PATCH 18/18] test: model parameter disconnect interaction

---
 .../parameters/WidgetItem.test.ts             | 31 ++++++++++++-------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 58df1eb178b..c1a3d276875 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -1,5 +1,6 @@
-import { fireEvent, render, screen } from '@testing-library/vue'
 import { fromAny } from '@total-typescript/shoehorn'
+import userEvent from '@testing-library/user-event'
+import { render, screen } from '@testing-library/vue'
 import PrimeVue from 'primevue/config'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createI18n } from 'vue-i18n'
@@ -244,16 +245,15 @@ describe('WidgetItem', () => {
         type: 'text',
         value: 'STALE PARAMETER TEXT'
       })
+      const promptInput = {
+        name: 'prompt',
+        type: 'STRING',
+        link: toLinkId(1),
+        boundingRect: [0, 0, 0, 0],
+        widget: { name: 'prompt' }
+      }
       const node = createMockNode({
-        inputs: [
-          {
-            name: 'prompt',
-            type: 'STRING',
-            link: toLinkId(1),
-            boundingRect: [0, 0, 0, 0],
-            widget: { name: 'prompt' }
-          }
-        ]
+        inputs: [promptInput]
       })
 
       const view = renderWidgetItem(widget, node)
@@ -268,7 +268,12 @@ describe('WidgetItem', () => {
         screen.getByRole('img', { name: 'prompt: Linked input' })
       ).toBeVisible()
 
-      await view.rerender({ widget, node: createMockNode({ inputs: [] }) })
+      await view.rerender({
+        widget,
+        node: createMockNode({
+          inputs: [{ ...promptInput, link: null }]
+        })
+      })
 
       expect(screen.queryByRole('img')).toBeNull()
       const restoredInput = screen.getByRole('textbox', { name: 'prompt' })
@@ -276,7 +281,9 @@ describe('WidgetItem', () => {
       expect(restoredInput).toBeEnabled()
       expect(restoredInput).toHaveValue('STALE PARAMETER TEXT')
 
-      await fireEvent.update(restoredInput, 'restored parameter text')
+      const user = userEvent.setup()
+      await user.clear(restoredInput)
+      await user.type(restoredInput, 'restored parameter text')
 
       expect(view.emitted()['update:widgetValue']).toContainEqual([
         'restored parameter text'