test: extract waitForDraftPersisted helper and relax timeout

Move draft localStorage polling into WorkflowHelper for reuse.
Use default 5s timeout instead of 3s per review feedback.

CODEOWNERS

@@ -69,9 +69,6 @@
 /src/renderer/extensions/vueNodes/widgets/composables/usePainterWidget.ts @jtydhr88
 /src/lib/litegraph/src/widgets/PainterWidget.ts   @jtydhr88
 
-# GLSL
-/src/renderer/glsl/                               @jtydhr88 @pythongosssss @christian-byrne
-
 # 3D
 /src/extensions/core/load3d.ts                    @jtydhr88
 /src/extensions/core/load3dLazy.ts                @jtydhr88

browser_tests/assets/missing/missing_models_with_nodes.json

@@ -1,85 +0,0 @@
-{
-  "last_node_id": 2,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "CheckpointLoaderSimple",
-      "pos": [100, 100],
-      "size": [315, 98],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": null
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": null
-        },
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": null
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CheckpointLoaderSimple"
-      },
-      "widgets_values": ["fake_model.safetensors"]
-    },
-    {
-      "id": 2,
-      "type": "CheckpointLoaderSimple",
-      "pos": [500, 100],
-      "size": [315, 98],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "MODEL",
-          "type": "MODEL",
-          "links": null
-        },
-        {
-          "name": "CLIP",
-          "type": "CLIP",
-          "links": null
-        },
-        {
-          "name": "VAE",
-          "type": "VAE",
-          "links": null
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "CheckpointLoaderSimple"
-      },
-      "widgets_values": ["fake_model.safetensors"]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "scale": 1,
-      "offset": [0, 0]
-    }
-  },
-  "models": [
-    {
-      "name": "fake_model.safetensors",
-      "url": "http://localhost:8188/api/devtools/fake_model.safetensors",
-      "directory": "text_encoders"
-    }
-  ],
-  "version": 0.4
-}

browser_tests/assets/missing/missing_nodes_and_media.json

@@ -1,72 +0,0 @@
-{
-  "last_node_id": 10,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "UNKNOWN NODE",
-      "pos": [48, 86],
-      "size": [358, 314],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "image",
-          "type": "IMAGE",
-          "link": null,
-          "slot_index": 0
-        }
-      ],
-      "outputs": [
-        {
-          "name": "STRING",
-          "type": "STRING",
-          "links": [],
-          "slot_index": 0,
-          "shape": 6
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "UNKNOWN NODE"
-      },
-      "widgets_values": ["wd-v1-4-moat-tagger-v2", 0.35, 0.85, false, false, ""]
-    },
-    {
-      "id": 10,
-      "type": "LoadImage",
-      "pos": [450, 86],
-      "size": [315, 314],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": null
-        },
-        {
-          "name": "MASK",
-          "type": "MASK",
-          "links": null
-        }
-      ],
-      "properties": {
-        "Node name for S&R": "LoadImage"
-      },
-      "widgets_values": ["nonexistent_test_image_12345.png", "image"]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "offset": [0, 0],
-      "scale": 1
-    }
-  },
-  "version": 0.4
-}

browser_tests/fixtures/ComfyPage.ts

@@ -19,9 +19,7 @@ import { QueuePanel } from '@e2e/fixtures/components/QueuePanel'
 import { SettingDialog } from '@e2e/fixtures/components/SettingDialog'
 import {
   AssetsSidebarTab,
-  ModelLibrarySidebarTab,
   NodeLibrarySidebarTab,
-  NodeLibrarySidebarTabV2,
   WorkflowsSidebarTab
 } from '@e2e/fixtures/components/SidebarTab'
 import { Topbar } from '@e2e/fixtures/components/Topbar'
@@ -33,7 +31,6 @@ import { CommandHelper } from '@e2e/fixtures/helpers/CommandHelper'
 import { DragDropHelper } from '@e2e/fixtures/helpers/DragDropHelper'
 import { FeatureFlagHelper } from '@e2e/fixtures/helpers/FeatureFlagHelper'
 import { KeyboardHelper } from '@e2e/fixtures/helpers/KeyboardHelper'
-import { ModelLibraryHelper } from '@e2e/fixtures/helpers/ModelLibraryHelper'
 import { NodeOperationsHelper } from '@e2e/fixtures/helpers/NodeOperationsHelper'
 import { PerformanceHelper } from '@e2e/fixtures/helpers/PerformanceHelper'
 import { SettingsHelper } from '@e2e/fixtures/helpers/SettingsHelper'
