fix: restore dragged-node1 screenshot (CI timing fluke)

- Clear collapsedSizes in initializeFromLiteGraph to prevent stale
  entries from previous workflows
- Merge collapsedSize in customRef getter instead of setter to ensure
  persistence across reads
- Use trigger() instead of nodeRef.value assignment in
  updateNodeCollapsedSize

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_media_multiple.json

@@ -1,68 +0,0 @@
-{
-  "last_node_id": 12,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 10,
-      "type": "LoadImage",
-      "pos": [50, 50],
-      "size": [315, 314],
-      "flags": {},
-      "order": 0,
-      "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_aaa.png", "image"]
-    },
-    {
-      "id": 11,
-      "type": "LoadImage",
-      "pos": [450, 50],
-      "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_bbb.png", "image"]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": {
-      "offset": [0, 0],
-      "scale": 1
-    }
-  },
-  "version": 0.4
-}

browser_tests/assets/missing/missing_media_single.json

@@ -1,42 +0,0 @@
-{
-  "last_node_id": 10,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 10,
-      "type": "LoadImage",
-      "pos": [50, 50],
-      "size": [315, 314],
-      "flags": {},
-      "order": 0,
-      "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/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/assets/selection/subgraph-with-regular-node.json

@@ -0,0 +1,116 @@
+{
+  "id": "selection-bbox-test",
+  "revision": 0,
+  "last_node_id": 3,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 2,
+      "type": "e5fb1765-9323-4548-801a-5aead34d879e",
+      "pos": [300, 200],
+      "size": [400, 200],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [1]
+        }
+      ],
+      "properties": {},
+      "widgets_values": []
+    },
+    {
+      "id": 3,
+      "type": "EmptyLatentImage",
+      "pos": [800, 200],
+      "size": [400, 200],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": null
+        }
+      ],
+      "properties": {},
+      "widgets_values": [512, 512, 1]
+    }
+  ],
+  "links": [[1, 2, 0, 3, 0, "LATENT"]],
+  "groups": [],
+  "definitions": {
+    "subgraphs": [
+      {
+        "id": "e5fb1765-9323-4548-801a-5aead34d879e",
+        "version": 1,
+        "state": {
+          "lastGroupId": 0,
+          "lastNodeId": 1,
+          "lastLinkId": 0,
+          "lastRerouteId": 0
+        },
+        "revision": 0,
+        "config": {},
+        "name": "Test Subgraph",
+        "inputNode": {
+          "id": -10,
+          "bounding": [100, 200, 120, 60]
+        },
+        "outputNode": {
+          "id": -20,
+          "bounding": [500, 200, 120, 60]
+        },
+        "inputs": [
+          {
+            "id": "c5cc99d8-a2b6-4bf3-8be7-d4949ef736cd",
+            "name": "positive",
+            "type": "CONDITIONING",
+            "linkIds": [],
+            "pos": { "0": 200, "1": 220 }
+          }
+        ],
+        "outputs": [
+          {
+            "id": "9bd488b9-e907-4c95-a7a4-85c5597a87af",
+            "name": "LATENT",
+            "type": "LATENT",
+            "linkIds": [],
+            "pos": { "0": 520, "1": 220 }
+          }
+        ],
+        "widgets": [],
+        "nodes": [],
+        "groups": [],
+        "links": [],
+        "extra": {}
+      }
+    ]
+  },
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 1,
+      "offset": [0, 0]
+    }
+  },
+  "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,9 +31,9 @@ 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 { QueueHelper } from '@e2e/fixtures/helpers/QueueHelper'
 import { SettingsHelper } from '@e2e/fixtures/helpers/SettingsHelper'
 import { SubgraphHelper } from '@e2e/fixtures/helpers/SubgraphHelper'
 import { ToastHelper } from '@e2e/fixtures/helpers/ToastHelper'
@@ -58,9 +56,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 +74,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 +200,7 @@ export class ComfyPage {
   public readonly queuePanel: QueuePanel
   public readonly perf: PerformanceHelper
   public readonly assets: AssetsHelper
-  public readonly modelLibrary: ModelLibraryHelper
+  public readonly queue: QueueHelper
 
   /** Worker index to test user ID */
   public readonly userIds: string[] = []
@@ -262,7 +248,7 @@ export class ComfyPage {
     this.queuePanel = new QueuePanel(page)
     this.perf = new PerformanceHelper(page)
     this.assets = new AssetsHelper(page)
-    this.modelLibrary = new ModelLibraryHelper(page)
+    this.queue = new QueueHelper(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/BuilderFooterHelper.ts

@@ -30,10 +30,6 @@ export class BuilderFooterHelper {
     return this.page.getByTestId(TestIds.builder.saveButton)
   }
 
-  get saveGroup(): Locator {
-    return this.page.getByTestId(TestIds.builder.saveGroup)
-  }
-
   get saveAsButton(): Locator {
     return this.page.getByTestId(TestIds.builder.saveAsButton)
   }

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/NodeOperationsHelper.ts

@@ -4,7 +4,10 @@ import type {
   LGraph,
   LGraphNode
 } from '../../../src/lib/litegraph/src/litegraph'
-import type { NodeId } from '../../../src/platform/workflow/validation/schemas/workflowSchema'
+import type {
+  ComfyWorkflowJSON,
+  NodeId
+} from '../../../src/platform/workflow/validation/schemas/workflowSchema'
 import type { ComfyPage } from '../ComfyPage'
 import { DefaultGraphPositions } from '../constants/defaultGraphPositions'
 import type { Position, Size } from '../types'
@@ -111,6 +114,27 @@ export class NodeOperationsHelper {
     }
   }
 
+  async getSerializedGraph(): Promise<ComfyWorkflowJSON> {
+    return this.page.evaluate(
+      () => window.app!.graph.serialize() as ComfyWorkflowJSON
+    )
+  }
+
+  async loadGraph(data: ComfyWorkflowJSON): Promise<void> {
+    await this.page.evaluate(
+      (d) => window.app!.loadGraphData(d, true, true, null),
+      data
+    )
+  }
+
+  async repositionNodes(
+    positions: Record<string, [number, number]>
+  ): Promise<void> {
+    const data = await this.getSerializedGraph()
+    applyNodePositions(data, positions)
+    await this.loadGraph(data)
+  }
+
   async resizeNode(
     nodePos: Position,
     nodeSize: Size,
@@ -185,3 +209,13 @@ export class NodeOperationsHelper {
     await this.comfyPage.nextFrame()
   }
 }
+
+function applyNodePositions(
+  data: ComfyWorkflowJSON,
+  positions: Record<string, [number, number]>
+): void {
+  for (const node of data.nodes) {
+    const pos = positions[String(node.id)]
+    if (pos) node.pos = pos
+  }
+}

browser_tests/fixtures/helpers/QueueHelper.ts

@@ -0,0 +1,79 @@
+import type { Page, Route } from '@playwright/test'
+
+export class QueueHelper {
+  private queueRouteHandler: ((route: Route) => void) | null = null
+  private historyRouteHandler: ((route: Route) => void) | null = null
+
+  constructor(private readonly page: Page) {}
+
+  /**
+   * Mock the /api/queue endpoint to return specific queue state.
+   */
+  async mockQueueState(
+    running: number = 0,
+    pending: number = 0
+  ): Promise<void> {
+    this.queueRouteHandler = (route: Route) =>
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({
+          queue_running: Array.from({ length: running }, (_, i) => [
+            i,
+            `running-${i}`,
+            {},
+            {},
+            []
+          ]),
+          queue_pending: Array.from({ length: pending }, (_, i) => [
+            i,
+            `pending-${i}`,
+            {},
+            {},
+            []
+          ])
+        })
+      })
+    await this.page.route('**/api/queue', this.queueRouteHandler)
+  }
+
+  /**
+   * Mock the /api/history endpoint with completed/failed job entries.
+   */
+  async mockHistory(
+    jobs: Array<{ promptId: string; status: 'success' | 'error' }>
+  ): Promise<void> {
+    const history: Record<string, unknown> = {}
+    for (const job of jobs) {
+      history[job.promptId] = {
+        prompt: [0, job.promptId, {}, {}, []],
+        outputs: {},
+        status: {
+          status_str: job.status === 'success' ? 'success' : 'error',
+          completed: true
+        }
+      }
+    }
+    this.historyRouteHandler = (route: Route) =>
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(history)
+      })
+    await this.page.route('**/api/history**', this.historyRouteHandler)
+  }
+
+  /**
+   * Clear all route mocks set by this helper.
+   */
+  async clearMocks(): Promise<void> {
+    if (this.queueRouteHandler) {
+      await this.page.unroute('**/api/queue', this.queueRouteHandler)
+      this.queueRouteHandler = null
+    }
+    if (this.historyRouteHandler) {
+      await this.page.unroute('**/api/history**', this.historyRouteHandler)
+      this.historyRouteHandler = null
+    }
+  }
+}

browser_tests/fixtures/helpers/boundsUtils.ts

