[automated] Apply ESLint and Oxfmt fixes

Add comprehensive E2E test coverage across 18 spec files and 2 test helpers:

Infrastructure:
- FeatureFlagHelper: manage localStorage feature flags and mock /api/features
- QueueHelper: mock queue API routes and wait for completion

Wave 1 (28 tests): toast notifications, error overlay, selection toolbox
actions, linear mode, selection rectangle for vue nodes

Wave 2 (30 tests): V2 node search, bottom panel logs, focus mode, job
history actions, right side panel tabs

Wave 3 (24 tests): errors tab interactions, vue node header actions,
queue notification banners, settings sidebar button

Wave 4 (24 tests): minimap status, widget copy button, floating menus,
node library essentials tab

browser_tests/fixtures/ComfyPage.ts

@@ -25,9 +25,11 @@ import {
 import { Topbar } from './components/Topbar'
 import { CanvasHelper } from './helpers/CanvasHelper'
 import { PerformanceHelper } from './helpers/PerformanceHelper'
+import { QueueHelper } from './helpers/QueueHelper'
 import { ClipboardHelper } from './helpers/ClipboardHelper'
 import { CommandHelper } from './helpers/CommandHelper'
 import { DragDropHelper } from './helpers/DragDropHelper'
+import { FeatureFlagHelper } from './helpers/FeatureFlagHelper'
 import { KeyboardHelper } from './helpers/KeyboardHelper'
 import { NodeOperationsHelper } from './helpers/NodeOperationsHelper'
 import { SettingsHelper } from './helpers/SettingsHelper'
@@ -184,9 +186,11 @@ export class ComfyPage {
   public readonly contextMenu: ContextMenu
   public readonly toast: ToastHelper
   public readonly dragDrop: DragDropHelper
+  public readonly featureFlags: FeatureFlagHelper
   public readonly command: CommandHelper
   public readonly bottomPanel: BottomPanel
   public readonly perf: PerformanceHelper
+  public readonly queue: QueueHelper
 
   /** Worker index to test user ID */
   public readonly userIds: string[] = []
@@ -229,9 +233,11 @@ export class ComfyPage {
     this.contextMenu = new ContextMenu(page)
     this.toast = new ToastHelper(page)
     this.dragDrop = new DragDropHelper(page, this.assetPath.bind(this))
+    this.featureFlags = new FeatureFlagHelper(page)
     this.command = new CommandHelper(page)
     this.bottomPanel = new BottomPanel(page)
     this.perf = new PerformanceHelper(page)
+    this.queue = new QueueHelper(page)
   }
 
   get visibleToasts() {

browser_tests/fixtures/helpers/FeatureFlagHelper.ts

@@ -0,0 +1,47 @@
+import type { Page } from '@playwright/test'
+
+export class FeatureFlagHelper {
+  constructor(private readonly page: Page) {}
+
+  /**
+   * Set feature flags via localStorage. Uses the `ff:` prefix
+   * that devFeatureFlagOverride.ts reads in dev mode.
+   * Call BEFORE comfyPage.setup() for flags needed at init time,
+   * or use page.evaluate() for runtime changes.
+   */
+  async setFlags(flags: Record<string, unknown>): Promise<void> {
+    await this.page.evaluate((flagMap: Record<string, unknown>) => {
+      for (const [key, value] of Object.entries(flagMap)) {
+        localStorage.setItem(`ff:${key}`, JSON.stringify(value))
+      }
+    }, flags)
+  }
+
+  async setFlag(name: string, value: unknown): Promise<void> {
+    await this.setFlags({ [name]: value })
+  }
+
+  async clearFlags(): Promise<void> {
+    await this.page.evaluate(() => {
+      const keysToRemove: string[] = []
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key?.startsWith('ff:')) keysToRemove.push(key)
+      }
+      keysToRemove.forEach((k) => localStorage.removeItem(k))
+    })
+  }
+
+  /**
+   * Mock server feature flags via route interception on /api/features.
+   */
+  async mockServerFeatures(features: Record<string, unknown>): Promise<void> {
+    await this.page.route('**/api/features', (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(features)
+      })
+    )
+  }
+}

browser_tests/fixtures/helpers/QueueHelper.ts