@@ -58,9 +55,7 @@ class ComfyPropertiesPanel {
 
 class ComfyMenu {
   private _assetsTab: AssetsSidebarTab | null = null
-  private _modelLibraryTab: ModelLibrarySidebarTab | null = null
   private _nodeLibraryTab: NodeLibrarySidebarTab | null = null
-  private _nodeLibraryTabV2: NodeLibrarySidebarTabV2 | null = null
   private _workflowsTab: WorkflowsSidebarTab | null = null
   private _topbar: Topbar | null = null
 
@@ -78,21 +73,11 @@ class ComfyMenu {
     return this.sideToolbar.locator('.side-bar-button')
   }
 
-  get modelLibraryTab() {
-    this._modelLibraryTab ??= new ModelLibrarySidebarTab(this.page)
-    return this._modelLibraryTab
-  }
-
   get nodeLibraryTab() {
     this._nodeLibraryTab ??= new NodeLibrarySidebarTab(this.page)
     return this._nodeLibraryTab
   }
 
-  get nodeLibraryTabV2() {
-    this._nodeLibraryTabV2 ??= new NodeLibrarySidebarTabV2(this.page)
-    return this._nodeLibraryTabV2
-  }
-
   get assetsTab() {
     this._assetsTab ??= new AssetsSidebarTab(this.page)
     return this._assetsTab
@@ -214,7 +199,6 @@ export class ComfyPage {
   public readonly queuePanel: QueuePanel
   public readonly perf: PerformanceHelper
   public readonly assets: AssetsHelper
-  public readonly modelLibrary: ModelLibraryHelper
 
   /** Worker index to test user ID */
   public readonly userIds: string[] = []
@@ -262,7 +246,6 @@ export class ComfyPage {
     this.queuePanel = new QueuePanel(page)
     this.perf = new PerformanceHelper(page)
     this.assets = new AssetsHelper(page)
-    this.modelLibrary = new ModelLibraryHelper(page)
   }
 
   get visibleToasts() {

browser_tests/fixtures/components/SidebarTab.ts

@@ -100,59 +100,6 @@ export class NodeLibrarySidebarTab extends SidebarTab {
   }
 }
 
-export class NodeLibrarySidebarTabV2 extends SidebarTab {
-  constructor(public override readonly page: Page) {
-    super(page, 'node-library')
-  }
-
-  get searchInput() {
-    return this.page.getByPlaceholder('Search...')
-  }
-
-  get sidebarContent() {
-    return this.page.locator('.sidebar-content-container')
-  }
-
-  getTab(name: string) {
-    return this.sidebarContent.getByRole('tab', { name, exact: true })
-  }
-
-  get allTab() {
-    return this.getTab('All')
-  }
-
-  get blueprintsTab() {
-    return this.getTab('Blueprints')
-  }
-
-  get sortButton() {
-    return this.sidebarContent.getByRole('button', { name: 'Sort' })
-  }
-
-  getFolder(folderName: string) {
-    return this.sidebarContent
-      .getByRole('treeitem', { name: folderName })
-      .first()
-  }
-
-  getNode(nodeName: string) {
-    return this.sidebarContent.getByRole('treeitem', { name: nodeName }).first()
-  }
-
-  async expandFolder(folderName: string) {
-    const folder = this.getFolder(folderName)
-    const isExpanded = await folder.getAttribute('aria-expanded')
-    if (isExpanded !== 'true') {
-      await folder.click()
-    }
-  }
-
-  override async open() {
-    await super.open()
-    await this.searchInput.waitFor({ state: 'visible' })
-  }
-}
-
 export class WorkflowsSidebarTab extends SidebarTab {
   constructor(public override readonly page: Page) {
     super(page, 'workflows')
@@ -223,59 +170,6 @@ export class WorkflowsSidebarTab extends SidebarTab {
   }
 }
 
-export class ModelLibrarySidebarTab extends SidebarTab {
-  constructor(public override readonly page: Page) {
-    super(page, 'model-library')
-  }
-
-  get searchInput() {
-    return this.page.getByPlaceholder('Search Models...')
-  }
-
-  get modelTree() {
-    return this.page.locator('.model-lib-tree-explorer')
-  }
-
-  get refreshButton() {
-    return this.page.getByRole('button', { name: 'Refresh' })
-  }
-
-  get loadAllFoldersButton() {
-    return this.page.getByRole('button', { name: 'Load All Folders' })
-  }
-
-  get folderNodes() {
-    return this.modelTree.locator('.p-tree-node:not(.p-tree-node-leaf)')
-  }
-
-  get leafNodes() {
-    return this.modelTree.locator('.p-tree-node-leaf')
-  }
-
-  get modelPreview() {
-    return this.page.locator('.model-lib-model-preview')
-  }
-
-  override async open() {
-    await super.open()
-    await this.modelTree.waitFor({ state: 'visible' })
-  }
-
-  getFolderByLabel(label: string) {
-    return this.modelTree
-      .locator('.p-tree-node:not(.p-tree-node-leaf)')
-      .filter({ hasText: label })
-      .first()
-  }
-
-  getLeafByLabel(label: string) {
-    return this.modelTree
-      .locator('.p-tree-node-leaf')
-      .filter({ hasText: label })
-      .first()
-  }
-}
-
 export class AssetsSidebarTab extends SidebarTab {
   constructor(public override readonly page: Page) {
     super(page, 'assets')

browser_tests/fixtures/components/Topbar.ts

@@ -50,30 +50,15 @@ export class Topbar {
     return classes ? !classes.includes('invisible') : false
   }
 
-  get newWorkflowButton(): Locator {
-    return this.page.locator('.new-blank-workflow-button')
-  }
-
   getWorkflowTab(tabName: string): Locator {
     return this.page
       .locator(`.workflow-tabs .workflow-label:has-text("${tabName}")`)
       .locator('..')
   }
 
-  getTab(index: number): Locator {
-    return this.page.locator('.workflow-tabs .p-togglebutton').nth(index)
-  }
-
-  getActiveTab(): Locator {
-    return this.page.locator(
-      '.workflow-tabs .p-togglebutton.p-togglebutton-checked'
-    )
-  }
-
   async closeWorkflowTab(tabName: string) {
     const tab = this.getWorkflowTab(tabName)
-    await tab.hover()
-    await tab.locator('.close-button').click({ force: true })
+    await tab.getByRole('button', { name: 'Close' }).click({ force: true })
   }
 
   getSaveDialog(): Locator {

browser_tests/fixtures/helpers/ModelLibraryHelper.ts

@@ -1,134 +0,0 @@
-import type { Page, Route } from '@playwright/test'
-
-import type {
-  ModelFile,
-  ModelFolderInfo
-} from '../../../src/platform/assets/schemas/assetSchema'
-
-const modelFoldersRoutePattern = /\/api\/experiment\/models$/
-const modelFilesRoutePattern = /\/api\/experiment\/models\/([^?]+)/
-const viewMetadataRoutePattern = /\/api\/view_metadata\/([^?]+)/
-
-export interface MockModelMetadata {
-  'modelspec.title'?: string
-  'modelspec.author'?: string
-  'modelspec.architecture'?: string
-  'modelspec.description'?: string
-  'modelspec.resolution'?: string
-  'modelspec.tags'?: string
-}
-
-export function createMockModelFolders(names: string[]): ModelFolderInfo[] {
-  return names.map((name) => ({ name, folders: [] }))
-}
-
-export function createMockModelFiles(
-  filenames: string[],
-  pathIndex = 0
-): ModelFile[] {
-  return filenames.map((name) => ({ name, pathIndex }))
-}
-
-export class ModelLibraryHelper {
-  private foldersRouteHandler: ((route: Route) => Promise<void>) | null = null
-  private filesRouteHandler: ((route: Route) => Promise<void>) | null = null
-  private metadataRouteHandler: ((route: Route) => Promise<void>) | null = null
-  private folders: ModelFolderInfo[] = []
-  private filesByFolder: Record<string, ModelFile[]> = {}
-  private metadataByModel: Record<string, MockModelMetadata> = {}
-
-  constructor(private readonly page: Page) {}
-
-  async mockModelFolders(folders: ModelFolderInfo[]): Promise<void> {
-    this.folders = [...folders]
-
-    if (this.foldersRouteHandler) return
-
-    this.foldersRouteHandler = async (route: Route) => {
-      await route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify(this.folders)
-      })
-    }
-
-    await this.page.route(modelFoldersRoutePattern, this.foldersRouteHandler)
-  }
-
-  async mockModelFiles(folder: string, files: ModelFile[]): Promise<void> {
-    this.filesByFolder[folder] = [...files]
-
-    if (this.filesRouteHandler) return
-
-    this.filesRouteHandler = async (route: Route) => {
-      const match = route.request().url().match(modelFilesRoutePattern)
-      const folderName = match?.[1] ? decodeURIComponent(match[1]) : undefined
-      const files = folderName ? (this.filesByFolder[folderName] ?? []) : []
-
-      await route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify(files)
-      })
-    }
-
-    await this.page.route(modelFilesRoutePattern, this.filesRouteHandler)
-  }
-
-  async mockMetadata(
-    entries: Record<string, MockModelMetadata>
-  ): Promise<void> {
-    Object.assign(this.metadataByModel, entries)
-
-    if (this.metadataRouteHandler) return
-
-    this.metadataRouteHandler = async (route: Route) => {
-      const url = new URL(route.request().url())
-      const filename = url.searchParams.get('filename') ?? ''
-      const metadata = this.metadataByModel[filename]
-
-      await route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify(metadata ?? {})
-      })
-    }
-
-    await this.page.route(viewMetadataRoutePattern, this.metadataRouteHandler)
-  }
-
-  async mockFoldersWithFiles(config: Record<string, string[]>): Promise<void> {
-    const folderNames = Object.keys(config)
-    await this.mockModelFolders(createMockModelFolders(folderNames))
-    for (const [folder, files] of Object.entries(config)) {
-      await this.mockModelFiles(folder, createMockModelFiles(files))
-    }
-  }
-
-  async clearMocks(): Promise<void> {
-    this.folders = []
-    this.filesByFolder = {}
-    this.metadataByModel = {}
-
-    if (this.foldersRouteHandler) {
-      await this.page.unroute(
-        modelFoldersRoutePattern,
-        this.foldersRouteHandler
-      )
-      this.foldersRouteHandler = null
-    }
-
-    if (this.filesRouteHandler) {
-      await this.page.unroute(modelFilesRoutePattern, this.filesRouteHandler)
-      this.filesRouteHandler = null
-    }
-
-    if (this.metadataRouteHandler) {
-      await this.page.unroute(
-        viewMetadataRoutePattern,
-        this.metadataRouteHandler
-      )
-      this.metadataRouteHandler = null
-    }
-  }
-}

browser_tests/fixtures/helpers/SubgraphHelper.ts

@@ -484,7 +484,16 @@ export class SubgraphHelper {
     await this.comfyPage.vueNodes.enterSubgraph(hostNodeId)
     await this.comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
     await this.comfyPage.nextFrame()
-    await this.comfyPage.canvas.click()
+    await this.comfyPage.canvas.dispatchEvent('pointerdown', {
+      bubbles: true,
+      cancelable: true,
+      button: 0
+    })
+    await this.comfyPage.canvas.dispatchEvent('pointerup', {
+      bubbles: true,
+      cancelable: true,
+      button: 0
+    })
     await this.comfyPage.canvas.press('Control+a')
     await this.comfyPage.nextFrame()
     await this.page.evaluate(() => {
@@ -493,7 +502,16 @@ export class SubgraphHelper {
     })
     await this.comfyPage.nextFrame()
     await this.exitViaBreadcrumb()
-    await this.comfyPage.canvas.click()
+    await this.comfyPage.canvas.dispatchEvent('pointerdown', {
+      bubbles: true,
+      cancelable: true,
+      button: 0
+    })
+    await this.comfyPage.canvas.dispatchEvent('pointerup', {
+      bubbles: true,
+      cancelable: true,
+      button: 0
+    })
     await this.comfyPage.nextFrame()
   }
 

browser_tests/fixtures/helpers/WorkflowHelper.ts

@@ -58,6 +58,16 @@ export class WorkflowHelper {
     await this.comfyPage.nextFrame()
   }
 
+  async waitForDraftPersisted({ timeout = 5000 } = {}) {
+    await this.comfyPage.page.waitForFunction(
+      () =>
+        Object.keys(localStorage).some((k) =>
+          k.startsWith('Comfy.Workflow.Draft.v2:')
+        ),
+      { timeout }
+    )
+  }
+
   async loadWorkflow(workflowName: string) {
     await this.comfyPage.workflowUploadInput.setInputFiles(
       assetPath(`${workflowName}.json`)

browser_tests/fixtures/selectors.ts

@@ -41,21 +41,10 @@ export const TestIds = {
     missingNodeCard: 'missing-node-card',
     errorCardFindOnGithub: 'error-card-find-on-github',
     errorCardCopy: 'error-card-copy',
-    errorDialog: 'error-dialog',
-    errorDialogShowReport: 'error-dialog-show-report',
-    errorDialogContactSupport: 'error-dialog-contact-support',
-    errorDialogCopyReport: 'error-dialog-copy-report',
-    errorDialogFindIssues: 'error-dialog-find-issues',
     about: 'about-panel',
     whatsNewSection: 'whats-new-section',
     missingNodePacksGroup: 'error-group-missing-node',
     missingModelsGroup: 'error-group-missing-model',
-    missingModelExpand: 'missing-model-expand',
-    missingModelLocate: 'missing-model-locate',
-    missingModelCopyName: 'missing-model-copy-name',
-    missingModelCopyUrl: 'missing-model-copy-url',
-    missingModelDownload: 'missing-model-download',
-    missingModelImportUnsupported: 'missing-model-import-unsupported',
     missingMediaGroup: 'error-group-missing-media',
     missingMediaRow: 'missing-media-row',
     missingMediaUploadDropzone: 'missing-media-upload-dropzone',
@@ -91,10 +80,7 @@ export const TestIds = {
     widgetActionsMenuButton: 'widget-actions-menu-button'
   },
   node: {
-    titleInput: 'node-title-input',
-    pinIndicator: 'node-pin-indicator',
-    innerWrapper: 'node-inner-wrapper',
-    mainImage: 'main-image'
+    titleInput: 'node-title-input'
   },
   selectionToolbox: {
     colorPickerButton: 'color-picker-button',

browser_tests/fixtures/utils/vueNodeFixtures.ts

@@ -1,7 +1,5 @@
 import type { Locator } from '@playwright/test'
 
-import { TestIds } from '../selectors'
-
 /** DOM-centric helper for a single Vue-rendered node on the canvas. */
 export class VueNodeFixture {
   constructor(private readonly locator: Locator) {}
@@ -22,10 +20,6 @@ export class VueNodeFixture {
     return this.locator.locator('[data-testid^="node-body-"]')
   }
 
-  get pinIndicator(): Locator {
-    return this.locator.getByTestId(TestIds.node.pinIndicator)
-  }
-
   get collapseButton(): Locator {
     return this.locator.locator('[data-testid="node-collapse-button"]')
   }

browser_tests/helpers/clipboardSpy.ts

@@ -1,19 +0,0 @@
-import type { Page } from '@playwright/test'
-
-export async function interceptClipboardWrite(page: Page) {
-  await page.evaluate(() => {
-    const w = window as Window & { __copiedText?: string }
-    w.__copiedText = ''
-    navigator.clipboard.writeText = async (text: string) => {
-      w.__copiedText = text
-    }
-  })
-}
-
-export async function getClipboardText(page: Page): Promise<string> {
-  return (
-    (await page.evaluate(
-      () => (window as Window & { __copiedText?: string }).__copiedText
-    )) ?? ''
-  )
-}

browser_tests/tests/dialog.spec.ts

@@ -3,11 +3,261 @@ import { expect } from '@playwright/test'
 import type { Keybinding } from '../../src/platform/keybindings/types'
 import { comfyPageFixture as test } from '../fixtures/ComfyPage'
 import { DefaultGraphPositions } from '../fixtures/constants/defaultGraphPositions'
+import { TestIds } from '../fixtures/selectors'
 
 test.beforeEach(async ({ comfyPage }) => {
   await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
 })
 
+test.describe('Missing nodes in Error Overlay', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+  })
+
+  test('Should show error overlay when loading a workflow with missing nodes', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
+
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+
+    const messages = errorOverlay.getByTestId(
+      TestIds.dialogs.errorOverlayMessages
+    )
+    await expect(messages).toBeVisible()
+    await expect(messages).toHaveText(/missing.*installed/i)
+  })
+
+  test('Should show error overlay when loading a workflow with missing nodes in subgraphs', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('missing/missing_nodes_in_subgraph')
+
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+
+    const messages = errorOverlay.getByTestId(
+      TestIds.dialogs.errorOverlayMessages
+    )
+    await expect(messages).toBeVisible()
+    await expect(messages).toHaveText(/missing.*installed/i)
+
+    // Click "See Errors" to open the errors tab and verify subgraph node content
+    await errorOverlay
+      .getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
+      .click()
+    await expect(errorOverlay).not.toBeVisible()
+
+    const missingNodeCard = comfyPage.page.getByTestId(
+      TestIds.dialogs.missingNodeCard
+    )
+    await expect(missingNodeCard).toBeVisible()
+
+    // Expand the pack group row to reveal node type names
+    await missingNodeCard
+      .getByRole('button', { name: /expand/i })
+      .first()
+      .click()
+    await expect(
+      missingNodeCard.getByText('MISSING_NODE_TYPE_IN_SUBGRAPH')
+    ).toBeVisible()
+  })
+
+  test('Should show MissingNodeCard in errors tab when clicking See Errors', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
+
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+
+    // Click "See Errors" to open the right side panel errors tab
+    await errorOverlay
+      .getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
+      .click()
+    await expect(errorOverlay).not.toBeVisible()
+
+    // Verify MissingNodeCard is rendered in the errors tab
+    const missingNodeCard = comfyPage.page.getByTestId(
+      TestIds.dialogs.missingNodeCard
+    )
+    await expect(missingNodeCard).toBeVisible()
+  })
+})
+
+test('Does not resurface missing nodes on undo/redo', async ({ comfyPage }) => {
+  await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+  await comfyPage.settings.setSetting(
+    'Comfy.RightSidePanel.ShowErrorsTab',
+    true
+  )
+  await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
+
+  const errorOverlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+  await expect(errorOverlay).toBeVisible()
+
+  // Dismiss the error overlay
+  await errorOverlay.getByTestId(TestIds.dialogs.errorOverlayDismiss).click()
+  await expect(errorOverlay).not.toBeVisible()
+
+  // Make a change to the graph by moving a node
+  await comfyPage.canvas.click()
+  await comfyPage.nextFrame()
+  await comfyPage.page.keyboard.press('Control+a')
+  await comfyPage.page.mouse.move(400, 300)
+  await comfyPage.page.mouse.down()
+  await comfyPage.page.mouse.move(450, 350, { steps: 5 })
+  await comfyPage.page.mouse.up()
+  await comfyPage.nextFrame()
+
+  // Undo and redo should not resurface the error overlay
+  await comfyPage.keyboard.undo()
+  await expect(errorOverlay).not.toBeVisible({ timeout: 5000 })
+
+  await comfyPage.keyboard.redo()
+  await expect(errorOverlay).not.toBeVisible({ timeout: 5000 })
+})
+
+test.describe('Execution error', () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+    await comfyPage.setup()
+  })
+
+  test('Should display an error message when an execution error occurs', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('nodes/execution_error')
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+    await comfyPage.nextFrame()
+
+    // Wait for the error overlay to be visible
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+  })
+})
+
+test.describe('Error actions in Errors Tab', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+  })
+
+  test('Should show Find on GitHub and Copy buttons in error card after execution error', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('nodes/execution_error')
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+    await comfyPage.nextFrame()
+
+    // Wait for error overlay and click "See Errors"
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+    await errorOverlay
+      .getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
+      .click()
+    await expect(errorOverlay).not.toBeVisible()
+
+    // Verify Find on GitHub button is present in the error card
+    const findOnGithubButton = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorCardFindOnGithub
+    )
+    await expect(findOnGithubButton).toBeVisible()
+
+    // Verify Copy button is present in the error card
+    const copyButton = comfyPage.page.getByTestId(TestIds.dialogs.errorCardCopy)
+    await expect(copyButton).toBeVisible()
+  })
+})
+
+test.describe('Missing models in Error Tab', () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+    const cleanupOk = await comfyPage.page.evaluate(async (url: string) => {
+      const response = await fetch(`${url}/api/devtools/cleanup_fake_model`)
+      return response.ok
+    }, comfyPage.url)
+    expect(cleanupOk).toBeTruthy()
+  })
+
+  test('Should show error overlay with missing models when workflow has missing models', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('missing/missing_models')
+
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+
+    const messages = errorOverlay.getByTestId(
+      TestIds.dialogs.errorOverlayMessages
+    )
+    await expect(messages).toBeVisible()
+    await expect(messages).toHaveText(/required model.*missing/i)
+  })
+
+  test('Should show missing models from node properties', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow(
+      'missing/missing_models_from_node_properties'
+    )
+
+    const errorOverlay = comfyPage.page.getByTestId(
+      TestIds.dialogs.errorOverlay
+    )
+    await expect(errorOverlay).toBeVisible()
+
+    const messages = errorOverlay.getByTestId(
+      TestIds.dialogs.errorOverlayMessages
+    )
+    await expect(messages).toBeVisible()
+    await expect(messages).toHaveText(/required model.*missing/i)
+  })
+
+  test('Should not show missing models when widget values have changed', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow(
+      'missing/model_metadata_widget_mismatch'
+    )
+
+    await expect(
+      comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    ).not.toBeVisible()
+    await expect(
+      comfyPage.page.getByTestId(TestIds.dialogs.errorOverlayMessages)
+    ).not.toBeVisible()
+  })
+})
+
 test.describe('Settings', () => {
   test('@mobile Should be visible on mobile', async ({ comfyPage }) => {
     await comfyPage.page.keyboard.press('Control+,')
@@ -129,6 +379,38 @@ test.describe('Support', () => {
   })
 })
 
+test.describe('Error dialog', () => {
+  test('Should display an error dialog when graph configure fails', async ({
+    comfyPage
+  }) => {
+    await comfyPage.page.evaluate(() => {
+      const graph = window.graph!
+      ;(graph as { configure: () => void }).configure = () => {
+        throw new Error('Error on configure!')
+      }
+    })
+
+    await comfyPage.workflow.loadWorkflow('default')
+
+    const errorDialog = comfyPage.page.locator('.comfy-error-report')
+    await expect(errorDialog).toBeVisible()
+  })
+
+  test('Should display an error dialog when prompt execution fails', async ({
+    comfyPage
+  }) => {
+    await comfyPage.page.evaluate(async () => {
+      const app = window.app!
+      app.api.queuePrompt = () => {
+        throw new Error('Error on queuePrompt!')
+      }
+      await app.queuePrompt(0)
+    })
+    const errorDialog = comfyPage.page.locator('.comfy-error-report')
+    await expect(errorDialog).toBeVisible()
+  })
+})
+
 test.describe('Signin dialog', () => {
   test('Paste content to signin dialog should not paste node on canvas', async ({
     comfyPage

browser_tests/tests/errorDialog.spec.ts

@@ -1,139 +0,0 @@
-import type { Page } from '@playwright/test'
-
-import { expect } from '@playwright/test'
-
-import type { ComfyPage } from '../fixtures/ComfyPage'
-import { comfyPageFixture as test } from '../fixtures/ComfyPage'
-import { TestIds } from '../fixtures/selectors'
-import {
-  interceptClipboardWrite,
-  getClipboardText
-} from '../helpers/clipboardSpy'
-
-async function triggerConfigureError(
-  comfyPage: ComfyPage,
-  message = 'Error on configure!'
-) {
-  await comfyPage.page.evaluate((msg: string) => {
-    const graph = window.graph!
-    ;(graph as { configure: () => void }).configure = () => {
-      throw new Error(msg)
-    }
-  }, message)
-
-  await comfyPage.workflow.loadWorkflow('default')
-
-  return comfyPage.page.getByTestId(TestIds.dialogs.errorDialog)
-}
-
-async function waitForPopupNavigation(page: Page, action: () => Promise<void>) {
-  const popupPromise = page.waitForEvent('popup')
-  await action()
-  const popup = await popupPromise
-  await popup.waitForLoadState()
-  return popup
-}
-
-test.describe('Error dialog', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
-  })
-
-  test('Should display an error dialog when graph configure fails', async ({
-    comfyPage
-  }) => {
-    const errorDialog = await triggerConfigureError(comfyPage)
-    await expect(errorDialog).toBeVisible()
-  })
-
-  test('Should display an error dialog when prompt execution fails', async ({
-    comfyPage
-  }) => {
-    await comfyPage.page.evaluate(async () => {
-      const app = window.app!
-      app.api.queuePrompt = () => {
-        throw new Error('Error on queuePrompt!')
-      }
-      await app.queuePrompt(0)
-    })
-    const errorDialog = comfyPage.page.getByTestId(TestIds.dialogs.errorDialog)
-    await expect(errorDialog).toBeVisible()
-  })
-
-  test('Should display error message body', async ({ comfyPage }) => {
-    const errorDialog = await triggerConfigureError(
-      comfyPage,
-      'Test error message body'
-    )
-    await expect(errorDialog).toBeVisible()
-    await expect(errorDialog).toContainText('Test error message body')
-  })
-
-  test('Should show report section when "Show Report" is clicked', async ({
-    comfyPage
-  }) => {
-    const errorDialog = await triggerConfigureError(comfyPage)
-    await expect(errorDialog).toBeVisible()
-    await expect(errorDialog.locator('pre')).not.toBeVisible()
-
-    await errorDialog.getByTestId(TestIds.dialogs.errorDialogShowReport).click()
-
-    const reportPre = errorDialog.locator('pre')
-    await expect(reportPre).toBeVisible()
-    await expect(reportPre).toHaveText(/\S/)
-    await expect(
-      errorDialog.getByTestId(TestIds.dialogs.errorDialogShowReport)
-    ).not.toBeVisible()
-  })
-
-  test('Should copy report to clipboard when "Copy to Clipboard" is clicked', async ({
-    comfyPage
-  }) => {
-    const errorDialog = await triggerConfigureError(comfyPage)
-    await expect(errorDialog).toBeVisible()
-
-    await errorDialog.getByTestId(TestIds.dialogs.errorDialogShowReport).click()
-    await expect(errorDialog.locator('pre')).toBeVisible()
-
-    await interceptClipboardWrite(comfyPage.page)
-
-    await errorDialog.getByTestId(TestIds.dialogs.errorDialogCopyReport).click()
-
-    const reportText = await errorDialog.locator('pre').textContent()
-    const copiedText = await getClipboardText(comfyPage.page)
-    expect(copiedText).toBe(reportText)
-  })
-
-  test('Should open GitHub issues search when "Find Issues" is clicked', async ({
-    comfyPage
-  }) => {
-    const errorDialog = await triggerConfigureError(comfyPage)
-    await expect(errorDialog).toBeVisible()
-
-    const popup = await waitForPopupNavigation(comfyPage.page, () =>
-      errorDialog.getByTestId(TestIds.dialogs.errorDialogFindIssues).click()
-    )
-
-    const url = new URL(popup.url())
-    expect(url.hostname).toBe('github.com')
-    expect(url.pathname).toContain('/issues')
-
-    await popup.close()
-  })
-
-  test('Should open contact support when "Help Fix This" is clicked', async ({
-    comfyPage
-  }) => {
-    const errorDialog = await triggerConfigureError(comfyPage)
-    await expect(errorDialog).toBeVisible()
-
-    const popup = await waitForPopupNavigation(comfyPage.page, () =>
-      errorDialog.getByTestId(TestIds.dialogs.errorDialogContactSupport).click()
-    )
-
-    const url = new URL(popup.url())
-    expect(url.hostname).toBe('support.comfy.org')
-
-    await popup.close()
-  })
-})

browser_tests/tests/errorOverlay.spec.ts

@@ -1,195 +0,0 @@
-import type { Page } from '@playwright/test'
-
-import {
-  comfyPageFixture as test,
-  comfyExpect as expect
-} from '../fixtures/ComfyPage'
-import { TestIds } from '../fixtures/selectors'
-
-test.describe('Error overlay', { tag: '@ui' }, () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.RightSidePanel.ShowErrorsTab',
-      true
-    )
-  })
-
-  function getOverlay(page: Page) {
-    return page.getByTestId(TestIds.dialogs.errorOverlay)
-  }
-
-  function getSeeErrorsButton(page: Page) {
-    return getOverlay(page).getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
-  }
-
-  test.describe('Labels', () => {
-    test('Should display singular error count label for single error', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-      await expect(getOverlay(comfyPage.page)).toContainText(/1 ERROR/i)
-    })
-
-    test('Should display "Show missing nodes" button for missing node errors', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-      await expect(getSeeErrorsButton(comfyPage.page)).toContainText(
-        /Show missing nodes/i
-      )
-    })
-
-    test('Should display "Show missing models" button for missing model errors', async ({
-      comfyPage
-    }) => {
-      const cleanupOk = await comfyPage.page.evaluate(async (url: string) => {
-        const response = await fetch(`${url}/api/devtools/cleanup_fake_model`)
-        return response.ok
-      }, comfyPage.url)
-      expect(cleanupOk).toBeTruthy()
-
-      await comfyPage.workflow.loadWorkflow('missing/missing_models')
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-      await expect(getSeeErrorsButton(comfyPage.page)).toContainText(
-        /Show missing models/i
-      )
-    })
-
-    test('Should display "Show missing inputs" button for missing media errors', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_media_single')
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-      await expect(getSeeErrorsButton(comfyPage.page)).toContainText(
-        /Show missing inputs/i
-      )
-    })
-
-    test('Should display generic "See Errors" button for multiple error types', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes_and_media')
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-      await expect(getSeeErrorsButton(comfyPage.page)).toContainText(
-        /See Errors/i
-      )
-    })
-  })
-
-  test.describe('Persistence', () => {
-    test('Does not resurface missing nodes on undo/redo', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-
-      const errorOverlay = getOverlay(comfyPage.page)
-      await expect(errorOverlay).toBeVisible()
-      await errorOverlay
-        .getByTestId(TestIds.dialogs.errorOverlayDismiss)
-        .click()
-      await expect(errorOverlay).not.toBeVisible()
-
-      await comfyPage.canvas.click()
-      await comfyPage.nextFrame()
-      await comfyPage.page.keyboard.press('Control+a')
-      await comfyPage.page.mouse.move(400, 300)
-      await comfyPage.page.mouse.down()
-      await comfyPage.page.mouse.move(450, 350, { steps: 5 })
-      await comfyPage.page.mouse.up()
-      await comfyPage.nextFrame()
-
-      await comfyPage.keyboard.undo()
-      await expect(errorOverlay).not.toBeVisible({ timeout: 5000 })
-
-      await comfyPage.keyboard.redo()
-      await expect(errorOverlay).not.toBeVisible({ timeout: 5000 })
-    })
-  })
-
-  test.describe('See Errors flow', () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.setup()
-    })
-
-    async function triggerExecutionError(comfyPage: {
-      canvasOps: { disconnectEdge: () => Promise<void> }
-      page: Page
-      command: { executeCommand: (cmd: string) => Promise<void> }
-    }) {
-      await comfyPage.canvasOps.disconnectEdge()
-      await comfyPage.page.keyboard.press('Escape')
-      await comfyPage.command.executeCommand('Comfy.QueuePrompt')
-    }
-
-    test('Error overlay appears on execution error', async ({ comfyPage }) => {
-      await triggerExecutionError(comfyPage)
-
-      await expect(getOverlay(comfyPage.page)).toBeVisible()
-    })
-
-    test('Error overlay shows error message', async ({ comfyPage }) => {
-      await triggerExecutionError(comfyPage)
-
-      const overlay = getOverlay(comfyPage.page)
-      await expect(overlay).toBeVisible()
-      await expect(overlay).toHaveText(/\S/)
-    })
-
-    test('"See Errors" opens right side panel', async ({ comfyPage }) => {
-      await triggerExecutionError(comfyPage)
-
-      const overlay = getOverlay(comfyPage.page)
-      await expect(overlay).toBeVisible()
-
-      await overlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
-
-      await expect(comfyPage.page.getByTestId('properties-panel')).toBeVisible()
-    })
-
-    test('"See Errors" dismisses the overlay', async ({ comfyPage }) => {
-      await triggerExecutionError(comfyPage)
-
-      const overlay = getOverlay(comfyPage.page)
-      await expect(overlay).toBeVisible()
-
-      await overlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
-
-      await expect(overlay).not.toBeVisible()
-    })
-
-    test('"Dismiss" closes overlay without opening panel', async ({
-      comfyPage
-    }) => {
-      await triggerExecutionError(comfyPage)
-
-      const overlay = getOverlay(comfyPage.page)
-      await expect(overlay).toBeVisible()
-
-      await overlay.getByTestId(TestIds.dialogs.errorOverlayDismiss).click()
-
-      await expect(overlay).not.toBeVisible()
-      await expect(
-        comfyPage.page.getByTestId('properties-panel')
-      ).not.toBeVisible()
-    })
-
-    test('Close button (X) dismisses overlay', async ({ comfyPage }) => {
-      await triggerExecutionError(comfyPage)
-
-      const overlay = getOverlay(comfyPage.page)
-      await expect(overlay).toBeVisible()
-
-      await overlay.getByRole('button', { name: /close/i }).click()
-
-      await expect(overlay).not.toBeVisible()
-    })
-  })
-})

