fix: correct nested subgraph promotion fixture for E2E test

- Fix node 6 proxyWidget ["5","string_a"] → ["9","string_a"]: node 5
  does not exist inside Sub 1 (only nodes 9, 10, 11), causing the entry
  to be filtered out and leaving only 3 widgets instead of 4.
- Add ["6","string_a"] to node 5 proxyWidgets so the isWidgetPromoted
  fallback lookup ("6:string_a" without disambiguator) matches, enabling
  the promoted ring on node 6's string_a widgets inside Sub 0.

browser_tests/assets/subgraphs/basic-subgraph-zero-uuid.json

@@ -0,0 +1,197 @@
+{
+  "id": "00000000-0000-0000-0000-000000000000",
+  "revision": 0,
+  "last_node_id": 2,
+  "last_link_id": 0,
+  "nodes": [
+    {
+      "id": 2,
+      "type": "e5fb1765-9323-4548-801a-5aead34d879e",
+      "pos": [627.5973510742188, 423.0972900390625],
+      "size": [144.15234375, 46],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": null
+        }
+      ],
+      "properties": {},
+      "widgets_values": []
+    }
+  ],
+  "links": [],
+  "groups": [],
+  "definitions": {
+    "subgraphs": [
+      {
+        "id": "e5fb1765-9323-4548-801a-5aead34d879e",
+        "version": 1,
+        "state": {
+          "lastGroupId": 0,
+          "lastNodeId": 2,
+          "lastLinkId": 4,
+          "lastRerouteId": 0
+        },
+        "revision": 0,
+        "config": {},
+        "name": "New Subgraph",
+        "inputNode": {
+          "id": -10,
+          "bounding": [347.90441582814213, 417.3822440655296, 120, 60]
+        },
+        "outputNode": {
+          "id": -20,
+          "bounding": [892.5973510742188, 416.0972900390625, 120, 60]
+        },
+        "inputs": [
+          {
+            "id": "c5cc99d8-a2b6-4bf3-8be7-d4949ef736cd",
+            "name": "positive",
+            "type": "CONDITIONING",
+            "linkIds": [1],
+            "pos": {
+              "0": 447.9044189453125,
+              "1": 437.3822326660156
+            }
+          }
+        ],
+        "outputs": [
+          {
+            "id": "9bd488b9-e907-4c95-a7a4-85c5597a87af",
+            "name": "LATENT",
+            "type": "LATENT",
+            "linkIds": [2],
+            "pos": {
+              "0": 912.5973510742188,
+              "1": 436.0972900390625
+            }
+          }
+        ],
+        "widgets": [],
+        "nodes": [
+          {
+            "id": 1,
+            "type": "KSampler",
+            "pos": [554.8743286132812, 100.95539093017578],
+            "size": [270, 262],
+            "flags": {},
+            "order": 1,
+            "mode": 0,
+            "inputs": [
+              {
+                "localized_name": "model",
+                "name": "model",
+                "type": "MODEL",
+                "link": null
+              },
+              {
+                "localized_name": "positive",
+                "name": "positive",
+                "type": "CONDITIONING",
+                "link": 1
+              },
+              {
+                "localized_name": "negative",
+                "name": "negative",
+                "type": "CONDITIONING",
+                "link": null
+              },
+              {
+                "localized_name": "latent_image",
+                "name": "latent_image",
+                "type": "LATENT",
+                "link": null
+              }
+            ],
+            "outputs": [
+              {
+                "localized_name": "LATENT",
+                "name": "LATENT",
+                "type": "LATENT",
+                "links": [2]
+              }
+            ],
+            "properties": {
+              "Node name for S&R": "KSampler"
+            },
+            "widgets_values": [0, "randomize", 20, 8, "euler", "simple", 1]
+          },
+          {
+            "id": 2,
+            "type": "VAEEncode",
+            "pos": [685.1265869140625, 439.1734619140625],
+            "size": [140, 46],
+            "flags": {},
+            "order": 0,
+            "mode": 0,
+            "inputs": [
+              {
+                "localized_name": "pixels",
+                "name": "pixels",
+                "type": "IMAGE",
+                "link": null
+              },
+              {
+                "localized_name": "vae",
+                "name": "vae",
+                "type": "VAE",
+                "link": null
+              }
+            ],
+            "outputs": [
+              {
+                "localized_name": "LATENT",
+                "name": "LATENT",
+                "type": "LATENT",
+                "links": [4]
+              }
+            ],
+            "properties": {
+              "Node name for S&R": "VAEEncode"
+            }
+          }
+        ],
+        "groups": [],
+        "links": [
+          {
+            "id": 1,
+            "origin_id": -10,
+            "origin_slot": 0,
+            "target_id": 1,
+            "target_slot": 1,
+            "type": "CONDITIONING"
+          },
+          {
+            "id": 2,
+            "origin_id": 1,
+            "origin_slot": 0,
+            "target_id": -20,
+            "target_slot": 0,
+            "type": "LATENT"
+          }
+        ],
+        "extra": {}
+      }
+    ]
+  },
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.8894351682943402,
+      "offset": [58.7671207025881, 137.7124650620126]
+    },
+    "frontendVersion": "1.24.1"
+  },
+  "version": 0.4
+}

browser_tests/assets/subgraphs/subgraph-nested-promotion.json

@@ -55,7 +55,8 @@
           ["3", "string_a"],
           ["4", "value"],
           ["6", "value"],
-          ["6", "value_1"]
+          ["6", "value_1"],
+          ["6", "string_a"]
         ]
       },
       "widgets_values": []
@@ -272,7 +273,7 @@
             ],
             "properties": {
               "proxyWidgets": [
-                ["5", "string_a"],
+                ["9", "string_a"],
                 ["11", "value"],
                 ["9", "value"],
                 ["10", "string_a"]

browser_tests/tests/subgraph/subgraphNested.spec.ts

@@ -458,4 +458,71 @@ test.describe('Subgraph Nested Scenarios', { tag: ['@subgraph'] }, () => {
       })
     }
   )