@@ -0,0 +1,112 @@
+import type { Page } from '@playwright/test'
+
+export interface CanvasRect {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+export interface MeasureResult {
+  selectionBounds: CanvasRect | null
+  nodeVisualBounds: Record<string, CanvasRect>
+}
+
+// Must match createBounds(selectedItems, 10) in src/extensions/core/selectionBorder.ts:19
+const SELECTION_PADDING = 10
+
+export async function measureSelectionBounds(
+  page: Page,
+  nodeIds: string[]
+): Promise<MeasureResult> {
+  return page.evaluate(
+    ({ ids, padding }) => {
+      const canvas = window.app!.canvas
+      const ds = canvas.ds
+
+      const selectedItems = canvas.selectedItems
+      let minX = Infinity
+      let minY = Infinity
+      let maxX = -Infinity
+      let maxY = -Infinity
+      for (const item of selectedItems) {
+        const rect = item.boundingRect
+        // For collapsed nodes, use DOM element size (matches selectionBorder.ts
+        // which reads layoutStore.collapsedSize in Vue mode)
+        const id = 'id' in item ? String(item.id) : null
+        const isCollapsed =
+          'flags' in item &&
+          !!(item as { flags?: { collapsed?: boolean } }).flags?.collapsed
+        const el =
+          id && isCollapsed
+            ? document.querySelector(`[data-node-id="${id}"]`)
+            : null
+        const w = el instanceof HTMLElement ? el.offsetWidth : rect[2]
+        const h = el instanceof HTMLElement ? el.offsetHeight : rect[3]
+
+        minX = Math.min(minX, rect[0])
+        minY = Math.min(minY, rect[1])
+        maxX = Math.max(maxX, rect[0] + w)
+        maxY = Math.max(maxY, rect[1] + h)
+      }
+      const selectionBounds =
+        selectedItems.size > 0
+          ? {
+              x: minX - padding,
+              y: minY - padding,
+              w: maxX - minX + 2 * padding,
+              h: maxY - minY + 2 * padding
+            }
+          : null
+
+      const canvasEl = canvas.canvas as HTMLCanvasElement
+      const canvasRect = canvasEl.getBoundingClientRect()
+      const nodeVisualBounds: Record<
+        string,
+        { x: number; y: number; w: number; h: number }
+      > = {}
+
+      for (const id of ids) {
+        const nodeEl = document.querySelector(
+          `[data-node-id="${id}"]`
+        ) as HTMLElement | null
+
+        // Legacy mode: no Vue DOM element, use boundingRect directly
+        if (!nodeEl) {
+          const node = window.app!.graph._nodes.find(
+            (n: { id: number | string }) => String(n.id) === id
+          )
+          if (node) {
+            const rect = node.boundingRect
+            nodeVisualBounds[id] = {
+              x: rect[0],
+              y: rect[1],
+              w: rect[2],
+              h: rect[3]
+            }
+          }
+          continue
+        }
+
+        const domRect = nodeEl.getBoundingClientRect()
+        const footerEls = nodeEl.querySelectorAll(
+          '[data-testid="subgraph-enter-button"], [data-testid="node-footer"]'
+        )
+        let bottom = domRect.bottom
+        for (const footerEl of footerEls) {
+          bottom = Math.max(bottom, footerEl.getBoundingClientRect().bottom)
+        }
+
+        nodeVisualBounds[id] = {
+          x: (domRect.left - canvasRect.left) / ds.scale - ds.offset[0],
+          y: (domRect.top - canvasRect.top) / ds.scale - ds.offset[1],
+          w: domRect.width / ds.scale,
+          h: (bottom - domRect.top) / ds.scale
+        }
+      }
+
+      return { selectionBounds, nodeVisualBounds }
+    },
+    { ids: nodeIds, padding: SELECTION_PADDING }
+  ) as Promise<MeasureResult>
+}

browser_tests/fixtures/selectors.ts

@@ -41,29 +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',
-    missingMediaLibrarySelect: 'missing-media-library-select',
-    missingMediaStatusCard: 'missing-media-status-card',
-    missingMediaConfirmButton: 'missing-media-confirm-button',
-    missingMediaCancelButton: 'missing-media-cancel-button',
-    missingMediaLocateButton: 'missing-media-locate-button'
+    missingModelsGroup: 'error-group-missing-model'
   },
   keybindings: {
     presetMenu: 'keybinding-preset-menu'
@@ -80,21 +61,8 @@ export const TestIds = {
   propertiesPanel: {
     root: 'properties-panel'
   },
-  subgraphEditor: {
-    toggle: 'subgraph-editor-toggle',
-    shownSection: 'subgraph-editor-shown-section',
-    hiddenSection: 'subgraph-editor-hidden-section',
-    widgetToggle: 'subgraph-widget-toggle',
-    widgetLabel: 'subgraph-widget-label',
-    iconLink: 'icon-link',
-    iconEye: 'icon-eye',
-    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',
@@ -102,9 +70,6 @@ export const TestIds = {
     colorBlue: 'blue',
     colorRed: 'red'
   },
-  menu: {
-    moreMenuContent: 'more-menu-content'
-  },
   widgets: {
     container: 'node-widgets',
     widget: 'node-widget',
@@ -117,7 +82,6 @@ export const TestIds = {
     footerNav: 'builder-footer-nav',
     saveButton: 'builder-save-button',
     saveAsButton: 'builder-save-as-button',
-    saveGroup: 'builder-save-group',
     saveAsChevron: 'builder-save-as-chevron',
     ioItem: 'builder-io-item',
     ioItemTitle: 'builder-io-item-title',
@@ -166,7 +130,5 @@ export type TestIdValue =
       (id: string) => string
     >
   | (typeof TestIds.user)[keyof typeof TestIds.user]
-  | (typeof TestIds.menu)[keyof typeof TestIds.menu]
-  | (typeof TestIds.subgraphEditor)[keyof typeof TestIds.subgraphEditor]
   | (typeof TestIds.queue)[keyof typeof TestIds.queue]
   | (typeof TestIds.errors)[keyof typeof TestIds.errors]

browser_tests/fixtures/utils/litegraphUtils.ts

@@ -332,6 +332,18 @@ export class NodeReference {
   async isCollapsed() {
     return !!(await this.getFlags()).collapsed
   }
+  /** Deterministic setter using node.collapse() API (not a toggle). */
+  async setCollapsed(collapsed: boolean) {
+    await this.comfyPage.page.evaluate(
+      ([id, collapsed]) => {
+        const node = window.app!.canvas.graph!.getNodeById(id)
+        if (!node) throw new Error('Node not found')
+        if (node.collapsed !== collapsed) node.collapse(true)
+      },
+      [this.id, collapsed] as const
+    )
+    await this.comfyPage.nextFrame()
+  }
   async isBypassed() {
     return (await this.getProperty<number | null | undefined>('mode')) === 4
   }

browser_tests/fixtures/utils/slotBoundsUtil.ts

@@ -1,98 +0,0 @@
-import { expect } from '@playwright/test'
-import type { Page } from '@playwright/test'
-
-export interface SlotMeasurement {
-  key: string
-  offsetX: number
-  offsetY: number
-}
-
-export interface NodeSlotData {
-  nodeId: string
-  nodeW: number
-  nodeH: number
-  slots: SlotMeasurement[]
-}
-
-/**
- * Collect slot center offsets relative to the parent node element.
- * Returns `null` when the node element is not found.
- */
-export async function measureNodeSlotOffsets(
-  page: Page,
-  nodeId: string
-): Promise<NodeSlotData | null> {
-  return page.evaluate((id) => {
-    const nodeEl = document.querySelector(`[data-node-id="${id}"]`)
-    if (!nodeEl || !(nodeEl instanceof HTMLElement)) return null
-
-    const nodeRect = nodeEl.getBoundingClientRect()
-    const slotEls = nodeEl.querySelectorAll('[data-slot-key]')
-    const slots: SlotMeasurement[] = []
-
-    for (const slotEl of slotEls) {
-      const slotRect = slotEl.getBoundingClientRect()
-      slots.push({
-        key: (slotEl as HTMLElement).dataset.slotKey ?? 'unknown',
-        offsetX: slotRect.left + slotRect.width / 2 - nodeRect.left,
-        offsetY: slotRect.top + slotRect.height / 2 - nodeRect.top
-      })
-    }
-
-    return {
-      nodeId: id,
-      nodeW: nodeRect.width,
-      nodeH: nodeRect.height,
-      slots
-    }
-  }, nodeId)
-}
-
-/**
- * Assert that every slot falls within the node dimensions (± `margin` px).
- */
-export function expectSlotsWithinBounds(
-  data: NodeSlotData,
-  margin: number,
-  label?: string
-) {
-  const prefix = label ? `${label}: ` : ''
-
-  for (const slot of data.slots) {
-    expect(
-      slot.offsetX,
-      `${prefix}Slot ${slot.key} X=${slot.offsetX} outside width=${data.nodeW}`
-    ).toBeGreaterThanOrEqual(-margin)
-    expect(
-      slot.offsetX,
-      `${prefix}Slot ${slot.key} X=${slot.offsetX} outside width=${data.nodeW}`
-    ).toBeLessThanOrEqual(data.nodeW + margin)
-
-    expect(
-      slot.offsetY,
-      `${prefix}Slot ${slot.key} Y=${slot.offsetY} outside height=${data.nodeH}`
-    ).toBeGreaterThanOrEqual(-margin)
-    expect(
-      slot.offsetY,
-      `${prefix}Slot ${slot.key} Y=${slot.offsetY} outside height=${data.nodeH}`
-    ).toBeLessThanOrEqual(data.nodeH + margin)
-  }
-}
-
-/**
- * Wait for slots, measure, and assert within bounds — single-node convenience.
- */
-export async function assertNodeSlotsWithinBounds(
-  page: Page,
-  nodeId: string,
-  margin: number = 20
-) {
-  await page
-    .locator(`[data-node-id="${nodeId}"] [data-slot-key]`)
-    .first()
-    .waitFor()
-
-  const data = await measureNodeSlotOffsets(page, nodeId)
-  expect(data, `Node ${nodeId} not found in DOM`).not.toBeNull()
-  expectSlotsWithinBounds(data!, margin, `Node ${nodeId}`)
-}

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/builderSaveFlow.spec.ts

@@ -189,41 +189,6 @@ test.describe('Builder save flow', { tag: ['@ui'] }, () => {
     await expect(saveAs.nameInput).toBeVisible()
   })
 
-  test('Save button width is consistent across all states', async ({
-    comfyPage
-  }) => {
-    const { appMode } = comfyPage
-    await comfyPage.workflow.loadWorkflow('default')
-    await fitToViewInstant(comfyPage)
-    await appMode.enterBuilder()
-
-    // State 1: Disabled "Save as" (no outputs selected)
-    const disabledBox = await appMode.footer.saveAsButton.boundingBox()
-    expect(disabledBox).toBeTruthy()
-
-    // Select I/O to enable the button
-    await appMode.steps.goToInputs()
-    const ksampler = await comfyPage.nodeOps.getNodeRefById('3')
-    await appMode.select.selectInputWidget(ksampler)
-    await appMode.steps.goToOutputs()
-    await appMode.select.selectOutputNode()
-
-    // State 2: Enabled "Save as" (unsaved, has outputs)
-    const enabledBox = await appMode.footer.saveAsButton.boundingBox()
-    expect(enabledBox).toBeTruthy()
-    expect(enabledBox!.width).toBe(disabledBox!.width)
-
-    // Save the workflow to transition to the Save + chevron state
-    await builderSaveAs(appMode, `${Date.now()} width-test`, 'App')
-    await appMode.saveAs.closeButton.click()
-    await comfyPage.nextFrame()
-
-    // State 3: Save + chevron button group (saved workflow)
-    const saveButtonGroupBox = await appMode.footer.saveGroup.boundingBox()
-    expect(saveButtonGroupBox).toBeTruthy()
-    expect(saveButtonGroupBox!.width).toBe(disabledBox!.width)
-  })
-
   test('Connect output popover appears when no outputs selected', async ({
     comfyPage
   }) => {

browser_tests/tests/collapsedNodeLinks.spec.ts

@@ -1,68 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../fixtures/ComfyPage'
-import { assertNodeSlotsWithinBounds } from '../fixtures/utils/slotBoundsUtil'
-
-const NODE_ID = '3'
-const NODE_TITLE = 'KSampler'
-
-test.describe(
-  'Collapsed node link positions',
-  { tag: ['@canvas', '@node'] },
-  () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
-      await comfyPage.workflow.loadWorkflow('default')
-      await comfyPage.vueNodes.waitForNodes()
-    })
-
-    test.afterEach(async ({ comfyPage }) => {
-      await comfyPage.canvasOps.resetView()
-    })
-
-    test('link endpoints stay within collapsed node bounds', async ({
-      comfyPage
-    }) => {
-      const node = await comfyPage.vueNodes.getFixtureByTitle(NODE_TITLE)
-      await node.toggleCollapse()
-      await comfyPage.nextFrame()
-
-      await assertNodeSlotsWithinBounds(comfyPage.page, NODE_ID)
-    })
-
-    test('links follow collapsed node after drag', async ({ comfyPage }) => {
-      const node = await comfyPage.vueNodes.getFixtureByTitle(NODE_TITLE)
-      await node.toggleCollapse()
-      await comfyPage.nextFrame()
-
-      const box = await node.boundingBox()
-      expect(box).not.toBeNull()
-      await comfyPage.page.mouse.move(
-        box!.x + box!.width / 2,
-        box!.y + box!.height / 2
-      )
-      await comfyPage.page.mouse.down()
-      await comfyPage.page.mouse.move(
-        box!.x + box!.width / 2 + 200,
-        box!.y + box!.height / 2 + 100,
-        { steps: 10 }
-      )
-      await comfyPage.page.mouse.up()
-      await comfyPage.nextFrame()
-
-      await assertNodeSlotsWithinBounds(comfyPage.page, NODE_ID)
-    })
-
-    test('links recover correct positions after expand', async ({
-      comfyPage
-    }) => {
-      const node = await comfyPage.vueNodes.getFixtureByTitle(NODE_TITLE)
-      await node.toggleCollapse()
-      await comfyPage.nextFrame()
-      await node.toggleCollapse()
-      await comfyPage.nextFrame()
-
-      await assertNodeSlotsWithinBounds(comfyPage.page, NODE_ID)
-    })
-  }
-)

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/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/errorsTabMissingMedia.spec.ts

@@ -1,184 +0,0 @@
-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'
-
-async function uploadFileViaDropzone(comfyPage: ComfyPage) {
-  const dropzone = comfyPage.page.getByTestId(
-    TestIds.dialogs.missingMediaUploadDropzone
-  )
-  const [fileChooser] = await Promise.all([
-    comfyPage.page.waitForEvent('filechooser'),
-    dropzone.click()
-  ])
-  await fileChooser.setFiles(comfyPage.assetPath('test_upload_image.png'))
-}
-
-async function confirmPendingSelection(comfyPage: ComfyPage) {
-  const confirmButton = comfyPage.page.getByTestId(
-    TestIds.dialogs.missingMediaConfirmButton
-  )
-  await expect(confirmButton).toBeEnabled()
-  await confirmButton.click()
-}
-
-function getMediaRow(comfyPage: ComfyPage) {
-  return comfyPage.page.getByTestId(TestIds.dialogs.missingMediaRow)
-}
-
-function getStatusCard(comfyPage: ComfyPage) {
-  return comfyPage.page.getByTestId(TestIds.dialogs.missingMediaStatusCard)
-}
-
-function getDropzone(comfyPage: ComfyPage) {
-  return comfyPage.page.getByTestId(TestIds.dialogs.missingMediaUploadDropzone)
-}
-
-test.describe('Errors tab - Missing media', { tag: '@ui' }, () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.settings.setSetting(
-      'Comfy.RightSidePanel.ShowErrorsTab',
-      true
-    )
-  })
-
-  test.describe('Detection', () => {
-    test('Shows missing media group in errors tab', async ({ comfyPage }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-
-      await expect(
-        comfyPage.page.getByTestId(TestIds.dialogs.missingMediaGroup)
-      ).toBeVisible()
-    })
-
-    test('Shows correct number of missing media rows', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(
-        comfyPage,
-        'missing/missing_media_multiple'
-      )
-
-      await expect(getMediaRow(comfyPage)).toHaveCount(2)
-    })
-
-    test('Shows upload dropzone and library select for each missing item', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-
-      await expect(getDropzone(comfyPage)).toBeVisible()
-      await expect(
-        comfyPage.page.getByTestId(TestIds.dialogs.missingMediaLibrarySelect)
-      ).toBeVisible()
-    })
-  })
-
-  test.describe('Upload flow', () => {
-    test('Upload via file picker shows status card then allows confirm', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-      await uploadFileViaDropzone(comfyPage)
-
-      await expect(getStatusCard(comfyPage)).toBeVisible()
-
-      await confirmPendingSelection(comfyPage)
-      await expect(getMediaRow(comfyPage)).toHaveCount(0)
-    })
-  })
-
-  test.describe('Library select flow', () => {
-    test('Selecting from library shows status card then allows confirm', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-
-      const librarySelect = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingMediaLibrarySelect
-      )
-      await librarySelect.getByRole('combobox').click()
-
-      const optionCount = await comfyPage.page.getByRole('option').count()
-      if (optionCount === 0) {
-        test.skip()
-        return
-      }
-
-      await comfyPage.page.getByRole('option').first().click()
-
-      await expect(getStatusCard(comfyPage)).toBeVisible()
-
-      await confirmPendingSelection(comfyPage)
-      await expect(getMediaRow(comfyPage)).toHaveCount(0)
-    })
-  })
-
-  test.describe('Cancel selection', () => {
-    test('Cancelling pending selection returns to upload/library UI', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-      await uploadFileViaDropzone(comfyPage)
-
-      await expect(getStatusCard(comfyPage)).toBeVisible()
-      await expect(getDropzone(comfyPage)).not.toBeVisible()
-
-      await comfyPage.page
-        .getByTestId(TestIds.dialogs.missingMediaCancelButton)
-        .click()
-
-      await expect(getStatusCard(comfyPage)).not.toBeVisible()
-      await expect(getDropzone(comfyPage)).toBeVisible()
-    })
-  })
-
-  test.describe('All resolved', () => {
-    test('Missing Inputs group disappears when all items are resolved', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-      await uploadFileViaDropzone(comfyPage)
-      await confirmPendingSelection(comfyPage)
-
-      await expect(
-        comfyPage.page.getByTestId(TestIds.dialogs.missingMediaGroup)
-      ).not.toBeVisible()
-    })
-  })
-
-  test.describe('Locate node', () => {
-    test('Locate button navigates canvas to the missing media node', async ({
-      comfyPage
-    }) => {
-      await openErrorsTabViaSeeErrors(comfyPage, 'missing/missing_media_single')
-
-      const offsetBefore = await comfyPage.page.evaluate(() => {
-        const canvas = window['app']?.canvas
-        return canvas?.ds?.offset
-          ? [canvas.ds.offset[0], canvas.ds.offset[1]]
-          : null
-      })
-
-      const locateButton = comfyPage.page.getByTestId(
-        TestIds.dialogs.missingMediaLocateButton
-      )
-      await expect(locateButton).toBeVisible()
-      await locateButton.click()
-
-      await expect
-        .poll(async () => {
-          return await comfyPage.page.evaluate(() => {
-            const canvas = window['app']?.canvas
-            return canvas?.ds?.offset
-              ? [canvas.ds.offset[0], canvas.ds.offset[1]]
-              : null
-          })
-        })
-        .not.toEqual(offsetBefore)
-    })
-  })
-})

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/selectionBoundingBox.spec.ts

@@ -0,0 +1,151 @@
+import { expect } from '@playwright/test'
+import type { Page } from '@playwright/test'
+
+import type { ComfyPage } from '../fixtures/ComfyPage'
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+import { measureSelectionBounds } from '../fixtures/helpers/boundsUtils'
+
+const SUBGRAPH_ID = '2'
+const REGULAR_ID = '3'
+const WORKFLOW = 'selection/subgraph-with-regular-node'
+
+const REF_POS: [number, number] = [100, 100]
+const TARGET_POSITIONS: Record<string, [number, number]> = {
+  'bottom-left': [50, 500],
+  'bottom-right': [600, 500]
+}
+
+type NodeType = 'subgraph' | 'regular'
+type NodeState = 'expanded' | 'collapsed'
+type Position = 'bottom-left' | 'bottom-right'
+
+function getTargetId(type: NodeType): string {
+  return type === 'subgraph' ? SUBGRAPH_ID : REGULAR_ID
+}
+
+function getRefId(type: NodeType): string {
+  return type === 'subgraph' ? REGULAR_ID : SUBGRAPH_ID
+}
+
+async function assertSelectionEncompassesNodes(
+  page: Page,
+  comfyPage: ComfyPage,
+  nodeIds: string[]
+) {
+  await comfyPage.canvas.press('Control+a')
+  await expect
+    .poll(() => comfyPage.nodeOps.getSelectedGraphNodesCount())
+    .toBe(2)
+  await comfyPage.nextFrame()
+
+  const result = await measureSelectionBounds(page, nodeIds)
+  expect(result.selectionBounds).not.toBeNull()
+
+  const sel = result.selectionBounds!
+  const selRight = sel.x + sel.w
+  const selBottom = sel.y + sel.h
+
+  for (const nodeId of nodeIds) {
+    const vis = result.nodeVisualBounds[nodeId]
+    expect(vis).toBeDefined()
+
+    expect(sel.x).toBeLessThanOrEqual(vis.x)
+    expect(selRight).toBeGreaterThanOrEqual(vis.x + vis.w)
+    expect(sel.y).toBeLessThanOrEqual(vis.y)
+    expect(selBottom).toBeGreaterThanOrEqual(vis.y + vis.h)
+  }
+}
+
+test.describe(
+  'Selection bounding box (Vue mode)',
+  { tag: ['@canvas', '@node'] },
+  () => {
+    test.beforeEach(async ({ comfyPage }) => {
+      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+      await comfyPage.workflow.loadWorkflow(WORKFLOW)
+      await comfyPage.vueNodes.waitForNodes()
+    })
+
+    test.afterEach(async ({ comfyPage }) => {
+      await comfyPage.canvasOps.resetView()
+    })
+
+    const nodeTypes: NodeType[] = ['subgraph', 'regular']
+    const nodeStates: NodeState[] = ['expanded', 'collapsed']
+    const positions: Position[] = ['bottom-left', 'bottom-right']
+
+    for (const type of nodeTypes) {
+      for (const state of nodeStates) {
+        for (const pos of positions) {
+          test(`${type} node (${state}) at ${pos}: selection bounds encompass node`, async ({
+            comfyPage
+          }) => {
+            const targetId = getTargetId(type)
+            const refId = getRefId(type)
+
+            await comfyPage.nodeOps.repositionNodes({
+              [refId]: REF_POS,
+              [targetId]: TARGET_POSITIONS[pos]
+            })
+            await comfyPage.vueNodes.waitForNodes()
+            await comfyPage.vueNodes.getNodeLocator(targetId).waitFor()
+            await comfyPage.vueNodes.getNodeLocator(refId).waitFor()
+
+            if (state === 'collapsed') {
+              const nodeRef = await comfyPage.nodeOps.getNodeRefById(targetId)
+              await nodeRef.setCollapsed(true)
+            }
+
+            await assertSelectionEncompassesNodes(comfyPage.page, comfyPage, [
+              refId,
+              targetId
+            ])
+          })
+        }
+      }
+    }
+  }
+)
+
+test.describe(
+  'Selection bounding box (legacy mode)',
+  { tag: ['@canvas', '@node'] },
+  () => {
+    test.beforeEach(async ({ comfyPage }) => {
+      await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
+      await comfyPage.workflow.loadWorkflow(WORKFLOW)
+      await comfyPage.nextFrame()
+    })
+
+    test.afterEach(async ({ comfyPage }) => {
+      await comfyPage.canvasOps.resetView()
+    })
+
+    const nodeStates: NodeState[] = ['expanded', 'collapsed']
+    const positions: Position[] = ['bottom-left', 'bottom-right']
+
+    for (const state of nodeStates) {
+      for (const pos of positions) {
+        test(`legacy node (${state}) at ${pos}: selection bounds encompass node`, async ({
+          comfyPage
+        }) => {
+          await comfyPage.nodeOps.repositionNodes({
+            [SUBGRAPH_ID]: REF_POS,
+            [REGULAR_ID]: TARGET_POSITIONS[pos]
+          })
+          await comfyPage.nextFrame()
+
+          if (state === 'collapsed') {
+            const nodeRef = await comfyPage.nodeOps.getNodeRefById(REGULAR_ID)
+            await nodeRef.setCollapsed(true)
+          }
+
+          await assertSelectionEncompassesNodes(comfyPage.page, comfyPage, [
+            SUBGRAPH_ID,
+            REGULAR_ID
+          ])
+        })
+      }
+    }
+  }
+)

browser_tests/tests/sidebar/assets.spec.ts