browser_tests/tests/errorOverlaySeeErrors.spec.ts

@@ -0,0 +1,93 @@
+import type { Page } from '@playwright/test'
+
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+import { TestIds } from '../fixtures/selectors'
+
+test.describe('Error overlay See Errors flow', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+    await comfyPage.setup()
+  })
+
+  async function triggerExecutionError(comfyPage: {
+    canvasOps: { disconnectEdge: () => Promise<void> }
+    page: Page
+    command: { executeCommand: (cmd: string) => Promise<void> }
+  }) {
+    await comfyPage.canvasOps.disconnectEdge()
+    await comfyPage.page.keyboard.press('Escape')
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+  }
+
+  test('Error overlay appears on execution error', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(
+      comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    ).toBeVisible()
+  })
+
+  test('Error overlay shows error message', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    await expect(overlay).toBeVisible()
+    await expect(overlay).toHaveText(/\S/)
+  })
+
+  test('"See Errors" opens right side panel', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
+
+    await expect(comfyPage.page.getByTestId('properties-panel')).toBeVisible()
+  })
+
+  test('"See Errors" dismisses the overlay', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
+
+    await expect(overlay).not.toBeVisible()
+  })
+
+  test('"Dismiss" closes overlay without opening panel', async ({
+    comfyPage
+  }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByTestId(TestIds.dialogs.errorOverlayDismiss).click()
+
+    await expect(overlay).not.toBeVisible()
+    await expect(
+      comfyPage.page.getByTestId('properties-panel')
+    ).not.toBeVisible()
+  })
+
+  test('Close button (X) dismisses overlay', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByRole('button', { name: /close/i }).click()
+
+    await expect(overlay).not.toBeVisible()
+  })
+})