+
+  /**
+   * Regression test for #10612: promoted widget indicator ring missing on
+   * nested subgraph nodes.
+   *
+   * Uses the 3-level nested fixture (subgraph-nested-promotion):
+   *   Root → Sub 0 (node 5) → Sub 1 (node 6) → Sub 2 (node 9)
+   *
+   * Node 6 (Sub 1) has proxyWidgets promoting widgets from inner nodes,
+   * and those promotions are also promoted up to node 5 (Sub 0). When
+   * navigating into Sub 0, node 6 should show the promoted ring on its
+   * widgets.
+   */
+  test.describe(
+    'Promoted indicator on 3-level nested subgraphs (#10612)',
+    { tag: ['@widget'] },
+    () => {
+      const WORKFLOW = 'subgraphs/subgraph-nested-promotion'
+      const PROMOTED_BORDER_CLASS = 'ring-component-node-widget-promoted'
+
+      test.beforeEach(async ({ comfyPage }) => {
+        await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+      })
+
+      test('Intermediate SubgraphNode shows promoted ring inside parent subgraph', async ({
+        comfyPage
+      }) => {
+        await comfyPage.workflow.loadWorkflow(WORKFLOW)
+        await comfyPage.vueNodes.waitForNodes()
+
+        // At root level, node 5 (Sub 0) is the outermost SubgraphNode.
+        // Its widgets are not promoted further, so no ring expected.
+        const outerNode = comfyPage.vueNodes.getNodeLocator('5')
+        await comfyExpect(outerNode).toBeVisible()
+
+        const outerRings = outerNode.locator(`.${PROMOTED_BORDER_CLASS}`)
+        await comfyExpect(outerRings).toHaveCount(0)
+
+        // Navigate programmatically — the enter-subgraph button on
+        // node 5 is obscured by the canvas z-999 overlay at root level.
+        await comfyPage.page.evaluate(() => {
+          const node = window.app!.graph!.getNodeById('5')
+          if (node?.isSubgraphNode()) {
+            window.app!.canvas.setGraph(node.subgraph)
+          }
+        })
+        await comfyPage.nextFrame()
+        await comfyPage.vueNodes.waitForNodes()
+
+        // Node 6 (Sub 1) has 4 proxyWidgets promoted up to Sub 0
+        // (node 5). Each should carry the promoted ring.
+        const intermediateNode = comfyPage.vueNodes.getNodeLocator('6')
+        await comfyExpect(intermediateNode).toBeVisible()
+
+        const intermediateRings = intermediateNode.locator(
+          `.${PROMOTED_BORDER_CLASS}`
+        )
+        await expect
+          .poll(() => intermediateRings.count(), {
+            timeout: 5000,
+            message:
+              'Node 6 (Sub 1) should show promoted rings for all 4 proxyWidgets'
+          })
+          .toBe(4)
+      })
+    }
+  )
 })

browser_tests/tests/subgraph/subgraphZeroUuid.spec.ts

@@ -0,0 +1,49 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
+
+test.describe(
+  'Zero UUID workflow: subgraph undo rendering',
+  { tag: ['@workflow', '@subgraph'] },
+  () => {
+    test.beforeEach(async ({ comfyPage }) => {
+      test.setTimeout(30000) // Extend timeout as we need to reload the page an additional time
+      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+      await comfyPage.page.reload() // Reload page as we need to enter in Vue mode
+      await comfyPage.page.waitForFunction(() => !!window.app?.graph)
+    })
+
+    test('Undo after subgraph enter/exit renders all nodes when workflow starts with zero UUID', async ({
+      comfyPage
+    }) => {
+      await comfyPage.workflow.loadWorkflow(
+        'subgraphs/basic-subgraph-zero-uuid'
+      )
+      await comfyPage.vueNodes.waitForNodes()
+
+      const assertInSubgraph = async (inSubgraph: boolean) => {
+        await expect
+          .poll(() => comfyPage.subgraph.isInSubgraph())
+          .toBe(inSubgraph)
+      }
+
+      // Root graph has 1 subgraph node, rendered in the DOM
+      await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(1)
+      await expect.poll(() => comfyPage.vueNodes.getNodeCount()).toBe(1)
+
+      await comfyPage.vueNodes.enterSubgraph()
+      await assertInSubgraph(true)
+
+      await comfyPage.subgraph.exitViaBreadcrumb()
+      await assertInSubgraph(false)
+
+      await comfyPage.canvas.focus()
+      await comfyPage.keyboard.undo()
+      await comfyPage.nextFrame()
+
+      // After undo, the subgraph node is still visible and rendered
+      await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(1)
+      await expect.poll(() => comfyPage.vueNodes.getNodeCount()).toBe(1)
+    })
+  }
+)

src/core/graph/subgraph/promotedWidgetIndicator.test.ts

