Merge branch 'main' into fix/double-promotion

.claude/skills/red-green-fix/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: red-green-fix
+description: 'Bug fix workflow that proves test validity with a red-then-green CI sequence. Commits a failing test first (CI red), then the minimal fix (CI green). Use when fixing a bug, writing a regression test, or when asked to prove a fix works.'
+---
+
+# Red-Green Fix
+
+Fixes bugs as two commits so CI automatically proves the test catches the bug.
+
+## Why Two Commits
+
+If you commit the test and fix together, the test always passes — reviewers cannot tell whether the test actually detects the bug or is a no-op. Splitting into two commits creates a verifiable CI trail:
+
+1. **Commit 1 (test-only)** — adds a test that exercises the bug. CI runs it → test fails → red X.
+2. **Commit 2 (fix)** — adds the minimal fix. CI runs the same test → test passes → green check.
+
+The red-then-green sequence in the commit history proves the test is valid.
+
+## Input
+
+The user provides a bug description as an argument. If no description is given, ask the user to describe the bug before proceeding.
+
+Bug description: $ARGUMENTS
+
+## Step 0 — Setup
+
+Create an isolated branch from main:
+
+```bash
+git fetch origin main
+git checkout -b fix/<bug-name> origin/main
+```
+
+## Step 1 — Red: Failing Test Only
+
+Write a test that reproduces the bug. **Do NOT write any fix code.**
+
+### Choosing the Test Framework
+
+| Bug type                          | Framework  | File location                   |
+| --------------------------------- | ---------- | ------------------------------- |
+| Logic, utils, stores, composables | Vitest     | `src/**/*.test.ts` (colocated)  |
+| UI interaction, canvas, workflows | Playwright | `browser_tests/tests/*.spec.ts` |
+
+For Playwright tests, follow the `/writing-playwright-tests` skill for patterns, fixtures, and tags.
+
+### Rules
+
+- The test MUST fail against the current codebase (this is the whole point)
+- Do NOT modify any source code outside of test files
+- Do NOT include any fix, workaround, or behavioral change
+- Do NOT add unrelated tests or refactor existing tests
+- Keep the test minimal — only what is needed to reproduce the bug
+- Avoid common anti-patterns — see `reference/testing-anti-patterns.md`
+
+### Vitest Example
+
+```typescript
+// src/utils/pathUtil.test.ts
+import { describe, expect, it } from 'vitest'
+import { resolveModelPath } from './pathUtil'
+
+describe('resolveModelPath', () => {
+  it('handles absolute paths from folder_paths API', () => {
+    const result = resolveModelPath(
+      '/absolute/models',
+      '/absolute/models/checkpoints'
+    )
+    expect(result).toBe('/absolute/models/checkpoints')
+  })
+})
+```
+
+### Playwright Example
+
+```typescript
+import {
+  comfyPageFixture as test,
+  comfyExpect as expect
+} from '../fixtures/ComfyPage'
+
+test.describe('Model Download', { tag: ['@smoke'] }, () => {
+  test('downloads model when path is absolute', async ({ comfyPage }) => {
+    await comfyPage.workflow.loadWorkflow('missing-model')
+    const downloadBtn = comfyPage.page.getByTestId('download-model-button')
+    await downloadBtn.click()
+    await expect(comfyPage.page.getByText('Download complete')).toBeVisible()
+  })
+})
+```
+
+### Verify Locally First
+
+Run the test locally before pushing to confirm it fails for the right reason:
+
+```bash
+# Vitest
+pnpm test:unit -- <test-file>
+
+# Playwright
+pnpm test:browser:local -- --grep "<test name>"
+```
+
+If the test passes locally, it does not reproduce the bug — revisit your test before pushing.
+
+### Quality Checks and Commit
+
+```bash
+pnpm typecheck
+pnpm lint
+pnpm format:check
+
+git add <test-files-only>
+git commit -m "test: add failing test for <concise bug description>"
+git push -u origin HEAD
+```
+
+### Verify CI Failure
+
+```bash
+gh run list --branch $(git branch --show-current) --limit 1
+```
+
+**STOP HERE.** Inform the user of the CI status and wait for confirmation before proceeding to Step 2.
+
+- If CI passes: the test does not catch the bug. Revisit the test.
+- If CI fails for unrelated reasons: investigate and fix the test setup, not the bug.
+- If CI fails because the test correctly catches the bug: proceed to Step 2.
+
+## Step 2 — Green: Minimal Fix
+
+Write the minimum code change needed to make the failing test pass.
+
+### Rules
+
+- Do NOT modify, weaken, or delete the test from Step 1 — it is immutable. If the test needs changes, restart from Step 1 and re-prove the red.
+- Do NOT add new tests (tests were finalized in Step 1)
+- Do NOT refactor, clean up, or make "drive-by" improvements
+- Do NOT modify code unrelated to the bug
+- The fix should be the smallest correct change
+
+### Quality Checks and Commit
+
+```bash
+pnpm typecheck
+pnpm lint
+pnpm format
+
+git add <fix-files-only>
+git commit -m "fix: <concise bug description>"
+git push
+```
+
+### Verify CI Pass
+
+```bash
+gh run list --branch $(git branch --show-current) --limit 1
+```
+
+- If CI passes: the fix is verified. Proceed to PR creation.
+- If CI fails: investigate and fix. Do NOT change the test from Step 1.
+
+## Step 3 — Open Pull Request
+
+```bash
+gh pr create --title "fix: <description>" --body "$(cat <<'EOF'
+## Summary
+
+<Brief explanation of the bug and root cause>
+
+- Fixes #<issue-number>
+
+## Red-Green Verification
+
+| Commit | CI Status | Purpose |
+|--------|-----------|---------|
+| `test: ...` | :red_circle: Red | Proves the test catches the bug |
+| `fix: ...` | :green_circle: Green | Proves the fix resolves the bug |
+
+## Test Plan
+
+- [ ] CI red on test-only commit
+- [ ] CI green on fix commit
+- [ ] Added/updated E2E regression under `browser_tests/` or explained why not applicable
+- [ ] Manual verification (if applicable)
+EOF
+)"
+```
+
+## Gotchas
+
+### CI fails on test commit for unrelated reasons
+
+Lint, typecheck, or other tests may fail — not just your new test. Check the CI logs carefully. If the failure is unrelated, fix it in a separate commit before the `test:` commit so the red X is clearly attributable to your test.
+
+### Test passes when it should fail
+
+The bug may only manifest under specific conditions (e.g., Windows paths, external model directories, certain workflow structures). Make sure your test setup matches the actual bug scenario. Check that you're not accidentally testing the happy path.
+
+### Flaky Playwright tests
+
+If your e2e test is intermittent, it doesn't prove anything. Use retrying assertions (`toBeVisible`, `toHaveText`) instead of `waitForTimeout`. See the `/writing-playwright-tests` skill for anti-patterns.
+
+### Pre-existing CI failures on main
+
+If main itself is red, branch from the last green commit or fix the pre-existing failure first. A red-green proof is meaningless if the baseline is already red.
+
+## Reference
+
+| Resource              | Path                                               |
+| --------------------- | -------------------------------------------------- |
+| Unit test framework   | Vitest (`src/**/*.test.ts`)                        |
+| E2E test framework    | Playwright (`browser_tests/tests/*.spec.ts`)       |
+| E2E fixtures          | `browser_tests/fixtures/`                          |
+| E2E assets            | `browser_tests/assets/`                            |
+| Playwright skill      | `.claude/skills/writing-playwright-tests/SKILL.md` |
+| Unit CI               | `.github/workflows/ci-tests-unit.yaml`             |
+| E2E CI                | `.github/workflows/ci-tests-e2e.yaml`              |
+| Lint CI               | `.github/workflows/ci-lint-format.yaml`            |
+| Testing anti-patterns | `reference/testing-anti-patterns.md`               |
+| Related skill         | `.claude/skills/perf-fix-with-proof/SKILL.md`      |