browser_tests/tests/missingMedia.spec.ts

@@ -1,9 +1,21 @@
 import { expect } from '@playwright/test'
 
-import type { ComfyPage } from '../../fixtures/ComfyPage'
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
-import { openErrorsTabViaSeeErrors } from './ErrorsTabHelper'
+import type { ComfyPage } from '../fixtures/ComfyPage'
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+import { TestIds } from '../fixtures/selectors'
+
+async function loadMissingMediaAndOpenErrorsTab(
+  comfyPage: ComfyPage,
+  workflow = 'missing/missing_media_single'
+) {
+  await comfyPage.workflow.loadWorkflow(workflow)
+
+  const errorOverlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+  await expect(errorOverlay).toBeVisible()
+
+  await errorOverlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
+  await expect(errorOverlay).not.toBeVisible()
+}
 
 async function uploadFileViaDropzone(comfyPage: ComfyPage) {
   const dropzone = comfyPage.page.getByTestId(
@@ -36,7 +48,7 @@ function getDropzone(comfyPage: ComfyPage) {
   return comfyPage.page.getByTestId(TestIds.dialogs.missingMediaUploadDropzone)
 }
 
-test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
+test.describe('Missing media inputs in Error Tab', () => {
   test.beforeEach(async ({ comfyPage }) => {
     await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
     await comfyPage.settings.setSetting(
@@ -46,8 +58,27 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
   })
 
   test.describe('Detection', () => {
-    test('Shows missing media group in errors tab', async ({ comfyPage }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+    test('Shows error overlay when workflow has missing media inputs', async ({
+      comfyPage
+    }) => {
+      await comfyPage.workflow.loadWorkflow('missing/missing_media_single')
+
+      const errorOverlay = comfyPage.page.getByTestId(
+        TestIds.dialogs.errorOverlay
+      )
+      await expect(errorOverlay).toBeVisible()
+
+      const messages = errorOverlay.getByTestId(
+        TestIds.dialogs.errorOverlayMessages
+      )
+      await expect(messages).toBeVisible()
+      await expect(messages).toHaveText(/missing required inputs/i)
+    })
+
+    test('Shows missing media group in errors tab after clicking See Errors', async ({
+      comfyPage
+    }) => {
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
 
       await expect(
         comfyPage.page.getByTestId(TestIds.dialogs.missingMediaGroup)
@@ -57,7 +88,7 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     test('Shows correct number of missing media rows', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(
+      await loadMissingMediaAndOpenErrorsTab(
         comfyPage,
         'missing/missing_media_multiple'
       )
@@ -68,20 +99,30 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     test('Shows upload dropzone and library select for each missing item', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
 
       await expect(getDropzone(comfyPage)).toBeVisible()
       await expect(
         comfyPage.page.getByTestId(TestIds.dialogs.missingMediaLibrarySelect)
       ).toBeVisible()
     })
+
+    test('Does not show error overlay when all media inputs exist', async ({
+      comfyPage
+    }) => {
+      await comfyPage.workflow.loadWorkflow('widgets/load_image_widget')
+
+      await expect(
+        comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
+      ).not.toBeVisible()
+    })
   })
 
-  test.describe('Upload flow', () => {
+  test.describe('Upload flow (2-step confirm)', () => {
     test('Upload via file picker shows status card then allows confirm', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
       await uploadFileViaDropzone(comfyPage)
 
       await expect(getStatusCard(comfyPage)).toBeVisible()
@@ -91,11 +132,11 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     })
   })
 
-  test.describe('Library select flow', () => {
+  test.describe('Library select flow (2-step confirm)', () => {
     test('Selecting from library shows status card then allows confirm', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
 
       const librarySelect = comfyPage.page.getByTestId(
         TestIds.dialogs.missingMediaLibrarySelect
@@ -121,7 +162,7 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     test('Cancelling pending selection returns to upload/library UI', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
       await uploadFileViaDropzone(comfyPage)
 
       await expect(getStatusCard(comfyPage)).toBeVisible()
@@ -140,7 +181,7 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     test('Missing Inputs group disappears when all items are resolved', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
       await uploadFileViaDropzone(comfyPage)
       await confirmPendingSelection(comfyPage)
 
@@ -154,7 +195,7 @@ test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
     test('Locate button navigates canvas to the missing media node', async ({
       comfyPage
     }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
+      await loadMissingMediaAndOpenErrorsTab(comfyPage)
 
       const offsetBefore = await comfyPage.page.evaluate(() => {
         const canvas = window['app']?.canvas

browser_tests/tests/propertiesPanel/ErrorsTabHelper.ts

@@ -1,17 +0,0 @@
-import { expect } from '@playwright/test'
-
-import type { ComfyPage } from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
-
-export async function openErrorsTabViaSeeErrors(
-  comfyPage: ComfyPage,
-  workflow: string
-) {
-  await comfyPage.workflow.loadWorkflow(workflow)
-
-  const errorOverlay = comfyPage.page.getByTestId(TestIds.dialogs.errorOverlay)
-  await expect(errorOverlay).toBeVisible()
-
-  await errorOverlay.getByTestId(TestIds.dialogs.errorOverlaySeeErrors).click()
-  await expect(errorOverlay).not.toBeVisible()
-}

browser_tests/tests/propertiesPanel/errorsTab.spec.ts

@@ -1,73 +1,31 @@
 import { expect } from '@playwright/test'
 
 import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
 import { PropertiesPanelHelper } from './PropertiesPanelHelper'
 
-test.describe('Errors tab - common', { tag: '@ui' }, () => {
+test.describe('Properties panel - Errors tab', () => {
+  let panel: PropertiesPanelHelper
+
   test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    panel = new PropertiesPanelHelper(comfyPage.page)
+  })
+
+  test('should show Errors tab when errors exist', async ({ comfyPage }) => {
     await comfyPage.settings.setSetting(
       'Comfy.RightSidePanel.ShowErrorsTab',
       true
     )
+    await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
+    await comfyPage.actionbar.propertiesButton.click()
+    await comfyPage.nextFrame()
+
+    await expect(panel.errorsTabIcon).toBeVisible()
   })
 
-  test.describe('Tab visibility', () => {
-    test('Should show Errors tab when errors exist', async ({ comfyPage }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-      await comfyPage.actionbar.propertiesButton.click()
-      await comfyPage.nextFrame()
-
-      const panel = new PropertiesPanelHelper(comfyPage.page)
-      await expect(panel.errorsTabIcon).toBeVisible()
-    })
-
-    test('Should not show Errors tab when setting is disabled', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('missing/missing_nodes')
-      await comfyPage.settings.setSetting(
-        'Comfy.RightSidePanel.ShowErrorsTab',
-        false
-      )
-      await comfyPage.actionbar.propertiesButton.click()
-      await comfyPage.nextFrame()
-
-      const panel = new PropertiesPanelHelper(comfyPage.page)
-      await expect(panel.errorsTabIcon).not.toBeVisible()
-    })
-  })
-
-  test.describe('Search and filter', () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.setup()
-    })
-
-    test('Should filter execution errors by search query', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('nodes/execution_error')
-      await comfyPage.command.executeCommand('Comfy.QueuePrompt')
-      await comfyPage.nextFrame()
-
-      const errorOverlay = comfyPage.page.getByTestId(
-        TestIds.dialogs.errorOverlay
-      )
-      await expect(errorOverlay).toBeVisible()
-      await errorOverlay
-        .getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
-        .click()
-
-      const runtimePanel = comfyPage.page.getByTestId(
-        TestIds.dialogs.runtimeErrorPanel
-      )
-      await expect(runtimePanel).toBeVisible()
-
-      const searchInput = comfyPage.page.getByPlaceholder(/^Search/)
-      await searchInput.fill('nonexistent_query_xyz_12345')
-
-      await expect(runtimePanel).not.toBeVisible()
-    })
+  test('should not show Errors tab when errors are disabled', async ({
+    comfyPage
+  }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    await expect(panel.errorsTabIcon).not.toBeVisible()
   })
 })

browser_tests/tests/propertiesPanel/errorsTabExecution.spec.ts

@@ -1,57 +0,0 @@
-import type { ComfyPage } from '../../fixtures/ComfyPage'
-import {
-  comfyPageFixture as test,
-  comfyExpect as expect
-} from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
-
-test.describe('Errors tab - Execution errors', { tag: '@ui' }, () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.RightSidePanel.ShowErrorsTab',
-      true
-    )
-    await comfyPage.setup()
-  })
-
-  async function openExecutionErrorTab(comfyPage: ComfyPage) {
-    await comfyPage.workflow.loadWorkflow('nodes/execution_error')
-    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
-    await comfyPage.nextFrame()
-
-    const errorOverlay = comfyPage.page.getByTestId(
-      TestIds.dialogs.errorOverlay
-    )
-    await expect(errorOverlay).toBeVisible()
-    await errorOverlay
-      .getByTestId(TestIds.dialogs.errorOverlaySeeErrors)
-      .click()
-    await expect(errorOverlay).not.toBeVisible()
-  }
-
-  test('Should show Find on GitHub and Copy buttons in error card', async ({
-    comfyPage
-  }) => {
-    await openExecutionErrorTab(comfyPage)
-
-    await expect(
-      comfyPage.page.getByTestId(TestIds.dialogs.errorCardFindOnGithub)
-    ).toBeVisible()
-    await expect(
-      comfyPage.page.getByTestId(TestIds.dialogs.errorCardCopy)
-    ).toBeVisible()
-  })
-
-  test('Should show error message in runtime error panel', async ({
-    comfyPage
-  }) => {
-    await openExecutionErrorTab(comfyPage)
-
-    const runtimePanel = comfyPage.page.getByTestId(
-      TestIds.dialogs.runtimeErrorPanel
-    )
-    await expect(runtimePanel).toBeVisible()
-    await expect(runtimePanel).toContainText(/\S/)
-  })
-})

browser_tests/tests/propertiesPanel/errorsTabMissingModels.spec.ts

@@ -1,105 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
-import {
-  interceptClipboardWrite,
-  getClipboardText
-} from '../../helpers/clipboardSpy'
-import { openErrorsTabViaSeeErrors } from './ErrorsTabHelper'
-
-test.describe('Errors tab - Missing models', { tag: '@ui' }, () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.RightSidePanel.ShowErrorsTab',
-      true
-    )
-    const cleanupOk = await comfyPage.page.evaluate(async (url: string) => {
-      const response = await fetch(`${url}/api/devtools/cleanup_fake_model`)
-      return response.ok
-    }, comfyPage.url)
-    expect(cleanupOk).toBeTruthy()
-  })
-
-  test('Should show missing models group in errors tab', async ({
-    comfyPage
-  }) => {
-    await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_models')
-
-    await expect(
-      comfyPage.page.getByTestId(TestIds.dialogs.missingModelsGroup)
-    ).toBeVisible()
-  })
-
-  test('Should display model name with referencing node count', async ({
-    comfyPage
-  }) => {
-    await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_models')
-
-    const modelsGroup = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingModelsGroup
-    )
-    await expect(modelsGroup).toContainText(/fake_model\.safetensors\s*\(\d+\)/)
-  })
-
-  test('Should expand model row to show referencing nodes', async ({
-    comfyPage
-  }) => {
-    await openErrorsTabViaSeeErrors(
-      comfyPage,
-      'missing/missing_models_with_nodes'
-    )
-
-    const locateButton = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingModelLocate
-    )
-    await expect(locateButton.first()).not.toBeVisible()
-
-    const expandButton = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingModelExpand
-    )
-    await expect(expandButton.first()).toBeVisible()
-    await expandButton.first().click()
-
-    await expect(locateButton.first()).toBeVisible()
-  })
-
-  test('Should copy model name to clipboard', async ({ comfyPage }) => {
-    await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_models')
-    await interceptClipboardWrite(comfyPage.page)
-
-    const copyButton = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingModelCopyName
-    )
-    await expect(copyButton.first()).toBeVisible()
-    await copyButton.first().click()
-
-    const copiedText = await getClipboardText(comfyPage.page)
-    expect(copiedText).toContain('fake_model.safetensors')
-  })
-
-  test.describe('OSS-specific', { tag: '@oss' }, () => {
-    test('Should show Copy URL button for non-asset models', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_models')
-
-      const copyUrlButton = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingModelCopyUrl
-      )
-      await expect(copyUrlButton.first()).toBeVisible()
-    })
-
-    test('Should show Download button for downloadable models', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_models')
-
-      const downloadButton = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingModelDownload
-      )
-      await expect(downloadButton.first()).toBeVisible()
-    })
-  })
-})

browser_tests/tests/propertiesPanel/errorsTabMissingNodes.spec.ts

@@ -1,105 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-import { TestIds } from '../../fixtures/selectors'
-import { openErrorsTabViaSeeErrors } from './ErrorsTabHelper'
-
-test.describe('Errors tab - Missing nodes', { tag: '@ui' }, () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.RightSidePanel.ShowErrorsTab',
-      true
-    )
-  })
-
-  test('Should show MissingNodeCard in errors tab', async ({ comfyPage }) => {
-    await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_nodes')
-
-    await expect(
-      comfyPage.page.getByTestId(TestIds.dialogs.missingNodeCard)
-    ).toBeVisible()
-  })
-
-  test('Should show missing node packs group', async ({ comfyPage }) => {
-    await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_nodes')
-
-    await expect(
-      comfyPage.page.getByTestId(TestIds.dialogs.missingNodePacksGroup)
-    ).toBeVisible()
-  })
-
-  test('Should expand pack group to reveal node type names', async ({
-    comfyPage
-  }) => {
-    await openErrorsTabViaSeeErrors(
-      comfyPage,
-      'missing/missing_nodes_in_subgraph'
-    )
-
-    const missingNodeCard = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingNodeCard
-    )
-    await expect(missingNodeCard).toBeVisible()
-
-    await missingNodeCard
-      .getByRole('button', { name: /expand/i })
-      .first()
-      .click()
-    await expect(
-      missingNodeCard.getByText('MISSING_NODE_TYPE_IN_SUBGRAPH')
-    ).toBeVisible()
-  })
-
-  test('Should collapse expanded pack group', async ({ comfyPage }) => {
-    await openErrorsTabViaSeeErrors(
-      comfyPage,
-      'missing/missing_nodes_in_subgraph'
-    )
-
-    const missingNodeCard = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingNodeCard
-    )
-    await missingNodeCard
-      .getByRole('button', { name: /expand/i })
-      .first()
-      .click()
-    await expect(
-      missingNodeCard.getByText('MISSING_NODE_TYPE_IN_SUBGRAPH')
-    ).toBeVisible()
-
-    await missingNodeCard
-      .getByRole('button', { name: /collapse/i })
-      .first()
-      .click()
-    await expect(
-      missingNodeCard.getByText('MISSING_NODE_TYPE_IN_SUBGRAPH')
-    ).not.toBeVisible()
-  })
-
-  test('Locate node button is visible for expanded pack nodes', async ({
-    comfyPage
-  }) => {
-    await openErrorsTabViaSeeErrors(
-      comfyPage,
-      'missing/missing_nodes_in_subgraph'
-    )
-
-    const missingNodeCard = comfyPage.page.getByTestId(
-      TestIds.dialogs.missingNodeCard
-    )
-    await missingNodeCard
-      .getByRole('button', { name: /expand/i })
-      .first()
-      .click()
-
-    const locateButton = missingNodeCard.getByRole('button', {
-      name: /locate/i
-    })
-    await expect(locateButton.first()).toBeVisible()
-    // TODO: Add navigation assertion once subgraph node ID deduplication
-    // timing is fixed. Currently, collectMissingNodes runs before
-    // configure(), so execution IDs use pre-remapped node IDs that don't
-    // match the runtime graph. See PR #9510 / #8762.
-  })
-})