@@ -0,0 +1,133 @@
+import { createTestingPinia } from '@pinia/testing'
+import { render, screen } from '@testing-library/vue'
+import { setActivePinia } from 'pinia'
+import { defineComponent, h } from 'vue'
+import { describe, expect, test, vi } from 'vitest'
+
+import type {
+  SafeWidgetData,
+  VueNodeData
+} from '@/composables/graph/useGraphNodeManager'
+import NodeWidgets from '@/renderer/extensions/vueNodes/components/NodeWidgets.vue'
+import { usePromotionStore } from '@/stores/promotionStore'
+
+vi.mock('@/renderer/core/canvas/canvasStore', () => ({
+  useCanvasStore: () => ({
+    canvas: {
+      graph: {
+        rootGraph: {
+          id: 'graph-test'
+        }
+      }
+    }
+  })
+}))
+
+const PROMOTED_CLASS = 'ring-component-node-widget-promoted'
+
+const WidgetStub = defineComponent({
+  props: { widget: { type: Object, default: undefined } },
+  setup(props) {
+    return () =>
+      h('div', {
+        'data-testid': 'widget-stub',
+        class: props.widget?.borderStyle
+      })
+  }
+})
+
+vi.mock(
+  '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry',
+  () => ({
+    getComponent: () => WidgetStub,
+    shouldExpand: () => false,
+    shouldRenderAsVue: () => true
+  })
+)
+
+function createMockWidget(
+  overrides: Partial<SafeWidgetData> = {}
+): SafeWidgetData {
+  return {
+    nodeId: 'test_node',
+    name: 'test_widget',
+    type: 'combo',
+    options: undefined,
+    callback: undefined,
+    spec: undefined,
+    isDOMWidget: false,
+    slotMetadata: undefined,
+    ...overrides
+  }
+}
+
+function createMockNodeData(
+  nodeType: string,
+  widgets: SafeWidgetData[],
+  id: string
+): VueNodeData {
+  return {
+    id,
+    type: nodeType,
+    widgets,
+    title: 'Test Node',
+    mode: 0,
+    selected: false,
+    executing: false,
+    inputs: [],
+    outputs: []
+  }
+}
+
+function renderComponent(nodeData: VueNodeData, setupStores?: () => void) {
+  const pinia = createTestingPinia({ stubActions: false })
+  setActivePinia(pinia)
+  setupStores?.()
+
+  return render(NodeWidgets, {
+    props: { nodeData },
+    global: {
+      plugins: [pinia],
+      stubs: { InputSlot: true },
+      mocks: { $t: (key: string) => key }
+    }
+  })
+}
+
+describe('promoted widget indicator on nested subgraphs', () => {
+  test('shows promoted ring when promotion was stored without disambiguatingSourceNodeId', async () => {
+    // Scenario: SubBNode (id=3) inside SubA promotes a widget from
+    // ConcreteNode (id=1). The promotion at the SubA level is stored
+    // WITHOUT disambiguatingSourceNodeId because ConcreteNode is not
+    // itself a SubgraphNode.
+    //
+    // The widget rendered on SubBNode has storeName and storeNodeId set
+    // (because it's a promoted widget), so NodeWidgets.vue would normally
+    // compute a disambiguatingSourceNodeId from the storeNodeId.
+    // This causes a key mismatch: lookup key "3:text:1" vs stored "3:text".
+    const promotedWidget = createMockWidget({
+      name: 'text',
+      type: 'combo',
+      nodeId: 'inner-subgraph:1',
+      storeNodeId: 'inner-subgraph:1',
+      storeName: 'text',
+      slotName: 'text'
+    })
+    const nodeData = createMockNodeData('SubgraphNode', [promotedWidget], '3')
+    renderComponent(nodeData, () => {
+      // Store promotion WITHOUT disambiguatingSourceNodeId, as would
+      // happen for a first-level nested promotion where the inner node
+      // is not itself a SubgraphNode.
+      usePromotionStore().promote('graph-test', '4', {
+        sourceNodeId: '3',
+        sourceWidgetName: 'text'
+      })
+    })
+
+    const widgets = screen.getAllByTestId('widget-stub')
+    const hasPromotedRing = widgets.some((el) =>
+      el.classList.contains(PROMOTED_CLASS)
+    )
+    expect(hasPromotedRing).toBe(true)
+  })
+})

src/lib/litegraph/src/LGraph.test.ts

@@ -12,6 +12,7 @@ import {
 } from '@/lib/litegraph/src/litegraph'
 import type { SerialisableGraph } from '@/lib/litegraph/src/types/serialisation'
 import type { UUID } from '@/lib/litegraph/src/utils/uuid'
+import { zeroUuid } from '@/lib/litegraph/src/utils/uuid'
 import { usePromotionStore } from '@/stores/promotionStore'
 import { useWidgetValueStore } from '@/stores/widgetValueStore'
 import {
@@ -1005,3 +1006,25 @@ describe('deduplicateSubgraphNodeIds (via configure)', () => {
     expect(nodeIdSet(graph, SUBGRAPH_B)).toEqual(new Set([20, 21, 22]))
   })
 })
+
+describe('Zero UUID handling in configure', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia())
+  })
+
+  it('rejects zeroUuid for root graphs and assigns a new ID', () => {
+    const graph = new LGraph()
+    const data = graph.serialize()
+    data.id = zeroUuid
+    graph.configure(data)
+    expect(graph.id).not.toBe(zeroUuid)
+  })
+
+  it('preserves zeroUuid for subgraphs', () => {
+    const graph = new LGraph()
+    const subgraphData = { ...createTestSubgraphData(), id: zeroUuid }
+    const subgraph = graph.createSubgraph(subgraphData)
+    subgraph.configure(subgraphData)
+    expect(subgraph.id).toBe(zeroUuid)
+  })
+})

src/lib/litegraph/src/LGraph.ts