.claude/skills/red-green-fix/reference/testing-anti-patterns.md

@@ -0,0 +1,214 @@
+# Testing Anti-Patterns for Red-Green Fixes
+
+Common mistakes that undermine the red-green proof. Avoid these when writing the test commit (Step 1).
+
+## Testing Implementation Details
+
+Test observable behavior, not internal state.
+
+**Bad** — coupling to internals:
+
+```typescript
+it('uses cache internally', () => {
+  const service = new UserService()
+  service.getUser(1)
+  expect(service._cache.has(1)).toBe(true) // Implementation detail
+})
+```
+
+**Good** — testing through the public interface:
+
+```typescript
+it('returns same user on repeated calls', async () => {
+  const service = new UserService()
+  const user1 = await service.getUser(1)
+  const user2 = await service.getUser(1)
+  expect(user1).toBe(user2) // Behavior, not implementation
+})
+```
+
+Why this matters for red-green: if your test is coupled to internals, a valid fix that changes the implementation may break the test — even though the bug is fixed. The green commit should only require changing source code, not rewriting the test.
+
+## Assertion-Free Tests
+
+Every test must assert something meaningful. A test without assertions always passes — it cannot produce the red X needed in Step 1.
+
+**Bad**:
+
+```typescript
+it('processes the download', () => {
+  processDownload('/models/checkpoints', 'model.safetensors')
+  // No expect()!
+})
+```
+
+**Good**:
+
+```typescript
+it('processes the download to correct path', () => {
+  const result = processDownload('/models/checkpoints', 'model.safetensors')
+  expect(result.savePath).toBe('/models/checkpoints/model.safetensors')
+})
+```
+
+## Over-Mocking
+
+Mock only system boundaries (network, filesystem, Electron APIs). If you mock the module under test, you are testing your mocks — the test will not detect the real bug.
+
+**Bad** — mocking everything:
+
+```typescript
+vi.mock('./pathResolver')
+vi.mock('./validator')
+vi.mock('./downloader')
+
+it('downloads model', () => {
+  // This only tests that mocks were called, not that the bug exists
+})
+```
+
+**Good** — mock only the boundary:
+
+```typescript
+vi.mock('./electronAPI') // Boundary: Electron IPC
+
+it('resolves absolute path correctly', () => {
+  const result = resolveModelPath('/root/models', '/root/models/checkpoints')
+  expect(result).toBe('/root/models/checkpoints')
+})
+```
+
+See also: [Don't Mock What You Don't Own](https://hynek.me/articles/what-to-mock-in-5-mins/)
+
+## Giant Tests
+
+A test that covers the entire flow makes it hard to pinpoint which part catches the bug. Keep it focused — one concept per test.
+
+**Bad**:
+
+```typescript
+it('full model download flow', async () => {
+  // 80 lines: load workflow, open dialog, select model,
+  // click download, verify path, check progress, confirm completion
+})
+```
+
+**Good**:
+
+```typescript
+it('resolves absolute savePath without nesting under modelsDirectory', () => {
+  const result = getLocalSavePath(
+    '/models',
+    '/models/checkpoints',
+    'file.safetensors'
+  )
+  expect(result).toBe('/models/checkpoints/file.safetensors')
+})
+```
+
+If the bug is in path resolution, test path resolution — not the entire download flow.
+
+## Test Duplication
+
+Duplicated test code hides what actually differs between cases. Use parameterized tests.
+
+**Bad**:
+
+```typescript
+it('resolves checkpoints path', () => {
+  expect(resolve('/models', '/models/checkpoints', 'a.safetensors')).toBe(
+    '/models/checkpoints/a.safetensors'
+  )
+})
+it('resolves loras path', () => {
+  expect(resolve('/models', '/models/loras', 'b.safetensors')).toBe(
+    '/models/loras/b.safetensors'
+  )
+})
+```
+
+**Good**:
+
+```typescript
+it.each([
+  ['/models/checkpoints', 'a.safetensors', '/models/checkpoints/a.safetensors'],
+  ['/models/loras', 'b.safetensors', '/models/loras/b.safetensors']
+])('resolves %s/%s to %s', (dir, file, expected) => {
+  expect(resolve('/models', dir, file)).toBe(expected)
+})
+```
+
+## Flaky Tests
+
+A flaky test cannot prove anything — it may show red for reasons unrelated to the bug, or green despite the bug still existing.
+
+**Common causes in this codebase:**
+
+| Cause                                  | Fix                                     |
+| -------------------------------------- | --------------------------------------- |
+| Missing `nextFrame()` after canvas ops | Add `await comfyPage.nextFrame()`       |
+| `waitForTimeout` instead of assertions | Use `toBeVisible()`, `toHaveText()`     |
+| Shared state between tests             | Isolate with `afterEach` / `beforeEach` |
+| Timing-dependent logic                 | Use `expect.poll()` or `toPass()`       |
+
+## Gaming the Red-Green Process
+
+These are ways the red-green proof gets invalidated during Step 2 (the fix commit). The test from Step 1 is immutable — if any of these happen, restart from Step 1.
+
+**Weakening the assertion to make it pass:**
+
+```typescript
+// Step 1 (red) — strict assertion
+expect(result).toBe('/external/drive/models/checkpoints/file.safetensors')
+
+// Step 2 (green) — weakened to pass without a real fix
+expect(result).toBeDefined() // This proves nothing
+```
+
+**Updating snapshots to bless the bug:**
+
+```bash
+# Instead of fixing the code, just updating the snapshot to match buggy output
+pnpm test:unit -- --update
+```
+
+If a snapshot needs updating, the fix should change the code behavior, not the expected output.
+
+**Adding mocks in Step 2 that hide the failure:**
+
+```typescript
+// Step 2 adds a mock that didn't exist in Step 1
+vi.mock('./pathResolver', () => ({
+  resolve: () => '/expected/path' // Hardcoded to pass
+}))
+```
+
+Step 2 should only change source code — not test infrastructure.
+
+## Testing the Happy Path Only
+
+The red-green pattern specifically requires the test to exercise the **broken path**. If you only test the case that already works, the test will pass (green) on Step 1 — defeating the purpose.
+
+**Bad** — testing the default case that works:
+
+```typescript
+it('downloads to default models directory', () => {
+  // This already works — it won't produce a red X
+  const result = resolve('/models', 'checkpoints', 'file.safetensors')
+  expect(result).toBe('/models/checkpoints/file.safetensors')
+})
+```
+
+**Good** — testing the case that is actually broken:
+
+```typescript
+it('downloads to external models directory configured via extra_model_paths', () => {
+  // This is the broken case — absolute path from folder_paths API
+  const result = resolve(
+    '/models',
+    '/external/drive/models/checkpoints',
+    'file.safetensors'
+  )
+  expect(result).toBe('/external/drive/models/checkpoints/file.safetensors')
+})
+```

.coderabbit.yaml

@@ -3,6 +3,7 @@ issue_enrichment:
     enabled: true
 reviews:
   high_level_summary: false
+  request_changes_workflow: true
   auto_review:
     drafts: true
     ignore_title_keywords:
@@ -13,10 +14,14 @@ reviews:
       - github-actions
       - github-actions[bot]
   pre_merge_checks:
+    override_requested_reviewers_only: true
     custom_checks:
       - name: End-to-end regression coverage for fixes
-        mode: warning
+        mode: error
         instructions: |
+          Use only PR metadata already available in the review context: the PR title, commit subjects in this PR, the files changed in this PR relative to the PR base (equivalent to `base...head`), and the PR description.
+          Do not rely on shell commands. Do not inspect reverse diffs, files changed only on the base branch, or files outside this PR. If the changed-file list or commit subjects are unavailable, mark the check inconclusive instead of guessing.
+
           Pass if at least one of the following is true:
           1. Neither the PR title nor any commit subject in the PR uses bug-fix language such as `fix`, `fixed`, `fixes`, `fixing`, `bugfix`, or `hotfix`.
           2. The PR changes at least one file under `browser_tests/`.

.gitattributes

@@ -3,4 +3,6 @@
 
 # Generated files
 packages/registry-types/src/comfyRegistryTypes.ts linguist-generated=true
+packages/ingest-types/src/types.gen.ts linguist-generated=true
+packages/ingest-types/src/zod.gen.ts linguist-generated=true
 src/workbench/extensions/manager/types/generatedManagerTypes.ts linguist-generated=true

.github/workflows/ci-perf-report.yaml

@@ -10,7 +10,7 @@ on:
 
 concurrency:
   group: perf-${{ github.ref }}
-  cancel-in-progress: true
+  cancel-in-progress: false
 
 permissions:
   contents: read
@@ -26,12 +26,15 @@ jobs:
         username: ${{ github.actor }}
         password: ${{ secrets.GITHUB_TOKEN }}
     permissions:
-      contents: read
+      contents: write
       packages: read
+      actions: read
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Setup frontend
         uses: ./.github/actions/setup-frontend
@@ -68,3 +71,44 @@ jobs:
         with:
           name: perf-meta
           path: temp/perf-meta/
+
+      - name: Save perf baseline to perf-data branch
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main' && steps.perf.outcome == 'success'
+        continue-on-error: true
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git config url."https://x-access-token:${GH_TOKEN}@github.com/".insteadOf "https://github.com/"
+
+          cp test-results/perf-metrics.json /tmp/perf-metrics.json
+
+          git fetch origin perf-data || {
+            echo "Creating perf-data branch"
+            git checkout --orphan perf-data
+            git rm -rf . 2>/dev/null || true
+            echo "# Performance Baselines" > README.md
+            mkdir -p baselines
+            git add README.md baselines
+            git commit -m "Initialize perf-data branch"
+            git push origin perf-data
+            git fetch origin perf-data
+          }
+
+          git worktree add /tmp/perf-data origin/perf-data
+
+          TIMESTAMP=$(date -u +%Y%m%dT%H%M%SZ)
+          SHA=$(echo "${{ github.sha }}" | cut -c1-8)
+          mkdir -p /tmp/perf-data/baselines
+          cp /tmp/perf-metrics.json "/tmp/perf-data/baselines/perf-${TIMESTAMP}-${SHA}.json"
+
+          # Keep only last 20 baselines
+          cd /tmp/perf-data
+          ls -t baselines/perf-*.json 2>/dev/null | tail -n +21 | xargs -r rm
+
+          git -C /tmp/perf-data add baselines/
+          git -C /tmp/perf-data commit -m "perf: add baseline for ${SHA}" || echo "No changes to commit"
+          git -C /tmp/perf-data push origin HEAD:perf-data
+
+          git worktree remove /tmp/perf-data --force 2>/dev/null || true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pr-backport.yaml

@@ -348,6 +348,8 @@ jobs:
               PR_NUM=$(echo "${PR_URL}" | grep -o '[0-9]*$')
 
               if [ -n "${PR_NUM}" ]; then
+                gh pr merge "${PR_NUM}" --auto --squash --repo "${{ github.repository }}" \
+                  || echo "::warning::Failed to enable auto-merge for PR #${PR_NUM}"
                 gh pr comment "${PR_NUMBER}" --body "@${PR_AUTHOR} Successfully backported to #${PR_NUM}"
               fi
             else

.github/workflows/pr-perf-report.yaml

@@ -10,6 +10,7 @@ permissions:
   contents: read
   pull-requests: write
   issues: write
+  actions: read
 
 jobs:
   comment:
@@ -73,7 +74,28 @@ jobs:
             core.setOutput('number', String(pr.number));
             core.setOutput('base', trustedBase);
 
+      - name: Check if results are still current
+        id: sha-check
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const prNumber = Number('${{ steps.pr-meta.outputs.number }}');
+            const { data: pr } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: prNumber,
+            });
+            const runSha = context.payload.workflow_run.head_sha;
+            const currentSha = pr.head.sha;
+            if (runSha !== currentSha) {
+              core.info(`Skipping stale report: run SHA ${runSha} != current PR SHA ${currentSha}`);
+              core.setOutput('stale', 'true');
+            } else {
+              core.setOutput('stale', 'false');
+            }
+
       - name: Download PR perf metrics