browser_tests/tests/sidebar/assets.spec.ts

@@ -624,30 +624,21 @@ test.describe('Assets sidebar - pagination', () => {
     await comfyPage.assets.clearMocks()
   })
 
-  test('initial load fetches first batch with offset 0', async ({
+  test('Initially loads a batch of assets with has_more pagination', async ({
     comfyPage
   }) => {
-    const manyJobs = createMockJobs(250)
+    // Create a large set of jobs to trigger pagination
+    const manyJobs = createMockJobs(30)
     await comfyPage.assets.mockOutputHistory(manyJobs)
     await comfyPage.setup()
 
-    // Capture the first history fetch (terminal statuses only).
-    // Queue polling also hits /jobs but with status=in_progress,pending.
-    const firstRequest = comfyPage.page.waitForRequest((req) => {
-      if (!/\/api\/jobs\?/.test(req.url())) return false
-      const url = new URL(req.url())
-      const status = url.searchParams.get('status') ?? ''
-      return status.includes('completed')
-    })
-
     const tab = comfyPage.menu.assetsTab
     await tab.open()
     await tab.waitForAssets()
 
-    const req = await firstRequest
-    const url = new URL(req.url())
-    expect(url.searchParams.get('offset')).toBe('0')
-    expect(Number(url.searchParams.get('limit'))).toBeGreaterThan(0)
+    // Should load at least the first batch
+    const count = await tab.assetCards.count()
+    expect(count).toBeGreaterThanOrEqual(1)
   })
 })
 

browser_tests/tests/sidebar/modelLibrary.spec.ts

@@ -1,244 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-
-const MOCK_FOLDERS: Record<string, string[]> = {
-  checkpoints: [
-    'sd_xl_base_1.0.safetensors',
-    'dreamshaper_8.safetensors',
-    'realisticVision_v51.safetensors'
-  ],
-  loras: ['detail_tweaker_xl.safetensors', 'add_brightness.safetensors'],
-  vae: ['sdxl_vae.safetensors']
-}
-
-// ==========================================================================
-// 1. Tab open/close
-// ==========================================================================
-
-test.describe('Model library sidebar - tab', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS)
-    await comfyPage.setup()
-  })
-
-  test.afterEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.clearMocks()
-  })
-
-  test('Opens model library tab and shows tree', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await expect(tab.modelTree).toBeVisible()
-    await expect(tab.searchInput).toBeVisible()
-  })
-
-  test('Shows refresh and load all folders buttons', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await expect(tab.refreshButton).toBeVisible()
-    await expect(tab.loadAllFoldersButton).toBeVisible()
-  })
-})
-
-// ==========================================================================
-// 2. Folder display
-// ==========================================================================
-
-test.describe('Model library sidebar - folders', () => {
-  // Mocks are set up before setup(), so app.ts's loadModelFolders()
-  // call during initialization hits the mock and populates the store.
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS)
-    await comfyPage.setup()
-  })
-
-  test.afterEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.clearMocks()
-  })
-
-  test('Displays model folders after opening tab', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await expect(tab.getFolderByLabel('checkpoints')).toBeVisible()
-    await expect(tab.getFolderByLabel('loras')).toBeVisible()
-    await expect(tab.getFolderByLabel('vae')).toBeVisible()
-  })
-
-  test('Expanding a folder loads and shows models', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    // Click the folder to expand it
-    await tab.getFolderByLabel('checkpoints').click()
-
-    // Models should appear as leaf nodes
-    await expect(tab.getLeafByLabel('sd_xl_base_1.0')).toBeVisible({
-      timeout: 5000
-    })
-    await expect(tab.getLeafByLabel('dreamshaper_8')).toBeVisible()
-    await expect(tab.getLeafByLabel('realisticVision_v51')).toBeVisible()
-  })
-
-  test('Expanding a different folder shows its models', async ({
-    comfyPage
-  }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await tab.getFolderByLabel('loras').click()
-
-    await expect(tab.getLeafByLabel('detail_tweaker_xl')).toBeVisible({
-      timeout: 5000
-    })
-    await expect(tab.getLeafByLabel('add_brightness')).toBeVisible()
-  })
-})
-
-// ==========================================================================
-// 3. Search
-// ==========================================================================
-
-test.describe('Model library sidebar - search', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS)
-    await comfyPage.setup()
-  })
-
-  test.afterEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.clearMocks()
-  })
-
-  test('Search filters models by filename', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await tab.searchInput.fill('dreamshaper')
-
-    // Wait for debounce (300ms) + load + render
-    await expect(tab.getLeafByLabel('dreamshaper_8')).toBeVisible({
-      timeout: 5000
-    })
-
-    // Other models should not be visible
-    await expect(tab.getLeafByLabel('sd_xl_base_1.0')).not.toBeVisible()
-  })
-
-  test('Clearing search restores folder view', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await tab.searchInput.fill('dreamshaper')
-    await expect(tab.getLeafByLabel('dreamshaper_8')).toBeVisible({
-      timeout: 5000
-    })
-
-    // Clear the search
-    await tab.searchInput.fill('')
-
-    // Folders should be visible again (collapsed)
-    await expect(tab.getFolderByLabel('checkpoints')).toBeVisible({
-      timeout: 5000
-    })
-    await expect(tab.getFolderByLabel('loras')).toBeVisible()
-  })
-
-  test('Search with no matches shows empty tree', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await tab.searchInput.fill('nonexistent_model_xyz')
-
-    // Wait for debounce, then verify no leaf nodes
-    await expect
-      .poll(async () => await tab.leafNodes.count(), { timeout: 5000 })
-      .toBe(0)
-  })
-})
-
-// ==========================================================================
-// 4. Refresh and load all
-// ==========================================================================
-
-test.describe('Model library sidebar - refresh', () => {
-  test.afterEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.clearMocks()
-  })
-
-  test('Refresh button reloads folder list', async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles({
-      checkpoints: ['model_a.safetensors']
-    })
-    await comfyPage.setup()
-
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await expect(tab.getFolderByLabel('checkpoints')).toBeVisible()
-
-    // Update mock to include a new folder
-    await comfyPage.modelLibrary.clearMocks()
-    await comfyPage.modelLibrary.mockFoldersWithFiles({
-      checkpoints: ['model_a.safetensors'],
-      loras: ['lora_b.safetensors']
-    })
-
-    // Wait for the refresh request to complete
-    const refreshRequest = comfyPage.page.waitForRequest(
-      (req) => req.url().endsWith('/experiment/models'),
-      { timeout: 5000 }
-    )
-    await tab.refreshButton.click()
-    await refreshRequest
-
-    await expect(tab.getFolderByLabel('loras')).toBeVisible({ timeout: 5000 })
-  })
-
-  test('Load all folders button triggers loading all model data', async ({
-    comfyPage
-  }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS)
-    await comfyPage.setup()
-
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    // Wait for a per-folder model files request triggered by load all
-    const folderRequest = comfyPage.page.waitForRequest(
-      (req) =>
-        /\/api\/experiment\/models\/[^/]+$/.test(req.url()) &&
-        req.method() === 'GET',
-      { timeout: 5000 }
-    )
-
-    await tab.loadAllFoldersButton.click()
-    await folderRequest
-  })
-})
-
-// ==========================================================================
-// 5. Empty state
-// ==========================================================================
-
-test.describe('Model library sidebar - empty state', () => {
-  test.afterEach(async ({ comfyPage }) => {
-    await comfyPage.modelLibrary.clearMocks()
-  })
-
-  test('Shows empty tree when no model folders exist', async ({
-    comfyPage
-  }) => {
-    await comfyPage.modelLibrary.mockFoldersWithFiles({})
-    await comfyPage.setup()
-
-    const tab = comfyPage.menu.modelLibraryTab
-    await tab.open()
-
-    await expect(tab.modelTree).toBeVisible()
-    expect(await tab.folderNodes.count()).toBe(0)
-    expect(await tab.leafNodes.count()).toBe(0)
-  })
-})