@@ -527,27 +527,20 @@ test.describe('Assets sidebar - context menu', () => {
     // Dismiss any toasts that appeared after asset loading
     await tab.dismissToasts()
 
-    // Multi-select: use keyboard.down/up so useKeyModifier('Control') detects
-    // the modifier — click({ modifiers }) only sets the mouse event flag and
-    // does not fire a keydown event that VueUse tracks.
+    // Multi-select: click first, then Ctrl/Cmd+click second
     await cards.first().click()
-    await comfyPage.page.keyboard.down('Control')
-    await cards.nth(1).click()
-    await comfyPage.page.keyboard.up('Control')
+    await cards.nth(1).click({ modifiers: ['ControlOrMeta'] })
 
     // Verify multi-selection took effect and footer is stable before right-clicking
     await expect(tab.selectedCards).toHaveCount(2, { timeout: 3000 })
     await expect(tab.selectionFooter).toBeVisible({ timeout: 3000 })
 
-    // Use dispatchEvent instead of click({ button: 'right' }) to avoid any
-    // overlay intercepting the event, and assert directly without toPass.
+    // Right-click on a selected card (retry to let grid layout settle)
     const contextMenu = comfyPage.page.locator('.p-contextmenu')
-    await cards.first().dispatchEvent('contextmenu', {
-      bubbles: true,
-      cancelable: true,
-      button: 2
-    })
-    await expect(contextMenu).toBeVisible()
+    await expect(async () => {
+      await cards.first().click({ button: 'right' })
+      await expect(contextMenu).toBeVisible()
+    }).toPass({ intervals: [300], timeout: 5000 })
 
     // Bulk menu should show bulk download action
     await expect(tab.contextMenuItem('Download all')).toBeVisible()
@@ -624,30 +617,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/subgraphSlots.spec.ts

@@ -7,10 +7,6 @@ import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/w
 
 import { comfyPageFixture as test, comfyExpect } from '../../fixtures/ComfyPage'
 import { SubgraphHelper } from '../../fixtures/helpers/SubgraphHelper'
-import {
-  expectSlotsWithinBounds,
-  measureNodeSlotOffsets
-} from '../../fixtures/utils/slotBoundsUtil'
 
 // Constants
 const RENAMED_INPUT_NAME = 'renamed_input'
@@ -23,6 +19,20 @@ const SELECTORS = {
   promptDialog: '.graphdialog input'
 } as const
 
+interface SlotMeasurement {
+  key: string
+  offsetX: number
+  offsetY: number
+}
+
+interface NodeSlotData {
+  nodeId: string
+  isSubgraph: boolean
+  nodeW: number
+  nodeH: number
+  slots: SlotMeasurement[]
+}
+
 test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
   test.beforeEach(async ({ comfyPage }) => {
     await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
@@ -594,19 +604,71 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
       )
       await comfyPage.nextFrame()
 
+      // Wait for slot elements to appear in DOM
       await comfyPage.page.locator('[data-slot-key]').first().waitFor()
 
-      const nodeIds = await comfyPage.page.evaluate(() =>
-        window
-          .app!.graph._nodes.filter((n) => !!n.isSubgraphNode?.())
-          .map((n) => String(n.id))
-      )
-      expect(nodeIds.length).toBeGreaterThan(0)
+      const result: NodeSlotData[] = await comfyPage.page.evaluate(() => {
+        const nodes = window.app!.graph._nodes
+        const slotData: NodeSlotData[] = []
 
-      for (const nodeId of nodeIds) {
-        const data = await measureNodeSlotOffsets(comfyPage.page, nodeId)
-        expect(data, `Node ${nodeId} not found in DOM`).not.toBeNull()
-        expectSlotsWithinBounds(data!, SLOT_BOUNDS_MARGIN, `Node ${nodeId}`)
+        for (const node of nodes) {
+          const nodeId = String(node.id)
+          const nodeEl = document.querySelector(
+            `[data-node-id="${nodeId}"]`
+          ) as HTMLElement | null
+          if (!nodeEl) continue
+
+          const slotEls = nodeEl.querySelectorAll('[data-slot-key]')
+          if (slotEls.length === 0) continue
+
+          const slots: SlotMeasurement[] = []
+
+          const nodeRect = nodeEl.getBoundingClientRect()
+          for (const slotEl of slotEls) {
+            const slotRect = slotEl.getBoundingClientRect()
+            const slotKey = (slotEl as HTMLElement).dataset.slotKey ?? 'unknown'
+            slots.push({
+              key: slotKey,
+              offsetX: slotRect.left + slotRect.width / 2 - nodeRect.left,
+              offsetY: slotRect.top + slotRect.height / 2 - nodeRect.top
+            })
+          }
+
+          slotData.push({
+            nodeId,
+            isSubgraph: !!node.isSubgraphNode?.(),
+            nodeW: nodeRect.width,
+            nodeH: nodeRect.height,
+            slots
+          })
+        }
+
+        return slotData
+      })
+
+      const subgraphNodes = result.filter((n) => n.isSubgraph)
+      expect(subgraphNodes.length).toBeGreaterThan(0)
+
+      for (const node of subgraphNodes) {
+        for (const slot of node.slots) {
+          expect(
+            slot.offsetX,
+            `Slot ${slot.key} on node ${node.nodeId}: X offset ${slot.offsetX} outside node width ${node.nodeW}`
+          ).toBeGreaterThanOrEqual(-SLOT_BOUNDS_MARGIN)
+          expect(
+            slot.offsetX,
+            `Slot ${slot.key} on node ${node.nodeId}: X offset ${slot.offsetX} outside node width ${node.nodeW}`
+          ).toBeLessThanOrEqual(node.nodeW + SLOT_BOUNDS_MARGIN)
+
+          expect(
+            slot.offsetY,
+            `Slot ${slot.key} on node ${node.nodeId}: Y offset ${slot.offsetY} outside node height ${node.nodeH}`
+          ).toBeGreaterThanOrEqual(-SLOT_BOUNDS_MARGIN)
+          expect(
+            slot.offsetY,
+            `Slot ${slot.key} on node ${node.nodeId}: Y offset ${slot.offsetY} outside node height ${node.nodeH}`
+          ).toBeLessThanOrEqual(node.nodeH + SLOT_BOUNDS_MARGIN)
+        }
       }
     })
   })

browser_tests/tests/subgraphPromotedWidgetPanel.spec.ts

@@ -1,148 +0,0 @@
-import type { Locator } from '@playwright/test'
-import type { ComfyPage } from '../fixtures/ComfyPage'
-import {
-  comfyPageFixture as test,
-  comfyExpect as expect
-} from '../fixtures/ComfyPage'
-import { TestIds } from '../fixtures/selectors'
-
-async function ensurePropertiesPanel(comfyPage: ComfyPage) {
-  const panel = comfyPage.menu.propertiesPanel.root
-  if (!(await panel.isVisible())) {
-    await comfyPage.actionbar.propertiesButton.click()
-  }
-  await expect(panel).toBeVisible()
-  return panel
-}
-
-async function selectSubgraphAndOpenEditor(
-  comfyPage: ComfyPage,
-  nodeTitle: string
-) {
-  const subgraphNodes = await comfyPage.nodeOps.getNodeRefsByTitle(nodeTitle)
-  expect(subgraphNodes.length).toBeGreaterThan(0)
-  await subgraphNodes[0].click('title')
-
-  await ensurePropertiesPanel(comfyPage)
-
-  const editorToggle = comfyPage.page.getByTestId(TestIds.subgraphEditor.toggle)
-  await expect(editorToggle).toBeVisible()
-  await editorToggle.click()
-
-  const shownSection = comfyPage.page.getByTestId(
-    TestIds.subgraphEditor.shownSection
-  )
-  await expect(shownSection).toBeVisible()
-  return shownSection
-}
-
-async function collectWidgetLabels(shownSection: Locator) {
-  const labels = shownSection.getByTestId(TestIds.subgraphEditor.widgetLabel)
-  const texts = await labels.allTextContents()
-  return texts.map((t) => t.trim())
-}
-
-test.describe(
-  'Subgraph promoted widget panel',
-  { tag: ['@node', '@widget'] },
-  () => {
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
-    })
-
-    test.describe('SubgraphEditor (Settings panel)', () => {
-      test('linked promoted widgets have hide toggle disabled', async ({
-        comfyPage
-      }) => {
-        await comfyPage.workflow.loadWorkflow(
-          'subgraphs/subgraph-nested-promotion'
-        )
-        const shownSection = await selectSubgraphAndOpenEditor(
-          comfyPage,
-          'Sub 0'
-        )
-
-        const toggleButtons = shownSection.getByTestId(
-          TestIds.subgraphEditor.widgetToggle
-        )
-        await expect(toggleButtons.first()).toBeVisible()
-
-        const count = await toggleButtons.count()
-        for (let i = 0; i < count; i++) {
-          await expect(toggleButtons.nth(i)).toBeDisabled()
-        }
-      })
-
-      test('linked promoted widgets show link icon instead of eye icon', async ({
-        comfyPage
-      }) => {
-        await comfyPage.workflow.loadWorkflow(
-          'subgraphs/subgraph-nested-promotion'
-        )
-        const shownSection = await selectSubgraphAndOpenEditor(
-          comfyPage,
-          'Sub 0'
-        )
-
-        const linkIcons = shownSection.getByTestId(
-          TestIds.subgraphEditor.iconLink
-        )
-        await expect(linkIcons.first()).toBeVisible()
-
-        const eyeIcons = shownSection.getByTestId(
-          TestIds.subgraphEditor.iconEye
-        )
-        await expect(eyeIcons).toHaveCount(0)
-      })
-
-      test('widget labels display renamed values instead of raw names', async ({
-        comfyPage
-      }) => {
-        await comfyPage.workflow.loadWorkflow(
-          'subgraphs/test-values-input-subgraph'
-        )
-        const shownSection = await selectSubgraphAndOpenEditor(
-          comfyPage,
-          'Input Test Subgraph'
-        )
-
-        const allTexts = await collectWidgetLabels(shownSection)
-        expect(allTexts.length).toBeGreaterThan(0)
-
-        // The fixture has a widget with name="text" but
-        // label="renamed_from_sidepanel". The panel should show the
-        // renamed label, not the raw widget name.
-        expect(allTexts).toContain('renamed_from_sidepanel')
-        expect(allTexts).not.toContain('text')
-      })
-    })
-
-    test.describe('Parameters tab (WidgetActions menu)', () => {
-      test('linked promoted widget menu should not show Hide/Show input', async ({
-        comfyPage
-      }) => {
-        await comfyPage.workflow.loadWorkflow(
-          'subgraphs/subgraph-nested-promotion'
-        )
-        const subgraphNodes =
-          await comfyPage.nodeOps.getNodeRefsByTitle('Sub 0')
-        expect(subgraphNodes.length).toBeGreaterThan(0)
-        await subgraphNodes[0].click('title')
-
-        const panel = await ensurePropertiesPanel(comfyPage)
-
-        const moreButtons = panel.getByTestId(
-          TestIds.subgraphEditor.widgetActionsMenuButton
-        )
-        await expect(moreButtons.first()).toBeVisible()
-        await moreButtons.first().click()
-
-        const menu = comfyPage.page.getByTestId(TestIds.menu.moreMenuContent)
-        await expect(menu).toBeVisible()
-        await expect(menu.getByText('Hide input')).toHaveCount(0)
-        await expect(menu.getByText('Show input')).toHaveCount(0)
-        await expect(menu.getByText('Rename')).toBeVisible()
-      })
-    })
-  }
-)

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()
       }
     })
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfyorg/comfyui-frontend",
-  "version": "1.43.11",
+  "version": "1.43.10",
   "private": true,
   "description": "Official front-end implementation of ComfyUI",
   "homepage": "https://comfy.org",
@@ -140,7 +140,6 @@
     "@testing-library/jest-dom": "catalog:",
     "@testing-library/user-event": "catalog:",
     "@testing-library/vue": "catalog:",
-    "@total-typescript/shoehorn": "catalog:",
     "@types/fs-extra": "catalog:",
     "@types/jsdom": "catalog:",
     "@types/node": "catalog:",

pnpm-lock.yaml

@@ -135,9 +135,6 @@ catalogs:
     '@tiptap/starter-kit':
       specifier: ^2.27.2
       version: 2.27.2
-    '@total-typescript/shoehorn':
-      specifier: ^0.1.2
-      version: 0.1.2
     '@types/fs-extra':
       specifier: ^11.0.4
       version: 11.0.4
@@ -654,9 +651,6 @@ importers:
       '@testing-library/vue':
         specifier: 'catalog:'
         version: 8.1.0(@vue/compiler-sfc@3.5.28)(vue@3.5.13(typescript@5.9.3))
-      '@total-typescript/shoehorn':
-        specifier: 'catalog:'
-        version: 0.1.2
       '@types/fs-extra':
         specifier: 'catalog:'
         version: 11.0.4
@@ -4280,9 +4274,6 @@ packages:
       '@tmcp/auth':
         optional: true
 
-  '@total-typescript/shoehorn@0.1.2':
-    resolution: {integrity: sha512-p7nNZbOZIofpDNyP0u1BctFbjxD44Qc+oO5jufgQdFdGIXJLc33QRloJpq7k5T59CTgLWfQSUxsuqLcmeurYRw==}
-
   '@tweenjs/tween.js@23.1.3':
     resolution: {integrity: sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==}
 
@@ -13317,8 +13308,6 @@ snapshots:
       esm-env: 1.2.2
       tmcp: 1.19.0(typescript@5.9.3)
 
-  '@total-typescript/shoehorn@0.1.2': {}
-
   '@tweenjs/tween.js@23.1.3': {}
 
   '@tybys/wasm-util@0.10.1':

pnpm-workspace.yaml

@@ -46,7 +46,6 @@ catalog:
   '@tiptap/extension-table-row': ^2.27.2
   '@tiptap/pm': 2.27.2
   '@tiptap/starter-kit': ^2.27.2
-  '@total-typescript/shoehorn': ^0.1.2
   '@types/fs-extra': ^11.0.4
   '@types/jsdom': ^21.1.7
   '@types/node': ^24.1.0

src/base/common/downloadUtil.test.ts

@@ -1,4 +1,3 @@
-import { fromAny, fromPartial } from '@total-typescript/shoehorn'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import {
@@ -44,12 +43,12 @@ describe('downloadUtil', () => {
     createObjectURLSpy.mockClear().mockReturnValue('blob:mock-url')
     revokeObjectURLSpy.mockClear().mockImplementation(() => {})
     // Create a mock anchor element
-    mockLink = fromPartial<HTMLAnchorElement>({
+    mockLink = {
       href: '',
       download: '',
       click: vi.fn(),
       style: { display: '' }
-    })
+    } as unknown as HTMLAnchorElement
 
     // Spy on DOM methods
     vi.spyOn(document, 'createElement').mockReturnValue(mockLink)
@@ -173,14 +172,12 @@ describe('downloadUtil', () => {
       const headersMock = {
         get: vi.fn().mockReturnValue(null)
       }
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          status: 200,
-          blob: blobFn,
-          headers: headersMock
-        })
-      )
+      fetchMock.mockResolvedValue({
+        ok: true,
+        status: 200,
+        blob: blobFn,
+        headers: headersMock
+      } as unknown as Response)
 
       downloadFile(testUrl)
 
@@ -201,13 +198,11 @@ describe('downloadUtil', () => {
       mockIsCloud.value = true
       const testUrl = 'https://storage.googleapis.com/bucket/missing.bin'
       const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: false,
-          status: 404,
-          blob: vi.fn()
-        })
-      )
+      fetchMock.mockResolvedValue({
+        ok: false,
+        status: 404,
+        blob: vi.fn()
+      } as Partial<Response> as Response)
 
       downloadFile(testUrl)
 
@@ -229,14 +224,12 @@ describe('downloadUtil', () => {
       const headersMock = {
         get: vi.fn().mockReturnValue('attachment; filename="user-friendly.png"')
       }
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          status: 200,
-          blob: blobFn,
-          headers: headersMock
-        })
-      )
+      fetchMock.mockResolvedValue({
+        ok: true,
+        status: 200,
+        blob: blobFn,
+        headers: headersMock
+      } as unknown as Response)
 
       downloadFile(testUrl)
 
@@ -263,14 +256,12 @@ describe('downloadUtil', () => {
             'attachment; filename="fallback.png"; filename*=UTF-8\'\'%E4%B8%AD%E6%96%87.png'
           )
       }
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          status: 200,
-          blob: blobFn,
-          headers: headersMock
-        })
-      )
+      fetchMock.mockResolvedValue({
+        ok: true,
+        status: 200,
+        blob: blobFn,
+        headers: headersMock
+      } as unknown as Response)
 
       downloadFile(testUrl)
 
@@ -291,14 +282,12 @@ describe('downloadUtil', () => {
       const headersMock = {
         get: vi.fn().mockReturnValue(null)
       }
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          status: 200,
-          blob: blobFn,
-          headers: headersMock
-        })
-      )
+      fetchMock.mockResolvedValue({
+        ok: true,
+        status: 200,
+        blob: blobFn,
+        headers: headersMock
+      } as unknown as Response)
 
       downloadFile(testUrl, 'my-fallback.png')
 
