fix: re-check tab fallback after deferred error scans

src/components/rightSidePanel/RightSidePanel.test.ts

@@ -0,0 +1,171 @@
+import { createTestingPinia } from '@pinia/testing'
+import { render, screen } from '@testing-library/vue'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import { createI18n } from 'vue-i18n'
+
+import RightSidePanel from '@/components/rightSidePanel/RightSidePanel.vue'
+import { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
+import { useExecutionErrorStore } from '@/stores/executionErrorStore'
+import { useRightSidePanelStore } from '@/stores/workspace/rightSidePanelStore'
+import { createNodeExecutionId } from '@/types/nodeIdentification'
+import { toNodeId } from '@/types/nodeId'
+
+const mockApp = vi.hoisted(() => ({
+  isGraphReady: true,
+  rootGraph: null as LGraph | null
+}))
+
+vi.mock('@/scripts/app', () => ({ app: mockApp }))
+
+vi.mock('@/composables/graph/useGraphHierarchy', () => ({
+  useGraphHierarchy: () => ({ findParentGroup: vi.fn(() => null) })
+}))
+
+vi.mock('@/platform/telemetry', () => ({ useTelemetry: () => undefined }))
+
+vi.mock('@/platform/settings/settingStore', () => ({
+  useSettingStore: () => ({
+    get: (key: string) => {
+      if (key === 'Comfy.RightSidePanel.ShowErrorsTab') return true
+      if (key === 'Comfy.Sidebar.Location') return 'left'
+      if (key === 'Comfy.UseNewMenu') return 'Top'
+      if (key === 'Comfy.RightSidePanel.IsOpen') return true
+      return undefined
+    },
+    set: vi.fn()
+  })
+}))
+
+function renderPanel(activeTab: 'errors' | 'parameters' = 'errors') {
+  const pinia = createTestingPinia({ createSpy: vi.fn, stubActions: false })
+  setActivePinia(pinia)
+
+  const graph = new LGraph()
+  const node = new LGraphNode('CheckpointLoaderSimple')
+  node.id = toNodeId(1)
+  graph.add(node)
+  mockApp.rootGraph = graph
+
+  const canvasStore = useCanvasStore()
+  canvasStore.currentGraph = graph
+  canvasStore.selectedItems = [node]
+
+  const rightSidePanelStore = useRightSidePanelStore()
+  rightSidePanelStore.activeTab = activeTab
+  const executionErrorStore = useExecutionErrorStore()
+  const executionId = createNodeExecutionId([node.id])
+  const finishScan = executionErrorStore.beginAddedNodeErrorScan(
+    graph,
+    executionId
+  )
+  const openPanel = vi.spyOn(rightSidePanelStore, 'openPanel')
+
+  const i18n = createI18n({
+    legacy: false,
+    locale: 'en',
+    messages: {
+      en: {
+        g: { settings: 'Settings' },
+        rightSidePanel: {
+          errors: 'Errors',
+          parameters: 'Parameters',
+          info: 'Info',
+          togglePanel: 'Toggle panel',
+          fallbackNodeTitle: 'Node'
+        }
+      }
+    }
+  })
+
+  const rendered = render(RightSidePanel, {
+    global: {
+      plugins: [pinia, i18n],
+      stubs: {
+        Button: { template: '<button><slot /></button>' },
+        EditableText: true,
+        Tab: { template: '<button v-bind="$attrs"><slot /></button>' },
+        TabErrors: true,
+        TabInfo: true,
+        TabList: { template: '<div><slot /></div>' },
+        TabNormalInputs: true,
+        TabSettings: true
+      }
+    }
+  })
+
+  return {
+    ...rendered,
+    executionId,
+    executionErrorStore,
+    finishScan,
+    graph,
+    node,
+    openPanel,
+    rightSidePanelStore
+  }
+}
+
+describe('RightSidePanel active tab fallback', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+    mockApp.rootGraph = null
+  })
+
+  it('keeps the active errors tab until the selected node scan settles', async () => {
+    const { finishScan, openPanel, rightSidePanelStore } = renderPanel()
+
+    expect(screen.getByTestId('panel-tab-errors')).toBeInTheDocument()
+    expect(rightSidePanelStore.activeTab).toBe('errors')
+    expect(openPanel).not.toHaveBeenCalled()
+
+    finishScan()
+    await Promise.resolve()
+
+    expect(rightSidePanelStore.activeTab).toBe('parameters')
+    expect(openPanel).toHaveBeenCalledWith('parameters')
+  })
+
+  it('keeps errors active when the scan surfaces an error before settling', async () => {
+    const { executionId, finishScan, openPanel, rightSidePanelStore } =
+      renderPanel()
+
+    useMissingModelStore().addMissingModels([
+      {
+        nodeId: executionId,
+        nodeType: 'CheckpointLoaderSimple',
+        widgetName: 'ckpt_name',
+        isAssetSupported: false,
+        name: 'missing.safetensors',
+        directory: 'checkpoints',
+        isMissing: true
+      }
+    ])
+    finishScan()
+    await nextTick()
+
+    expect(rightSidePanelStore.activeTab).toBe('errors')
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+
+  it('does not show errors solely because a scan is pending', () => {
+    const { openPanel } = renderPanel('parameters')
+
+    expect(screen.queryByTestId('panel-tab-errors')).not.toBeInTheDocument()
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+
+  it('does not update the panel after unmount', async () => {
+    const { finishScan, openPanel, unmount } = renderPanel()
+    finishScan()
+    await Promise.resolve()
+    openPanel.mockClear()
+    unmount()
+    await Promise.resolve()
+
+    expect(openPanel).not.toHaveBeenCalled()
+  })
+})

src/components/rightSidePanel/RightSidePanel.vue

@@ -9,7 +9,10 @@ import TabList from '@/components/tab/TabList.vue'
 import Button from '@/components/ui/button/Button.vue'
 import { useGraphHierarchy } from '@/composables/graph/useGraphHierarchy'
 import { app } from '@/scripts/app'
-import { getActiveGraphNodeIds } from '@/utils/graphTraversalUtil'
+import {
+  getActiveGraphNodeIds,
+  getExecutionIdByNode
+} from '@/utils/graphTraversalUtil'
 import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { useSettingStore } from '@/platform/settings/settingStore'
@@ -173,12 +176,27 @@ const hasRelevantErrors = computed(() => {
   )
 })
 
+const hasPendingErrorScanSelected = computed(() => {
+  if (!app.rootGraph) return false
+  return selectedNodes.value.some((node) => {
+    const executionId = getExecutionIdByNode(app.rootGraph, node)
+    return (
+      executionId !== null &&
+      executionErrorStore.hasPendingAddedNodeErrorScan(
+        app.rootGraph,
+        executionId
+      )
+    )
+  })
+})
+
 const tabs = computed<RightSidePanelTabList>(() => {
   const list: RightSidePanelTabList = []
 
   if (
     settingStore.get('Comfy.RightSidePanel.ShowErrorsTab') &&
-    hasRelevantErrors.value
+    (hasRelevantErrors.value ||
+      (activeTab.value === 'errors' && hasPendingErrorScanSelected.value))
   ) {
     list.push({
       label: () => t('rightSidePanel.errors'),
@@ -222,12 +240,15 @@ const tabs = computed<RightSidePanelTabList>(() => {
   return list
 })
 
-// Use global state for activeTab and ensure it's valid
+function isActiveTabAvailable() {
+  return (
+    tabs.value.some((tab) => tab.value === activeTab.value) ||
+    (activeTab.value === 'subgraph' && isSingleSubgraphNode.value)
+  )
+}
+
 watchEffect(() => {
-  if (
-    !tabs.value.some((tab) => tab.value === activeTab.value) &&
-    !(activeTab.value === 'subgraph' && isSingleSubgraphNode.value)
-  ) {
+  if (!isActiveTabAvailable()) {
     rightSidePanelStore.openPanel(tabs.value[0].value)
   }
 })

src/composables/graph/useErrorClearingHooks.test.ts

@@ -535,6 +535,137 @@ describe('installErrorClearingHooks lifecycle', () => {
     expect(useMissingMediaStore().missingMediaCandidates).toBeNull()
     expect(mediaScan).toHaveBeenCalledOnce()
   })
+
+  it('keeps an added-node scan pending until async verification settles', async () => {
+    const graph = new LGraph()
+    vi.spyOn(app, 'rootGraph', 'get').mockReturnValue(graph)
+    const candidate = fromAny<MissingModelCandidate, unknown>({
+      nodeId: '1',
+      nodeType: 'CheckpointLoaderSimple',
+      widgetName: 'ckpt_name',
+      name: 'pending.safetensors',
+      isMissing: undefined
+    })
+    vi.spyOn(missingModelScan, 'scanNodeModelCandidates').mockReturnValue([
+      candidate
+    ])
+    vi.spyOn(missingMediaScan, 'scanNodeMediaCandidates').mockReturnValue([])
+    let resolveVerification: () => void = () => undefined
+    vi.spyOn(
+      missingModelScan,
+      'verifyAssetSupportedCandidates'
+    ).mockImplementation(async () => {
+      await new Promise<void>((resolve) => {
+        resolveVerification = resolve
+      })
+      candidate.isMissing = true
+    })
+    installErrorClearingHooks(graph)
+
+    const node = new LGraphNode('CheckpointLoaderSimple')
+    node.id = toNodeId(1)
+    graph.add(node)
+
+    const store = useExecutionErrorStore()
+    const executionId = createNodeExecutionId([node.id])
+    expect(store.hasPendingAddedNodeErrorScan(graph, executionId)).toBe(true)
+
+    await vi.waitFor(() =>
+      expect(
+        missingModelScan.verifyAssetSupportedCandidates
+      ).toHaveBeenCalledOnce()
+    )
+    expect(store.hasPendingAddedNodeErrorScan(graph, executionId)).toBe(true)
+
+    resolveVerification()
+    await vi.waitFor(() =>
+      expect(store.hasPendingAddedNodeErrorScan(graph, executionId)).toBe(false)
+    )
+    expect(useMissingModelStore().missingModelCandidates).toEqual([candidate])
+  })
+
+  it('releases a pending added-node scan when hooks are disposed', () => {
+    const graph = new LGraph()
+    vi.spyOn(app, 'rootGraph', 'get').mockReturnValue(graph)
+    const cleanup = installErrorClearingHooks(graph)
+    const node = new LGraphNode('test')
+    graph.add(node)
+
+    const store = useExecutionErrorStore()
+    const executionId = createNodeExecutionId([node.id])
+    expect(store.hasPendingAddedNodeErrorScan(graph, executionId)).toBe(true)
+
+    cleanup()
+
+    expect(store.hasPendingAddedNodeErrorScan(graph, executionId)).toBe(false)
+  })
+
+  it('does not surface async verification after hooks are disposed', async () => {
+    const graph = new LGraph()
+    vi.spyOn(app, 'rootGraph', 'get').mockReturnValue(graph)
+    const candidate = fromAny<MissingModelCandidate, unknown>({
+      nodeId: '1',
+      nodeType: 'CheckpointLoaderSimple',
+      widgetName: 'ckpt_name',
+      name: 'pending.safetensors',
+      isMissing: undefined
+    })
+    vi.spyOn(missingModelScan, 'scanNodeModelCandidates').mockReturnValue([
+      candidate
+    ])
+    vi.spyOn(missingMediaScan, 'scanNodeMediaCandidates').mockReturnValue([])
+    let resolveVerification: () => void = () => undefined
+    vi.spyOn(
+      missingModelScan,
+      'verifyAssetSupportedCandidates'
+    ).mockImplementation(async () => {
+      await new Promise<void>((resolve) => {
+        resolveVerification = resolve
+      })
+      candidate.isMissing = true
+    })
+    const cleanup = installErrorClearingHooks(graph)
+    const node = new LGraphNode('CheckpointLoaderSimple')
+    node.id = toNodeId(1)
+    graph.add(node)
+
+    await vi.waitFor(() =>
+      expect(
+        missingModelScan.verifyAssetSupportedCandidates
+      ).toHaveBeenCalledOnce()
+    )
+    cleanup()
+    resolveVerification()
+    await vi.waitFor(() => expect(candidate.isMissing).toBe(true))
+
+    expect(
+      useExecutionErrorStore().hasPendingAddedNodeErrorScan(
+        graph,
+        createNodeExecutionId([node.id])
+      )
+    ).toBe(false)
+    expect(useMissingModelStore().missingModelCandidates).toBeNull()
+  })
+
+  it('does not schedule scans through a retained disposed callback', () => {
+    const graph = new LGraph()
+    vi.spyOn(app, 'rootGraph', 'get').mockReturnValue(graph)
+    const cleanup = installErrorClearingHooks(graph)
+    const disposedOnNodeAdded = graph.onNodeAdded
+    cleanup()
+
+    const node = new LGraphNode('test')
+    node.id = toNodeId(1)
+    graph.add(node, true)
+    disposedOnNodeAdded?.(node)
+
+    expect(
+      useExecutionErrorStore().hasPendingAddedNodeErrorScan(
+        graph,
+        createNodeExecutionId([node.id])
+      )
+    ).toBe(false)
+  })
 })
 
 describe('onNodeRemoved clears missing asset errors by execution ID', () => {