browser_tests/tests/sidebar/nodeLibraryV2.spec.ts

@@ -1,126 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-
-test.describe('Node library sidebar V2', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting('Comfy.NodeLibrary.NewDesign', true)
-
-    const tab = comfyPage.menu.nodeLibraryTabV2
-    await tab.open()
-  })
-
-  test('Can switch between tabs', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await expect(tab.allTab).toHaveAttribute('aria-selected', 'true')
-
-    await tab.blueprintsTab.click()
-    await expect(tab.blueprintsTab).toHaveAttribute('aria-selected', 'true')
-    await expect(tab.allTab).toHaveAttribute('aria-selected', 'false')
-
-    await tab.allTab.click()
-    await expect(tab.allTab).toHaveAttribute('aria-selected', 'true')
-    await expect(tab.blueprintsTab).toHaveAttribute('aria-selected', 'false')
-  })
-
-  test('All tab displays node tree with folders', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await expect(tab.allTab).toHaveAttribute('aria-selected', 'true')
-    await expect(tab.getFolder('sampling')).toBeVisible()
-  })
-
-  test('Can expand folder and see nodes in All tab', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await tab.expandFolder('sampling')
-    await expect(tab.getNode('KSampler (Advanced)')).toBeVisible()
-  })
-
-  test('Search filters nodes in All tab', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await expect(tab.getNode('KSampler (Advanced)')).not.toBeVisible()
-
-    await tab.searchInput.fill('KSampler')
-    await expect(tab.getNode('KSampler (Advanced)')).toBeVisible({
-      timeout: 5000
-    })
-    await expect(tab.getNode('CLIPLoader')).not.toBeVisible()
-  })
-
-  test('Drag node to canvas adds it', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await tab.expandFolder('sampling')
-    await expect(tab.getNode('KSampler (Advanced)')).toBeVisible()
-
-    const initialCount = await comfyPage.nodeOps.getGraphNodesCount()
-
-    const canvasBoundingBox = await comfyPage.page
-      .locator('#graph-canvas')
-      .boundingBox()
-    expect(canvasBoundingBox).not.toBeNull()
-    const targetPosition = {
-      x: canvasBoundingBox!.x + canvasBoundingBox!.width / 2,
-      y: canvasBoundingBox!.y + canvasBoundingBox!.height / 2
-    }
-
-    const nodeLocator = tab.getNode('KSampler (Advanced)')
-    await nodeLocator.dragTo(comfyPage.page.locator('#graph-canvas'), {
-      targetPosition
-    })
-
-    await expect
-      .poll(() => comfyPage.nodeOps.getGraphNodesCount(), { timeout: 5000 })
-      .toBe(initialCount + 1)
-  })
-
-  test('Right-click node shows context menu with bookmark option', async ({
-    comfyPage
-  }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await tab.expandFolder('sampling')
-    const node = tab.getNode('KSampler (Advanced)')
-    await expect(node).toBeVisible()
-
-    await node.click({ button: 'right' })
-
-    const contextMenu = comfyPage.page.getByRole('menuitem', {
-      name: /Bookmark Node/
-    })
-    await expect(contextMenu).toBeVisible({ timeout: 3000 })
-  })
-
-  test('Search clear restores folder view', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await expect(tab.getFolder('sampling')).toBeVisible()
-
-    await tab.searchInput.fill('KSampler')
-    await expect(tab.getNode('KSampler (Advanced)')).toBeVisible({
-      timeout: 5000
-    })
-
-    await tab.searchInput.clear()
-    await tab.searchInput.press('Enter')
-
-    await expect(tab.getFolder('sampling')).toBeVisible({ timeout: 5000 })
-  })
-
-  test('Sort dropdown shows sorting options', async ({ comfyPage }) => {
-    const tab = comfyPage.menu.nodeLibraryTabV2
-
-    await tab.sortButton.click()
-
-    // Reka UI DropdownMenuRadioItem renders with role="menuitemradio"
-    const options = comfyPage.page.getByRole('menuitemradio')
-    await expect(options.first()).toBeVisible({ timeout: 3000 })
-    await expect
-      .poll(() => options.count(), { timeout: 3000 })
-      .toBeGreaterThanOrEqual(2)
-  })
-})