@@ -0,0 +1,70 @@
+import type { Page } from '@playwright/test'
+
+export class QueueHelper {
+  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> {
+    await this.page.route('**/api/queue', (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}`,
+            {},
+            {},
+            []
+          ])
+        })
+      })
+    )
+  }
+
+  /**
+   * 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: job.status === 'success'
+        }
+      }
+    }
+    await this.page.route('**/api/history**', (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(history)
+      })
+    )
+  }
+
+  /**
+   * Clear all route mocks set by this helper.
+   */
+  async clearMocks(): Promise<void> {
+    await this.page.unroute('**/api/queue')
+    await this.page.unroute('**/api/history**')
+  }
+}

browser_tests/tests/bottomPanelLogs.spec.ts

@@ -0,0 +1,116 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+
+test.describe('Bottom Panel Logs', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+  })
+
+  test('should open bottom panel via toggle button', async ({ comfyPage }) => {
+    const { bottomPanel } = comfyPage
+
+    await expect(bottomPanel.root).not.toBeVisible()
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+  })
+
+  test('should show Logs tab when terminal panel opens', async ({
+    comfyPage
+  }) => {
+    const { bottomPanel } = comfyPage
+
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+
+    const logsTab = comfyPage.page.getByRole('tab', { name: /Logs/i })
+    const hasLogs = await logsTab.isVisible().catch(() => false)
+
+    if (hasLogs) {
+      await expect(logsTab).toBeVisible()
+    }
+  })
+
+  test('should close bottom panel via toggle button', async ({ comfyPage }) => {
+    const { bottomPanel } = comfyPage
+
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).not.toBeVisible()
+  })
+
+  test('should switch between shortcuts and terminal panels', async ({
+    comfyPage
+  }) => {
+    const { bottomPanel } = comfyPage
+
+    await bottomPanel.keyboardShortcutsButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+    await expect(
+      comfyPage.page.locator('[id*="tab_shortcuts-essentials"]')
+    ).toBeVisible()
+
+    await bottomPanel.toggleButton.click()
+
+    const logsTab = comfyPage.page.getByRole('tab', { name: /Logs/i })
+    const hasTerminalTabs = await logsTab.isVisible().catch(() => false)
+
+    if (hasTerminalTabs) {
+      await expect(logsTab).toBeVisible()
+      await expect(
+        comfyPage.page.locator('[id*="tab_shortcuts-essentials"]')
+      ).not.toBeVisible()
+    }
+  })
+
+  test('should persist Logs tab content in bottom panel', async ({
+    comfyPage
+  }) => {
+    const { bottomPanel } = comfyPage
+
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+
+    const logsTab = comfyPage.page.getByRole('tab', { name: /Logs/i })
+    const hasLogs = await logsTab.isVisible().catch(() => false)
+
+    if (hasLogs) {
+      await logsTab.click()
+
+      const xtermContainer = bottomPanel.root.locator('.xterm')
+      const hasXterm = await xtermContainer.isVisible().catch(() => false)
+
+      if (hasXterm) {
+        await expect(xtermContainer).toBeVisible()
+      }
+    }
+  })
+
+  test('should render xterm container in terminal panel', async ({
+    comfyPage
+  }) => {
+    const { bottomPanel } = comfyPage
+
+    await bottomPanel.toggleButton.click()
+    await expect(bottomPanel.root).toBeVisible()
+
+    const logsTab = comfyPage.page.getByRole('tab', { name: /Logs/i })
+    const hasLogs = await logsTab.isVisible().catch(() => false)
+
+    if (hasLogs) {
+      await logsTab.click()
+
+      const xtermScreen = bottomPanel.root.locator('.xterm, .xterm-screen')
+      const hasXterm = await xtermScreen
+        .first()
+        .isVisible()
+        .catch(() => false)
+
+      if (hasXterm) {
+        await expect(xtermScreen.first()).toBeVisible()
+      }
+    }
+  })
+})

browser_tests/tests/errorOverlaySeeErrors.spec.ts

@@ -0,0 +1,88 @@
+import type { Page } from '@playwright/test'
+
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+test.describe('Error overlay See Errors flow', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    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.locator('[data-testid="error-overlay"]')
+    ).toBeVisible()
+  })
+
+  test('Error overlay shows error message', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    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.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    await expect(comfyPage.page.getByTestId('properties-panel')).toBeVisible()
+  })
+
+  test('"See Errors" dismisses the overlay', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    await expect(overlay).not.toBeVisible()
+  })
+
+  test('"Dismiss" closes overlay without opening panel', async ({
+    comfyPage
+  }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByRole('button', { name: /Dismiss/i }).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.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+
+    await overlay.getByRole('button', { name: /close/i }).click()
+
+    await expect(overlay).not.toBeVisible()
+  })
+})

browser_tests/tests/errorsTab.spec.ts

@@ -0,0 +1,148 @@
+import type { Page } from '@playwright/test'
+
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+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.describe('Errors tab in right side panel', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
+    await comfyPage.setup()
+  })
+
+  test('Errors tab appears after execution error', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    // Dismiss the error overlay
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /Dismiss/i }).click()
+
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await expect(propertiesPanel.root).toBeVisible()
+    await expect(
+      propertiesPanel.root.getByRole('tab', { name: 'Errors' })
+    ).toBeVisible()
+  })
+
+  test('Error card shows locate button', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    const { propertiesPanel } = comfyPage.menu
+    await expect(propertiesPanel.root).toBeVisible()
+
+    const locateButton = propertiesPanel.root.locator(
+      'button .icon-\\[lucide--locate\\]'
+    )
+    await expect(locateButton.first()).toBeVisible()
+  })
+
+  test('Clicking locate button focuses canvas', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    const { propertiesPanel } = comfyPage.menu
+    await expect(propertiesPanel.root).toBeVisible()
+
+    const locateButton = propertiesPanel.root
+      .locator('button')
+      .filter({ has: comfyPage.page.locator('.icon-\\[lucide--locate\\]') })
+      .first()
+    await locateButton.click()
+
+    await expect(comfyPage.canvas).toBeVisible()
+  })
+
+  test('Collapse all button collapses error groups', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    const { propertiesPanel } = comfyPage.menu
+    await expect(propertiesPanel.root).toBeVisible()
+
+    const collapseButton = propertiesPanel.root.getByRole('button', {
+      name: 'Collapse all'
+    })
+
+    // The collapse toggle only appears when there are multiple groups.
+    // If only one group exists, this test verifies the button is not shown.
+    const count = await collapseButton.count()
+    if (count > 0) {
+      await collapseButton.click()
+      const expandButton = propertiesPanel.root.getByRole('button', {
+        name: 'Expand all'
+      })
+      await expect(expandButton).toBeVisible()
+    }
+  })
+
+  test('Search filters errors', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    const { propertiesPanel } = comfyPage.menu
+    await expect(propertiesPanel.root).toBeVisible()
+
+    // Search for a term that won't match any error
+    await propertiesPanel.searchBox.fill('zzz_nonexistent_zzz')
+
+    await expect(
+      propertiesPanel.root.locator('.icon-\\[lucide--locate\\]')
+    ).toHaveCount(0)
+
+    // Clear the search to restore results
+    await propertiesPanel.searchBox.fill('')
+
+    await expect(
+      propertiesPanel.root.locator('.icon-\\[lucide--locate\\]').first()
+    ).toBeVisible()
+  })
+
+  test('Errors tab shows error message text', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const overlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(overlay).toBeVisible()
+    await overlay.getByRole('button', { name: /See Errors/i }).click()
+
+    const { propertiesPanel } = comfyPage.menu
+    await expect(propertiesPanel.root).toBeVisible()
+
+    // Error cards contain <p> elements with error messages
+    const errorMessage = propertiesPanel.root
+      .locator('.whitespace-pre-wrap')
+      .first()
+    await expect(errorMessage).toBeVisible()
+    await expect(errorMessage).not.toHaveText('')
+  })
+})

browser_tests/tests/floatingMenus.spec.ts

@@ -0,0 +1,75 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+import { TestIds } from '../fixtures/selectors'
+
+test.describe('Floating Canvas Menus', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting('Comfy.Graph.CanvasMenu', true)
+    await comfyPage.setup()
+  })
+
+  test('Floating menu is visible on canvas', async ({ comfyPage }) => {
+    const toggleLinkButton = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleLinkVisibilityButton
+    )
+    const toggleMinimapButton = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleMinimapButton
+    )
+    await expect(toggleLinkButton).toBeVisible()
+    await expect(toggleMinimapButton).toBeVisible()
+  })
+
+  test('Link visibility toggle button is present', async ({ comfyPage }) => {
+    const button = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleLinkVisibilityButton
+    )
+    await expect(button).toBeVisible()
+    await expect(button).toBeEnabled()
+  })
+
+  test('Clicking link toggle changes link render mode', async ({
+    comfyPage
+  }) => {
+    await comfyPage.settings.setSetting('Comfy.LinkRenderMode', 2)
+    const button = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleLinkVisibilityButton
+    )
+
+    await button.click()
+    await comfyPage.nextFrame()
+
+    const hiddenLinkRenderMode = await comfyPage.page.evaluate(() => {
+      return window.LiteGraph!.HIDDEN_LINK
+    })
+    expect(await comfyPage.settings.getSetting('Comfy.LinkRenderMode')).toBe(
+      hiddenLinkRenderMode
+    )
+  })
+
+  test('Zoom controls button shows percentage', async ({ comfyPage }) => {
+    const zoomButton = comfyPage.page.getByTestId('zoom-controls-button')
+    await expect(zoomButton).toBeVisible()
+    await expect(zoomButton).toContainText('%')
+  })
+
+  test('Fit view button is present and clickable', async ({ comfyPage }) => {
+    const fitViewButton = comfyPage.page
+      .locator('button')
+      .filter({ has: comfyPage.page.locator('.icon-\\[lucide--focus\\]') })
+    await expect(fitViewButton).toBeVisible()
+    await fitViewButton.click()
+    await comfyPage.nextFrame()
+  })
+
+  test('Zoom controls popup opens on click', async ({ comfyPage }) => {
+    const zoomButton = comfyPage.page.getByTestId('zoom-controls-button')
+    await zoomButton.click()
+    await comfyPage.nextFrame()
+
+    const zoomModal = comfyPage.page.getByText('Zoom To Fit')
+    await expect(zoomModal).toBeVisible()
+  })
+})

browser_tests/tests/focusMode.spec.ts

@@ -0,0 +1,65 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('Focus Mode', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  test('Focus mode hides UI chrome', async ({ comfyPage }) => {
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+
+    await comfyPage.setFocusMode(true)
+
+    await expect(comfyPage.menu.sideToolbar).not.toBeVisible()
+  })
+
+  test('Focus mode restores UI chrome', async ({ comfyPage }) => {
+    await comfyPage.setFocusMode(true)
+    await expect(comfyPage.menu.sideToolbar).not.toBeVisible()
+
+    await comfyPage.setFocusMode(false)
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+  })
+
+  test('Toggle focus mode command works', async ({ comfyPage }) => {
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+
+    await comfyPage.command.executeCommand('Workspace.ToggleFocusMode')
+    await comfyPage.nextFrame()
+    await expect(comfyPage.menu.sideToolbar).not.toBeVisible()
+
+    await comfyPage.command.executeCommand('Workspace.ToggleFocusMode')
+    await comfyPage.nextFrame()
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+  })
+
+  test('Focus mode hides topbar', async ({ comfyPage }) => {
+    const topMenu = comfyPage.page.locator('.comfy-menu-button-wrapper')
+    await expect(topMenu).toBeVisible()
+
+    await comfyPage.setFocusMode(true)
+
+    await expect(topMenu).not.toBeVisible()
+  })
+
+  test('Canvas remains visible in focus mode', async ({ comfyPage }) => {
+    await comfyPage.setFocusMode(true)
+
+    await expect(comfyPage.canvas).toBeVisible()
+  })
+
+  test('Focus mode can be toggled multiple times', async ({ comfyPage }) => {
+    await comfyPage.setFocusMode(true)
+    await expect(comfyPage.menu.sideToolbar).not.toBeVisible()
+
+    await comfyPage.setFocusMode(false)
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+
+    await comfyPage.setFocusMode(true)
+    await expect(comfyPage.menu.sideToolbar).not.toBeVisible()
+  })
+})

browser_tests/tests/jobHistoryActions.spec.ts

@@ -0,0 +1,96 @@
+import type { Locator } from '@playwright/test'
+
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+test.describe('Job History Actions', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  async function openMoreOptionsPopover(comfyPage: {
+    page: { locator(sel: string): Locator }
+  }) {
+    const moreButton = comfyPage.page
+      .locator('.icon-\\[lucide--more-horizontal\\]')
+      .first()
+    await moreButton.click()
+  }
+
+  test('More options popover opens', async ({ comfyPage }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="docked-job-history-action"]')
+    ).toBeVisible()
+  })
+
+  test('Docked job history action is visible with text', async ({
+    comfyPage
+  }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    const action = comfyPage.page.locator(
+      '[data-testid="docked-job-history-action"]'
+    )
+    await expect(action).toBeVisible()
+    await expect(action).not.toBeEmpty()
+  })
+
+  test('Show run progress bar action is visible', async ({ comfyPage }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="show-run-progress-bar-action"]')
+    ).toBeVisible()
+  })
+
+  test('Clear history action is visible', async ({ comfyPage }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="clear-history-action"]')
+    ).toBeVisible()
+  })
+
+  test('Clicking docked job history closes popover', async ({ comfyPage }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    const action = comfyPage.page.locator(
+      '[data-testid="docked-job-history-action"]'
+    )
+    await expect(action).toBeVisible()
+    await action.click()
+
+    await expect(action).not.toBeVisible()
+  })
+
+  test('Clicking show run progress bar toggles check icon', async ({
+    comfyPage
+  }) => {
+    await openMoreOptionsPopover(comfyPage)
+
+    const action = comfyPage.page.locator(
+      '[data-testid="show-run-progress-bar-action"]'
+    )
+    const checkIcon = action.locator('.icon-\\[lucide--check\\]')
+    const hadCheck = await checkIcon.isVisible()
+
+    await action.click()
+
+    await openMoreOptionsPopover(comfyPage)
+
+    const checkIconAfter = comfyPage.page
+      .locator('[data-testid="show-run-progress-bar-action"]')
+      .locator('.icon-\\[lucide--check\\]')
+
+    if (hadCheck) {
+      await expect(checkIconAfter).not.toBeVisible()
+    } else {
+      await expect(checkIconAfter).toBeVisible()
+    }
+  })
+})

browser_tests/tests/linearMode.spec.ts

@@ -0,0 +1,87 @@
+import type { Page } from '@playwright/test'
+
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+import type { WorkspaceStore } from '../types/globals'
+
+test.describe('Linear Mode', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.setup()
+  })
+
+  async function enterAppMode(comfyPage: {
+    page: Page
+    nextFrame: () => Promise<void>
+  }) {
+    await comfyPage.page.evaluate(() => {
+      const workflow = (window.app!.extensionManager as WorkspaceStore).workflow
+        .activeWorkflow
+      if (workflow) workflow.activeMode = 'app'
+    })
+    await comfyPage.nextFrame()
+  }
+
+  async function enterGraphMode(comfyPage: {
+    page: Page
+    nextFrame: () => Promise<void>
+  }) {
+    await comfyPage.page.evaluate(() => {
+      const workflow = (window.app!.extensionManager as WorkspaceStore).workflow
+        .activeWorkflow
+      if (workflow) workflow.activeMode = 'graph'
+    })
+    await comfyPage.nextFrame()
+  }
+
+  test('Displays linear controls when app mode active', async ({
+    comfyPage
+  }) => {
+    await enterAppMode(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-widgets"]')
+    ).toBeVisible({ timeout: 5000 })
+  })
+
+  test('Run button visible in linear mode', async ({ comfyPage }) => {
+    await enterAppMode(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-run-button"]')
+    ).toBeVisible({ timeout: 5000 })
+  })
+
+  test('Workflow info section visible', async ({ comfyPage }) => {
+    await enterAppMode(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-workflow-info"]')
+    ).toBeVisible({ timeout: 5000 })
+  })
+
+  test('Returns to graph mode', async ({ comfyPage }) => {
+    await enterAppMode(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-widgets"]')
+    ).toBeVisible({ timeout: 5000 })
+
+    await enterGraphMode(comfyPage)
+
+    await expect(comfyPage.canvas).toBeVisible({ timeout: 5000 })
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-widgets"]')
+    ).not.toBeVisible()
+  })
+
+  test('Canvas not visible in app mode', async ({ comfyPage }) => {
+    await enterAppMode(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('[data-testid="linear-widgets"]')
+    ).toBeVisible({ timeout: 5000 })
+    await expect(comfyPage.canvas).not.toBeVisible()
+  })
+})

browser_tests/tests/minimapStatus.spec.ts

@@ -0,0 +1,71 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+import { TestIds } from '../fixtures/selectors'
+
+test.describe('Minimap Status', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting('Comfy.Minimap.Visible', true)
+    await comfyPage.settings.setSetting('Comfy.Graph.CanvasMenu', true)
+    await comfyPage.setup()
+  })
+
+  test('Minimap is visible when enabled', async ({ comfyPage }) => {
+    const minimap = comfyPage.page.locator('.litegraph-minimap')
+    await expect(minimap).toBeVisible()
+  })
+
+  test('Minimap contains canvas and viewport elements', async ({
+    comfyPage
+  }) => {
+    const minimap = comfyPage.page.locator('.litegraph-minimap')
+    await expect(minimap.locator('.minimap-canvas')).toBeVisible()
+    await expect(minimap.locator('.minimap-viewport')).toBeVisible()
+  })
+
+  test('Minimap toggle button exists in canvas menu', async ({ comfyPage }) => {
+    const toggleButton = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleMinimapButton
+    )
+    await expect(toggleButton).toBeVisible()
+  })
+
+  test('Minimap can be hidden via toggle', async ({ comfyPage }) => {
+    const minimap = comfyPage.page.locator('.litegraph-minimap')
+    const toggleButton = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleMinimapButton
+    )
+
+    await expect(minimap).toBeVisible()
+    await toggleButton.click()
+    await comfyPage.nextFrame()
+    await expect(minimap).not.toBeVisible()
+  })
+
+  test('Minimap can be re-shown via toggle', async ({ comfyPage }) => {
+    const minimap = comfyPage.page.locator('.litegraph-minimap')
+    const toggleButton = comfyPage.page.getByTestId(
+      TestIds.canvas.toggleMinimapButton
+    )
+
+    await toggleButton.click()
+    await comfyPage.nextFrame()
+    await expect(minimap).not.toBeVisible()
+
+    await toggleButton.click()
+    await comfyPage.nextFrame()
+    await expect(minimap).toBeVisible()
+  })
+
+  test('Minimap persists across queue operations', async ({ comfyPage }) => {
+    const minimap = comfyPage.page.locator('.litegraph-minimap')
+    await expect(minimap).toBeVisible()
+
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+    await comfyPage.nextFrame()
+
+    await expect(minimap).toBeVisible()
+  })
+})

browser_tests/tests/nodeLibraryEssentials.spec.ts

@@ -0,0 +1,99 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('Node Library Essentials Tab', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  test('Node library opens via sidebar', async ({ comfyPage }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const sidebarContent = comfyPage.page.locator(
+      '.comfy-vue-side-bar-container'
+    )
+    await expect(sidebarContent).toBeVisible()
+  })
+
+  test('Essentials tab is visible in node library', async ({ comfyPage }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const essentialsTab = comfyPage.page.getByRole('tab', {
+      name: /essentials/i
+    })
+    await expect(essentialsTab).toBeVisible()
+  })
+
+  test('Clicking essentials tab shows essentials panel', async ({
+    comfyPage
+  }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const essentialsTab = comfyPage.page.getByRole('tab', {
+      name: /essentials/i
+    })
+    await essentialsTab.click()
+
+    const essentialCards = comfyPage.page.locator('[data-node-name]')
+    await expect(essentialCards.first()).toBeVisible()
+  })
+
+  test('Essential node cards are displayed', async ({ comfyPage }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const essentialsTab = comfyPage.page.getByRole('tab', {
+      name: /essentials/i
+    })
+    await essentialsTab.click()
+
+    const essentialCards = comfyPage.page.locator('[data-node-name]')
+    await expect(async () => {
+      expect(await essentialCards.count()).toBeGreaterThan(0)
+    }).toPass()
+  })
+
+  test('Essential node cards have node names', async ({ comfyPage }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const essentialsTab = comfyPage.page.getByRole('tab', {
+      name: /essentials/i
+    })
+    await essentialsTab.click()
+
+    const firstCard = comfyPage.page.locator('[data-node-name]').first()
+    await expect(firstCard).toBeVisible()
+
+    const nodeName = await firstCard.getAttribute('data-node-name')
+    expect(nodeName).toBeTruthy()
+    expect(nodeName!.length).toBeGreaterThan(0)
+  })
+
+  test('Node library can switch between all and essentials tabs', async ({
+    comfyPage
+  }) => {
+    const tabButton = comfyPage.page.locator('.node-library-tab-button')
+    await tabButton.click()
+
+    const essentialsTab = comfyPage.page.getByRole('tab', {
+      name: /essentials/i
+    })
+    const allNodesTab = comfyPage.page.getByRole('tab', {
+      name: /all nodes/i
+    })
+
+    await essentialsTab.click()
+    const essentialCards = comfyPage.page.locator('[data-node-name]')
+    await expect(essentialCards.first()).toBeVisible()
+
+    await allNodesTab.click()
+    await expect(essentialCards.first()).not.toBeVisible()
+  })
+})

browser_tests/tests/nodeSearchBoxV2Extended.spec.ts

@@ -0,0 +1,140 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('Node search box V2 extended', { tag: '@node' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
+    await comfyPage.settings.setSetting('Comfy.NodeSearchBoxImpl', 'default')
+    await comfyPage.settings.setSetting(
+      'Comfy.LinkRelease.Action',
+      'search box'
+    )
+    await comfyPage.settings.setSetting(
+      'Comfy.LinkRelease.ActionShift',
+      'search box'
+    )
+    await comfyPage.searchBoxV2.reload(comfyPage)
+  })
+
+  test('Double-click on empty canvas opens search', async ({ comfyPage }) => {
+    const { searchBoxV2 } = comfyPage
+
+    await comfyPage.canvasOps.doubleClick()
+    await expect(searchBoxV2.input).toBeVisible()
+    await expect(searchBoxV2.dialog).toBeVisible()
+  })
+
+  test('Escape closes search box without adding node', async ({
+    comfyPage
+  }) => {
+    const { searchBoxV2 } = comfyPage
+    const initialCount = await comfyPage.nodeOps.getGraphNodesCount()
+
+    await comfyPage.canvasOps.doubleClick()
+    await expect(searchBoxV2.input).toBeVisible()
+
+    await searchBoxV2.input.fill('KSampler')
+    await expect(searchBoxV2.results.first()).toBeVisible()
+
+    await comfyPage.page.keyboard.press('Escape')
+    await expect(searchBoxV2.input).not.toBeVisible()
+
+    const newCount = await comfyPage.nodeOps.getGraphNodesCount()
+    expect(newCount).toBe(initialCount)
+  })
+
+  test('Search clears when reopening', async ({ comfyPage }) => {
+    const { searchBoxV2 } = comfyPage
+
+    await comfyPage.canvasOps.doubleClick()
+    await expect(searchBoxV2.input).toBeVisible()
+
+    await searchBoxV2.input.fill('KSampler')
+    await expect(searchBoxV2.results.first()).toBeVisible()
+
+    await comfyPage.page.keyboard.press('Escape')
+    await expect(searchBoxV2.input).not.toBeVisible()
+
+    await comfyPage.canvasOps.doubleClick()
+    await expect(searchBoxV2.input).toBeVisible()
+    await expect(searchBoxV2.input).toHaveValue('')
+  })
+
+  test.describe('Category navigation', () => {
+    test('Category navigation updates results', async ({ comfyPage }) => {
+      const { searchBoxV2 } = comfyPage
+
+      await comfyPage.canvasOps.doubleClick()
+      await expect(searchBoxV2.input).toBeVisible()
+
+      await searchBoxV2.categoryButton('sampling').click()
+      await expect(searchBoxV2.results.first()).toBeVisible()
+      const samplingResults = await searchBoxV2.results.allTextContents()
+
+      await searchBoxV2.categoryButton('loaders').click()
+      await expect(searchBoxV2.results.first()).toBeVisible()
+      const loaderResults = await searchBoxV2.results.allTextContents()
+
+      expect(samplingResults).not.toEqual(loaderResults)
+    })
+  })
+
+  test.describe('Filter workflow', () => {
+    test('Filter chip removal restores results', async ({ comfyPage }) => {
+      const { searchBoxV2 } = comfyPage
+
+      await comfyPage.canvasOps.doubleClick()
+      await expect(searchBoxV2.input).toBeVisible()
+
+      // Get unfiltered count
+      await expect(searchBoxV2.results.first()).toBeVisible()
+      const unfilteredCount = await searchBoxV2.results.count()
+
+      // Apply Input filter with MODEL type
+      await searchBoxV2.filterBarButton('Input').click()
+      await expect(searchBoxV2.filterOptions.first()).toBeVisible()
+      await searchBoxV2.input.fill('MODEL')
+      await searchBoxV2.filterOptions
+        .filter({ hasText: 'MODEL' })
+        .first()
+        .click()
+
+      await expect(searchBoxV2.results.first()).toBeVisible()
+      const filteredCount = await searchBoxV2.results.count()
+      expect(filteredCount).toBeLessThanOrEqual(unfilteredCount)
+
+      // Remove filter by pressing Backspace with empty input
+      await searchBoxV2.input.fill('')
+      await comfyPage.page.keyboard.press('Backspace')
+
+      // Results should restore to unfiltered count
+      await expect(searchBoxV2.results.first()).toBeVisible()
+      const restoredCount = await searchBoxV2.results.count()
+      expect(restoredCount).toBeGreaterThanOrEqual(filteredCount)
+    })
+  })
+
+  test.describe('Keyboard navigation', () => {
+    test('ArrowUp on first item keeps first selected', async ({
+      comfyPage
+    }) => {
+      const { searchBoxV2 } = comfyPage
+
+      await comfyPage.canvasOps.doubleClick()
+      await expect(searchBoxV2.input).toBeVisible()
+
+      await searchBoxV2.input.fill('KSampler')
+      const results = searchBoxV2.results
+      await expect(results.first()).toBeVisible()
+
+      // First result should be selected by default
+      await expect(results.first()).toHaveAttribute('aria-selected', 'true')
+
+      // ArrowUp on first item should keep first selected
+      await comfyPage.page.keyboard.press('ArrowUp')
+      await expect(results.first()).toHaveAttribute('aria-selected', 'true')
+    })
+  })
+})

browser_tests/tests/queueNotificationBanners.spec.ts

@@ -0,0 +1,82 @@
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+test.describe('Queue Notification Banners', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  async function triggerExecutionError(comfyPage: {
+    canvasOps: { disconnectEdge(): Promise<void> }
+    page: { keyboard: { press(key: string): Promise<void> } }
+    command: { executeCommand(cmd: string): Promise<void> }
+    nextFrame(): Promise<void>
+  }) {
+    await comfyPage.canvasOps.disconnectEdge()
+    await comfyPage.nextFrame()
+    await comfyPage.page.keyboard.press('Escape')
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+  }
+
+  test('Toast appears when prompt is queued', async ({ comfyPage }) => {
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+  })
+
+  test('Error toast appears on failed execution', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const errorToast = comfyPage.page.locator(
+      '.p-toast-message.p-toast-message-error'
+    )
+    await expect(errorToast.first()).toBeVisible()
+  })
+
+  test('Error toast contains error description', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const errorToast = comfyPage.page.locator(
+      '.p-toast-message.p-toast-message-error'
+    )
+    await expect(errorToast.first()).toBeVisible()
+    await expect(errorToast.first()).not.toHaveText('')
+  })
+
+  test('Toast close button dismisses individual toast', async ({
+    comfyPage
+  }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+
+    const closeButton = comfyPage.page.locator('.p-toast-close-button').first()
+    await closeButton.click()
+
+    await expect(comfyPage.toast.visibleToasts).toHaveCount(0)
+  })
+
+  test('Multiple toasts can stack', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+
+    await triggerExecutionError(comfyPage)
+    await expect(comfyPage.toast.visibleToasts).not.toHaveCount(0)
+
+    const count = await comfyPage.toast.getVisibleToastCount()
+    expect(count).toBeGreaterThanOrEqual(2)
+  })
+
+  test('All toasts can be cleared', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+
+    await comfyPage.toast.closeToasts()
+
+    expect(await comfyPage.toast.getVisibleToastCount()).toBe(0)
+  })
+})

browser_tests/tests/rightSidePanelTabs.spec.ts

@@ -0,0 +1,113 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+
+test.describe('Right Side Panel Tabs', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+  })
+
+  test('Properties panel opens with workflow overview', async ({
+    comfyPage
+  }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await expect(propertiesPanel.root).toBeVisible()
+    await expect(propertiesPanel.panelTitle).toContainText('Workflow Overview')
+  })
+
+  test('Properties panel shows node details on selection', async ({
+    comfyPage
+  }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+
+    await expect(propertiesPanel.panelTitle).toContainText('KSampler')
+  })
+
+  test('Node title input is editable', async ({ comfyPage }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await expect(propertiesPanel.panelTitle).toContainText('KSampler')
+
+    // Click on the title to enter edit mode
+    await propertiesPanel.panelTitle.click()
+    const titleInput = propertiesPanel.root.getByTestId('node-title-input')
+    await expect(titleInput).toBeVisible()
+
+    await titleInput.fill('My Custom Sampler')
+    await titleInput.press('Enter')
+
+    await expect(propertiesPanel.panelTitle).toContainText('My Custom Sampler')
+  })
+
+  test('Search box filters properties', async ({ comfyPage }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await comfyPage.nodeOps.selectNodes([
+      'KSampler',
+      'CLIP Text Encode (Prompt)'
+    ])
+
+    await expect(propertiesPanel.panelTitle).toContainText('3 items selected')
+    await expect(propertiesPanel.root.getByText('KSampler')).toHaveCount(1)
+    await expect(
+      propertiesPanel.root.getByText('CLIP Text Encode (Prompt)')
+    ).toHaveCount(2)
+
+    await propertiesPanel.searchBox.fill('seed')
+    await expect(propertiesPanel.root.getByText('KSampler')).toHaveCount(1)
+    await expect(
+      propertiesPanel.root.getByText('CLIP Text Encode (Prompt)')
+    ).toHaveCount(0)
+
+    await propertiesPanel.searchBox.fill('')
+    await expect(propertiesPanel.root.getByText('KSampler')).toHaveCount(1)
+    await expect(
+      propertiesPanel.root.getByText('CLIP Text Encode (Prompt)')
+    ).toHaveCount(2)
+  })
+
+  test('Collapse all / Expand all toggles sections', async ({ comfyPage }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    // Select multiple nodes so collapse toggle button appears
+    await comfyPage.nodeOps.selectNodes([
+      'KSampler',
+      'CLIP Text Encode (Prompt)'
+    ])
+
+    const collapseButton = propertiesPanel.root.getByRole('button', {
+      name: 'Collapse all'
+    })
+    await expect(collapseButton).toBeVisible()
+    await collapseButton.click()
+
+    const expandButton = propertiesPanel.root.getByRole('button', {
+      name: 'Expand all'
+    })
+    await expect(expandButton).toBeVisible()
+    await expandButton.click()
+
+    // After expanding, the button label switches back to "Collapse all"
+    await expect(collapseButton).toBeVisible()
+  })
+
+  test('Properties panel can be closed', async ({ comfyPage }) => {
+    await comfyPage.actionbar.propertiesButton.click()
+    const { propertiesPanel } = comfyPage.menu
+
+    await expect(propertiesPanel.root).toBeVisible()
+
+    // Click the properties button again to close
+    await comfyPage.actionbar.propertiesButton.click()
+    await expect(propertiesPanel.root).toBeHidden()
+  })
+})

browser_tests/tests/selectionRectangle.spec.ts

@@ -0,0 +1,79 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('@canvas Selection Rectangle', () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+    await comfyPage.setup()
+    await comfyPage.vueNodes.waitForNodes()
+  })
+
+  test('Ctrl+A selects all nodes', async ({ comfyPage }) => {
+    const totalCount = await comfyPage.vueNodes.getNodeCount()
+    expect(totalCount).toBeGreaterThan(0)
+
+    await comfyPage.canvas.click({ position: { x: 10, y: 10 } })
+    await comfyPage.nextFrame()
+    await comfyPage.page.keyboard.press('Control+a')
+    await comfyPage.nextFrame()
+
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(totalCount)
+  })
+
+  test('Click empty space deselects all', async ({ comfyPage }) => {
+    await comfyPage.canvas.click({ position: { x: 10, y: 10 } })
+    await comfyPage.page.keyboard.press('Control+a')
+    await comfyPage.nextFrame()
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBeGreaterThan(0)
+
+    await comfyPage.vueNodes.clearSelection()
+    await comfyPage.nextFrame()
+
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(0)
+  })
+
+  test('Single click selects one node', async ({ comfyPage }) => {
+    await comfyPage.page.getByText('Load Checkpoint').click()
+    await comfyPage.nextFrame()
+
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(1)
+  })
+
+  test('Ctrl+click adds to selection', async ({ comfyPage }) => {
+    await comfyPage.page.getByText('Load Checkpoint').click()
+    await comfyPage.nextFrame()
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(1)
+
+    await comfyPage.page.getByText('Empty Latent Image').click({
+      modifiers: ['Control']
+    })
+    await comfyPage.nextFrame()
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(2)
+  })
+
+  test('Selected nodes have visual indicator', async ({ comfyPage }) => {
+    const checkpointNode = comfyPage.vueNodes.getNodeByTitle('Load Checkpoint')
+
+    await comfyPage.page.getByText('Load Checkpoint').click()
+    await comfyPage.nextFrame()
+
+    await expect(checkpointNode).toHaveClass(/outline-node-component-outline/)
+  })
+
+  test('Drag-select rectangle selects multiple nodes', async ({
+    comfyPage
+  }) => {
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBe(0)
+
+    await comfyPage.page.mouse.move(10, 400)
+    await comfyPage.page.mouse.down()
+    await comfyPage.page.mouse.move(800, 600, { steps: 10 })
+    await comfyPage.page.mouse.up()
+    await comfyPage.nextFrame()
+
+    expect(await comfyPage.vueNodes.getSelectedNodeCount()).toBeGreaterThan(1)
+  })
+})

browser_tests/tests/selectionToolboxActions.spec.ts

@@ -0,0 +1,121 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.beforeEach(async ({ comfyPage }) => {
+  await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
+})
+
+test.describe('Selection Toolbox - Button Actions', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.Canvas.SelectionToolbox', true)
+    await comfyPage.workflow.loadWorkflow('nodes/single_ksampler')
+    await comfyPage.nextFrame()
+  })
+
+  test('bypass button toggles node bypass state', async ({ comfyPage }) => {
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await comfyPage.nextFrame()
+
+    const nodeRef = (await comfyPage.nodeOps.getNodeRefsByTitle('KSampler'))[0]
+
+    // Click bypass button to bypass the node
+    await comfyPage.page.locator('[data-testid="bypass-button"]').click()
+    await comfyPage.nextFrame()
+
+    await expect(nodeRef).toBeBypassed()
+
+    // Re-select the node to show toolbox again
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await comfyPage.nextFrame()
+
+    // Click bypass button again to un-bypass
+    await comfyPage.page.locator('[data-testid="bypass-button"]').click()
+    await comfyPage.nextFrame()
+
+    await expect(nodeRef).not.toBeBypassed()
+  })
+
+  test('delete button removes selected node', async ({ comfyPage }) => {
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await comfyPage.nextFrame()
+
+    const initialCount = await comfyPage.page.evaluate(
+      () => window.app!.graph!._nodes.length
+    )
+
+    await comfyPage.page.locator('[data-testid="delete-button"]').click()
+    await comfyPage.nextFrame()
+
+    const newCount = await comfyPage.page.evaluate(
+      () => window.app!.graph!._nodes.length
+    )
+    expect(newCount).toBe(initialCount - 1)
+  })
+
+  test('info button opens properties panel', async ({ comfyPage }) => {
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await comfyPage.nextFrame()
+
+    await comfyPage.page.locator('[data-testid="info-button"]').click()
+    await comfyPage.nextFrame()
+
+    await expect(
+      comfyPage.page.locator('[data-testid="properties-panel"]')
+    ).toBeVisible()
+  })
+
+  test('refresh button is visible when node is selected', async ({
+    comfyPage
+  }) => {
+    await comfyPage.nodeOps.selectNodes(['KSampler'])
+    await comfyPage.nextFrame()
+
+    await expect(
+      comfyPage.page.locator('[data-testid="refresh-button"]')
+    ).toBeVisible()
+  })
+
+  test('convert-to-subgraph button visible with multi-select', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('default')
+    await comfyPage.nextFrame()
+
+    await comfyPage.nodeOps.selectNodes([
+      'KSampler',
+      'CLIP Text Encode (Prompt)'
+    ])
+    await comfyPage.nextFrame()
+
+    await expect(
+      comfyPage.page.locator('[data-testid="convert-to-subgraph-button"]')
+    ).toBeVisible()
+  })
+
+  test('delete button removes multiple selected nodes', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('default')
+    await comfyPage.nextFrame()
+
+    await comfyPage.nodeOps.selectNodes([
+      'KSampler',
+      'CLIP Text Encode (Prompt)'
+    ])
+    await comfyPage.nextFrame()
+
+    const initialCount = await comfyPage.page.evaluate(
+      () => window.app!.graph!._nodes.length
+    )
+
+    await comfyPage.page.locator('[data-testid="delete-button"]').click()
+    await comfyPage.nextFrame()
+
+    const newCount = await comfyPage.page.evaluate(
+      () => window.app!.graph!._nodes.length
+    )
+    expect(newCount).toBe(initialCount - 2)
+  })
+})

browser_tests/tests/settingsSidebar.spec.ts

@@ -0,0 +1,57 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('Settings Sidebar', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  test('Settings button is visible in sidebar', async ({ comfyPage }) => {
+    await expect(comfyPage.menu.sideToolbar).toBeVisible()
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await expect(settingsButton).toBeVisible()
+  })
+
+  test('Clicking settings button opens settings dialog', async ({
+    comfyPage
+  }) => {
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await settingsButton.click()
+    await expect(comfyPage.settingDialog.root).toBeVisible()
+  })
+
+  test('Settings dialog shows categories', async ({ comfyPage }) => {
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await settingsButton.click()
+    await expect(comfyPage.settingDialog.root).toBeVisible()
+    await expect(comfyPage.settingDialog.categories.first()).toBeVisible()
+    expect(await comfyPage.settingDialog.categories.count()).toBeGreaterThan(0)
+  })
+
+  test('Settings dialog can be closed with Escape', async ({ comfyPage }) => {
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await settingsButton.click()
+    await expect(comfyPage.settingDialog.root).toBeVisible()
+    await comfyPage.page.keyboard.press('Escape')
+    await expect(comfyPage.settingDialog.root).not.toBeVisible()
+  })
+
+  test('Settings search box is functional', async ({ comfyPage }) => {
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await settingsButton.click()
+    await expect(comfyPage.settingDialog.root).toBeVisible()
+    await comfyPage.settingDialog.searchBox.fill('color')
+    await expect(comfyPage.settingDialog.searchBox).toHaveValue('color')
+  })
+
+  test('Settings dialog can navigate to About panel', async ({ comfyPage }) => {
+    const settingsButton = comfyPage.menu.sideToolbar.getByLabel(/settings/i)
+    await settingsButton.click()
+    await expect(comfyPage.settingDialog.root).toBeVisible()
+    await comfyPage.settingDialog.goToAboutPanel()
+    await expect(comfyPage.page.locator('.about-container')).toBeVisible()
+  })
+})

browser_tests/tests/toastNotifications.spec.ts

@@ -0,0 +1,70 @@
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+test.describe('Toast Notifications', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.setup()
+  })
+
+  async function triggerExecutionError(comfyPage: {
+    canvasOps: { disconnectEdge(): Promise<void> }
+    page: { keyboard: { press(key: string): Promise<void> } }
+    command: { executeCommand(cmd: string): Promise<void> }
+    nextFrame(): Promise<void>
+  }) {
+    await comfyPage.canvasOps.disconnectEdge()
+    await comfyPage.nextFrame()
+    await comfyPage.page.keyboard.press('Escape')
+    await comfyPage.command.executeCommand('Comfy.QueuePrompt')
+  }
+
+  test('Error toast appears on execution failure', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+  })
+
+  test('Toast shows correct error severity class', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    const errorToast = comfyPage.page.locator(
+      '.p-toast-message.p-toast-message-error'
+    )
+    await expect(errorToast.first()).toBeVisible()
+  })
+
+  test('Toast can be dismissed via close button', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+
+    const closeButton = comfyPage.page.locator('.p-toast-close-button').first()
+    await closeButton.click()
+
+    await expect(comfyPage.toast.visibleToasts).toHaveCount(0)
+  })
+
+  test('All toasts cleared via closeToasts helper', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(comfyPage.toast.visibleToasts.first()).toBeVisible()
+
+    await comfyPage.toast.closeToasts()
+
+    expect(await comfyPage.toast.getVisibleToastCount()).toBe(0)
+  })
+
+  test('Toast error count is accurate', async ({ comfyPage }) => {
+    await triggerExecutionError(comfyPage)
+
+    await expect(
+      comfyPage.page.locator('.p-toast-message.p-toast-message-error').first()
+    ).toBeVisible()
+
+    const errorCount = await comfyPage.toast.getToastErrorCount()
+    expect(errorCount).toBeGreaterThanOrEqual(1)
+  })
+})

browser_tests/tests/vueNodes/nodeHeaderActions.spec.ts

@@ -0,0 +1,69 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../../fixtures/ComfyPage'
+
+test.describe('Vue Node Header Actions', { tag: '@node' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting('Comfy.Graph.CanvasMenu', false)
+    await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+    await comfyPage.setup()
+    await comfyPage.vueNodes.waitForNodes()
+  })
+
+  test('Collapse button is visible on node header', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+    await expect(vueNode.collapseButton).toBeVisible()
+  })
+
+  test('Clicking collapse button hides node body', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+    await expect(vueNode.body).toBeVisible()
+
+    await vueNode.toggleCollapse()
+    await comfyPage.nextFrame()
+
+    await expect(vueNode.body).not.toBeVisible()
+  })
+
+  test('Clicking collapse button again expands node', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+
+    await vueNode.toggleCollapse()
+    await comfyPage.nextFrame()
+    await expect(vueNode.body).not.toBeVisible()
+
+    await vueNode.toggleCollapse()
+    await comfyPage.nextFrame()
+    await expect(vueNode.body).toBeVisible()
+  })
+
+  test('Double-click header enters title edit mode', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+
+    await vueNode.header.dblclick()
+    await expect(vueNode.titleInput).toBeVisible()
+  })
+
+  test('Title edit saves on Enter', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+
+    await vueNode.setTitle('My Custom Sampler')
+    expect(await vueNode.getTitle()).toBe('My Custom Sampler')
+  })
+
+  test('Title edit cancels on Escape', async ({ comfyPage }) => {
+    const vueNode = await comfyPage.vueNodes.getFixtureByTitle('KSampler')
+
+    await vueNode.setTitle('Renamed Sampler')
+    expect(await vueNode.getTitle()).toBe('Renamed Sampler')
+
+    await vueNode.header.dblclick()
+    await vueNode.titleInput.fill('This Should Be Cancelled')
+    await vueNode.titleInput.press('Escape')
+    await comfyPage.nextFrame()
+
+    expect(await vueNode.getTitle()).toBe('Renamed Sampler')
+  })
+})

browser_tests/tests/widgetCopyButton.spec.ts

@@ -0,0 +1,84 @@
+import {
+  comfyExpect as expect,
+  comfyPageFixture as test
+} from '../fixtures/ComfyPage'
+
+test.describe('Widget copy button', { tag: '@ui' }, () => {
+  test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true)
+    await comfyPage.setup()
+    await comfyPage.vueNodes.waitForNodes()
+  })
+
+  test('Vue nodes render with widgets', async ({ comfyPage }) => {
+    const nodeCount = await comfyPage.vueNodes.getNodeCount()
+    expect(nodeCount).toBeGreaterThan(0)
+
+    const firstNode = comfyPage.vueNodes.nodes.first()
+    await expect(firstNode).toBeVisible()
+  })
+
+  test('Textarea widgets exist on nodes', async ({ comfyPage }) => {
+    const textareas = comfyPage.page.locator('[data-node-id] textarea')
+    await expect(textareas.first()).toBeVisible()
+    expect(await textareas.count()).toBeGreaterThan(0)
+  })
+
+  test('Copy button has correct aria-label', async ({ comfyPage }) => {
+    const copyButtons = comfyPage.page.locator(
+      '[data-node-id] button[aria-label]'
+    )
+    const count = await copyButtons.count()
+
+    if (count > 0) {
+      const button = copyButtons.filter({
+        has: comfyPage.page.locator('.icon-\\[lucide--copy\\]')
+      })
+      if ((await button.count()) > 0) {
+        await expect(button.first()).toHaveAttribute('aria-label', /copy/i)
+      }
+    }
+  })
+
+  test('Copy icon uses lucide copy class', async ({ comfyPage }) => {
+    const copyIcons = comfyPage.page.locator(
+      '[data-node-id] .icon-\\[lucide--copy\\]'
+    )
+    const count = await copyIcons.count()
+
+    if (count > 0) {
+      await expect(copyIcons.first()).toBeVisible()
+    }
+  })
+
+  test('Widget container has group class for hover', async ({ comfyPage }) => {
+    const textareas = comfyPage.page.locator('[data-node-id] textarea')
+    const count = await textareas.count()
+
+    if (count > 0) {
+      const container = textareas.first().locator('..')
+      await expect(container).toHaveClass(/group/)
+    }
+  })
+
+  test('Copy button exists within textarea widget group container', async ({
+    comfyPage
+  }) => {
+    const groupContainers = comfyPage.page.locator('[data-node-id] div.group')
+    const count = await groupContainers.count()
+
+    if (count > 0) {
+      const container = groupContainers.first()
+      await container.hover()
+      await comfyPage.nextFrame()
+
+      const copyButton = container.locator('button').filter({
+        has: comfyPage.page.locator('.icon-\\[lucide--copy\\]')
+      })
+      if ((await copyButton.count()) > 0) {
+        await expect(copyButton.first()).toHaveClass(/invisible/)
+      }
+    }
+  })
+})

src/platform/workflow/sharing/components/OpenSharedWorkflowDialogContent.vue

@@ -31,7 +31,7 @@
     </template>
 
     <template v-else-if="error">
-      <main class="flex flex-col items-center gap-4 px-8 py-8">
+      <main class="flex flex-col items-center gap-4 p-8">
         <i
           class="icon-[lucide--circle-alert] size-8 text-warning-background"
           aria-hidden="true"

src/platform/workflow/sharing/components/profile/ComfyHubCreateProfileForm.vue

@@ -24,7 +24,7 @@
           {{ $t('comfyHubProfile.chooseProfilePicture') }}
         </label>
         <label
-          class="flex size-13 cursor-pointer items-center justify-center overflow-hidden rounded-full bg-gradient-to-b from-green-600/50 to-green-900"
+          class="flex size-13 cursor-pointer items-center justify-center overflow-hidden rounded-full bg-linear-to-b from-green-600/50 to-green-900"
         >
           <input
             id="profile-picture"

src/platform/workflow/sharing/components/publish/ComfyHubExamplesStep.vue

@@ -57,7 +57,7 @@
         <img
           :src="image.url"
           :alt="$t('comfyHubPublish.exampleImage', { index: index + 1 })"
-          class="h-full w-full object-cover"
+          class="size-full object-cover"
         />
         <div
           v-if="isSelected(image.id)"

src/platform/workflow/sharing/components/publish/ComfyHubThumbnailStep.vue

@@ -50,12 +50,12 @@
             <img
               :src="comparisonPreviewUrls.after!"
               :alt="$t('comfyHubPublish.uploadComparisonAfterPrompt')"
-              class="h-full w-full object-contain"
+              class="size-full object-contain"
             />
             <img
               :src="comparisonPreviewUrls.before!"
               :alt="$t('comfyHubPublish.uploadComparisonBeforePrompt')"
-              class="absolute inset-0 h-full w-full object-contain"
+              class="absolute inset-0 size-full object-contain"
               :style="{
                 clipPath: `inset(0 ${100 - previewSliderPosition}% 0 0)`
               }"

src/renderer/extensions/vueNodes/VideoPreview.vue

@@ -247,7 +247,7 @@ const handleFocusOut = (event: FocusEvent) => {
 
 const getNavigationDotClass = (index: number) =>
   cn(
-    'w-2 h-2 rounded-full transition-all duration-200 border-0 cursor-pointer',
+    'size-2 rounded-full transition-all duration-200 border-0 cursor-pointer',
     index === currentIndex.value
       ? 'bg-base-foreground'
       : 'bg-base-foreground/50 hover:bg-base-foreground/80'