+        if: steps.sha-check.outputs.stale != 'true'
         uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           name: perf-metrics
@@ -81,6 +103,7 @@ jobs:
           path: test-results/
 
       - name: Download baseline perf metrics
+        if: steps.sha-check.outputs.stale != 'true'
         uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           branch: ${{ steps.pr-meta.outputs.base }}
@@ -90,10 +113,33 @@ jobs:
           path: temp/perf-baseline/
           if_no_artifact_found: warn
 
+      - name: Load historical baselines from perf-data branch
+        if: steps.sha-check.outputs.stale != 'true'
+        continue-on-error: true
+        run: |
+          mkdir -p temp/perf-history
+
+          git fetch origin perf-data 2>/dev/null || {
+            echo "perf-data branch not found, skipping historical data"
+            exit 0
+          }
+
+          INDEX=0
+          for file in $(git ls-tree --name-only origin/perf-data baselines/ 2>/dev/null | sort -r | head -5); do
+            DIR="temp/perf-history/$INDEX"
+            mkdir -p "$DIR"
+            git show "origin/perf-data:${file}" > "$DIR/perf-metrics.json" 2>/dev/null || true
+            INDEX=$((INDEX + 1))
+          done
+
+          echo "Loaded $INDEX historical baselines"
+
       - name: Generate perf report