browser_tests/tests/subgraph/subgraphDraftPositions.spec.ts

@@ -0,0 +1,78 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
+
+test.describe(
+  'Subgraph node positions after draft reload',
+  { tag: ['@subgraph'] },
+  () => {
+    test('Node positions are preserved after draft reload with subgraph auto-entry', async ({
+      comfyPage
+    }) => {
+      test.setTimeout(30000)
+
+      // Enable workflow persistence explicitly
+      await comfyPage.settings.setSetting('Comfy.Workflow.Persist', true)
+
+      // Load a workflow containing a subgraph
+      await comfyPage.workflow.loadWorkflow('subgraphs/basic-subgraph')
+
+      // Enter the subgraph programmatically (fixture node is too small for UI click)
+      await comfyPage.page.evaluate(() => {
+        const sg = [...window.app!.rootGraph.subgraphs.values()][0]
+        if (sg) window.app!.canvas.setGraph(sg)
+      })
+      await comfyPage.nextFrame()
+      await expect.poll(() => comfyPage.subgraph.isInSubgraph()).toBe(true)
+
+      const positionsBefore = await comfyPage.page.evaluate(() => {
+        const sg = [...window.app!.rootGraph.subgraphs.values()][0]
+        return sg.nodes.map((n) => ({
+          id: n.id,
+          x: n.pos[0],
+          y: n.pos[1]
+        }))
+      })
+
+      expect(positionsBefore.length).toBeGreaterThan(0)
+
+      // Wait for the debounced draft persistence to flush to localStorage
+      await comfyPage.workflow.waitForDraftPersisted()
+
+      // Reload the page (draft auto-loads with hash preserved)
+      await comfyPage.page.reload({ waitUntil: 'networkidle' })
+      await comfyPage.page.waitForFunction(
+        () => window.app && window.app.extensionManager
+      )
+      await comfyPage.page.waitForSelector('.p-blockui-mask', {
+        state: 'hidden'
+      })
+      await comfyPage.nextFrame()
+
+      // Wait for subgraph auto-entry via hash navigation
+      await expect
+        .poll(() => comfyPage.subgraph.isInSubgraph(), { timeout: 10000 })
+        .toBe(true)
+
+      // Verify all internal node positions are preserved
+      const positionsAfter = await comfyPage.page.evaluate(() => {
+        const sg = [...window.app!.rootGraph.subgraphs.values()][0]
+        return sg.nodes.map((n) => ({
+          id: n.id,
+          x: n.pos[0],
+          y: n.pos[1]
+        }))
+      })
+
+      for (const before of positionsBefore) {
+        const after = positionsAfter.find((n) => n.id === before.id)
+        expect(
+          after,
+          `Node ${before.id} should exist after reload`
+        ).toBeDefined()
+        expect(after!.x).toBeCloseTo(before.x, 0)
+        expect(after!.y).toBeCloseTo(before.y, 0)
+      }
+    })
+  }
+)

browser_tests/tests/topbar/workflowTabs.spec.ts

@@ -1,154 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../../fixtures/ComfyPage'
-
-test.describe('Workflow tabs', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.Workflow.WorkflowTabsPosition',
-      'Topbar'
-    )
-    await comfyPage.setup()
-  })
-
-  test('Default workflow tab is visible on load', async ({ comfyPage }) => {
-    const tabNames = await comfyPage.menu.topbar.getTabNames()
-    expect(tabNames.length).toBe(1)
-    expect(tabNames[0]).toContain('Unsaved Workflow')
-  })
-
-  test('Creating a new workflow adds a tab', async ({ comfyPage }) => {
-    const topbar = comfyPage.menu.topbar
-
-    expect(await topbar.getTabNames()).toHaveLength(1)
-
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-
-    const tabNames = await topbar.getTabNames()
-    expect(tabNames[1]).toContain('Unsaved Workflow (2)')
-  })
-
-  test('Switching tabs changes active workflow', async ({ comfyPage }) => {
-    const topbar = comfyPage.menu.topbar
-
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-
-    const activeNameBefore = await topbar.getActiveTabName()
-    expect(activeNameBefore).toContain('Unsaved Workflow (2)')
-
-    await topbar.getTab(0).click()
-    await expect
-      .poll(() => topbar.getActiveTabName())
-      .toContain('Unsaved Workflow')
-
-    const activeAfter = await topbar.getActiveTabName()
-    expect(activeAfter).not.toContain('(2)')
-  })
-
-  test('Closing a tab removes it', async ({ comfyPage }) => {
-    const topbar = comfyPage.menu.topbar
-
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-
-    await topbar.closeWorkflowTab('Unsaved Workflow (2)')
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(1)
-
-    const remaining = await topbar.getTabNames()
-    expect(remaining[0]).toContain('Unsaved Workflow')
-  })
-
-  test('Right-clicking a tab shows context menu', async ({ comfyPage }) => {
-    const topbar = comfyPage.menu.topbar
-
-    await topbar.getTab(0).click({ button: 'right' })
-
-    // Reka UI ContextMenuContent gets data-state="open" when active
-    const contextMenu = comfyPage.page.locator(
-      '[role="menu"][data-state="open"]'
-    )
-    await expect(contextMenu).toBeVisible({ timeout: 5000 })
-
-    await expect(
-      contextMenu.getByRole('menuitem', { name: /Close Tab/i }).first()
-    ).toBeVisible()
-    await expect(
-      contextMenu.getByRole('menuitem', { name: /Save/i }).first()
-    ).toBeVisible()
-  })
-
-  test('Context menu Close Tab action removes the tab', async ({
-    comfyPage
-  }) => {
-    const topbar = comfyPage.menu.topbar
-
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-
-    await topbar.getTab(1).click({ button: 'right' })
-    const contextMenu = comfyPage.page.locator(
-      '[role="menu"][data-state="open"]'
-    )
-    await expect(contextMenu).toBeVisible({ timeout: 5000 })
-
-    await contextMenu
-      .getByRole('menuitem', { name: /Close Tab/i })
-      .first()
-      .click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(1)
-  })
-
-  test('Closing the last tab creates a new default workflow', async ({
-    comfyPage
-  }) => {
-    const topbar = comfyPage.menu.topbar
-
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(1)
-
-    await topbar.closeWorkflowTab('Unsaved Workflow')
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(1)
-
-    const tabNames = await topbar.getTabNames()
-    expect(tabNames[0]).toContain('Unsaved Workflow')
-  })
-
-  test('Modified workflow shows unsaved indicator', async ({ comfyPage }) => {
-    const topbar = comfyPage.menu.topbar
-
-    // Modify the graph via litegraph API to trigger unsaved state
-    await comfyPage.page.evaluate(() => {
-      const graph = window.app?.graph
-      const node = window.LiteGraph?.createNode('Note')
-      if (graph && node) graph.add(node)
-    })
-
-    // WorkflowTab renders "•" when the workflow has unsaved changes
-    const activeTab = topbar.getActiveTab()
-    await expect(activeTab.locator('text=•')).toBeVisible({ timeout: 5000 })
-  })
-
-  test('Multiple tabs can be created, switched, and closed', async ({
-    comfyPage
-  }) => {
-    const topbar = comfyPage.menu.topbar
-
-    // Create 2 additional tabs (3 total)
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-    await topbar.newWorkflowButton.click()
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(3)
-
-    // Switch to first tab
-    await topbar.getTab(0).click()
-    await expect
-      .poll(() => topbar.getActiveTabName())
-      .toContain('Unsaved Workflow')
-
-    // Close the middle tab
-    await topbar.closeWorkflowTab('Unsaved Workflow (2)')
-    await expect.poll(() => topbar.getTabNames()).toHaveLength(2)
-  })
-})

browser_tests/tests/vueNodes/interactions/node/contextMenu.spec.ts

@@ -5,9 +5,9 @@ import {
   comfyPageFixture as test
 } from '../../../../fixtures/ComfyPage'
 import type { ComfyPage } from '../../../../fixtures/ComfyPage'
-import { TestIds } from '../../../../fixtures/selectors'
 
 const BYPASS_CLASS = /before:bg-bypass\/60/