@@ -339,13 +328,11 @@ describe('downloadUtil', () => {
       const testUrl = 'https://storage.googleapis.com/bucket/image.png'
       const blob = new Blob(['test'], { type: 'image/png' })
       const mockTab = { location: { href: '' }, closed: false, close: vi.fn() }
-      windowOpenSpy.mockReturnValue(fromAny<Window, unknown>(mockTab))
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          blob: vi.fn().mockResolvedValue(blob)
-        })
-      )
+      windowOpenSpy.mockReturnValue(mockTab as unknown as Window)
+      fetchMock.mockResolvedValue({
+        ok: true,
+        blob: vi.fn().mockResolvedValue(blob)
+      } as unknown as Response)
 
       await openFileInNewTab(testUrl)
 
@@ -359,13 +346,11 @@ describe('downloadUtil', () => {
       mockIsCloud.value = true
       const blob = new Blob(['test'], { type: 'image/png' })
       const mockTab = { location: { href: '' }, closed: false, close: vi.fn() }
-      windowOpenSpy.mockReturnValue(fromAny<Window, unknown>(mockTab))
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          blob: vi.fn().mockResolvedValue(blob)
-        })
-      )
+      windowOpenSpy.mockReturnValue(mockTab as unknown as Window)
+      fetchMock.mockResolvedValue({
+        ok: true,
+        blob: vi.fn().mockResolvedValue(blob)
+      } as unknown as Response)
 
       await openFileInNewTab('https://example.com/image.png')
 