+        if: steps.sha-check.outputs.stale != 'true'
         run: npx --yes tsx scripts/perf-report.ts > perf-report.md
 
       - name: Post PR comment
+        if: steps.sha-check.outputs.stale != 'true'
         uses: ./.github/actions/post-pr-report-comment
         with:
           pr-number: ${{ steps.pr-meta.outputs.number }}

.github/workflows/pr-request-team-review.yaml

@@ -0,0 +1,24 @@
+# Request team review for PRs from external contributors.
+name: PR:Request Team Review
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions:
+  pull-requests: write
+
+jobs:
+  request-review:
+    if: >-
+      !contains(fromJson('["OWNER","MEMBER","COLLABORATOR"]'),
+                github.event.pull_request.author_association)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Request team review
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit ${{ github.event.pull_request.number }} \
+            --repo ${{ github.repository }} \
+            --add-reviewer Comfy-org/comfy_frontend_devs

.github/workflows/release-biweekly-comfyui.yaml

@@ -162,9 +162,132 @@ jobs:
           echo "- Target version: ${{ needs.resolve-version.outputs.target_version }}" >> $GITHUB_STEP_SUMMARY
           echo "- [View workflow runs](https://github.com/Comfy-Org/ComfyUI_frontend/actions/workflows/release-version-bump.yaml)" >> $GITHUB_STEP_SUMMARY
 