@@ -2480,8 +2480,8 @@ export class LGraph
   protected _configureBase(data: ISerialisedGraph | SerialisableGraph): void {
     const { id, extra } = data
 
-    // Create a new graph ID if none is provided
-    if (id) {
+    // Create a new graph ID if none is provided or the zero UUID is used on the root graph
+    if (id && !(this.isRootGraph && id === zeroUuid)) {
       this.id = id
     } else if (this.id === zeroUuid) {
       this.id = createUuidv4()

src/lib/litegraph/src/widgets/BaseWidget.ts

@@ -211,10 +211,11 @@ export abstract class BaseWidget<TWidget extends IBaseWidget = IBaseWidget>
     if (
       graphId &&
       !suppressPromotedOutline &&
-      usePromotionStore().isPromotedByAny(graphId, {
-        sourceNodeId: String(this.node.id),
-        sourceWidgetName: this.name
-      })
+      usePromotionStore().isWidgetPromoted(
+        graphId,
+        String(this.node.id),
+        this.name
+      )
     )
       return LiteGraph.WIDGET_PROMOTED_OUTLINE_COLOR
     return this.advanced

src/renderer/extensions/vueNodes/components/NodeWidgets.vue

@@ -390,17 +390,20 @@ const processedWidgets = computed((): ProcessedWidget[] => {
       ? { ...mergedOptions, disabled: true }
       : mergedOptions
 
-    const borderStyle =
+    const sourceWidgetName = widget.storeName ?? widget.name
+    const isPromoted =
       graphId &&
-      promotionStore.isPromotedByAny(graphId, {
-        sourceNodeId: hostNodeId,
-        sourceWidgetName: widget.storeName ?? widget.name,
-        disambiguatingSourceNodeId: promotionSourceNodeId
-      })
-        ? 'ring ring-component-node-widget-promoted'
-        : mergedOptions.advanced
-          ? 'ring ring-component-node-widget-advanced'
-          : undefined
+      promotionStore.isWidgetPromoted(
+        graphId,
+        hostNodeId,
+        sourceWidgetName,
+        promotionSourceNodeId
+      )
+    const borderStyle = isPromoted
+      ? 'ring ring-component-node-widget-promoted'
+      : mergedOptions.advanced
+        ? 'ring ring-component-node-widget-advanced'
+        : undefined
 
     const linkedUpstream: LinkedUpstreamInfo | undefined =
       slotMetadata?.linked && slotMetadata.originNodeId

src/renderer/extensions/vueNodes/widgets/components/RichComboWidget.vue

@@ -1,184 +0,0 @@
-<script setup lang="ts">
-import { computed, onMounted, provide, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-
-import type { FilterOption } from '@/platform/assets/types/filterTypes'
-import { isComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
-import type { SimplifiedWidget } from '@/types/simplifiedWidget'
-
-import FormDropdown from './form/dropdown/FormDropdown.vue'
-import type { FormDropdownItem, LayoutMode } from './form/dropdown/types'
-import { AssetKindKey } from './form/dropdown/types'
-import {
-  buildSearchText,
-  extractFilterValues,
-  getByPath,
-  mapToDropdownItem
-} from '../utils/resolveItemSchema'
-import { fetchRemoteRoute } from '../utils/resolveRemoteRoute'
-
-const props = defineProps<{
-  modelValue?: string
-  widget: SimplifiedWidget<string | undefined>
-}>()
-
-const emit = defineEmits<{
-  'update:modelValue': [value: string]
-}>()
-
-const { t } = useI18n()
-
-const comboSpec = computed(() => {
-  if (props.widget.spec && isComboInputSpec(props.widget.spec)) {
-    return props.widget.spec
-  }
-  return undefined
-})
-const remoteConfig = computed(() => comboSpec.value?.remote!)
-const itemSchema = computed(() => remoteConfig.value?.item_schema!)
-
-const rawItems = ref<unknown[]>([])
-const loading = ref(false)
-
-async function fetchItems() {
-  loading.value = true
-  try {
-    const res = await fetchRemoteRoute(remoteConfig.value.route, {
-      params: remoteConfig.value.query_params,
-      timeout: remoteConfig.value.timeout ?? 30000,
-      useComfyApi: remoteConfig.value.use_comfy_api
-    })
-    const data = remoteConfig.value.response_key
-      ? res.data[remoteConfig.value.response_key]
-      : res.data
-    rawItems.value = Array.isArray(data) ? data : []
-  } catch (err) {
-    console.error('RichComboWidget: fetch error', err)
-  } finally {
-    loading.value = false
-  }
-}
-
-onMounted(() => {
-  void fetchItems()
-})
-
-const assetKind = computed(() => {
-  const pt = itemSchema.value.preview_type ?? 'image'
-  return pt as 'image' | 'video' | 'audio'
-})
-
-provide(AssetKindKey, assetKind)
-
-const items = computed<FormDropdownItem[]>(() =>
-  rawItems.value.map((raw) => mapToDropdownItem(raw, itemSchema.value))
-)
-
-const searchIndex = computed(() => {
-  const schema = itemSchema.value
-  const fields = schema.search_fields ?? [schema.label_field]
-  const index = new Map<string, string>()
-  for (const raw of rawItems.value) {
-    const id = String(getByPath(raw, schema.value_field) ?? '')
-    index.set(id, buildSearchText(raw, fields))
-  }
-  return index
-})
-
-const filterOptions = computed<FilterOption[]>(() => {
-  const schema = itemSchema.value
-  if (!schema.filter_field) return []
-  const values = extractFilterValues(rawItems.value, schema.filter_field)
-  return [
-    { name: 'All', value: 'all' },
-    ...values.map((v) => ({ name: v, value: v }))
-  ]
-})
-
-const filterSelected = ref('all')
-const layoutMode = ref<LayoutMode>('list')
-const selectedSet = ref<Set<string>>(new Set())
-
-const filteredItems = computed<FormDropdownItem[]>(() => {
-  const schema = itemSchema.value
-  if (filterSelected.value === 'all' || !schema.filter_field) {
-    return items.value
-  }
-  const filterField = schema.filter_field
-  return rawItems.value
-    .filter(
-      (raw) =>
-        String(getByPath(raw, filterField) ?? '') === filterSelected.value
-    )
-    .map((raw) => mapToDropdownItem(raw, schema))
-})
-
-async function searcher(
-  query: string,
-  searchItems: FormDropdownItem[],
-  _onCleanup: (cleanupFn: () => void) => void
-): Promise<FormDropdownItem[]> {
-  if (!query.trim()) return searchItems
-  const q = query.toLowerCase()
-  return searchItems.filter((item) => {
-    const text = searchIndex.value.get(item.id) ?? item.name.toLowerCase()
-    return text.includes(q)
-  })
-}
-
-watch(
-  [() => props.modelValue, items],
-  ([val]) => {
-    selectedSet.value.clear()
-    if (val) {
-      const item = items.value.find((i) => i.id === val)
-      if (item) selectedSet.value.add(item.id)
-    }
-  },
-  { immediate: true }
-)
-
-function handleRefresh() {
-  void fetchItems()
-}
-
-function handleSelection(selected: Set<string>) {
-  const id = selected.values().next().value
-  if (id) {
-    emit('update:modelValue', id)
-  }
-}
-</script>
-
-<template>
-  <div class="flex w-full items-center gap-1">
-    <FormDropdown
-      v-model:selected="selectedSet"
-      v-model:filter-selected="filterSelected"
-      v-model:layout-mode="layoutMode"
-      :items="filteredItems"
-      :placeholder="loading ? 'Loading...' : t('widgets.uploadSelect.placeholder')"
-      :multiple="false"
-      :filter-options="[]"
-      :show-sort="false"
-      :show-layout-switcher="false"
-      :searcher="searcher"
-      class="flex-1"
-      @update:selected="handleSelection"
-    />
-    <button
-      v-if="remoteConfig?.refresh_button !== false"
-      class="flex size-7 shrink-0 items-center justify-center rounded text-secondary hover:bg-component-node-widget-background-hovered"
-      title="Refresh"
-      @pointerdown.stop
-      @click.stop="handleRefresh"
-    >
-      <i
-        :class="[
-          'icon-[lucide--refresh-cw] size-3.5',
-          loading && 'animate-spin'
-        ]"
-      />
-    </button>
-  </div>
-</template>

src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue

@@ -1,11 +1,6 @@
 <template>
-  <RichComboWidget
-    v-if="hasItemSchema"
-    v-model="modelValue"
-    :widget
-  />
   <WidgetSelectDropdown
-    v-else-if="isDropdownUIWidget"
+    v-if="isDropdownUIWidget"
     v-model="modelValue"
     :widget
     :node-type="widget.nodeType ?? nodeType"
@@ -29,7 +24,6 @@
 import { computed } from 'vue'
 
 import { assetService } from '@/platform/assets/services/assetService'
-import RichComboWidget from '@/renderer/extensions/vueNodes/widgets/components/RichComboWidget.vue'
 import WidgetSelectDefault from '@/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue'
 import WidgetSelectDropdown from '@/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue'
 import WidgetWithControl from '@/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue'
@@ -59,10 +53,6 @@ const comboSpec = computed<ComboInputSpec | undefined>(() => {
   return undefined
 })
 
-const hasItemSchema = computed(
-  () => !!comboSpec.value?.remote?.item_schema
-)
-
 const specDescriptor = computed<{
   kind: AssetKind
   allowUpload: boolean

src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue

@@ -34,8 +34,6 @@ interface Props {
   accept?: string
   filterOptions?: FilterOption[]
   sortOptions?: SortOption[]
-  showSort?: boolean
-  showLayoutSwitcher?: boolean
   showOwnershipFilter?: boolean
   ownershipOptions?: OwnershipFilterOption[]
   showBaseModelFilter?: boolean
@@ -63,8 +61,6 @@ const {
   accept,
   filterOptions = [],
   sortOptions = getDefaultSortOptions(),
-  showSort = true,
-  showLayoutSwitcher = true,
   showOwnershipFilter,
   ownershipOptions,
   showBaseModelFilter,
@@ -236,8 +232,6 @@ function handleSelection(item: FormDropdownItem, index: number) {
         v-model:base-model-selected="baseModelSelected"
         :filter-options
         :sort-options
-        :show-sort
-        :show-layout-switcher="showLayoutSwitcher"
         :show-ownership-filter
         :ownership-options
         :show-base-model-filter

src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownMenu.vue

@@ -20,8 +20,6 @@ interface Props {
   isSelected: (item: FormDropdownItem, index: number) => boolean
   filterOptions: FilterOption[]
   sortOptions: SortOption[]
-  showSort?: boolean
-  showLayoutSwitcher?: boolean
   showOwnershipFilter?: boolean
   ownershipOptions?: OwnershipFilterOption[]
   showBaseModelFilter?: boolean
@@ -33,8 +31,6 @@ const {
   isSelected,
   filterOptions,
   sortOptions,
-  showSort = true,
-  showLayoutSwitcher = true,
   showOwnershipFilter,
   ownershipOptions,
   showBaseModelFilter,
@@ -116,8 +112,6 @@ const virtualItems = computed<VirtualDropdownItem[]>(() =>
       v-model:ownership-selected="ownershipSelected"
       v-model:base-model-selected="baseModelSelected"
       :sort-options
-      :show-sort
-      :show-layout-switcher="showLayoutSwitcher"
       :show-ownership-filter
       :ownership-options
       :show-base-model-filter
@@ -151,7 +145,6 @@ const virtualItems = computed<VirtualDropdownItem[]>(() =>
           :preview-url="item.preview_url ?? ''"
           :name="item.name"
           :label="item.label"
-          :description="item.description"
           :layout="layoutMode"
           @click="emit('item-click', item, index)"
         />

src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownMenuActions.vue

@@ -18,13 +18,8 @@ import type { LayoutMode, SortOption } from './types'
 const { t } = useI18n()
 const overlayProps = useTransformCompatOverlayProps()
 
-const {
-  showSort = true,
-  showLayoutSwitcher = true
-} = defineProps<{
+defineProps<{
   sortOptions: SortOption[]
-  showSort?: boolean
-  showLayoutSwitcher?: boolean
   showOwnershipFilter?: boolean
   ownershipOptions?: OwnershipFilterOption[]
   showBaseModelFilter?: boolean
@@ -119,7 +114,6 @@ function toggleBaseModelSelection(item: FilterOption) {
     />
 
     <Button
-      v-if="showSort"
       ref="sortTriggerRef"
       variant="textonly"
       size="icon"
@@ -138,7 +132,6 @@ function toggleBaseModelSelection(item: FilterOption) {
       <i class="icon-[lucide--arrow-up-down] size-4" />
     </Button>
     <Popover
-      v-if="showSort"
       ref="sortPopoverRef"
       :dismissable="true"
       :close-on-escape="true"
@@ -316,7 +309,6 @@ function toggleBaseModelSelection(item: FilterOption) {
     </Popover>
 
     <div
-      v-if="showLayoutSwitcher"
       :class="
         cn(
           actionButtonStyle,

src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownMenuItem.vue

@@ -12,7 +12,6 @@ interface Props {
   previewUrl: string
   name: string
   label?: string
-  description?: string
   layout?: LayoutMode
 }
 
@@ -28,31 +27,11 @@ const actualDimensions = ref<string | null>(null)
 const assetKind = inject(AssetKindKey)
 
 const isVideo = computed(() => assetKind?.value === 'video')
-const isAudio = computed(() => assetKind?.value === 'audio')
-
-const audioRef = ref<HTMLAudioElement | null>(null)
-const isPlayingAudio = ref(false)
 
 function handleClick() {
   emit('click', props.index)
 }
 
-function toggleAudioPreview(event: Event) {
-  event.stopPropagation()
-  if (!audioRef.value) return
-  if (isPlayingAudio.value) {
-    audioRef.value.pause()
-    isPlayingAudio.value = false
-  } else {
-    void audioRef.value.play()
-    isPlayingAudio.value = true
-  }
-}
-
-function handleAudioEnded() {
-  isPlayingAudio.value = false
-}
-
 function handleImageLoad(event: Event) {
   emit('mediaLoad', event)
   if (!event.target || !(event.target instanceof HTMLImageElement)) return
@@ -128,25 +107,6 @@ function handleVideoLoad(event: Event) {
         muted
         @loadeddata="handleVideoLoad"
       />
-      <div
-        v-else-if="previewUrl && isAudio"
-        class="flex size-full cursor-pointer items-center justify-center bg-gradient-to-tr from-violet-500 via-purple-500 to-fuchsia-400"
-        @click.stop="toggleAudioPreview"
-      >
-        <audio
-          ref="audioRef"
-          :src="previewUrl"
-          preload="none"
-          @ended="handleAudioEnded"
-        />
-        <i
-          :class="
-            isPlayingAudio
-              ? 'icon-[lucide--pause] size-5 text-white'
-              : 'icon-[lucide--play] size-5 text-white'
-          "
-        />
-      </div>
       <img
         v-else-if="previewUrl"
         :src="previewUrl"
@@ -184,13 +144,6 @@ function handleVideoLoad(event: Event) {
       >
         {{ label ?? name }}
       </span>
-      <!-- Description -->
-      <span
-        v-if="description && layout !== 'grid'"
-        class="text-secondary line-clamp-1 block overflow-hidden text-xs"
-      >
-        {{ description }}
-      </span>
       <!-- Meta Data -->
       <span v-if="actualDimensions" class="text-secondary block text-xs">
         {{ actualDimensions }}

src/renderer/extensions/vueNodes/widgets/components/form/dropdown/types.ts

@@ -12,9 +12,7 @@ export interface FormDropdownItem {
   name: string
   /** Original/alternate label (e.g., original filename) */
   label?: string
-  /** Short description shown below the name in list view */
-  description?: string
-  /** Preview image/video/audio URL */
+  /** Preview image/video URL */
   preview_url?: string
   /** Whether the item is immutable (public model) - used for ownership filtering */
   is_immutable?: boolean

src/renderer/extensions/vueNodes/widgets/composables/useComboWidget.ts

@@ -214,9 +214,7 @@ const addComboWidget = (
     }
   )
 
-  if (inputSpec.remote && !inputSpec.remote.item_schema) {
-    // Skip useRemoteWidget when item_schema is present —
-    // RichComboWidget handles its own data fetching and rendering.
+  if (inputSpec.remote) {
     if (!isComboWidget(widget)) {
       throw new Error(`Expected combo widget but received ${widget.type}`)
     }

src/renderer/extensions/vueNodes/widgets/composables/useRemoteWidget.ts

@@ -2,12 +2,10 @@ import axios from 'axios'
 
 import { useChainCallback } from '@/composables/functional/useChainCallback'
 import type { IWidget, LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { isCloud } from '@/platform/distribution/types'
 import type { RemoteWidgetConfig } from '@/schemas/nodeDefSchema'
 import { api } from '@/scripts/api'
-import {
-  getRemoteAuthHeaders,
-  resolveRoute
-} from '../utils/resolveRemoteRoute'
+import { useAuthStore } from '@/stores/authStore'
 
 const MAX_RETRIES = 5
 const TIMEOUT = 4096
@@ -23,6 +21,17 @@ interface CacheEntry<T> {
   failed?: boolean
 }
 
+async function getAuthHeaders() {
+  if (isCloud) {
+    const authStore = useAuthStore()
+    const authHeader = await authStore.getAuthHeader()
+    return {
+      ...(authHeader && { headers: authHeader })
+    }
+  }
+  return {}
+}
+
 const dataCache = new Map<string, CacheEntry<unknown>>()
 
 const createCacheKey = (config: RemoteWidgetConfig): string => {
@@ -64,10 +73,9 @@ const fetchData = async (
 ) => {
   const { route, response_key, query_params, timeout = TIMEOUT } = config
 
-  const url = resolveRoute(route, config.use_comfy_api)
-  const authHeaders = await getRemoteAuthHeaders(config.use_comfy_api)
+  const authHeaders = await getAuthHeaders()
 
-  const res = await axios.get(url, {
+  const res = await axios.get(route, {
     params: query_params,
     signal: controller.signal,
     timeout,

src/renderer/extensions/vueNodes/widgets/utils/resolveItemSchema.ts

@@ -1,70 +0,0 @@
-import type { RemoteItemSchema } from '@/schemas/nodeDefSchema'
-import type { FormDropdownItem } from '@/renderer/extensions/vueNodes/widgets/components/form/dropdown/types'
-
-/** Traverse an object by dot-path, treating numeric segments as array indices */
-export function getByPath(obj: unknown, path: string): unknown {
-  return path.split('.').reduce((acc: unknown, key: string) => {
-    if (acc == null) return undefined
-    const idx = Number(key)
-    if (Number.isInteger(idx) && idx >= 0 && Array.isArray(acc)) return acc[idx]
-    return (acc as Record<string, unknown>)[key]
-  }, obj)
-}
-
-/** Resolve a label — either dot-path or template with {field.path} placeholders */
-export function resolveLabel(template: string, item: unknown): string {
-  if (!template.includes('{')) {
-    return String(getByPath(item, template) ?? '')
-  }
-  return template.replace(/\{([^}]+)\}/g, (_, path: string) =>
-    String(getByPath(item, path) ?? '')
-  )
-}
-
-/** Map a raw API object to a FormDropdownItem using the item_schema */
-export function mapToDropdownItem(
-  raw: unknown,
-  schema: RemoteItemSchema
-): FormDropdownItem {
-  return {
-    id: String(getByPath(raw, schema.value_field) ?? ''),
-    name: resolveLabel(schema.label_field, raw),
-    description: schema.description_field
-      ? resolveLabel(schema.description_field, raw)
-      : undefined,
-    preview_url: schema.preview_url_field
-      ? String(getByPath(raw, schema.preview_url_field) ?? '')
-      : undefined
-  }
-}
-
-/** Extract items array from full API response using response_key */
-export function extractItems(
-  response: unknown,
-  responseKey?: string
-): unknown[] {
-  const data = responseKey ? getByPath(response, responseKey) : response
-  return Array.isArray(data) ? data : []
-}
-
-/** Build search text for an item from the specified search fields */
-export function buildSearchText(raw: unknown, searchFields: string[]): string {
-  return searchFields
-    .map((field) => String(getByPath(raw, field) ?? ''))
-    .filter(Boolean)
-    .join(' ')
-    .toLowerCase()
-}
-
-/** Extract unique filter values from items */
-export function extractFilterValues(
-  items: unknown[],
-  filterField: string
-): string[] {
-  const values = new Set<string>()
-  for (const item of items) {
-    const value = getByPath(item, filterField)
-    if (value != null) values.add(String(value))
-  }
-  return Array.from(values).sort()
-}

src/renderer/extensions/vueNodes/widgets/utils/resolveRemoteRoute.ts

@@ -1,55 +0,0 @@
-import axios from 'axios'
-
-import { getComfyApiBaseUrl } from '@/config/comfyApi'
-import { useAuthStore } from '@/stores/authStore'
-
-/**
- * Resolve a RemoteOptions route to a full URL.
- * - useComfyApi=true → prepend getComfyApiBaseUrl()
- * - Otherwise → use as-is
- */
-export function resolveRoute(
-  route: string,
-  useComfyApi?: boolean
-): string {
-  if (useComfyApi) {
-    return getComfyApiBaseUrl() + route
-  }
-  return route
-}
-
-/**
- * Get auth headers for a remote request.
- * - useComfyApi=true → inject auth headers (comfy-api requires it)
- * - Otherwise → no auth headers injected
- */
-export async function getRemoteAuthHeaders(
-  useComfyApi?: boolean
-): Promise<Record<string, any>> {
-  if (useComfyApi) {
-    const authStore = useAuthStore()
-    const authHeader = await authStore.getAuthHeader()
-    if (authHeader) {
-      return { headers: authHeader }
-    }
-  }
-  return {}
-}
-
-/**
- * Convenience: make an authenticated GET request to a remote route.
- */
-export async function fetchRemoteRoute(
-  route: string,
-  options: {
-    params?: Record<string, string>
-    timeout?: number
-    signal?: AbortSignal
-    useComfyApi?: boolean
-  } = {}
-) {
-  const { useComfyApi, ...requestOptions } = options
-  const url = resolveRoute(route, useComfyApi)
-  const authHeaders = await getRemoteAuthHeaders(useComfyApi)
-  return axios.get(url, { ...requestOptions, ...authHeaders })
-}

src/schemas/nodeDefSchema.ts

@@ -5,16 +5,6 @@ import { resultItemType } from '@/schemas/apiSchema'
 import { CONTROL_OPTIONS } from '@/types/simplifiedWidget'
 
 const zComboOption = z.union([z.string(), z.number()])
-const zRemoteItemSchema = z.object({
-  value_field: z.string(),
-  label_field: z.string(),
-  preview_url_field: z.string().optional(),
-  preview_type: z.enum(['image', 'video', 'audio']).default('image'),
-  description_field: z.string().optional(),
-  search_fields: z.array(z.string()).optional(),
-  filter_field: z.string().optional()
-})
-
 const zRemoteWidgetConfig = z.object({
   route: z.string().url().or(z.string().startsWith('/')),
   refresh: z.number().gte(128).safe().or(z.number().lte(0).safe()).optional(),
@@ -23,9 +13,7 @@ const zRemoteWidgetConfig = z.object({
   refresh_button: z.boolean().optional(),
   control_after_refresh: z.enum(['first', 'last']).optional(),
   timeout: z.number().gte(0).optional(),
-  max_retries: z.number().gte(0).optional(),
-  item_schema: zRemoteItemSchema.optional(),
-  use_comfy_api: z.boolean().optional()
+  max_retries: z.number().gte(0).optional()
 })
 const zMultiSelectOption = z.object({
   placeholder: z.string().optional(),
@@ -366,7 +354,6 @@ export const zMatchTypeOptions = z.object({
 export type ComfyInputsSpec = z.infer<typeof zComfyInputsSpec>
 export type ComfyOutputTypesSpec = z.infer<typeof zComfyOutputTypesSpec>
 export type ComfyNodeDef = z.infer<typeof zComfyNodeDef>
-export type RemoteItemSchema = z.infer<typeof zRemoteItemSchema>
 export type RemoteWidgetConfig = z.infer<typeof zRemoteWidgetConfig>
 
 export type ComboInputOptions = z.infer<typeof zComboInputOptions>

src/scripts/domWidget.test.ts

@@ -3,7 +3,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest'
 import { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { ComponentWidgetImpl, DOMWidgetImpl } from '@/scripts/domWidget'
 
-const isPromotedByAnyMock = vi.hoisted(() => vi.fn())
+const isWidgetPromotedMock = vi.hoisted(() => vi.fn())
 
 // Mock dependencies
 vi.mock('@/stores/domWidgetStore', () => ({
@@ -14,7 +14,7 @@ vi.mock('@/stores/domWidgetStore', () => ({
 
 vi.mock('@/stores/promotionStore', () => ({
   usePromotionStore: () => ({
-    isPromotedByAny: isPromotedByAnyMock
+    isWidgetPromoted: isWidgetPromotedMock
   })
 }))
 
@@ -120,7 +120,7 @@ describe('DOMWidget draw promotion behavior', () => {
   })
 
   test('draws promoted outline for visible promoted widgets', () => {
-    isPromotedByAnyMock.mockReturnValue(true)
+    isWidgetPromotedMock.mockReturnValue(true)
 
     const node = new LGraphNode('test-node')
     const rootGraph = { id: 'root-graph-id' }
@@ -138,16 +138,17 @@ describe('DOMWidget draw promotion behavior', () => {
 
     widget.draw(ctx as CanvasRenderingContext2D, node, 200, 30, 40)
 
-    expect(isPromotedByAnyMock).toHaveBeenCalledWith('root-graph-id', {
-      sourceNodeId: '-1',
-      sourceWidgetName: 'seed'
-    })
+    expect(isWidgetPromotedMock).toHaveBeenCalledWith(
+      'root-graph-id',
+      '-1',
+      'seed'
+    )
     expect(ctx.strokeRect).toHaveBeenCalledOnce()
     expect(onDraw).toHaveBeenCalledWith(widget)
   })
 
   test('does not draw promoted outline when widget is not promoted', () => {
-    isPromotedByAnyMock.mockReturnValue(false)
+    isWidgetPromotedMock.mockReturnValue(false)
 
     const node = new LGraphNode('test-node')
     const rootGraph = { id: 'root-graph-id' }
@@ -187,7 +188,7 @@ describe('DOMWidget draw promotion behavior', () => {
 
     widget.draw(ctx as CanvasRenderingContext2D, node, 200, 30, 40)
 
-    expect(isPromotedByAnyMock).not.toHaveBeenCalled()
+    expect(isWidgetPromotedMock).not.toHaveBeenCalled()
     expect(ctx.strokeRect).not.toHaveBeenCalled()
     expect(onDraw).toHaveBeenCalledWith(widget)
   })

src/scripts/domWidget.ts

@@ -125,8 +125,6 @@ abstract class BaseDOMWidgetImpl<V extends object | string>
   declare readonly name: string
   declare readonly options: DOMWidgetOptions<V>
   declare callback?: (value: V) => void
-  readonly promotionStore = usePromotionStore()
-
   readonly id: string
 
   constructor(obj: {
@@ -190,10 +188,11 @@ abstract class BaseDOMWidgetImpl<V extends object | string>
       const graphId = this.node.graph?.rootGraph.id
       const isPromoted =
         graphId &&
-        this.promotionStore.isPromotedByAny(graphId, {
-          sourceNodeId: String(this.node.id),
-          sourceWidgetName: this.name
-        })
+        usePromotionStore().isWidgetPromoted(
+          graphId,
+          String(this.node.id),
+          this.name
+        )
       if (!isPromoted) {
         this.options.onDraw?.(this)
         return

src/stores/promotionStore.ts

@@ -190,11 +190,35 @@ export const usePromotionStore = defineStore('promotion', () => {
     graphRefCounts.value.delete(graphId)
   }
 
+  /**
+   * Checks whether a widget is promoted by any subgraph node in the given
+   * graph. Handles nested subgraph promotions where the stored key may omit
+   * the disambiguatingSourceNodeId — checks both key shapes (#10612).
+   */
+  function isWidgetPromoted(
+    graphId: UUID,
+    sourceNodeId: string,
+    sourceWidgetName: string,
+    disambiguatingSourceNodeId?: string
+  ): boolean {
+    if (
+      disambiguatingSourceNodeId &&
+      isPromotedByAny(graphId, {
+        sourceNodeId,
+        sourceWidgetName,
+        disambiguatingSourceNodeId
+      })
+    )
+      return true
+    return isPromotedByAny(graphId, { sourceNodeId, sourceWidgetName })
+  }
+
   return {
     getPromotionsRef,
     getPromotions,
     isPromoted,
     isPromotedByAny,
+    isWidgetPromoted,
     setPromotions,
     promote,
     demote,

src/stores/subgraphNavigationStore.ts

@@ -12,6 +12,7 @@ import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import { useLitegraphService } from '@/services/litegraphService'
 import { app } from '@/scripts/app'
 import { findSubgraphPathById } from '@/utils/graphTraversalUtil'
+import { anyItemOverlapsRect } from '@/utils/mathUtil'
 import { isNonNullish, isSubgraph } from '@/utils/typeGuardUtil'
 
 export const VIEWPORT_CACHE_MAX_SIZE = 32
@@ -138,11 +139,19 @@ export const useSubgraphNavigationStore = defineStore(
         return
       }
 
-      // Cache miss — fit to content after the canvas has the new graph.
-      // rAF fires after layout + paint, when nodes are positioned.
-      const expectedGraphId = graphId
+      // Cache miss — fit to content only if no nodes are currently visible.
+      // loadGraphData may have already restored extra.ds or called fitView
+      // for templates, so only intervene when the viewport is truly empty.
       requestAnimationFrame(() => {
-        if (getActiveGraphId() !== expectedGraphId) return
+        if (getActiveGraphId() !== graphId) return
+        if (!canvas.graph) return
+
+        const nodes = canvas.graph.nodes
+        if (!nodes?.length) return
+
+        canvas.ds.computeVisibleArea(canvas.viewport)
+        if (anyItemOverlapsRect(nodes, canvas.ds.visible_area)) return
+
         useLitegraphService().fitView()
       })
     }

src/stores/subgraphNavigationStore.viewport.test.ts

@@ -24,8 +24,11 @@ vi.mock('@/scripts/app', () => {
       scale: 1,
       offset: [0, 0],
       state: { scale: 1, offset: [0, 0] },
-      fitToBounds: vi.fn()
+      fitToBounds: vi.fn(),
+      visible_area: [0, 0, 1000, 1000],
+      computeVisibleArea: vi.fn()
     },
+    viewport: [0, 0, 1000, 1000],
     setDirty: mockSetDirty,
     get empty() {
       return true
@@ -184,6 +187,11 @@ describe('useSubgraphNavigationStore - Viewport Persistence', () => {
       // Ensure no cached entry
       store.viewportCache.delete(':root')
 
+      // Add a node outside the visible area so anyItemOverlapsRect returns false
+      const mockGraph = app.graph as { nodes: unknown[]; _nodes: unknown[] }
+      mockGraph.nodes = [{ pos: [9999, 9999], size: [100, 100] }]
+      mockGraph._nodes = mockGraph.nodes
+
       // Use the root graph ID so the stale-guard passes
       store.restoreViewport('root')
 
@@ -194,6 +202,10 @@ describe('useSubgraphNavigationStore - Viewport Persistence', () => {
       rafCallbacks[0](performance.now())
 
       expect(mockFitView).toHaveBeenCalledOnce()
+
+      // Cleanup
+      mockGraph.nodes = []
+      mockGraph._nodes = []
     })
 
     it('skips fitView if active graph changed before rAF fires', () => {