+const PIN_INDICATOR = '[data-testid="node-pin-indicator"]'
 
 async function clickExactMenuItem(comfyPage: ComfyPage, name: string) {
   await comfyPage.page.getByRole('menuitem', { name, exact: true }).click()
@@ -15,10 +15,12 @@ async function clickExactMenuItem(comfyPage: ComfyPage, name: string) {
 }
 
 async function openContextMenu(comfyPage: ComfyPage, nodeTitle: string) {
-  const fixture = await comfyPage.vueNodes.getFixtureByTitle(nodeTitle)
-  await fixture.header.click()
-  await fixture.header.click({ button: 'right' })
-  const menu = comfyPage.contextMenu.primeVueMenu
+  const header = comfyPage.vueNodes
+    .getNodeByTitle(nodeTitle)
+    .locator('.lg-node-header')
+  await header.click()
+  await header.click({ button: 'right' })
+  const menu = comfyPage.page.locator('.p-contextmenu')
   await menu.waitFor({ state: 'visible' })
   return menu
 }
@@ -33,13 +35,17 @@ async function openMultiNodeContextMenu(
   await comfyPage.nextFrame()
 
   for (const title of titles) {
-    const fixture = await comfyPage.vueNodes.getFixtureByTitle(title)
-    await fixture.header.click({ modifiers: ['ControlOrMeta'] })
+    const header = comfyPage.vueNodes
+      .getNodeByTitle(title)
+      .locator('.lg-node-header')
+    await header.click({ modifiers: ['ControlOrMeta'] })
   }
   await comfyPage.nextFrame()
 
-  const firstFixture = await comfyPage.vueNodes.getFixtureByTitle(titles[0])
-  const box = await firstFixture.header.boundingBox()
+  const firstHeader = comfyPage.vueNodes
+    .getNodeByTitle(titles[0])
+    .locator('.lg-node-header')
+  const box = await firstHeader.boundingBox()
   if (!box) throw new Error(`Header for "${titles[0]}" not found`)
   await comfyPage.page.mouse.click(
     box.x + box.width / 2,
@@ -47,15 +53,16 @@ async function openMultiNodeContextMenu(
     { button: 'right' }
   )
 
-  const menu = comfyPage.contextMenu.primeVueMenu
+  const menu = comfyPage.page.locator('.p-contextmenu')
   await menu.waitFor({ state: 'visible' })
   return menu
 }
 
 function getNodeWrapper(comfyPage: ComfyPage, nodeTitle: string): Locator {
-  return comfyPage.vueNodes
-    .getNodeByTitle(nodeTitle)
-    .getByTestId(TestIds.node.innerWrapper)
+  return comfyPage.page
+    .locator('[data-node-id]')
+    .filter({ hasText: nodeTitle })
+    .getByTestId('node-inner-wrapper')
 }
 
 async function getNodeRef(comfyPage: ComfyPage, nodeTitle: string) {
@@ -75,7 +82,9 @@ test.describe('Vue Node Context Menu', () => {
       await openContextMenu(comfyPage, 'KSampler')
       await clickExactMenuItem(comfyPage, 'Rename')
 
-      const titleInput = comfyPage.page.getByTestId(TestIds.node.titleInput)
+      const titleInput = comfyPage.page.locator(
+        '.node-title-editor input[type="text"]'
+      )
       await titleInput.waitFor({ state: 'visible' })
       await titleInput.fill('My Renamed Sampler')
       await titleInput.press('Enter')
@@ -126,12 +135,16 @@ test.describe('Vue Node Context Menu', () => {
       await openContextMenu(comfyPage, nodeTitle)
       await clickExactMenuItem(comfyPage, 'Pin')
 
-      const fixture = await comfyPage.vueNodes.getFixtureByTitle(nodeTitle)
-      await expect(fixture.pinIndicator).toBeVisible()
+      const pinIndicator = comfyPage.vueNodes
+        .getNodeByTitle(nodeTitle)
+        .locator(PIN_INDICATOR)
+      await expect(pinIndicator).toBeVisible()
       expect(await nodeRef.isPinned()).toBe(true)
 
       // Verify drag blocked
-      const header = fixture.header
+      const header = comfyPage.vueNodes
+        .getNodeByTitle(nodeTitle)
+        .locator('.lg-node-header')
       const posBeforeDrag = await header.boundingBox()
       if (!posBeforeDrag) throw new Error('Header not found')
       await comfyPage.canvasOps.dragAndDrop(
@@ -145,7 +158,7 @@ test.describe('Vue Node Context Menu', () => {
       await openContextMenu(comfyPage, nodeTitle)
       await clickExactMenuItem(comfyPage, 'Unpin')
 
-      await expect(fixture.pinIndicator).not.toBeVisible()
+      await expect(pinIndicator).not.toBeVisible()
       expect(await nodeRef.isPinned()).toBe(false)
     })
 
@@ -231,9 +244,7 @@ test.describe('Vue Node Context Menu', () => {
       comfyPage
     }) => {
       // Capture the original image src from the node's preview
-      const imagePreview = comfyPage.vueNodes
-        .getNodeByTitle('Load Image')
-        .getByTestId(TestIds.node.mainImage)
+      const imagePreview = comfyPage.page.locator('.image-preview img')
       const originalSrc = await imagePreview.getAttribute('src')
 
       // Write a test image into the browser clipboard
@@ -336,7 +347,8 @@ test.describe('Vue Node Context Menu', () => {
       await comfyPage.nodeOps.fillPromptDialog('TestBlueprint')
 
       // Open node library sidebar and search for the blueprint
-      await comfyPage.menu.nodeLibraryTab.tabButton.click()
+      await comfyPage.page.getByRole('button', { name: 'Node Library' }).click()
+      await comfyPage.nextFrame()
       const searchBox = comfyPage.page.getByRole('combobox', {
         name: 'Search'
       })
@@ -402,16 +414,20 @@ test.describe('Vue Node Context Menu', () => {
       await clickExactMenuItem(comfyPage, 'Pin')
 
       for (const title of nodeTitles) {
-        const fixture = await comfyPage.vueNodes.getFixtureByTitle(title)
-        await expect(fixture.pinIndicator).toBeVisible()
+        const pinIndicator = comfyPage.vueNodes
+          .getNodeByTitle(title)
+          .locator(PIN_INDICATOR)
+        await expect(pinIndicator).toBeVisible()
       }
 
       await openMultiNodeContextMenu(comfyPage, nodeTitles)
       await clickExactMenuItem(comfyPage, 'Unpin')
 
       for (const title of nodeTitles) {
-        const fixture = await comfyPage.vueNodes.getFixtureByTitle(title)
-        await expect(fixture.pinIndicator).not.toBeVisible()
+        const pinIndicator = comfyPage.vueNodes
+          .getNodeByTitle(title)
+          .locator(PIN_INDICATOR)
+        await expect(pinIndicator).not.toBeVisible()
       }
     })
 

src/components/dialog/content/ErrorDialogContent.vue

@@ -1,8 +1,5 @@
 <template>
-  <div
-    data-testid="error-dialog"
-    class="comfy-error-report flex flex-col gap-4"
-  >
+  <div class="comfy-error-report flex flex-col gap-4">
     <NoResultsPlaceholder
       class="pb-0"
       icon="pi pi-exclamation-circle"
@@ -17,17 +14,11 @@
     </template>
 
     <div class="flex justify-center gap-2">
-      <Button
-        v-show="!reportOpen"
-        data-testid="error-dialog-show-report"
-        variant="textonly"
-        @click="showReport"
-      >
+      <Button v-show="!reportOpen" variant="textonly" @click="showReport">
         {{ $t('g.showReport') }}
       </Button>
       <Button
         v-show="!reportOpen"
-        data-testid="error-dialog-contact-support"
         variant="textonly"
         @click="showContactSupport"
       >
@@ -49,11 +40,7 @@
         :repo-owner="repoOwner"
         :repo-name="repoName"
       />
-      <Button
-        v-if="reportOpen"
-        data-testid="error-dialog-copy-report"
-        @click="copyReportToClipboard"
-      >
+      <Button v-if="reportOpen" @click="copyReportToClipboard">
         <i class="pi pi-copy" />
         {{ $t('g.copyToClipboard') }}
       </Button>

src/components/dialog/content/error/FindIssueButton.vue

@@ -1,9 +1,5 @@
 <template>
-  <Button
-    data-testid="error-dialog-find-issues"
-    variant="secondary"
-    @click="openGitHubIssues"
-  >
+  <Button variant="secondary" @click="openGitHubIssues">
     <i class="pi pi-github" />
     {{ $t('g.findIssues') }}
   </Button>

src/components/graph/TitleEditor.vue

@@ -7,7 +7,6 @@
     <EditableText
       :is-editing="showInput"
       :model-value="editedTitle"
-      :input-attrs="{ 'data-testid': 'node-title-input' }"
       @edit="onEdit"
     />
   </div>

src/platform/missingModel/components/MissingModelCard.vue

@@ -38,7 +38,6 @@
       <!-- Asset unsupported group notice -->
       <div
         v-if="isCloud && !group.isAssetSupported"
-        data-testid="missing-model-import-unsupported"
         class="flex items-start gap-1.5 px-0.5 py-1 pl-2"
       >
         <i

src/platform/missingModel/components/MissingModelRow.vue

@@ -16,7 +16,6 @@
         </p>
 
         <Button
-          data-testid="missing-model-copy-name"
           variant="textonly"
           size="icon-sm"
           class="size-8 shrink-0 hover:bg-transparent"
@@ -33,7 +32,6 @@
 
       <Button
         v-if="!isCloud && model.representative.url && !isAssetSupported"
-        data-testid="missing-model-copy-url"
         variant="secondary"
         size="sm"
         class="h-8 shrink-0 rounded-lg text-sm"
@@ -64,7 +62,6 @@
 
       <Button
         v-if="model.referencingNodes.length > 0"
-        data-testid="missing-model-expand"
         variant="textonly"
         size="icon-sm"
         :aria-label="
@@ -109,7 +106,6 @@
             {{ getNodeDisplayLabel(ref.nodeId, model.representative.nodeType) }}
           </p>
           <Button
-            data-testid="missing-model-locate"
             variant="textonly"
             size="icon-sm"
             :aria-label="t('rightSidePanel.missingModels.locateNode')"
@@ -152,7 +148,6 @@
           class="flex w-full items-start py-1"
         >
           <Button
-            data-testid="missing-model-download"
             variant="secondary"
             size="md"
             class="flex w-full flex-1"

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

@@ -181,7 +181,9 @@ describe('useVueNodeResizeTracking', () => {
 
     resizeObserverState.callback?.([entry], createObserverMock())
 
-    expect(rectSpy).toHaveBeenCalledTimes(1)
+    // When layout store already has correct position, getBoundingClientRect
+    // is not needed — position is read from the store instead.
+    expect(rectSpy).not.toHaveBeenCalled()
     expect(testState.setSource).not.toHaveBeenCalled()
     expect(testState.batchUpdateNodeBounds).not.toHaveBeenCalled()
     expect(testState.syncNodeSlotLayoutsFromDOM).not.toHaveBeenCalled()
@@ -192,13 +194,13 @@ describe('useVueNodeResizeTracking', () => {
 
     resizeObserverState.callback?.([entry], createObserverMock())
 
-    expect(rectSpy).toHaveBeenCalledTimes(1)
+    expect(rectSpy).not.toHaveBeenCalled()
     expect(testState.setSource).not.toHaveBeenCalled()
     expect(testState.batchUpdateNodeBounds).not.toHaveBeenCalled()
     expect(testState.syncNodeSlotLayoutsFromDOM).not.toHaveBeenCalled()
   })
 
-  it('updates bounds on first observation when size matches but position differs', () => {
+  it('preserves layout store position when size matches but DOM position differs', () => {
     const nodeId = 'test-node'
     const width = 240
     const height = 180
@@ -209,7 +211,6 @@ describe('useVueNodeResizeTracking', () => {
       left: 100,
       top: 200
     })
-    const titleHeight = LiteGraph.NODE_TITLE_HEIGHT
 
     seedNodeLayout({
       nodeId,
@@ -221,20 +222,10 @@ describe('useVueNodeResizeTracking', () => {
 
     resizeObserverState.callback?.([entry], createObserverMock())
 
-    expect(rectSpy).toHaveBeenCalledTimes(1)
-    expect(testState.setSource).toHaveBeenCalledWith(LayoutSource.DOM)
-    expect(testState.batchUpdateNodeBounds).toHaveBeenCalledWith([
-      {
-        nodeId,
-        bounds: {
-          x: 100,
-          y: 200 + titleHeight,
-          width,
-          height
-        }
-      }
-    ])
-    expect(testState.syncNodeSlotLayoutsFromDOM).toHaveBeenCalledWith(nodeId)
+    // Position from DOM should NOT override layout store position
+    expect(rectSpy).not.toHaveBeenCalled()
+    expect(testState.setSource).not.toHaveBeenCalled()
+    expect(testState.batchUpdateNodeBounds).not.toHaveBeenCalled()
   })
 
   it('updates node bounds + slot layouts when size changes', () => {

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

@@ -186,13 +186,26 @@ const resizeObserver = new ResizeObserver((entries) => {
       continue
     }
 
-    // Screen-space rect
-    const rect = element.getBoundingClientRect()
-    const [cx, cy] = conv.clientPosToCanvasPos([rect.left, rect.top])
-    const topLeftCanvas = { x: cx, y: cy }
+    // Use existing position from layout store (source of truth) rather than
+    // converting screen-space getBoundingClientRect() back to canvas coords.
+    // The DOM→canvas conversion depends on the current canvas scale/offset,
+    // which can be stale during graph transitions (e.g. entering a subgraph
+    // before fitView runs), producing corrupted positions.
+    const existingPos = nodeLayout?.position
+    let posX: number
+    let posY: number
+    if (existingPos) {
+      posX = existingPos.x
+      posY = existingPos.y
+    } else {
+      const rect = element.getBoundingClientRect()
+      const [cx, cy] = conv.clientPosToCanvasPos([rect.left, rect.top])
+      posX = cx
+      posY = cy + LiteGraph.NODE_TITLE_HEIGHT
+    }
     const bounds: Bounds = {
-      x: topLeftCanvas.x,
-      y: topLeftCanvas.y + LiteGraph.NODE_TITLE_HEIGHT,
+      x: posX,
+      y: posY,
       width,
       height
     }