+  publish-pypi:
+    needs: [resolve-version, trigger-release-if-needed]
+    if: >
+      always() &&
+      needs.resolve-version.result == 'success' &&
+      (needs.trigger-release-if-needed.result == 'success' ||
+       needs.trigger-release-if-needed.result == 'skipped')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Wait for release PR to be created and merged
+        if: needs.trigger-release-if-needed.result == 'success'
+        env:
+          GH_TOKEN: ${{ secrets.PR_GH_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          TARGET_VERSION="${{ needs.resolve-version.outputs.target_version }}"
+          TARGET_BRANCH="${{ needs.resolve-version.outputs.target_branch }}"
+          echo "Waiting for version bump PR for v${TARGET_VERSION} on ${TARGET_BRANCH} to be merged..."
+
+          # Poll for up to 30 minutes (a human or automation needs to merge the version bump PR)
+          for i in $(seq 1 60); do
+            # Check if the tag exists (release-draft-create creates a tag on merge)
+            if gh api "repos/Comfy-Org/ComfyUI_frontend/git/ref/tags/v${TARGET_VERSION}" --silent 2>/dev/null; then
+              echo "✅ Tag v${TARGET_VERSION} found — release PR has been merged"
+              exit 0
+            fi
+            echo "Attempt $i/60: Tag v${TARGET_VERSION} not found yet, waiting 30s..."
+            sleep 30
+          done
+
+          echo "❌ Timed out waiting for tag v${TARGET_VERSION}"
+          exit 1
+
+      - name: Checkout code at target version
+        uses: actions/checkout@v6
+        with:
+          ref: v${{ needs.resolve-version.outputs.target_version }}
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@41ff72655975bd51cab0327fa583b6e92b6d3061 # v4.2.0
+        with:
+          version: 10
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'pnpm'
+
+      - name: Build project
+        env:
+          SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
+          ALGOLIA_APP_ID: ${{ secrets.ALGOLIA_APP_ID }}
+          ALGOLIA_API_KEY: ${{ secrets.ALGOLIA_API_KEY }}
+          ENABLE_MINIFY: 'true'
+          USE_PROD_CONFIG: 'true'
+        run: |
+          pnpm install --frozen-lockfile
+          pnpm build
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.x'
+
+      - name: Install build dependencies
+        run: python -m pip install build
+
+      - name: Build and publish PyPI package
+        run: |
+          set -euo pipefail
+          mkdir -p comfyui_frontend_package/comfyui_frontend_package/static/
+          cp -r dist/* comfyui_frontend_package/comfyui_frontend_package/static/
+
+      - name: Build pypi package
+        run: python -m build
+        working-directory: comfyui_frontend_package
+        env:
+          COMFYUI_FRONTEND_VERSION: ${{ needs.resolve-version.outputs.target_version }}
+
+      - name: Publish pypi package
+        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+        with:
+          skip-existing: true
+          password: ${{ secrets.PYPI_TOKEN }}
+          packages-dir: comfyui_frontend_package/dist
+
+      - name: Wait for PyPI propagation
+        run: |
+          set -euo pipefail
+
+          TARGET_VERSION="${{ needs.resolve-version.outputs.target_version }}"
+          PACKAGE="comfyui-frontend-package"
+          echo "Waiting for ${PACKAGE}==${TARGET_VERSION} to be available on PyPI..."
+
+          # Wait up to 15 minutes (polling every 30 seconds)
+          for i in $(seq 1 30); do
+            HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "https://pypi.org/pypi/${PACKAGE}/${TARGET_VERSION}/json")
+            if [ "$HTTP_CODE" = "200" ]; then
+              echo "✅ ${PACKAGE}==${TARGET_VERSION} is available on PyPI"
+              exit 0
+            fi
+            echo "Attempt $i/30: PyPI returned HTTP ${HTTP_CODE}, waiting 30s..."
+            sleep 30
+          done
+
+          echo "❌ Timed out waiting for ${PACKAGE}==${TARGET_VERSION} on PyPI"
+          exit 1
+
+      - name: Summary
+        run: |
+          echo "## PyPI Publishing" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- Package: comfyui-frontend-package" >> $GITHUB_STEP_SUMMARY
+          echo "- Version: ${{ needs.resolve-version.outputs.target_version }}" >> $GITHUB_STEP_SUMMARY
+          echo "- Status: ✅ Published and confirmed available" >> $GITHUB_STEP_SUMMARY
+
   create-comfyui-pr:
-    needs: [check-release-week, resolve-version, trigger-release-if-needed]
-    if: always() && needs.resolve-version.result == 'success' && (needs.check-release-week.outputs.is_release_week == 'true' || github.event_name == 'workflow_dispatch')
+    needs:
+      [
+        check-release-week,
+        resolve-version,
+        trigger-release-if-needed,
+        publish-pypi
+      ]
+    if: always() && needs.resolve-version.result == 'success' && needs.publish-pypi.result == 'success' && (needs.check-release-week.outputs.is_release_week == 'true' || github.event_name == 'workflow_dispatch')
     runs-on: ubuntu-latest
 
     steps:
@@ -236,11 +359,8 @@ jobs:
           EOF
           )
 
-          # Add release PR note if release was triggered
-          if [ "${{ needs.resolve-version.outputs.needs_release }}" = "true" ]; then
-            RELEASE_NOTE="⚠️ **Release PR must be merged first** - check [release workflow runs](https://github.com/Comfy-Org/ComfyUI_frontend/actions/workflows/release-version-bump.yaml)"
-            BODY=$''"${RELEASE_NOTE}"$'\n\n'"${BODY}"
-          fi
+          PYPI_NOTE="✅ **PyPI package confirmed available** — \`comfyui-frontend-package==${{ needs.resolve-version.outputs.target_version }}\` has been published and verified."
+          BODY=$''"${PYPI_NOTE}"$'\n\n'"${BODY}"
 
           # Save to file for later use
           printf '%s\n' "$BODY" > pr-body.txt
@@ -307,7 +427,11 @@ jobs:
             fi
 
             if [ -n "$EXISTING_PR" ] && [ "$EXISTING_PR" != "null" ]; then
-              echo "PR already exists (#${EXISTING_PR}), updating branch will update the PR"
+              echo "PR already exists (#${EXISTING_PR}), refreshing title/body"
+              gh pr edit "$EXISTING_PR" \
+                --repo Comfy-Org/ComfyUI \
+                --title "Bump comfyui-frontend-package to ${{ needs.resolve-version.outputs.target_version }}" \
+                --body-file ../pr-body.txt
             else
               echo "Failed to create PR and no existing PR found"
               exit 1

.github/workflows/release-draft-create.yaml

@@ -99,37 +99,6 @@ jobs:
             ${{ needs.build.outputs.is_prerelease == 'true' }}
           generate_release_notes: true
 
-  publish_pypi:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-      - name: Download dist artifact
-        uses: actions/download-artifact@v7
-        with:
-          name: dist-files
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.x'
-      - name: Install build dependencies
-        run: python -m pip install build
-      - name: Setup pypi package
-        run: |
-          mkdir -p comfyui_frontend_package/comfyui_frontend_package/static/
-          cp -r dist/* comfyui_frontend_package/comfyui_frontend_package/static/
-      - name: Build pypi package
-        run: python -m build
-        working-directory: comfyui_frontend_package
-        env:
-          COMFYUI_FRONTEND_VERSION: ${{ needs.build.outputs.version }}
-      - name: Publish pypi package
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
-        with:
-          password: ${{ secrets.PYPI_TOKEN }}
-          packages-dir: comfyui_frontend_package/dist
-
   publish_types:
     needs: build
     uses: ./.github/workflows/release-npm-types.yaml
@@ -142,7 +111,6 @@ jobs:
     name: Comment Release Summary
     needs:
       - draft_release
-      - publish_pypi
       - publish_types
     if: success()
     runs-on: ubuntu-latest

CODEOWNERS

@@ -1,61 +1,55 @@
-# Global Ownership
-*                                                 @Comfy-org/comfy_frontend_devs
-
 # Desktop/Electron
-/apps/desktop-ui/                                 @benceruleanlu @Comfy-org/comfy_frontend_devs
-/src/stores/electronDownloadStore.ts              @benceruleanlu @Comfy-org/comfy_frontend_devs
-/src/extensions/core/electronAdapter.ts           @benceruleanlu @Comfy-org/comfy_frontend_devs
-/vite.electron.config.mts                         @benceruleanlu @Comfy-org/comfy_frontend_devs
+/apps/desktop-ui/                                 @benceruleanlu
+/src/stores/electronDownloadStore.ts              @benceruleanlu
+/src/extensions/core/electronAdapter.ts           @benceruleanlu
+/vite.electron.config.mts                         @benceruleanlu
 
 # Common UI Components
-/src/components/chip/                             @viva-jinyi @Comfy-org/comfy_frontend_devs
-/src/components/card/                             @viva-jinyi @Comfy-org/comfy_frontend_devs
-/src/components/button/                           @viva-jinyi @Comfy-org/comfy_frontend_devs
-/src/components/input/                            @viva-jinyi @Comfy-org/comfy_frontend_devs
+/src/components/chip/                             @viva-jinyi
+/src/components/card/                             @viva-jinyi
+/src/components/button/                           @viva-jinyi
+/src/components/input/                            @viva-jinyi
 
 # Topbar
-/src/components/topbar/                           @pythongosssss @Comfy-org/comfy_frontend_devs
+/src/components/topbar/                           @pythongosssss
 
 # Thumbnail
-/src/renderer/core/thumbnail/                     @pythongosssss @Comfy-org/comfy_frontend_devs
+/src/renderer/core/thumbnail/                     @pythongosssss
 
 # Legacy UI
-/scripts/ui/                                      @pythongosssss @Comfy-org/comfy_frontend_devs
+/scripts/ui/                                      @pythongosssss
 
 # Link rendering
-/src/renderer/core/canvas/links/                  @benceruleanlu @Comfy-org/comfy_frontend_devs
+/src/renderer/core/canvas/links/                  @benceruleanlu
 
 # Partner Nodes
-/src/composables/node/useNodePricing.ts           @jojodecayz @bigcat88 @Comfy-org/comfy_frontend_devs
+/src/composables/node/useNodePricing.ts           @jojodecayz @bigcat88
 
 # Node help system
-/src/utils/nodeHelpUtil.ts                        @benceruleanlu @Comfy-org/comfy_frontend_devs
-/src/stores/workspace/nodeHelpStore.ts            @benceruleanlu @Comfy-org/comfy_frontend_devs
-/src/services/nodeHelpService.ts                  @benceruleanlu @Comfy-org/comfy_frontend_devs
+/src/utils/nodeHelpUtil.ts                        @benceruleanlu
+/src/stores/workspace/nodeHelpStore.ts            @benceruleanlu
+/src/services/nodeHelpService.ts                  @benceruleanlu
 
 # Selection toolbox
-/src/components/graph/selectionToolbox/           @Myestery @Comfy-org/comfy_frontend_devs
+/src/components/graph/selectionToolbox/           @Myestery
 
 # Minimap
-/src/renderer/extensions/minimap/                 @jtydhr88 @Myestery @Comfy-org/comfy_frontend_devs
+/src/renderer/extensions/minimap/                 @jtydhr88 @Myestery
 
 # Workflow Templates
-/src/platform/workflow/templates/                 @Myestery @christian-byrne @comfyui-wiki @Comfy-org/comfy_frontend_devs
-/src/components/templates/                        @Myestery @christian-byrne @comfyui-wiki @Comfy-org/comfy_frontend_devs
+/src/platform/workflow/templates/                 @Myestery @christian-byrne @comfyui-wiki
+/src/components/templates/                        @Myestery @christian-byrne @comfyui-wiki
 
 # Mask Editor
-/src/extensions/core/maskeditor.ts                @trsommer @brucew4yn3rp @Comfy-org/comfy_frontend_devs
-/src/extensions/core/maskEditorLayerFilenames.ts  @trsommer @brucew4yn3rp @Comfy-org/comfy_frontend_devs
+/src/extensions/core/maskeditor.ts                @trsommer @brucew4yn3rp
+/src/extensions/core/maskEditorLayerFilenames.ts  @trsommer @brucew4yn3rp
 
 # 3D
-/src/extensions/core/load3d.ts                    @jtydhr88 @Comfy-org/comfy_frontend_devs
-/src/components/load3d/                           @jtydhr88 @Comfy-org/comfy_frontend_devs
+/src/extensions/core/load3d.ts                    @jtydhr88
+/src/components/load3d/                           @jtydhr88
 
 # Manager
-/src/workbench/extensions/manager/                @viva-jinyi @christian-byrne @ltdrdata @Comfy-org/comfy_frontend_devs
-
-# Translations
-/src/locales/                                     @Comfy-Org/comfy_maintainer @Comfy-org/comfy_frontend_devs
+/src/workbench/extensions/manager/                @viva-jinyi @christian-byrne @ltdrdata
 
 # LLM Instructions (blank on purpose)
 .claude/

browser_tests/assets/subgraphs/subgraph-with-text-widget.json

@@ -8,7 +8,7 @@
       "id": 11,
       "type": "422723e8-4bf6-438c-823f-881ca81acead",
       "pos": [791.59912109375, 386.13336181640625],
-      "size": [140, 26],
+      "size": [400, 200],
       "flags": {},
       "order": 0,
       "mode": 0,

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[] = []
@@ -227,9 +231,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() {
@@ -431,9 +437,9 @@ export const comfyPageFixture = base.extend<{
         // Disable toast warning about version compatibility, as they may or
         // may not appear - depending on upstream ComfyUI dependencies
         'Comfy.VersionCompatibility.DisableWarnings': true,
-        // Browser tests should opt into missing-model warnings explicitly so
-        // workflows do not render differently based on models present on disk.
-        'Comfy.Workflow.ShowMissingModelsWarning': false
+        // Disable errors tab to prevent missing model detection from
+        // rendering error indicators on nodes during unrelated tests.
+        'Comfy.RightSidePanel.ShowErrorsTab': false
       })
     } catch (e) {
       console.error(e)

browser_tests/fixtures/helpers/FeatureFlagHelper.ts

@@ -0,0 +1,73 @@
+import type { Page, Route } from '@playwright/test'
+
+export class FeatureFlagHelper {
+  private featuresRouteHandler: ((route: Route) => void) | null = null
+
+  constructor(private readonly page: Page) {}
+
+  /**
+   * Seed feature flags via `addInitScript` so they are available in
+   * localStorage before the app JS executes on first load.
+   * Must be called before `comfyPage.setup()` / `page.goto()`.
+   *
+   * Note: Playwright init scripts persist for the page lifetime and
+   * cannot be removed. Call this once per test, before navigation.
+   */
+  async seedFlags(flags: Record<string, unknown>): Promise<void> {
+    await this.page.addInitScript((flagMap: Record<string, unknown>) => {
+      for (const [key, value] of Object.entries(flagMap)) {
+        localStorage.setItem(`ff:${key}`, JSON.stringify(value))
+      }
+    }, flags)
+  }
+
+  /**
+   * Set feature flags at runtime via localStorage. Uses the `ff:` prefix
+   * that devFeatureFlagOverride.ts reads in dev mode.
+   * For flags needed before page init, use `seedFlags()` instead.
+   */
+  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> {
+    this.featuresRouteHandler = (route: Route) =>
+      route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(features)
+      })
+    await this.page.route('**/api/features', this.featuresRouteHandler)
+  }
+
+  async clearMocks(): Promise<void> {
+    if (this.featuresRouteHandler) {
+      await this.page.unroute('**/api/features', this.featuresRouteHandler)
+      this.featuresRouteHandler = null
+    }
+  }
+}