@@ -379,10 +364,11 @@ describe('downloadUtil', () => {
       const testUrl = 'https://storage.googleapis.com/bucket/missing.png'
       const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       const mockTab = { location: { href: '' }, closed: false, close: vi.fn() }
-      windowOpenSpy.mockReturnValue(fromAny<Window, unknown>(mockTab))
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({ ok: false, status: 404 })
-      )
+      windowOpenSpy.mockReturnValue(mockTab as unknown as Window)
+      fetchMock.mockResolvedValue({
+        ok: false,
+        status: 404
+      } as unknown as Response)
 
       await openFileInNewTab(testUrl)
 
@@ -395,13 +381,11 @@ describe('downloadUtil', () => {
       mockIsCloud.value = true
       const blob = new Blob(['test'], { type: 'image/png' })
       const mockTab = { location: { href: '' }, closed: true, close: vi.fn() }
-      windowOpenSpy.mockReturnValue(fromAny<Window, unknown>(mockTab))
-      fetchMock.mockResolvedValue(
-        fromPartial<Response>({
-          ok: true,
-          blob: vi.fn().mockResolvedValue(blob)
-        })
-      )
+      windowOpenSpy.mockReturnValue(mockTab as unknown as Window)
+      fetchMock.mockResolvedValue({
+        ok: true,
+        blob: vi.fn().mockResolvedValue(blob)
+      } as unknown as Response)
 
       await openFileInNewTab('https://example.com/image.png')
 

src/components/builder/BuilderFooterToolbar.vue

@@ -33,91 +33,76 @@
         {{ t('g.next') }}
         <i class="icon-[lucide--chevron-right]" aria-hidden="true" />
       </Button>
-      <div class="relative min-w-24">
-        <!--
-          Invisible sizers: both labels rendered with matching button padding
-          so the container's intrinsic width equals the wider label.
-          height:0 + overflow:hidden keeps them invisible without affecting height.
-        -->
-        <div class="max-h-0 overflow-y-hidden" aria-hidden="true">
-          <div class="px-4 py-2 text-sm">{{ t('g.save') }}</div>
-          <div class="px-4 py-2 text-sm">{{ t('builderToolbar.saveAs') }}</div>
-        </div>
-        <ConnectOutputPopover
-          v-if="!hasOutputs"
-          class="w-full"
-          :is-select-active="isSelectStep"
-          @switch="navigateToStep('builder:outputs')"
-        >
-          <Button
-            size="lg"
-            class="w-full"
-            :class="disabledSaveClasses"
-            data-testid="builder-save-as-button"
-          >
-            {{ isSaved ? t('g.save') : t('builderToolbar.saveAs') }}
-          </Button>
-        </ConnectOutputPopover>
-        <ButtonGroup
-          v-else-if="isSaved"
-          data-testid="builder-save-group"
-          class="w-full rounded-lg bg-secondary-background has-[[data-save-chevron]:hover]:bg-secondary-background-hover"
-        >
-          <Button
-            size="lg"
-            :disabled="!isModified"
-            class="flex-1"
-            :class="isModified ? activeSaveClasses : disabledSaveClasses"
-            data-testid="builder-save-button"
-            @click="save()"
-          >
-            {{ t('g.save') }}
-          </Button>
-          <DropdownMenuRoot>
-            <DropdownMenuTrigger as-child>
-              <Button
-                size="lg"
-                :aria-label="t('builderToolbar.saveAs')"
-                data-save-chevron
-                data-testid="builder-save-as-chevron"
-                class="w-6 rounded-l-none border-l border-border-default px-0"
-              >
-                <i
-                  class="icon-[lucide--chevron-down] size-4"
-                  aria-hidden="true"
-                />
-              </Button>
-            </DropdownMenuTrigger>
-            <DropdownMenuPortal>
-              <DropdownMenuContent
-                align="end"
-                :side-offset="4"
-                class="z-1001 min-w-36 rounded-lg border border-border-subtle bg-base-background p-1 shadow-interface"
-              >
-                <DropdownMenuItem as-child @select="saveAs()">
-                  <Button
-                    variant="secondary"
-                    size="lg"
-                    class="w-full justify-start font-normal"
-                  >
-                    {{ t('builderToolbar.saveAs') }}
-                  </Button>
-                </DropdownMenuItem>
-              </DropdownMenuContent>
-            </DropdownMenuPortal>
-          </DropdownMenuRoot>
-        </ButtonGroup>
+      <ConnectOutputPopover
+        v-if="!hasOutputs"
+        :is-select-active="isSelectStep"
+        @switch="navigateToStep('builder:outputs')"
+      >
         <Button
-          v-else
           size="lg"
-          class="w-full"
-          :class="activeSaveClasses"
+          :class="cn('w-24', disabledSaveClasses)"
           data-testid="builder-save-as-button"
-          @click="saveAs()"
         >
-          {{ t('builderToolbar.saveAs') }}
+          {{ isSaved ? t('g.save') : t('builderToolbar.saveAs') }}
         </Button>
-      </div>
+      </ConnectOutputPopover>
+      <ButtonGroup
+        v-else-if="isSaved"
+        class="w-24 rounded-lg bg-secondary-background has-[[data-save-chevron]:hover]:bg-secondary-background-hover"
+      >
+        <Button
+          size="lg"
+          :disabled="!isModified"
+          class="flex-1"
+          :class="isModified ? activeSaveClasses : disabledSaveClasses"
+          data-testid="builder-save-button"
+          @click="save()"
+        >
+          {{ t('g.save') }}
+        </Button>
+        <DropdownMenuRoot>
+          <DropdownMenuTrigger as-child>
+            <Button
+              size="lg"
+              :aria-label="t('builderToolbar.saveAs')"
+              data-save-chevron
+              data-testid="builder-save-as-chevron"
+              class="w-6 rounded-l-none border-l border-border-default px-0"
+            >
+              <i
+                class="icon-[lucide--chevron-down] size-4"
+                aria-hidden="true"
+              />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuPortal>
+            <DropdownMenuContent
+              align="end"
+              :side-offset="4"
+              class="z-1001 min-w-36 rounded-lg border border-border-subtle bg-base-background p-1 shadow-interface"
+            >
+              <DropdownMenuItem as-child @select="saveAs()">
+                <Button
+                  variant="secondary"
+                  size="lg"
+                  class="w-full justify-start font-normal"
+                >
+                  {{ t('builderToolbar.saveAs') }}
+                </Button>
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenuPortal>
+        </DropdownMenuRoot>
+      </ButtonGroup>
+      <Button
+        v-else
+        size="lg"
+        :class="activeSaveClasses"
+        data-testid="builder-save-as-button"
+        @click="saveAs()"
+      >
+        {{ t('builderToolbar.saveAs') }}
+      </Button>
     </nav>
   </div>
 </template>
@@ -141,6 +126,8 @@ import { useAppMode } from '@/composables/useAppMode'
 import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
 import { useAppModeStore } from '@/stores/appModeStore'
 import { useDialogStore } from '@/stores/dialogStore'
+import { cn } from '@/utils/tailwindUtil'
+
 import BuilderOpensAsPopover from './BuilderOpensAsPopover.vue'
 import { setWorkflowDefaultView } from './builderViewOptions'
 import ConnectOutputPopover from './ConnectOutputPopover.vue'

src/components/button/MoreButton.vue

@@ -51,10 +51,7 @@
         }
       "
     >
-      <div
-        class="flex min-w-40 flex-col gap-2 p-2"
-        data-testid="more-menu-content"
-      >
+      <div class="flex min-w-40 flex-col gap-2 p-2">
         <slot :close="hide" />
       </div>
     </Popover>

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/DomWidgets.test.ts

@@ -1,5 +1,3 @@
-import { createTestingPinia } from '@pinia/testing'
-import { fromPartial } from '@total-typescript/shoehorn'
 import { mount } from '@vue/test-utils'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -11,6 +9,7 @@ import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import type { BaseDOMWidget } from '@/scripts/domWidget'
 import { useDomWidgetStore } from '@/stores/domWidgetStore'
+import { createTestingPinia } from '@pinia/testing'
 
 type TestWidget = BaseDOMWidget<object | string>
 
@@ -29,7 +28,7 @@ function createNode(
 }
 
 function createWidget(id: string, node: LGraphNode, y = 12): TestWidget {
-  return fromPartial<TestWidget>({
+  return {
     id,
     node,
     name: 'test_widget',
@@ -41,16 +40,16 @@ function createWidget(id: string, node: LGraphNode, y = 12): TestWidget {
     computedHeight: 40,
     margin: 10,
     isVisible: () => true
-  })
+  } as unknown as TestWidget
 }
 
 function createCanvas(graph: LGraph): LGraphCanvas {
-  return fromPartial<LGraphCanvas>({
+  return {
     graph,
     low_quality: false,
     read_only: false,
     isNodeVisible: vi.fn(() => true)
-  })
+  } as unknown as LGraphCanvas
 }
 
 function drawFrame(canvas: LGraphCanvas) {

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/components/graph/widgets/DomWidget.test.ts

@@ -1,14 +1,14 @@
-import { createTestingPinia } from '@pinia/testing'
-import { fromPartial } from '@total-typescript/shoehorn'
 import { mount } from '@vue/test-utils'
+import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { reactive } from 'vue'
 
+import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils'
 import type { BaseDOMWidget } from '@/scripts/domWidget'
 import type { DomWidgetState } from '@/stores/domWidgetStore'
 import { useDomWidgetStore } from '@/stores/domWidgetStore'
-import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils'
+
 import DomWidget from './DomWidget.vue'
 
 const mockUpdatePosition = vi.fn()
@@ -63,7 +63,7 @@ function createWidgetState(overrideDisabled: boolean): DomWidgetState {
     }
   })
 
-  const widget = fromPartial<BaseDOMWidget<object | string>>({
+  const widget = {
     id: 'dom-widget-id',
     name: 'test_widget',
     type: 'custom',
@@ -71,7 +71,7 @@ function createWidgetState(overrideDisabled: boolean): DomWidgetState {
     options: {},
     node,
     computedDisabled: false
-  })
+  } as unknown as BaseDOMWidget<object | string>
 
   domWidgetStore.registerWidget(widget)
   domWidgetStore.setPositionOverride(widget.id, {

src/components/graph/widgets/domWidgetZIndex.test.ts

@@ -1,7 +1,7 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { describe, expect, it } from 'vitest'
 
 import { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
+
 import { getDomWidgetZIndex } from './domWidgetZIndex'
 
 describe('getDomWidgetZIndex', () => {
@@ -15,7 +15,7 @@ describe('getDomWidgetZIndex', () => {
     first.order = 0
     second.order = 1
 
-    const nodes = fromPartial<{ _nodes: LGraphNode[] }>(graph)._nodes
+    const nodes = (graph as unknown as { _nodes: LGraphNode[] })._nodes
     nodes.splice(nodes.indexOf(first), 1)
     nodes.push(first)
 

src/components/load3d/Load3dViewerContent.vue

@@ -197,15 +197,4 @@ onBeforeUnmount(() => {
 :deep(.p-panel-content) {
   padding: 0;
 }
-
-:deep(.p-slider) {
-  height: 6px;
-}
-
-:deep(.p-slider-handle) {
-  width: 14px;
-  height: 14px;
-  margin-top: -4px;
-  margin-left: -7px;
-}
 </style>

src/components/load3d/controls/viewer/ViewerCameraControls.vue

@@ -1,7 +1,9 @@
 <template>
   <div class="space-y-4">
-    <div class="flex flex-col gap-2">
-      <label>{{ t('load3d.viewer.cameraType') }}</label>
+    <div class="space-y-4">
+      <label>
+        {{ t('load3d.viewer.cameraType') }}
+      </label>
       <Select
         v-model="cameraType"
         :options="cameras"
@@ -11,7 +13,7 @@
       </Select>
     </div>
 
-    <div v-if="showFOVButton" class="flex flex-col gap-2">
+    <div v-if="showFOVButton" class="space-y-4">
       <label>{{ t('load3d.fov') }}</label>
       <Slider
         v-model="fov"

src/components/load3d/controls/viewer/ViewerLightControls.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="flex flex-col gap-2">
+  <div class="space-y-4">
     <label>{{ $t('load3d.lightIntensity') }}</label>
 
     <Slider

src/components/load3d/controls/viewer/ViewerModelControls.vue

@@ -1,6 +1,6 @@
 <template>
   <div class="space-y-4">
-    <div class="flex flex-col gap-2">
+    <div>
       <label>{{ $t('load3d.upDirection') }}</label>
       <Select
         v-model="upDirection"
@@ -10,7 +10,7 @@
       />
     </div>
 
-    <div v-if="!hideMaterialMode" class="flex flex-col gap-2">
+    <div v-if="!hideMaterialMode">
       <label>{{ $t('load3d.materialMode') }}</label>
       <Select
         v-model="materialMode"

src/components/load3d/controls/viewer/ViewerSceneControls.vue

@@ -1,10 +1,10 @@
 <template>
   <div class="space-y-4">
-    <div v-if="!hasBackgroundImage" class="flex flex-col gap-2">
+    <div v-if="!hasBackgroundImage">
       <label>
         {{ $t('load3d.backgroundColor') }}
       </label>
-      <input v-model="backgroundColor" type="color" class="h-8 w-full" />
+      <input v-model="backgroundColor" type="color" class="w-full" />
     </div>
 
     <div>

src/components/rightSidePanel/RightSidePanel.vue

@@ -303,7 +303,6 @@ function handleTitleCancel() {
             v-if="isSingleSubgraphNode"
             variant="secondary"
             size="icon"
-            data-testid="subgraph-editor-toggle"
             :class="cn(isEditingSubgraph && 'bg-secondary-background-selected')"
             @click="
               rightSidePanelStore.openPanel(

src/components/rightSidePanel/errors/TabErrors.vue

@@ -15,7 +15,6 @@
     <div
       v-if="singleRuntimeErrorCard"
       data-testid="runtime-error-panel"
-      aria-live="polite"
       class="flex min-h-0 flex-1 flex-col overflow-hidden px-4 py-3"
     >
       <div
@@ -169,15 +168,7 @@
             v-else-if="group.type === 'missing_model'"
             :missing-model-groups="missingModelGroups"
             :show-node-id-badge="showNodeIdBadge"
-            @locate-model="handleLocateAssetNode"
-          />
-
-          <!-- Missing Media -->
-          <MissingMediaCard
-            v-else-if="group.type === 'missing_media'"
-            :missing-media-groups="missingMediaGroups"
-            :show-node-id-badge="showNodeIdBadge"
-            @locate-node="handleLocateAssetNode"
+            @locate-model="handleLocateModel"
           />
         </PropertiesAccordionItem>
       </TransitionGroup>
@@ -234,7 +225,6 @@ import ErrorNodeCard from './ErrorNodeCard.vue'
 import MissingNodeCard from './MissingNodeCard.vue'
 import SwapNodesCard from '@/platform/nodeReplacement/components/SwapNodesCard.vue'
 import MissingModelCard from '@/platform/missingModel/components/MissingModelCard.vue'
-import MissingMediaCard from '@/platform/missingMedia/components/MissingMediaCard.vue'
 import { isCloud } from '@/platform/distribution/types'
 import {
   downloadModel,
@@ -271,8 +261,7 @@ const isSearching = computed(() => searchQuery.value.trim() !== '')
 const fullSizeGroupTypes = new Set([
   'missing_node',
   'swap_nodes',
-  'missing_model',
-  'missing_media'
+  'missing_model'
 ])
 function getGroupSize(group: ErrorGroup) {
   return fullSizeGroupTypes.has(group.type) ? 'lg' : 'default'
@@ -294,7 +283,6 @@ const {
   missingNodeCache,
   missingPackGroups,
   missingModelGroups,
-  missingMediaGroups,
   swapNodeGroups
 } = useErrorGroups(searchQuery, t)
 
@@ -405,7 +393,7 @@ function handleLocateMissingNode(nodeId: string) {
   focusNode(nodeId, missingNodeCache.value)
 }
 
-function handleLocateAssetNode(nodeId: string) {
+function handleLocateModel(nodeId: string) {
   focusNode(nodeId)
 }
 

src/components/rightSidePanel/errors/swapNodeGroups.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { createPinia, setActivePinia } from 'pinia'
 import { nextTick, ref } from 'vue'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -160,7 +159,7 @@ describe('swapNodeGroups computed', () => {
 
   it('excludes string nodeType entries', async () => {
     const swap = getSwapNodeGroups([
-      fromAny<MissingNodeType, unknown>('StringGroupNode'),
+      'StringGroupNode' as unknown as MissingNodeType,
       makeMissingNodeType('OldNode', {
         nodeId: '1',
         isReplaceable: true,

src/components/rightSidePanel/errors/types.ts

@@ -25,4 +25,3 @@ export type ErrorGroup =
   | { type: 'missing_node'; title: string; priority: number }
   | { type: 'swap_nodes'; title: string; priority: number }
   | { type: 'missing_model'; title: string; priority: number }
-  | { type: 'missing_media'; title: string; priority: number }

src/components/rightSidePanel/errors/useErrorActions.ts

@@ -20,7 +20,7 @@ export function useErrorActions() {
       is_external: true,
       source: 'error_dialog'
     })
-    return commandStore.execute('Comfy.ContactSupport')
+    void commandStore.execute('Comfy.ContactSupport')
   }
 
   function findOnGitHub(errorMessage: string) {

src/components/rightSidePanel/errors/useErrorGroups.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { createPinia, setActivePinia } from 'pinia'
 import { nextTick, ref } from 'vue'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -216,7 +215,7 @@ describe('useErrorGroups', () => {
       const { groups } = createErrorGroups()
       const missingNodesStore = useMissingNodesErrorStore()
       missingNodesStore.setMissingNodeTypes([
-        fromAny<MissingNodeType, unknown>('StringGroupNode')
+        'StringGroupNode' as unknown as MissingNodeType
       ])
       await nextTick()
 

src/components/rightSidePanel/errors/useErrorGroups.ts

@@ -4,7 +4,6 @@ import Fuse from 'fuse.js'
 import type { IFuseOptions } from 'fuse.js'
 
 import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
-import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore'
 import { useExecutionErrorStore } from '@/stores/executionErrorStore'
 import { useMissingNodesErrorStore } from '@/platform/nodeReplacement/missingNodesErrorStore'
 import { useComfyRegistryStore } from '@/stores/comfyRegistryStore'
@@ -30,9 +29,7 @@ import type {
   MissingModelCandidate,
   MissingModelGroup
 } from '@/platform/missingModel/types'
-import type { MissingMediaGroup } from '@/platform/missingMedia/types'
 import { groupCandidatesByName } from '@/platform/missingModel/missingModelScan'
-import { groupCandidatesByMediaType } from '@/platform/missingMedia/missingMediaScan'
 import {
   isNodeExecutionId,
   compareExecutionId
@@ -242,7 +239,6 @@ export function useErrorGroups(
   const executionErrorStore = useExecutionErrorStore()
   const missingNodesStore = useMissingNodesErrorStore()
   const missingModelStore = useMissingModelStore()
-  const missingMediaStore = useMissingMediaStore()
   const canvasStore = useCanvasStore()
   const { inferPackFromNodeName } = useComfyRegistryStore()
   const collapseState = reactive<Record<string, boolean>>({})
@@ -639,27 +635,6 @@ export function useErrorGroups(
     ]
   }
 
-  const missingMediaGroups = computed<MissingMediaGroup[]>(() => {
-    const candidates = missingMediaStore.missingMediaCandidates
-    if (!candidates?.length) return []
-    return groupCandidatesByMediaType(candidates)
-  })
-
-  function buildMissingMediaGroups(): ErrorGroup[] {
-    if (!missingMediaGroups.value.length) return []
-    const totalItems = missingMediaGroups.value.reduce(
-      (count, group) => count + group.items.length,
-      0
-    )
-    return [
-      {
-        type: 'missing_media' as const,
-        title: `${t('rightSidePanel.missingMedia.missingMediaTitle')} (${totalItems})`,
-        priority: 3
-      }
-    ]
-  }
-
   const allErrorGroups = computed<ErrorGroup[]>(() => {
     const groupsMap = new Map<string, GroupEntry>()
 
@@ -670,7 +645,6 @@ export function useErrorGroups(
     return [
       ...buildMissingNodeGroups(),
       ...buildMissingModelGroups(),
-      ...buildMissingMediaGroups(),
       ...toSortedGroups(groupsMap)
     ]
   })
@@ -689,7 +663,6 @@ export function useErrorGroups(
     return [
       ...buildMissingNodeGroups(),
       ...buildMissingModelGroups(),
-      ...buildMissingMediaGroups(),
       ...executionGroups
     ]
   })
@@ -726,7 +699,6 @@ export function useErrorGroups(
     groupedErrorMessages,
     missingPackGroups,
     missingModelGroups,
-    missingMediaGroups,
     swapNodeGroups
   }
 }

src/components/rightSidePanel/errors/useErrorReport.ts

@@ -1,4 +1,4 @@
-import { computed, reactive, toValue, watch } from 'vue'
+import { computed, onMounted, onUnmounted, reactive, toValue } from 'vue'
 
 import type { MaybeRefOrGetter } from 'vue'
 
@@ -28,73 +28,66 @@ export function useErrorReport(cardSource: MaybeRefOrGetter<ErrorCardData>) {
     )
   })
 
-  watch(
-    () => toValue(cardSource),
-    async (card, _, onCleanup) => {
-      let cancelled = false
-      onCleanup(() => {
-        cancelled = true
-      })
+  let cancelled = false
+  onUnmounted(() => {
+    cancelled = true
+  })
 
-      for (const key of Object.keys(enrichedDetails)) {
-        delete enrichedDetails[key as unknown as number]
-      }
+  onMounted(async () => {
+    const card = toValue(cardSource)
+    const runtimeErrors = card.errors
+      .map((error, idx) => ({ error, idx }))
+      .filter(({ error }) => error.isRuntimeError)
 
-      const runtimeErrors = card.errors
-        .map((error, idx) => ({ error, idx }))
-        .filter(({ error }) => error.isRuntimeError)
+    if (runtimeErrors.length === 0) return
 
-      if (runtimeErrors.length === 0) return
-
-      if (!systemStatsStore.systemStats) {
-        if (systemStatsStore.isLoading) {
-          await until(() => systemStatsStore.isLoading).toBe(false)
-        } else {
-          try {
-            await systemStatsStore.refetchSystemStats()
-          } catch (e) {
-            console.warn('Failed to fetch system stats for error report:', e)
-            return
-          }
-        }
-      }
-      if (!systemStatsStore.systemStats || cancelled) return
-
-      const logs = await api
-        .getLogs()
-        .catch(() => 'Failed to retrieve server logs')
-      if (cancelled) return
-
-      const workflow = (() => {
+    if (!systemStatsStore.systemStats) {
+      if (systemStatsStore.isLoading) {
+        await until(systemStatsStore.isLoading).toBe(false)
+      } else {
         try {
-          return app.rootGraph.serialize()
+          await systemStatsStore.refetchSystemStats()
         } catch (e) {
-          console.warn('Failed to serialize workflow for error report:', e)
-          return null
-        }
-      })()
-      if (!workflow) return
-
-      for (const { error, idx } of runtimeErrors) {
-        try {
-          const report = generateErrorReport({
-            exceptionType: error.exceptionType ?? FALLBACK_EXCEPTION_TYPE,
-            exceptionMessage: error.message,
-            traceback: error.details,
-            nodeId: card.nodeId,
-            nodeType: card.title,
-            systemStats: systemStatsStore.systemStats,
-            serverLogs: logs,
-            workflow
-          })
-          enrichedDetails[idx] = report
-        } catch (e) {
-          console.warn('Failed to generate error report:', e)
+          console.warn('Failed to fetch system stats for error report:', e)
+          return
         }
       }
-    },
-    { immediate: true }
-  )
+    }
+    if (!systemStatsStore.systemStats || cancelled) return
+
+    const logs = await api
+      .getLogs()
+      .catch(() => 'Failed to retrieve server logs')
+    if (cancelled) return
+
+    const workflow = (() => {
+      try {
+        return app.rootGraph.serialize()
+      } catch (e) {
+        console.warn('Failed to serialize workflow for error report:', e)
+        return null
+      }
+    })()
+    if (!workflow) return
+
+    for (const { error, idx } of runtimeErrors) {
+      try {
+        const report = generateErrorReport({
+          exceptionType: error.exceptionType ?? FALLBACK_EXCEPTION_TYPE,
+          exceptionMessage: error.message,
+          traceback: error.details,
+          nodeId: card.nodeId,
+          nodeType: card.title,
+          systemStats: systemStatsStore.systemStats,
+          serverLogs: logs,
+          workflow
+        })
+        enrichedDetails[idx] = report
+      } catch (e) {
+        console.warn('Failed to generate error report:', e)
+      }
+    }
+  })
 
   return { displayedDetailsMap }
 }

src/components/rightSidePanel/parameters/SectionWidgets.vue

@@ -4,6 +4,7 @@ import { useI18n } from 'vue-i18n'
 
 import Button from '@/components/ui/button/Button.vue'
 import { isPromotedWidgetView } from '@/core/graph/subgraph/promotedWidgetTypes'
+import { getSourceNodeId } from '@/core/graph/subgraph/promotionUtils'
 import type { LGraphGroup, LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { SubgraphNode } from '@/lib/litegraph/src/litegraph'
 import { usePromotionStore } from '@/stores/promotionStore'
@@ -78,6 +79,7 @@ function isWidgetShownOnParents(
 ): boolean {
   return parents.some((parent) => {
     if (isPromotedWidgetView(widget)) {
+      const sourceNodeId = getSourceNodeId(widget)
       const interiorNodeId =
         String(widgetNode.id) === String(parent.id)
           ? widget.sourceNodeId
@@ -86,7 +88,7 @@ function isWidgetShownOnParents(
       return promotionStore.isPromoted(parent.rootGraph.id, parent.id, {
         sourceNodeId: interiorNodeId,
         sourceWidgetName: widget.sourceWidgetName,
-        disambiguatingSourceNodeId: widget.disambiguatingSourceNodeId
+        disambiguatingSourceNodeId: sourceNodeId
       })
     }
     return promotionStore.isPromoted(parent.rootGraph.id, parent.id, {

src/components/rightSidePanel/parameters/TabSubgraphInputs.vue

@@ -14,7 +14,10 @@ import {
 import { useI18n } from 'vue-i18n'
 
 import { isPromotedWidgetView } from '@/core/graph/subgraph/promotedWidgetTypes'
-import { getWidgetName } from '@/core/graph/subgraph/promotionUtils'
+import {
+  getSourceNodeId,
+  getWidgetName
+} from '@/core/graph/subgraph/promotionUtils'
 import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
 import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
 import FormSearchInput from '@/renderer/extensions/vueNodes/widgets/components/form/FormSearchInput.vue'
@@ -129,9 +132,7 @@ const advancedInputsWidgets = computed((): NodeWidgetsList => {
       !promotionStore.isPromoted(node.rootGraph.id, node.id, {
         sourceNodeId: String(interiorNode.id),
         sourceWidgetName: getWidgetName(widget),
-        disambiguatingSourceNodeId: isPromotedWidgetView(widget)
-          ? widget.disambiguatingSourceNodeId
-          : undefined
+        disambiguatingSourceNodeId: getSourceNodeId(widget)
       })
   )
 })

src/components/rightSidePanel/parameters/WidgetActions.test.ts

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { mount } from '@vue/test-utils'
 import { setActivePinia } from 'pinia'
 import type { Slots } from 'vue'
@@ -11,6 +10,7 @@ import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { usePromotionStore } from '@/stores/promotionStore'
+
 import WidgetActions from './WidgetActions.vue'
 
 const { mockGetInputSpecForWidget } = vi.hoisted(() => ({
@@ -93,14 +93,13 @@ describe('WidgetActions', () => {
   }
 
   function createMockNode(): LGraphNode {
-    return fromAny<LGraphNode, unknown>({
+    return {
       id: 1,
       type: 'TestNode',
       rootGraph: { id: 'graph-test' },
       computeSize: vi.fn(),
-      size: [200, 100],
-      isSubgraphNode: () => false
-    })
+      size: [200, 100]
+    } as unknown as LGraphNode
   }
 
   function mountWidgetActions(widget: IBaseWidget, node: LGraphNode) {
@@ -217,18 +216,17 @@ describe('WidgetActions', () => {
     mockGetInputSpecForWidget.mockReturnValue({
       type: 'CUSTOM'
     })
-    const parentSubgraphNode = fromAny<SubgraphNode, unknown>({
+    const parentSubgraphNode = {
       id: 4,
       rootGraph: { id: 'graph-test' },
       computeSize: vi.fn(),
       size: [300, 150]
-    })
-    const node = fromAny<LGraphNode, unknown>({
+    } as unknown as SubgraphNode
+    const node = {
       id: 4,
       type: 'SubgraphNode',
-      rootGraph: { id: 'graph-test' },
-      isSubgraphNode: () => false
-    })
+      rootGraph: { id: 'graph-test' }
+    } as unknown as LGraphNode
     const widget = {
       name: 'text',
       type: 'text',

src/components/rightSidePanel/parameters/WidgetActions.vue

@@ -9,7 +9,7 @@ import type { PromotedWidgetSource } from '@/core/graph/subgraph/promotedWidgetT
 import { isPromotedWidgetView } from '@/core/graph/subgraph/promotedWidgetTypes'
 import {
   demoteWidget,
-  isLinkedPromotion,
+  getSourceNodeId,
   promoteWidget
 } from '@/core/graph/subgraph/promotionUtils'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
@@ -47,11 +47,6 @@ const promotionStore = usePromotionStore()
 const { t } = useI18n()
 
 const hasParents = computed(() => parents?.length > 0)
-const isLinked = computed(() => {
-  if (!node.isSubgraphNode() || !isPromotedWidgetView(widget)) return false
-  return isLinkedPromotion(node, widget.sourceNodeId, widget.sourceWidgetName)
-})
-const canToggleVisibility = computed(() => hasParents.value && !isLinked.value)
 const favoriteNode = computed(() =>
   isShownOnParents && hasParents.value ? parents[0] : node
 )
@@ -81,6 +76,8 @@ function handleHideInput() {
   if (!parents?.length) return
 
   if (isPromotedWidgetView(widget)) {
+    const disambiguatingSourceNodeId = getSourceNodeId(widget)
+
     for (const parent of parents) {
       const source: PromotedWidgetSource = {
         sourceNodeId:
@@ -88,7 +85,7 @@ function handleHideInput() {
             ? widget.sourceNodeId
             : String(node.id),
         sourceWidgetName: widget.sourceWidgetName,
-        disambiguatingSourceNodeId: widget.disambiguatingSourceNodeId
+        disambiguatingSourceNodeId
       }
       promotionStore.demote(parent.rootGraph.id, parent.id, source)
       parent.computeSize(parent.size)
@@ -117,7 +114,6 @@ function handleResetToDefault() {
 <template>
   <MoreButton
     is-vertical
-    data-testid="widget-actions-menu-button"
     class="bg-transparent text-muted-foreground transition-all hover:bg-secondary-background-hover hover:text-base-foreground active:scale-95"
   >
     <template #default="{ close }">
@@ -137,7 +133,7 @@ function handleResetToDefault() {
       </Button>
 
       <Button
-        v-if="canToggleVisibility"
+        v-if="hasParents"
         variant="textonly"
         size="unset"
         class="flex w-full items-center gap-2 rounded-sm px-3 py-2 text-sm transition-all active:scale-95"

src/components/rightSidePanel/parameters/WidgetItem.test.ts

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { mount } from '@vue/test-utils'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -73,13 +72,13 @@ const i18n = createI18n({
 })
 
 function createMockNode(overrides: Partial<LGraphNode> = {}): LGraphNode {
-  return fromAny<LGraphNode, unknown>({
+  return {
     id: 1,
     type: 'TestNode',
     isSubgraphNode: () => false,
     graph: { rootGraph: { id: 'test-graph-id' } },
     ...overrides
-  })
+  } as unknown as LGraphNode
 }
 
 function createMockWidget(overrides: Partial<IBaseWidget> = {}): IBaseWidget {
@@ -129,7 +128,7 @@ function createMockPromotedWidgetView(
       return 0
     }
   }
-  return fromAny<IBaseWidget, unknown>(new MockPromotedWidgetView())
+  return new MockPromotedWidgetView() as unknown as IBaseWidget
 }
 
 function mountWidgetItem(

src/components/rightSidePanel/subgraph/SubgraphEditor.vue

@@ -11,7 +11,6 @@ import {
   getPromotableWidgets,
   getSourceNodeId,
   getWidgetName,
-  isLinkedPromotion,
   isRecommendedWidget,
   promoteWidget,
   pruneDisconnected
@@ -89,13 +88,14 @@ const activeWidgets = computed<WidgetItem[]>({
     promotionStore.setPromotions(
       node.rootGraph.id,
       node.id,
-      value.map(([n, w]) => ({
-        sourceNodeId: String(n.id),
-        sourceWidgetName: getWidgetName(w),
-        disambiguatingSourceNodeId: isPromotedWidgetView(w)
-          ? w.disambiguatingSourceNodeId
-          : undefined
-      }))
+      value.map(([n, w]) => {
+        const sid = getSourceNodeId(w)
+        return {
+          sourceNodeId: String(n.id),
+          sourceWidgetName: getWidgetName(w),
+          ...(sid && { disambiguatingSourceNodeId: sid })
+        }
+      })
     )
     refreshPromotedWidgetRendering()
   }
@@ -123,9 +123,7 @@ const candidateWidgets = computed<WidgetItem[]>(() => {
       !promotionStore.isPromoted(node.rootGraph.id, node.id, {
         sourceNodeId: String(n.id),
         sourceWidgetName: getWidgetName(w),
-        disambiguatingSourceNodeId: isPromotedWidgetView(w)
-          ? w.disambiguatingSourceNodeId
-          : undefined
+        disambiguatingSourceNodeId: getSourceNodeId(w)
       })
   )
 })
@@ -164,18 +162,6 @@ function refreshPromotedWidgetRendering() {
   canvasStore.canvas?.setDirty(true, true)
 }
 
-function isItemLinked([node, widget]: WidgetItem): boolean {
-  return (
-    node.id === -1 ||
-    (!!activeNode.value &&
-      isLinkedPromotion(
-        activeNode.value,
-        String(node.id),
-        getWidgetName(widget)
-      ))
-  )
-}
-
 function toKey(item: WidgetItem) {
   const sid = getSourceNodeId(item[1])
   return sid
@@ -201,14 +187,8 @@ function showAll() {
   }
 }
 function hideAll() {
-  const node = activeNode.value
   for (const item of filteredActive.value) {
     if (String(item[0].id) === '-1') continue
-    if (
-      node &&
-      isLinkedPromotion(node, String(item[0].id), getWidgetName(item[1]))
-    )
-      continue
     demote(item)
   }
 }
@@ -243,7 +223,6 @@ onMounted(() => {
 
       <div
         v-if="filteredActive.length"
-        data-testid="subgraph-editor-shown-section"
         class="flex flex-col border-b border-interface-stroke"
       >
         <div
@@ -265,8 +244,8 @@ onMounted(() => {
             :key="toKey([node, widget])"
             :class="cn(!searchQuery && dragClass, 'bg-comfy-menu-bg')"
             :node-title="node.title"
-            :widget-name="widget.label || widget.name"
-            :is-physical="isItemLinked([node, widget])"
+            :widget-name="widget.name"
+            :is-physical="node.id === -1"
             :is-draggable="!searchQuery"
             @toggle-visibility="demote([node, widget])"
           />
@@ -275,7 +254,6 @@ onMounted(() => {
 
       <div
         v-if="filteredCandidates.length"
-        data-testid="subgraph-editor-hidden-section"
         class="flex flex-col border-b border-interface-stroke"
       >
         <div

src/components/rightSidePanel/subgraph/SubgraphNodeWidget.vue

@@ -1,17 +1,9 @@
 <script setup lang="ts">
-import { computed } from 'vue'
-
 import Button from '@/components/ui/button/Button.vue'
 import { cn } from '@/utils/tailwindUtil'
 import type { ClassValue } from '@/utils/tailwindUtil'
 
-const {
-  nodeTitle,
-  widgetName,
-  isDraggable = false,
-  isPhysical = false,
-  class: className
-} = defineProps<{
+const props = defineProps<{
   nodeTitle: string
   widgetName: string
   isDraggable?: boolean
@@ -22,13 +14,13 @@ defineEmits<{
   (e: 'toggleVisibility'): void
 }>()
 
-const icon = computed(() =>
-  isPhysical
+function getIcon() {
+  return props.isPhysical
     ? 'icon-[lucide--link]'
-    : isDraggable
+    : props.isDraggable
       ? 'icon-[lucide--eye]'
       : 'icon-[lucide--eye-off]'
-)
+}
 </script>
 
 <template>
@@ -37,8 +29,8 @@ const icon = computed(() =>
       cn(
         'flex items-center gap-1 rounded-sm px-2 py-1 break-all',
         'bg-node-component-surface',
-        isDraggable && 'ring-accent-background hover:ring-1',
-        className
+        props.isDraggable && 'ring-accent-background hover:ring-1',
+        props.class
       )
     "
   >
@@ -46,18 +38,15 @@ const icon = computed(() =>
       <div class="line-clamp-1 text-xs text-text-secondary">
         {{ nodeTitle }}
       </div>
-      <div class="line-clamp-1 text-sm/8" data-testid="subgraph-widget-label">
-        {{ widgetName }}
-      </div>
+      <div class="line-clamp-1 text-sm/8">{{ widgetName }}</div>
     </div>
     <Button
       variant="muted-textonly"
       size="sm"
-      data-testid="subgraph-widget-toggle"
       :disabled="isPhysical"
       @click.stop="$emit('toggleVisibility')"
     >
-      <i :class="icon" :data-testid="isPhysical ? 'icon-link' : 'icon-eye'" />
+      <i :class="getIcon()" />
     </Button>
     <div
       v-if="isDraggable"

src/composables/element/useDomClipping.test.ts

@@ -1,4 +1,3 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
 
 import { useDomClipping } from './useDomClipping'
@@ -9,7 +8,7 @@ function createMockElement(rect: {
   width: number
   height: number
 }): HTMLElement {
-  return fromPartial<HTMLElement>({
+  return {
     getBoundingClientRect: vi.fn(
       () =>
         ({
@@ -21,7 +20,7 @@ function createMockElement(rect: {
           toJSON: () => ({})
         }) as DOMRect
     )
-  })
+  } as unknown as HTMLElement
 }
 
 function createMockCanvas(rect: {
@@ -30,7 +29,7 @@ function createMockCanvas(rect: {
   width: number
   height: number
 }): HTMLCanvasElement {
-  return fromPartial<HTMLCanvasElement>({
+  return {
     getBoundingClientRect: vi.fn(
       () =>
         ({
@@ -42,7 +41,7 @@ function createMockCanvas(rect: {
           toJSON: () => ({})
         }) as DOMRect
     )
-  })
+  } as unknown as HTMLCanvasElement
 }
 
 describe('useDomClipping', () => {

src/composables/graph/useErrorClearingHooks.test.ts

@@ -1,6 +1,5 @@
-import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
+import { createTestingPinia } from '@pinia/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { installErrorClearingHooks } from '@/composables/graph/useErrorClearingHooks'
@@ -195,7 +194,7 @@ describe('Widget change error clearing via onWidgetChanged', () => {
 
     const store = useExecutionErrorStore()
     vi.spyOn(app, 'rootGraph', 'get').mockReturnValue(
-      fromAny<LGraph, unknown>(undefined)
+      undefined as unknown as LGraph
     )
     store.lastNodeErrors = {
       [String(node.id)]: {

src/composables/graph/useGraphHierarchy.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { Rectangle } from '@/lib/litegraph/src/infrastructure/Rectangle'
@@ -9,6 +8,7 @@ import {
   createMockLGraphNode,
   createMockLGraphGroup
 } from '@/utils/__tests__/litegraphTestUtils'
+
 import { useGraphHierarchy } from './useGraphHierarchy'
 
 vi.mock('@/renderer/core/canvas/canvasStore')
@@ -36,10 +36,7 @@ describe('useGraphHierarchy', () => {
     mockNode = createMockNode()
     mockGroups = []
 
-    mockCanvasStore = fromAny<
-      Partial<ReturnType<typeof useCanvasStore>>,
-      unknown
-    >({
+    mockCanvasStore = {
       canvas: {
         graph: {
           groups: mockGroups
@@ -54,7 +51,7 @@ describe('useGraphHierarchy', () => {
       $dispose: vi.fn(),
       _customProperties: new Set(),
       _p: {}
-    })
+    } as unknown as Partial<ReturnType<typeof useCanvasStore>>
 
     vi.mocked(useCanvasStore).mockReturnValue(
       mockCanvasStore as ReturnType<typeof useCanvasStore>

src/composables/graph/useGraphNodeManager.test.ts

@@ -1,6 +1,5 @@
-import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
+import { createTestingPinia } from '@pinia/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { computed, nextTick, watch } from 'vue'
 
@@ -12,10 +11,10 @@ import {
   createTestSubgraphNode
 } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers'
 import { NodeSlotType } from '@/lib/litegraph/src/types/globalEnums'
-import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
-import { useSettingStore } from '@/platform/settings/settingStore'
 import { app } from '@/scripts/app'
 import { useExecutionErrorStore } from '@/stores/executionErrorStore'
+import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
+import { useSettingStore } from '@/platform/settings/settingStore'
 import { usePromotionStore } from '@/stores/promotionStore'
 import { useWidgetValueStore } from '@/stores/widgetValueStore'
 
@@ -278,20 +277,18 @@ describe('Widget slotMetadata reactivity on link disconnect', () => {
     const secondPromotedView = promotedViews[1]
     if (!secondPromotedView) throw new Error('Expected second promoted view')
 
-    fromAny<
-      {
+    ;(
+      secondPromotedView as unknown as {
         sourceNodeId: string
         sourceWidgetName: string
-      },
-      unknown
-    >(secondPromotedView).sourceNodeId = '9999'
-    fromAny<
-      {
+      }
+    ).sourceNodeId = '9999'
+    ;(
+      secondPromotedView as unknown as {
         sourceNodeId: string
         sourceWidgetName: string
-      },
-      unknown
-    >(secondPromotedView).sourceWidgetName = 'stale_widget'
+      }
+    ).sourceWidgetName = 'stale_widget'
 
     const { vueNodeData } = useGraphNodeManager(graph)
     const nodeData = vueNodeData.get(String(subgraphNode.id))

src/composables/graph/useImageMenuOptions.test.ts

@@ -1,8 +1,8 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
 import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils'
+
 import { useImageMenuOptions } from './useImageMenuOptions'
 
 vi.mock('vue-i18n', async (importOriginal) => {
@@ -112,11 +112,9 @@ describe('useImageMenuOptions', () => {
         getType: vi.fn().mockResolvedValue(mockBlob)
       }
 
-      mockClipboard(
-        fromPartial<Clipboard>({
-          read: vi.fn().mockResolvedValue([mockClipboardItem])
-        })
-      )
+      mockClipboard({
+        read: vi.fn().mockResolvedValue([mockClipboardItem])
+      } as unknown as Clipboard)
 
       const { getImageMenuOptions } = useImageMenuOptions()
       const options = getImageMenuOptions(node)
@@ -133,7 +131,7 @@ describe('useImageMenuOptions', () => {
 
     it('handles missing clipboard API gracefully', async () => {
       const node = createImageNode()
-      mockClipboard(fromPartial<Clipboard>({ read: undefined }))
+      mockClipboard({ read: undefined } as unknown as Clipboard)
 
       const { getImageMenuOptions } = useImageMenuOptions()
       const options = getImageMenuOptions(node)
@@ -150,11 +148,9 @@ describe('useImageMenuOptions', () => {
         getType: vi.fn()
       }
 
-      mockClipboard(
-        fromPartial<Clipboard>({
-          read: vi.fn().mockResolvedValue([mockClipboardItem])
-        })
-      )
+      mockClipboard({
+        read: vi.fn().mockResolvedValue([mockClipboardItem])
+      } as unknown as Clipboard)
 
       const { getImageMenuOptions } = useImageMenuOptions()
       const options = getImageMenuOptions(node)

src/composables/graph/useNodeErrorFlagSync.ts

@@ -3,7 +3,6 @@ import { computed, watch } from 'vue'
 
 import type { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
-import type { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore'
 import { useSettingStore } from '@/platform/settings/settingStore'
 import { app } from '@/scripts/app'
 import type { NodeError } from '@/schemas/apiSchema'
@@ -33,8 +32,7 @@ function setNodeHasErrors(node: LGraphNode, hasErrors: boolean): void {
 function reconcileNodeErrorFlags(
   rootGraph: LGraph,
   nodeErrors: Record<string, NodeError> | null,
-  missingModelExecIds: Set<string>,
-  missingMediaExecIds: Set<string> = new Set()
+  missingModelExecIds: Set<string>
 ): void {
   // Collect nodes and slot info that should be flagged
   // Includes both error-owning nodes and their ancestor containers
@@ -66,11 +64,6 @@ function reconcileNodeErrorFlags(
     if (node) flaggedNodes.add(node)
   }
 
-  for (const execId of missingMediaExecIds) {
-    const node = getNodeByExecutionId(rootGraph, execId)
-    if (node) flaggedNodes.add(node)
-  }
-
   forEachNode(rootGraph, (node) => {
     setNodeHasErrors(node, flaggedNodes.has(node))
 
@@ -85,8 +78,7 @@ function reconcileNodeErrorFlags(
 
 export function useNodeErrorFlagSync(
   lastNodeErrors: Ref<Record<string, NodeError> | null>,
-  missingModelStore: ReturnType<typeof useMissingModelStore>,
-  missingMediaStore: ReturnType<typeof useMissingMediaStore>
+  missingModelStore: ReturnType<typeof useMissingModelStore>
 ): () => void {
   const settingStore = useSettingStore()
   const showErrorsTab = computed(() =>
@@ -97,13 +89,12 @@ export function useNodeErrorFlagSync(
     [
       lastNodeErrors,
       () => missingModelStore.missingModelNodeIds,
-      () => missingMediaStore.missingMediaNodeIds,
       showErrorsTab
     ],
     () => {
       if (!app.isGraphReady) return
-      // Legacy (LGraphNode) only: suppress missing-model/media error flags
-      // when the Errors tab is hidden, since legacy nodes lack the per-widget
+      // Legacy (LGraphNode) only: suppress missing-model error flags when
+      // the Errors tab is hidden, since legacy nodes lack the per-widget
       // red highlight that Vue nodes use to indicate *why* a node has errors.
       // Vue nodes compute hasAnyError independently and are unaffected.
       reconcileNodeErrorFlags(
@@ -111,9 +102,6 @@ export function useNodeErrorFlagSync(
         lastNodeErrors.value,
         showErrorsTab.value
           ? missingModelStore.missingModelAncestorExecutionIds
-          : new Set(),
-        showErrorsTab.value
-          ? missingMediaStore.missingMediaAncestorExecutionIds
           : new Set()
       )
     },

src/composables/maskeditor/useMaskEditorSaver.test.ts

@@ -1,11 +1,10 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny, fromPartial } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { api } from '@/scripts/api'
 import { app } from '@/scripts/app'
+import { api } from '@/scripts/api'
 import { useNodeOutputStore } from '@/stores/nodeOutputStore'
 import { useMaskEditorSaver } from './useMaskEditorSaver'
 
@@ -22,7 +21,7 @@ vi.mock('@/stores/maskEditorDataStore', () => ({
 }))
 
 function createMockCtx(): CanvasRenderingContext2D {
-  return fromPartial<CanvasRenderingContext2D>({
+  return {
     drawImage: vi.fn(),
     getImageData: vi.fn(() => ({
       data: new Uint8ClampedArray(4 * 4 * 4),
@@ -31,11 +30,11 @@ function createMockCtx(): CanvasRenderingContext2D {
     })),
     putImageData: vi.fn(),
     globalCompositeOperation: 'source-over'
-  })
+  } as unknown as CanvasRenderingContext2D
 }
 
 function createMockCanvas(): HTMLCanvasElement {
-  return fromPartial<HTMLCanvasElement>({
+  return {
     width: 4,
     height: 4,
     getContext: vi.fn(() => createMockCtx()),
@@ -43,7 +42,7 @@ function createMockCanvas(): HTMLCanvasElement {
       cb(new Blob(['x'], { type: 'image/png' }))
     }),
     toDataURL: vi.fn(() => 'data:image/png;base64,mock')
-  })
+  } as unknown as HTMLCanvasElement
 }
 
 const mockEditorStore: Record<string, HTMLCanvasElement | null> = {
@@ -97,7 +96,7 @@ describe('useMaskEditorSaver', () => {
     app.nodeOutputs = {}
     app.nodePreviewImages = {}
 
-    mockNode = fromAny<LGraphNode, unknown>({
+    mockNode = {
       id: 42,
       type: 'LoadImage',
       images: [],
@@ -108,7 +107,7 @@ describe('useMaskEditorSaver', () => {
       widgets_values: ['original.png [input]'],
       properties: { image: 'original.png [input]' },
       graph: { setDirtyCanvas: vi.fn() }
-    })
+    } as unknown as LGraphNode
 
     mockDataStore.sourceNode = mockNode
     mockDataStore.inputData = {
@@ -136,7 +135,7 @@ describe('useMaskEditorSaver', () => {
     vi.spyOn(document, 'createElement').mockImplementation(
       (tagName: string, options?: ElementCreationOptions) => {
         if (tagName === 'canvas')
-          return fromAny<HTMLCanvasElement, unknown>(createMockCanvas())
+          return createMockCanvas() as unknown as HTMLCanvasElement
         return originalCreateElement(tagName, options)
       }
     )

src/composables/node/useNodeImageUpload.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
@@ -45,12 +44,12 @@ vi.mock('@/stores/assetsStore', () => ({
 }))
 
 function createMockNode(): LGraphNode {
-  return fromAny<LGraphNode, unknown>({
+  return {
     isUploading: false,
     imgs: [new Image()],
     graph: { setDirtyCanvas: vi.fn() },
     size: [300, 400]
-  })
+  } as unknown as LGraphNode
 }
 
 function createFile(name = 'test.png'): File {

src/composables/node/useNodePreviewAndDrag.test.ts

@@ -1,8 +1,8 @@
-import { fromAny, fromPartial } from '@total-typescript/shoehorn'
 import { ref } from 'vue'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore'
+
 import { useNodePreviewAndDrag } from './useNodePreviewAndDrag'
 
 const mockStartDrag = vi.fn()
@@ -72,9 +72,9 @@ describe('useNodePreviewAndDrag', () => {
         toJSON: () => ({})
       })
 
-      const mockEvent = fromPartial<MouseEvent>({
+      const mockEvent = {
         currentTarget: mockElement
-      })
+      } as Partial<MouseEvent> as MouseEvent
       result.handleMouseEnter(mockEvent)
 
       expect(result.isHovered.value).toBe(true)
@@ -85,9 +85,9 @@ describe('useNodePreviewAndDrag', () => {
       const result = useNodePreviewAndDrag(nodeDef)
 
       const mockElement = document.createElement('div')
-      const mockEvent = fromPartial<MouseEvent>({
+      const mockEvent = {
         currentTarget: mockElement
-      })
+      } as Partial<MouseEvent> as MouseEvent
       result.handleMouseEnter(mockEvent)
 
       expect(result.isHovered.value).toBe(false)
@@ -116,9 +116,9 @@ describe('useNodePreviewAndDrag', () => {
         setData: vi.fn(),
         setDragImage: vi.fn()
       }
-      const mockEvent = fromAny<DragEvent, unknown>({
+      const mockEvent = {
         dataTransfer: mockDataTransfer
-      })
+      } as unknown as DragEvent
 
       result.handleDragStart(mockEvent)
 
@@ -151,10 +151,10 @@ describe('useNodePreviewAndDrag', () => {
 
       result.isDragging.value = true
 
-      const mockEvent = fromPartial<DragEvent>({
+      const mockEvent = {
         clientX: 100,
         clientY: 200
-      })
+      } as Partial<DragEvent> as DragEvent
 
       result.handleDragEnd(mockEvent)
 
@@ -168,11 +168,11 @@ describe('useNodePreviewAndDrag', () => {
 
       result.isDragging.value = true
 
-      const mockEvent = fromPartial<DragEvent>({
+      const mockEvent = {
         dataTransfer: { dropEffect: 'none' },
         clientX: 300,
         clientY: 400
-      })
+      } as Partial<DragEvent> as DragEvent
 
       result.handleDragEnd(mockEvent)
 

src/composables/useServerLogs.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { useEventListener } from '@vueuse/core'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { nextTick } from 'vue'
@@ -80,10 +79,10 @@ describe('useServerLogs', () => {
 
     // Simulate receiving a log event
     const mockEvent = new CustomEvent('logs', {
-      detail: fromAny<LogsWsMessage, unknown>({
+      detail: {
         type: 'logs',
         entries: [{ m: 'Log message 1' }, { m: 'Log message 2' }]
-      })
+      } as unknown as LogsWsMessage
     }) as CustomEvent<LogsWsMessage>
 
     eventCallback(mockEvent)
@@ -104,14 +103,14 @@ describe('useServerLogs', () => {
     ) => void
 
     const mockEvent = new CustomEvent('logs', {
-      detail: fromAny<LogsWsMessage, unknown>({
+      detail: {
         type: 'logs',
         entries: [
           { m: 'Log message 1 dont remove me' },
           { m: 'remove me' },
           { m: '' }
         ]
-      })
+      } as unknown as LogsWsMessage
     }) as CustomEvent<LogsWsMessage>
 
     eventCallback(mockEvent)

src/composables/useWaveAudioPlayer.test.ts

@@ -1,4 +1,3 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { ref } from 'vue'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
@@ -81,12 +80,10 @@ describe('useWaveAudioPlayer', () => {
 
     const mockDecodeAudioData = vi.fn(() => Promise.resolve(mockAudioBuffer))
     const mockClose = vi.fn().mockResolvedValue(undefined)
-    globalThis.AudioContext = fromAny<typeof AudioContext, unknown>(
-      class {
-        decodeAudioData = mockDecodeAudioData
-        close = mockClose
-      }
-    )
+    globalThis.AudioContext = class {
+      decodeAudioData = mockDecodeAudioData
+      close = mockClose
+    } as unknown as typeof AudioContext
 
     mockFetchApi.mockResolvedValue({
       ok: true,

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

@@ -1,7 +1,7 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { describe, expect, it } from 'vitest'
 
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
+
 import { matchPromotedInput } from './matchPromotedInput'
 
 type MockInput = {
@@ -31,12 +31,10 @@ describe(matchPromotedInput, () => {
     }
 
     const matched = matchPromotedInput(
-      fromPartial<
-        Array<{
-          name: string
-          _widget?: IBaseWidget
-        }>
-      >([aliasInput, exactInput]),
+      [aliasInput, exactInput] as unknown as Array<{
+        name: string
+        _widget?: IBaseWidget
+      }>,
       targetWidget
     )
 
@@ -50,7 +48,7 @@ describe(matchPromotedInput, () => {
     }
 
     const matched = matchPromotedInput(
-      fromPartial<Array<{ name: string; _widget?: IBaseWidget }>>([aliasInput]),
+      [aliasInput] as unknown as Array<{ name: string; _widget?: IBaseWidget }>,
       targetWidget
     )
 
@@ -67,12 +65,10 @@ describe(matchPromotedInput, () => {
     }
 
     const matched = matchPromotedInput(
-      fromPartial<
-        Array<{
-          name: string
-          _widget?: IBaseWidget
-        }>
-      >([firstAliasInput, secondAliasInput]),
+      [firstAliasInput, secondAliasInput] as unknown as Array<{
+        name: string
+        _widget?: IBaseWidget
+      }>,
       targetWidget
     )
 

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

@@ -1,7 +1,6 @@
 import { createTestingPinia } from '@pinia/testing'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, test, vi } from 'vitest'
-import { fromAny, fromPartial } from '@total-typescript/shoehorn'
 
 // Barrel import must come first to avoid circular dependency
 // (promotedWidgetView → widgetMap → BaseWidget → LegacyWidget → barrel)
@@ -98,12 +97,11 @@ function promotedWidgets(node: SubgraphNode): PromotedWidgetView[] {
 }
 
 function callSyncPromotions(node: SubgraphNode) {
-  fromAny<
-    {
+  ;(
+    node as unknown as {
       _syncPromotions: () => void
-    },
-    unknown
-  >(node)._syncPromotions()
+    }
+  )._syncPromotions()
 }
 
 describe(createPromotedWidgetView, () => {
@@ -158,9 +156,7 @@ describe(createPromotedWidgetView, () => {
     const [subgraphNode] = setupSubgraph()
     const view = createPromotedWidgetView(subgraphNode, '1', 'myWidget')
     // node is defined via Object.defineProperty at runtime but not on the TS interface
-    expect(fromAny<Record<string, unknown>, unknown>(view).node).toBe(
-      subgraphNode
-    )
+    expect((view as unknown as Record<string, unknown>).node).toBe(subgraphNode)
   })
 
   test('serialize is false', () => {
@@ -293,7 +289,7 @@ describe(createPromotedWidgetView, () => {
       value: 'initial',
       options: {}
     } satisfies Pick<IBaseWidget, 'name' | 'type' | 'value' | 'options'>
-    const fallbackWidget = fromPartial<IBaseWidget>(fallbackWidgetShape)
+    const fallbackWidget = fallbackWidgetShape as unknown as IBaseWidget
     innerNode.widgets = [fallbackWidget]
 
     const widgetValueStore = useWidgetValueStore()
@@ -402,13 +398,13 @@ describe(createPromotedWidgetView, () => {
     subgraphNode.pos = [10, 20]
     const innerNode = firstInnerNode(innerNodes)
     const mouse = vi.fn(() => true)
-    const legacyWidget = fromAny<IBaseWidget, unknown>({
+    const legacyWidget = {
       name: 'legacyMouse',
       type: 'mystery-legacy',
       value: 'val',
       options: {},
       mouse
-    })
+    } as unknown as IBaseWidget
     innerNode.widgets = [legacyWidget]
 
     const view = createPromotedWidgetView(
@@ -1452,20 +1448,17 @@ describe('widgets getter caching', () => {
     subgraphNode.rootGraph.primaryCanvas = fakeCanvas as LGraphCanvas
 
     const reconcileSpy = vi.spyOn(
-      fromAny<
-        {
-          _buildPromotionReconcileState: (
-            entries: Array<{ sourceNodeId: string; sourceWidgetName: string }>,
-            linkedEntries: Array<{
-              inputName: string
-              inputKey: string
-              sourceNodeId: string
-              sourceWidgetName: string
-            }>
-          ) => unknown
-        },
-        unknown
-      >(subgraphNode),
+      subgraphNode as unknown as {
+        _buildPromotionReconcileState: (
+          entries: Array<{ sourceNodeId: string; sourceWidgetName: string }>,
+          linkedEntries: Array<{
+            inputName: string
+            inputKey: string
+            sourceNodeId: string
+            sourceWidgetName: string
+          }>
+        ) => unknown
+      },
       '_buildPromotionReconcileState'
     )
 
@@ -1485,20 +1478,17 @@ describe('widgets getter caching', () => {
     subgraphNode.rootGraph.primaryCanvas = fakeCanvas as LGraphCanvas
 
     const reconcileSpy = vi.spyOn(
-      fromAny<
-        {
-          _buildPromotionReconcileState: (
-            entries: Array<{ sourceNodeId: string; sourceWidgetName: string }>,
-            linkedEntries: Array<{
-              inputName: string
-              inputKey: string
-              sourceNodeId: string
-              sourceWidgetName: string
-            }>
-          ) => unknown
-        },
-        unknown
-      >(subgraphNode),
+      subgraphNode as unknown as {
+        _buildPromotionReconcileState: (
+          entries: Array<{ sourceNodeId: string; sourceWidgetName: string }>,
+          linkedEntries: Array<{
+            inputName: string
+            inputKey: string
+            sourceNodeId: string
+            sourceWidgetName: string
+          }>
+        ) => unknown
+      },
       '_buildPromotionReconcileState'
     )
 
@@ -1532,14 +1522,9 @@ describe('widgets getter caching', () => {
     subgraph.inputNode.slots[0].connect(linkedInputB, linkedNodeB)
 
     const resolveSpy = vi.spyOn(
-      fromAny<
-        {
-          _resolveLinkedPromotionBySubgraphInput: (
-            ...args: unknown[]
-          ) => unknown
-        },
-        unknown
-      >(subgraphNode),
+      subgraphNode as unknown as {
+        _resolveLinkedPromotionBySubgraphInput: (...args: unknown[]) => unknown
+      },
       '_resolveLinkedPromotionBySubgraphInput'
     )
 
@@ -1938,34 +1923,32 @@ function createFakeCanvasContext() {
 
 function createInspectableCanvasContext(fillText = vi.fn()) {
   const fallback = vi.fn()
-  return fromAny<CanvasRenderingContext2D, unknown>(
-    new Proxy(
-      {
-        fillText,
-        beginPath: vi.fn(),
-        roundRect: vi.fn(),
-        rect: vi.fn(),
-        fill: vi.fn(),
-        stroke: vi.fn(),
-        moveTo: vi.fn(),
-        lineTo: vi.fn(),
-        arc: vi.fn(),
-        measureText: (text: string) => ({ width: text.length * 8 }),
-        fillStyle: '#fff',
-        strokeStyle: '#fff',
-        textAlign: 'left',
-        globalAlpha: 1,
-        lineWidth: 1
-      } as Record<string, unknown>,
-      {
-        get(target, key) {
-          if (typeof key === 'string' && key in target)
-            return target[key as keyof typeof target]
-          return fallback
-        }
+  return new Proxy(
+    {
+      fillText,
+      beginPath: vi.fn(),
+      roundRect: vi.fn(),
+      rect: vi.fn(),
+      fill: vi.fn(),
+      stroke: vi.fn(),
+      moveTo: vi.fn(),
+      lineTo: vi.fn(),
+      arc: vi.fn(),
+      measureText: (text: string) => ({ width: text.length * 8 }),
+      fillStyle: '#fff',
+      strokeStyle: '#fff',
+      textAlign: 'left',
+      globalAlpha: 1,
+      lineWidth: 1
+    } as Record<string, unknown>,
+    {
+      get(target, key) {
+        if (typeof key === 'string' && key in target)
+          return target[key as keyof typeof target]
+        return fallback
       }
-    )
-  )
+    }
+  ) as unknown as CanvasRenderingContext2D
 }
 
 function createTwoLevelNestedSubgraph() {

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

@@ -1,14 +1,13 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromPartial } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
+import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import {
   createTestSubgraph,
   createTestSubgraphNode
 } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers'
-import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { usePromotionStore } from '@/stores/promotionStore'
 
 const updatePreviewsMock = vi.hoisted(() => vi.fn())
@@ -20,7 +19,6 @@ import {
   CANVAS_IMAGE_PREVIEW_WIDGET,
   getPromotableWidgets,
   hasUnpromotedWidgets,
-  isLinkedPromotion,
   isPreviewPseudoWidget,
   promoteRecommendedWidgets,
   pruneDisconnected
@@ -31,7 +29,7 @@ function widget(
     Pick<IBaseWidget, 'name' | 'serialize' | 'type' | 'options'>
   >
 ): IBaseWidget {
-  return fromPartial<IBaseWidget>({ name: 'widget', ...overrides })
+  return { name: 'widget', ...overrides } as unknown as IBaseWidget
 }
 
 describe('isPreviewPseudoWidget', () => {
@@ -335,84 +333,3 @@ describe('hasUnpromotedWidgets', () => {
     expect(hasUnpromotedWidgets(subgraphNode)).toBe(false)
   })
 })
-
-describe('isLinkedPromotion', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-  })
-
-  function linkedWidget(
-    sourceNodeId: string,
-    sourceWidgetName: string,
-    extra: Record<string, unknown> = {}
-  ): IBaseWidget {
-    return {
-      sourceNodeId,
-      sourceWidgetName,
-      name: 'value',
-      type: 'text',
-      value: '',
-      options: {},
-      y: 0,
-      ...extra
-    } as unknown as IBaseWidget
-  }
-
-  function createSubgraphWithInputs(count = 1) {
-    const subgraph = createTestSubgraph({
-      inputs: Array.from({ length: count }, (_, i) => ({
-        name: `input_${i}`,
-        type: 'STRING' as const
-      }))
-    })
-    return createTestSubgraphNode(subgraph)
-  }
-
-  it('returns true when an input has a matching _widget', () => {
-    const subgraphNode = createSubgraphWithInputs()
-    subgraphNode.inputs[0]._widget = linkedWidget('3', 'text')
-
-    expect(isLinkedPromotion(subgraphNode, '3', 'text')).toBe(true)
-  })
-
-  it('returns false when no inputs exist or none match', () => {
-    const subgraph = createTestSubgraph()
-    const subgraphNode = createTestSubgraphNode(subgraph)
-
-    expect(isLinkedPromotion(subgraphNode, '999', 'nonexistent')).toBe(false)
-  })
-
-  it('returns false when sourceNodeId matches but sourceWidgetName does not', () => {
-    const subgraphNode = createSubgraphWithInputs()
-    subgraphNode.inputs[0]._widget = linkedWidget('3', 'text')
-
-    expect(isLinkedPromotion(subgraphNode, '3', 'wrong_name')).toBe(false)
-  })
-
-  it('returns false when _widget is undefined on input', () => {
-    const subgraphNode = createSubgraphWithInputs()
-
-    expect(isLinkedPromotion(subgraphNode, '3', 'text')).toBe(false)
-  })
-
-  it('matches by sourceNodeId even when disambiguatingSourceNodeId is present', () => {
-    const subgraphNode = createSubgraphWithInputs()
-    subgraphNode.inputs[0]._widget = linkedWidget('6', 'text', {
-      disambiguatingSourceNodeId: '1'
-    })
-
-    expect(isLinkedPromotion(subgraphNode, '6', 'text')).toBe(true)
-    expect(isLinkedPromotion(subgraphNode, '1', 'text')).toBe(false)
-  })
-
-  it('identifies multiple linked widgets across different inputs', () => {
-    const subgraphNode = createSubgraphWithInputs(2)
-    subgraphNode.inputs[0]._widget = linkedWidget('3', 'string_a')
-    subgraphNode.inputs[1]._widget = linkedWidget('4', 'value')
-
-    expect(isLinkedPromotion(subgraphNode, '3', 'string_a')).toBe(true)
-    expect(isLinkedPromotion(subgraphNode, '4', 'value')).toBe(true)
-    expect(isLinkedPromotion(subgraphNode, '3', 'value')).toBe(false)
-    expect(isLinkedPromotion(subgraphNode, '5', 'string_a')).toBe(false)
-  })
-})

src/core/graph/subgraph/promotionUtils.ts

@@ -27,27 +27,6 @@ export function getWidgetName(w: IBaseWidget): string {
   return isPromotedWidgetView(w) ? w.sourceWidgetName : w.name
 }
 
-/**
- * Returns true if the given promotion entry corresponds to a linked promotion
- * on the subgraph node. Linked promotions are driven by subgraph input
- * connections and cannot be independently hidden or shown.
- */
-export function isLinkedPromotion(
-  subgraphNode: SubgraphNode,
-  sourceNodeId: string,
-  sourceWidgetName: string
-): boolean {
-  return subgraphNode.inputs.some((input) => {
-    const w = input._widget
-    return (
-      w &&
-      isPromotedWidgetView(w) &&
-      w.sourceNodeId === sourceNodeId &&
-      w.sourceWidgetName === sourceWidgetName
-    )
-  })
-}
-
 export function getSourceNodeId(w: IBaseWidget): string | undefined {
   if (!isPromotedWidgetView(w)) return undefined
   return w.disambiguatingSourceNodeId ?? w.sourceNodeId
@@ -60,9 +39,7 @@ function toPromotionSource(
   return {
     sourceNodeId: String(node.id),
     sourceWidgetName: getWidgetName(widget),
-    disambiguatingSourceNodeId: isPromotedWidgetView(widget)
-      ? widget.disambiguatingSourceNodeId
-      : undefined
+    disambiguatingSourceNodeId: getSourceNodeId(widget)
   }
 }
 

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

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromPartial } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, test, vi } from 'vitest'
 
@@ -102,14 +101,14 @@ describe('resolveSubgraphInputLink', () => {
     vi.spyOn(subgraph, 'getLink').mockImplementation((linkId) => {
       if (typeof linkId !== 'number') return originalGetLink(linkId)
       if (linkId === stale.linkId) {
-        return fromPartial<ReturnType<typeof subgraph.getLink>>({
+        return {
           resolve: () => ({
             inputNode: {
               inputs: undefined,
               getWidgetFromSlot: () => ({ name: 'ignored' })
             }
           })
-        })
+        } as unknown as ReturnType<typeof subgraph.getLink>
       }
 
       return originalGetLink(linkId)

src/core/graph/widgets/matchTypeConfiguring.test.ts

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, test, vi } from 'vitest'
 
@@ -73,8 +72,8 @@ describe('MatchType during configure', () => {
     const link2Id = switchNode.inputs[1].link!
 
     const outputTypeBefore = switchNode.outputs[0].type
-    fromAny<{ configuringGraphLevel: number }, unknown>(
-      app
+    ;(
+      app as unknown as { configuringGraphLevel: number }
     ).configuringGraphLevel = 1
 
     try {
@@ -93,8 +92,8 @@ describe('MatchType during configure', () => {
       expect(graph.links[link2Id]).toBeDefined()
       expect(switchNode.outputs[0].type).toBe(outputTypeBefore)
     } finally {
-      fromAny<{ configuringGraphLevel: number }, unknown>(
-        app
+      ;(
+        app as unknown as { configuringGraphLevel: number }
       ).configuringGraphLevel = 0
     }
   })

src/extensions/core/selectionBorder.ts

@@ -1,68 +1,93 @@
+import type { ReadOnlyRect } from '@/lib/litegraph/src/interfaces'
 import type { LGraphCanvas, Rectangle } from '@/lib/litegraph/src/litegraph'
-import { createBounds } from '@/lib/litegraph/src/litegraph'
+import { createBounds, LiteGraph } from '@/lib/litegraph/src/litegraph'
+import { layoutStore } from '@/renderer/core/layout/store/layoutStore'
 import { app } from '@/scripts/app'
 
-/**
- * Draws a dashed border around selected items that maintains constant pixel size
- * regardless of zoom level, similar to the DOM selection overlay.
- */
+function getSelectionBounds(canvas: LGraphCanvas): ReadOnlyRect | null {
+  const selectedItems = canvas.selectedItems
+  if (selectedItems.size <= 1) return null
+
+  if (!LiteGraph.vueNodesMode) return createBounds(selectedItems, 10)
+
+  // In Vue mode, use layoutStore.collapsedSize for collapsed nodes
+  // to get accurate dimensions instead of litegraph's fallback values.
+  const padding = 10
+  let minX = Infinity
+  let minY = Infinity
+  let maxX = -Infinity
+  let maxY = -Infinity
+
+  for (const item of selectedItems) {
+    const rect = item.boundingRect
+    const id = 'id' in item ? String(item.id) : null
+    const isCollapsed =
+      'flags' in item &&
+      !!(item as { flags?: { collapsed?: boolean } }).flags?.collapsed
+    const collapsedSize =
+      id && isCollapsed ? layoutStore.getNodeCollapsedSize(id) : undefined
+
+    if (collapsedSize) {
+      minX = Math.min(minX, rect[0])
+      minY = Math.min(minY, rect[1])
+      maxX = Math.max(maxX, rect[0] + collapsedSize.width)
+      maxY = Math.max(maxY, rect[1] + collapsedSize.height)
+    } else {
+      minX = Math.min(minX, rect[0])
+      minY = Math.min(minY, rect[1])
+      maxX = Math.max(maxX, rect[0] + rect[2])
+      maxY = Math.max(maxY, rect[1] + rect[3])
+    }
+  }
+
+  if (!Number.isFinite(minX)) return null
+  return [
+    minX - padding,
+    minY - padding,
+    maxX - minX + 2 * padding,
+    maxY - minY + 2 * padding
+  ]
+}
+
 function drawSelectionBorder(
   ctx: CanvasRenderingContext2D,
   canvas: LGraphCanvas
 ) {
-  const selectedItems = canvas.selectedItems
-
-  // Only draw if multiple items selected
-  if (selectedItems.size <= 1) return
-
-  // Use the same bounds calculation as the toolbox
-  const bounds = createBounds(selectedItems, 10)
+  const bounds = getSelectionBounds(canvas)
   if (!bounds) return
 
   const [x, y, width, height] = bounds
 
-  // Save context state
   ctx.save()
 
-  // Set up dashed line style that doesn't scale with zoom
-  const borderWidth = 2 / canvas.ds.scale // Constant 2px regardless of zoom
+  const borderWidth = 2 / canvas.ds.scale
   ctx.lineWidth = borderWidth
   ctx.strokeStyle =
     getComputedStyle(document.documentElement)
       .getPropertyValue('--border-color')
       .trim() || '#ffffff66'
 
-  // Create dash pattern that maintains visual size
   const dashSize = 5 / canvas.ds.scale
   ctx.setLineDash([dashSize, dashSize])
 
-  // Draw the border using the bounds directly
   ctx.beginPath()
   ctx.roundRect(x, y, width, height, 8 / canvas.ds.scale)
   ctx.stroke()
 
-  // Restore context
   ctx.restore()
 }
 
-/**
- * Extension that adds a dashed selection border for multiple selected nodes
- */
 const ext = {
   name: 'Comfy.SelectionBorder',
 
   async init() {
-    // Hook into the canvas drawing
     const originalDrawForeground = app.canvas.onDrawForeground
 
     app.canvas.onDrawForeground = function (
       ctx: CanvasRenderingContext2D,
       visibleArea: Rectangle
     ) {
-      // Call original if it exists
       originalDrawForeground?.call(this, ctx, visibleArea)
-
-      // Draw our selection border
       drawSelectionBorder(ctx, app.canvas)
     }
   }

src/lib/litegraph/src/LGraphCanvas.groupSelection.test.ts

@@ -1,7 +1,7 @@
-import { fromAny } from '@total-typescript/shoehorn'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { CanvasPointerEvent } from '@/lib/litegraph/src/types/events'
+
 import {
   LGraph,
   LGraphCanvas,
@@ -60,7 +60,7 @@ function createCanvas(graph: LGraph): LGraphCanvas {
 
   el.getContext = vi
     .fn()
-    .mockReturnValue(fromAny<CanvasRenderingContext2D, unknown>(ctx))
+    .mockReturnValue(ctx as unknown as CanvasRenderingContext2D)
   el.getBoundingClientRect = vi.fn().mockReturnValue({
     left: 0,
     top: 0,

src/lib/litegraph/src/subgraph/Subgraph.test.ts

@@ -6,12 +6,12 @@
  * and basic I/O management.
  */
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it } from 'vitest'
 
 import type { LGraph } from '@/lib/litegraph/src/litegraph'
 import { createUuidv4, Subgraph } from '@/lib/litegraph/src/litegraph'
+
 import { subgraphTest } from './__fixtures__/subgraphFixtures'
 import {
   assertSubgraphStructure,
@@ -48,7 +48,7 @@ describe('Subgraph Construction', () => {
   it('should require a root graph', () => {
     const subgraphData = createTestSubgraphData()
     const createWithoutRoot = () =>
-      new Subgraph(fromAny<LGraph, unknown>(null), subgraphData)
+      new Subgraph(null as unknown as LGraph, subgraphData)
 
     expect(createWithoutRoot).toThrow('Root graph is required')
   })

src/lib/litegraph/src/subgraph/SubgraphNode.test.ts

@@ -4,13 +4,13 @@
  * Tests for SubgraphNode instances including construction,
  * IO synchronization, and edge cases.
  */
-import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
-import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createTestingPinia } from '@pinia/testing'
+import { setActivePinia } from 'pinia'
 
-import { LGraph, LGraphNode, SubgraphNode } from '@/lib/litegraph/src/litegraph'
 import type { ExportedSubgraphInstance } from '@/lib/litegraph/src/types/serialisation'
+import { LGraph, LGraphNode, SubgraphNode } from '@/lib/litegraph/src/litegraph'
+
 import { subgraphTest } from './__fixtures__/subgraphFixtures'
 import {
   createTestSubgraph,
@@ -933,17 +933,14 @@ describe('SubgraphNode promotion view keys', () => {
 
     const subgraph = createTestSubgraph()
     const subgraphNode = createTestSubgraphNode(subgraph)
-    const nodeWithKeyBuilder = fromAny<
-      {
-        _makePromotionViewKey: (
-          inputKey: string,
-          interiorNodeId: string,
-          widgetName: string,
-          inputName?: string
-        ) => string
-      },
-      unknown
-    >(subgraphNode)
+    const nodeWithKeyBuilder = subgraphNode as unknown as {
+      _makePromotionViewKey: (
+        inputKey: string,
+        interiorNodeId: string,
+        widgetName: string,
+        inputName?: string
+      ) => string
+    }
 
     const firstKey = nodeWithKeyBuilder._makePromotionViewKey(
       '65',

src/lib/litegraph/src/subgraph/svgBitmapCache.test.ts

@@ -1,4 +1,3 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { describe, expect, it, vi } from 'vitest'
 
 import { createBitmapCache } from './svgBitmapCache'
@@ -26,9 +25,9 @@ describe('createBitmapCache', () => {
       )
   }
 
-  const stubContext = fromPartial<CanvasRenderingContext2D>({
+  const stubContext = {
     drawImage: vi.fn()
-  })
+  } as unknown as CanvasRenderingContext2D
 
   it('returns the SVG when image is not yet complete', () => {
     const svg = mockSvg({ complete: false, naturalWidth: 0 })

src/lib/litegraph/src/utils/textMeasureCache.test.ts

@@ -1,13 +1,12 @@
-import { fromPartial } from '@total-typescript/shoehorn'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { cachedMeasureText, clearTextMeasureCache } from './textMeasureCache'
 
 function createMockCtx(font = '12px sans-serif'): CanvasRenderingContext2D {
-  return fromPartial<CanvasRenderingContext2D>({
+  return {
     font,
     measureText: vi.fn((text: string) => ({ width: text.length * 7 }))
-  })
+  } as unknown as CanvasRenderingContext2D
 }
 
 describe('textMeasureCache', () => {

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

@@ -1,5 +1,4 @@
 import { createTestingPinia } from '@pinia/testing'
-import { fromAny } from '@total-typescript/shoehorn'
 import { setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it } from 'vitest'
 
@@ -168,7 +167,7 @@ describe('BaseWidget store integration', () => {
       const defaultValue = 'You are an expert image-generation engine.'
       const widget = createTestWidget(node, {
         name: 'system_prompt',
-        value: fromAny<number, unknown>(undefined)
+        value: undefined as unknown as number
       })
 
       // Simulate what addDOMWidget does: override value with getter/setter

src/locales/en/main.json

@@ -3528,23 +3528,6 @@
       "missingModelsTitle": "Missing Models",
       "assetLoadTimeout": "Model detection timed out. Try reloading the workflow.",
       "downloadAll": "Download all"
-    },
-    "missingMedia": {
-      "missingMediaTitle": "Missing Inputs",
-      "image": "Images",
-      "video": "Videos",
-      "audio": "Audio",
-      "locateNode": "Locate node",
-      "expandNodes": "Show referencing nodes",
-      "collapseNodes": "Hide referencing nodes",
-      "uploadFile": "Upload {type}",
-      "uploading": "Uploading...",
-      "uploaded": "Uploaded",
-      "selectedFromLibrary": "Selected from library",
-      "useFromLibrary": "Use from Library",
-      "confirmSelection": "Confirm selection",
-      "cancelSelection": "Cancel selection",
-      "or": "OR"
     }
   },
   "errorOverlay": {

src/locales/en/nodeDefs.json

@@ -798,7 +798,7 @@
     }
   },
   "CaseConverter": {
-    "display_name": "Text Case Converter",
+    "display_name": "Case Converter",
     "inputs": {
       "string": {
         "name": "string"
@@ -12840,7 +12840,7 @@
     }
   },
   "RegexExtract": {
-    "display_name": "Text Extract Substring",
+    "display_name": "Regex Extract",
     "inputs": {
       "string": {
         "name": "string"
@@ -12871,7 +12871,7 @@
     }
   },
   "RegexMatch": {
-    "display_name": "Text Match",
+    "display_name": "Regex Match",
     "inputs": {
       "string": {
         "name": "string"
@@ -12897,7 +12897,7 @@
     }
   },
   "RegexReplace": {
-    "display_name": "Text Replace (Regex)",
+    "display_name": "Regex Replace",
     "description": "Find and replace text using regex patterns.",
     "inputs": {
       "string": {
@@ -15220,7 +15220,7 @@
     }
   },
   "StringCompare": {
-    "display_name": "Text Compare",
+    "display_name": "Compare",
     "inputs": {
       "string_a": {
         "name": "string_a"
@@ -15242,7 +15242,7 @@
     }
   },
   "StringConcatenate": {
-    "display_name": "Text Concatenate",
+    "display_name": "Concatenate",
     "inputs": {
       "string_a": {
         "name": "string_a"
@@ -15261,7 +15261,7 @@
     }
   },
   "StringContains": {
-    "display_name": "Text Contains",
+    "display_name": "Contains",
     "inputs": {
       "string": {
         "name": "string"
@@ -15281,7 +15281,7 @@
     }
   },
   "StringLength": {
-    "display_name": "Text Length",
+    "display_name": "Length",
     "inputs": {
       "string": {
         "name": "string"
@@ -15295,7 +15295,7 @@
     }
   },
   "StringReplace": {
-    "display_name": "Text Replace",
+    "display_name": "Replace",
     "inputs": {
       "string": {
         "name": "string"
@@ -15314,7 +15314,7 @@
     }
   },
   "StringSubstring": {
-    "display_name": "Text Substring",
+    "display_name": "Substring",
     "inputs": {
       "string": {
         "name": "string"
@@ -15333,7 +15333,7 @@
     }
   },
   "StringTrim": {
-    "display_name": "Text Trim",
+    "display_name": "Trim",
     "inputs": {
       "string": {
         "name": "string"