browser_tests/fixtures/helpers/PerformanceHelper.ts

@@ -8,6 +8,10 @@ interface PerfSnapshot {
   TaskDuration: number
   JSHeapUsedSize: number
   Timestamp: number
+  Nodes: number
+  JSHeapTotalSize: number
+  ScriptDuration: number
+  JSEventListeners: number
 }
 
 export interface PerfMeasurement {
@@ -19,6 +23,12 @@ export interface PerfMeasurement {
   layoutDurationMs: number
   taskDurationMs: number
   heapDeltaBytes: number
+  domNodes: number
+  jsHeapTotalBytes: number
+  scriptDurationMs: number
+  eventListeners: number
+  totalBlockingTimeMs: number
+  frameDurationMs: number
 }
 
 export class PerformanceHelper {
@@ -59,16 +69,100 @@ export class PerformanceHelper {
       LayoutDuration: get('LayoutDuration'),
       TaskDuration: get('TaskDuration'),
       JSHeapUsedSize: get('JSHeapUsedSize'),
-      Timestamp: get('Timestamp')
+      Timestamp: get('Timestamp'),
+      Nodes: get('Nodes'),
+      JSHeapTotalSize: get('JSHeapTotalSize'),
+      ScriptDuration: get('ScriptDuration'),
+      JSEventListeners: get('JSEventListeners')
     }
   }
 
+  /**
+   * Collect longtask entries from PerformanceObserver and compute TBT.
+   * TBT = sum of (duration - 50ms) for every task longer than 50ms.
+   */
+  private async collectTBT(): Promise<number> {
+    return this.page.evaluate(() => {
+      const state = (window as unknown as Record<string, unknown>)
+        .__perfLongtaskState as
+        | { observer: PerformanceObserver; tbtMs: number }
+        | undefined
+      if (!state) return 0
+
+      // Flush any queued-but-undelivered entries into our accumulator
+      for (const entry of state.observer.takeRecords()) {
+        if (entry.duration > 50) state.tbtMs += entry.duration - 50
+      }
+      const result = state.tbtMs
+      state.tbtMs = 0
+      return result
+    })
+  }
+
+  /**
+   * Measure average frame duration via rAF timing over a sample window.
+   * Returns average ms per frame (lower = better, 16.67 = 60fps).
+   */
+  private async measureFrameDuration(sampleFrames = 10): Promise<number> {
+    return this.page.evaluate((frames) => {
+      return new Promise<number>((resolve) => {
+        const timeout = setTimeout(() => resolve(0), 5000)
+        const timestamps: number[] = []
+        let count = 0
+        function tick(ts: number) {
+          timestamps.push(ts)
+          count++
+          if (count <= frames) {
+            requestAnimationFrame(tick)
+          } else {
+            clearTimeout(timeout)
+            if (timestamps.length < 2) {
+              resolve(0)
+              return
+            }
+            const total = timestamps[timestamps.length - 1] - timestamps[0]
+            resolve(total / (timestamps.length - 1))
+          }
+        }
+        requestAnimationFrame(tick)
+      })
+    }, sampleFrames)
+  }
+
   async startMeasuring(): Promise<void> {
     if (this.snapshot) {
       throw new Error(
         'Measurement already in progress — call stopMeasuring() first'
       )
     }
+    // Install longtask observer if not already present, then reset the
+    // accumulator so old longtasks don't bleed into the new measurement window.
+    await this.page.evaluate(() => {
+      const win = window as unknown as Record<string, unknown>
+      if (!win.__perfLongtaskState) {
+        const state: { observer: PerformanceObserver; tbtMs: number } = {
+          observer: new PerformanceObserver((list) => {
+            const self = (window as unknown as Record<string, unknown>)
+              .__perfLongtaskState as {
+              observer: PerformanceObserver
+              tbtMs: number
+            }
+            for (const entry of list.getEntries()) {
+              if (entry.duration > 50) self.tbtMs += entry.duration - 50
+            }
+          }),
+          tbtMs: 0
+        }
+        state.observer.observe({ type: 'longtask', buffered: true })
+        win.__perfLongtaskState = state
+      }
+      const state = win.__perfLongtaskState as {
+        observer: PerformanceObserver
+        tbtMs: number
+      }
+      state.tbtMs = 0
+      state.observer.takeRecords()
+    })
     this.snapshot = await this.getSnapshot()
   }
 
@@ -82,6 +176,11 @@ export class PerformanceHelper {
       return after[key] - before[key]
     }
 
+    const [totalBlockingTimeMs, frameDurationMs] = await Promise.all([
+      this.collectTBT(),
+      this.measureFrameDuration()
+    ])
+
     return {
       name,
       durationMs: delta('Timestamp') * 1000,
@@ -90,7 +189,13 @@ export class PerformanceHelper {
       layouts: delta('LayoutCount'),
       layoutDurationMs: delta('LayoutDuration') * 1000,
       taskDurationMs: delta('TaskDuration') * 1000,
-      heapDeltaBytes: delta('JSHeapUsedSize')
+      heapDeltaBytes: delta('JSHeapUsedSize'),
+      domNodes: delta('Nodes'),
+      jsHeapTotalBytes: delta('JSHeapTotalSize'),
+      scriptDurationMs: delta('ScriptDuration') * 1000,
+      eventListeners: delta('JSEventListeners'),
+      totalBlockingTimeMs,
+      frameDurationMs
     }
   }
 }

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

@@ -1,4 +1,3 @@
-import type { Locator } from '@playwright/test'
 import { expect } from '@playwright/test'
 
 import type { Keybinding } from '../../src/platform/keybindings/types'
@@ -72,6 +71,10 @@ test('Does not report warning on undo/redo', async ({ comfyPage }) => {
 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()
   })
 
@@ -88,117 +91,58 @@ test.describe('Execution error', () => {
   })
 })
 
-test.describe('Missing models warning', () => {
-  test('Should be disabled by default in browser tests', async ({
-    comfyPage
-  }) => {
-    await comfyPage.workflow.loadWorkflow('missing/missing_models')
-
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).not.toBeVisible()
-  })
-
+test.describe('Missing models in Error Tab', () => {
   test.beforeEach(async ({ comfyPage }) => {
+    await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
     await comfyPage.settings.setSetting(
-      'Comfy.Workflow.ShowMissingModelsWarning',
+      'Comfy.RightSidePanel.ShowErrorsTab',
       true
     )
-    await comfyPage.page.evaluate((url: string) => {
-      return fetch(`${url}/api/devtools/cleanup_fake_model`)
+    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 display a warning when missing models are found', async ({
+  test('Should show error overlay with missing models when workflow has missing models', async ({
     comfyPage
   }) => {
     await comfyPage.workflow.loadWorkflow('missing/missing_models')
 
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).toBeVisible()
+    const errorOverlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(errorOverlay).toBeVisible()
 
-    const downloadAllButton = comfyPage.page.getByText('Download all')
-    await expect(downloadAllButton).toBeVisible()
+    const missingModelsTitle = comfyPage.page.getByText(/Missing Models/)
+    await expect(missingModelsTitle).toBeVisible()
   })
 
-  test('Should display a warning when missing models are found in node properties', async ({
+  test('Should show missing models from node properties', async ({
     comfyPage
   }) => {
-    // Load workflow that has a node with models metadata at the node level
     await comfyPage.workflow.loadWorkflow(
       'missing/missing_models_from_node_properties'
     )
 
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).toBeVisible()
+    const errorOverlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(errorOverlay).toBeVisible()
 
-    const downloadAllButton = comfyPage.page.getByText('Download all')
-    await expect(downloadAllButton).toBeVisible()
+    const missingModelsTitle = comfyPage.page.getByText(/Missing Models/)
+    await expect(missingModelsTitle).toBeVisible()
   })
 
-  test('Should not display a warning when no missing models are found', async ({
+  test('Should not show missing models when widget values have changed', async ({
     comfyPage
   }) => {
-    const modelFoldersRes = {
-      status: 200,
-      body: JSON.stringify([
-        {
-          name: 'text_encoders',
-          folders: ['ComfyUI/models/text_encoders']
-        }
-      ])
-    }
-    await comfyPage.page.route(
-      '**/api/experiment/models',
-      (route) => route.fulfill(modelFoldersRes),
-      { times: 1 }
-    )
-
-    // Reload page to trigger indexing of model folders
-    await comfyPage.setup()
-
-    const clipModelsRes = {
-      status: 200,
-      body: JSON.stringify([
-        {
-          name: 'fake_model.safetensors',
-          pathIndex: 0
-        }
-      ])
-    }
-    await comfyPage.page.route(
-      '**/api/experiment/models/text_encoders',
-      (route) => route.fulfill(clipModelsRes),
-      { times: 1 }
-    )
-
-    await comfyPage.workflow.loadWorkflow('missing/missing_models')
-
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).not.toBeVisible()
-  })
-
-  test('Should not display warning when model metadata exists but widget values have changed', async ({
-    comfyPage
-  }) => {
-    // This tests the scenario where outdated model metadata exists in the workflow
-    // but the actual selected models (widget values) have changed
     await comfyPage.workflow.loadWorkflow(
       'missing/model_metadata_widget_mismatch'
     )
 
-    // The missing models warning should NOT appear
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).not.toBeVisible()
+    const missingModelsTitle = comfyPage.page.getByText(/Missing Models/)
+    await expect(missingModelsTitle).not.toBeVisible()
+
+    const errorOverlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(errorOverlay).not.toBeVisible()
   })
 
   // Flaky test after parallelization
@@ -206,14 +150,10 @@ test.describe('Missing models warning', () => {
   test.skip('Should download missing model when clicking download button', async ({
     comfyPage
   }) => {
-    // The fake_model.safetensors is served by
-    // https://github.com/Comfy-Org/ComfyUI_devtools/blob/main/__init__.py
     await comfyPage.workflow.loadWorkflow('missing/missing_models')
 
-    const dialogTitle = comfyPage.page.getByText(
-      'This workflow is missing models'
-    )
-    await expect(dialogTitle).toBeVisible()
+    const errorOverlay = comfyPage.page.locator('[data-testid="error-overlay"]')
+    await expect(errorOverlay).toBeVisible()
 
     const downloadAllButton = comfyPage.page.getByText('Download all')
     await expect(downloadAllButton).toBeVisible()
@@ -223,50 +163,6 @@ test.describe('Missing models warning', () => {
     const download = await downloadPromise
     expect(download.suggestedFilename()).toBe('fake_model.safetensors')
   })
-
-  test.describe('Do not show again checkbox', () => {
-    let checkbox: Locator
-    let closeButton: Locator
-
-    test.beforeEach(async ({ comfyPage }) => {
-      await comfyPage.settings.setSetting(
-        'Comfy.Workflow.ShowMissingModelsWarning',
-        true
-      )
-      await comfyPage.workflow.loadWorkflow('missing/missing_models')
-
-      checkbox = comfyPage.page.getByLabel("Don't show this again")
-      closeButton = comfyPage.page.getByLabel('Close')
-    })
-
-    test('Should disable warning dialog when checkbox is checked', async ({
-      comfyPage
-    }) => {
-      const changeSettingPromise = comfyPage.page.waitForRequest(
-        '**/api/settings/Comfy.Workflow.ShowMissingModelsWarning'
-      )
-      await checkbox.click()
-      await changeSettingPromise
-
-      await closeButton.click()
-
-      const settingValue = await comfyPage.settings.getSetting(
-        'Comfy.Workflow.ShowMissingModelsWarning'
-      )
-      expect(settingValue).toBe(false)
-    })
-
-    test('Should keep warning dialog enabled when checkbox is unchecked', async ({
-      comfyPage
-    }) => {
-      await closeButton.click()
-
-      const settingValue = await comfyPage.settings.getSetting(
-        'Comfy.Workflow.ShowMissingModelsWarning'
-      )
-      expect(settingValue).toBe(true)
-    })
-  })
 })
 
 test.describe('Settings', () => {

browser_tests/tests/execution.spec.ts

@@ -9,6 +9,10 @@ test.beforeEach(async ({ comfyPage }) => {
 test.describe('Execution', { tag: ['@smoke', '@workflow'] }, () => {
   test.beforeEach(async ({ comfyPage }) => {
     await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top')
+    await comfyPage.settings.setSetting(
+      'Comfy.RightSidePanel.ShowErrorsTab',
+      true
+    )
     await comfyPage.setup()
   })
 

browser_tests/tests/graphCanvasMenu.spec.ts

@@ -60,6 +60,15 @@ test.describe('Graph Canvas Menu', { tag: ['@screenshot', '@canvas'] }, () => {
     await comfyPage.nextFrame()
   })
 
+  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 and closes', async ({ comfyPage }) => {
     // Find the zoom button by its percentage text content
     const zoomButton = comfyPage.page.locator('button').filter({

browser_tests/tests/groupCopyPaste.spec.ts

@@ -0,0 +1,44 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+
+test.describe('Group Copy Paste', { tag: ['@canvas'] }, () => {
+  test.afterEach(async ({ comfyPage }) => {
+    await comfyPage.canvasOps.resetView()
+  })
+
+  test('Pasted group is offset from original position', async ({
+    comfyPage
+  }) => {
+    await comfyPage.workflow.loadWorkflow('groups/single_group_only')
+
+    const titlePos = await comfyPage.page.evaluate(() => {
+      const app = window.app!
+      const group = app.graph.groups[0]
+      const clientPos = app.canvasPosToClientPos([
+        group.pos[0] + 50,
+        group.pos[1] + 15
+      ])
+      return { x: clientPos[0], y: clientPos[1] }
+    })
+    await comfyPage.canvas.click({ position: titlePos })
+    await comfyPage.nextFrame()
+
+    await comfyPage.clipboard.copy()
+    await comfyPage.clipboard.paste()
+    await comfyPage.nextFrame()
+
+    const positions = await comfyPage.page.evaluate(() =>
+      window.app!.graph.groups.map((g: { pos: number[] }) => ({
+        x: g.pos[0],
+        y: g.pos[1]
+      }))
+    )
+
+    expect(positions).toHaveLength(2)
+    const dx = Math.abs(positions[0].x - positions[1].x)
+    const dy = Math.abs(positions[0].y - positions[1].y)
+    expect(dx).toBeCloseTo(50, 0)
+    expect(dy).toBeCloseTo(15, 0)
+  })
+})