fix: resolve "No inner node DTO found" error when muting subgraphs

When a subgraph or group node is muted (mode=NEVER), resolveOutput()
still tried to look up inner node DTOs that were never registered,
causing execution errors. Add early returns for NEVER mode in both
ExecutableNodeDTO and ExecutableGroupNodeDTO.

Fixes #8986

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude/skills/backport-management/SKILL.md

@@ -1,150 +0,0 @@
----
-name: backport-management
-description: Manages cherry-pick backports across stable release branches. Discovers candidates from Slack/git, analyzes dependencies, resolves conflicts via worktree, and logs results. Use when asked to backport, cherry-pick to stable, manage release branches, do stable branch maintenance, or run a backport session.
----
-
-# Backport Management
-
-Cherry-pick backport management for Comfy-Org/ComfyUI_frontend stable release branches.
-
-## Quick Start
-
-1. **Discover** — Collect candidates from Slack bot + git log gap (`reference/discovery.md`)
-2. **Analyze** — Categorize MUST/SHOULD/SKIP, check deps (`reference/analysis.md`)
-3. **Plan** — Order by dependency (leaf fixes first), group into waves per branch
-4. **Execute** — Label-driven automation → worktree fallback for conflicts (`reference/execution.md`)
-5. **Verify** — After each wave, verify branch integrity before proceeding
-6. **Log & Report** — Generate session report with mermaid diagram (`reference/logging.md`)
-
-## System Context
-
-| Item           | Value                                             |
-| -------------- | ------------------------------------------------- |
-| Repo           | `~/ComfyUI_frontend` (Comfy-Org/ComfyUI_frontend) |
-| Merge strategy | Squash merge (`gh pr merge --squash --admin`)     |
-| Automation     | `pr-backport.yaml` GitHub Action (label-driven)   |
-| Tracking dir   | `~/temp/backport-session/`                        |
-
-## Branch Scope Rules
-
-**Critical: Match PRs to the correct target branches.**
-
-| Branch prefix | Scope                          | Example                                   |
-| ------------- | ------------------------------ | ----------------------------------------- |
-| `cloud/*`     | Cloud-hosted ComfyUI only      | App mode, cloud auth, cloud-specific UI   |
-| `core/*`      | Local/self-hosted ComfyUI only | Core editor, local workflows, node system |
-
-**⚠️ NEVER backport cloud-only PRs to `core/*` branches.** Cloud-only changes (app mode, cloud auth, cloud billing UI, cloud-specific API calls) are irrelevant to local users and waste effort. Before backporting any PR to a `core/*` branch, check:
-
-- Does the PR title/description mention "app mode", "cloud", or cloud-specific features?
-- Does the PR only touch files like `appModeStore.ts`, cloud auth, or cloud-specific components?
-- If yes → skip for `core/*` branches (may still apply to `cloud/*` branches)
-
-## ⚠️ Gotchas (Learn from Past Sessions)
-
-### Use `gh api` for Labels — NOT `gh pr edit`
-
-`gh pr edit --add-label` triggers Projects Classic deprecation errors. Always use:
-
-```bash
-gh api repos/Comfy-Org/ComfyUI_frontend/issues/$PR/labels \
-  -f "labels[]=needs-backport" -f "labels[]=TARGET_BRANCH"
-```
-
-### Automation Over-Reports Conflicts
-
-The `pr-backport.yaml` action reports more conflicts than reality. `git cherry-pick -m 1` with git auto-merge handles many cases the automation can't. Always attempt manual cherry-pick before skipping.
-
-### Never Skip Based on Conflict File Count
-
-12 or 27 conflicting files can be trivial (snapshots, new files). **Categorize conflicts first**, then decide. See Conflict Triage below.
-
-## Conflict Triage
-
-**Always categorize before deciding to skip. High conflict count ≠ hard conflicts.**
-
-| Type                         | Symptom                              | Resolution                                                      |
-| ---------------------------- | ------------------------------------ | --------------------------------------------------------------- |
-| **Binary snapshots (PNGs)**  | `.png` files in conflict list        | `git checkout --theirs $FILE && git add $FILE` — always trivial |
-| **Modify/delete (new file)** | PR introduces files not on target    | `git add $FILE` — keep the new file                             |
-| **Modify/delete (removed)**  | Target removed files the PR modifies | `git rm $FILE` — file no longer relevant                        |
-| **Content conflicts**        | Marker-based (`<<<<<<<`)             | Accept theirs via python regex (see below)                      |
-| **Add/add**                  | Both sides added same file           | Accept theirs, verify no logic conflict                         |
-| **Locale/JSON files**        | i18n key additions                   | Accept theirs, validate JSON after                              |
-
-```python
-# Accept theirs for content conflicts
-import re
-pattern = r'<<<<<<< HEAD\n(.*?)=======\n(.*?)>>>>>>> [^\n]+\n?'
-content = re.sub(pattern, r'\2', content, flags=re.DOTALL)
-```
-
-### Escalation Triggers (Flag for Human)
-
-- **Package.json/lockfile changes** → skip on stable (transitive dep regression risk)
-- **Core type definition changes** → requires human judgment
-- **Business logic conflicts** (not just imports/exports) → requires domain knowledge
-- **Admin-merged conflict resolutions** → get human review of the resolution before continuing the wave
-
-## Auto-Skip Categories
-
-Skip these without discussion:
-
-- **Dep refresh PRs** — Risk of transitive dep regressions on stable. Cherry-pick individual CVE fixes instead.
-- **CI/tooling changes** — Not user-facing
-- **Test-only / lint rule changes** — Not user-facing
-- **Revert pairs** — If PR A reverted by PR B, skip both. If fixed version (PR C) exists, backport only C.
-- **Features not on target branch** — e.g., Painter, GLSLShader, appModeStore on core/1.40
-- **Cloud-only PRs on core/\* branches** — App mode, cloud auth, cloud billing. These only affect cloud-hosted ComfyUI.
-
-## Wave Verification
-
-After merging each wave of PRs to a target branch, verify branch integrity before proceeding:
-
-```bash
-# Fetch latest state of target branch
-git fetch origin TARGET_BRANCH
-
-# Quick smoke check: does the branch build?
-git worktree add /tmp/verify-TARGET origin/TARGET_BRANCH
-cd /tmp/verify-TARGET
-source ~/.nvm/nvm.sh && nvm use 24 && pnpm install && pnpm typecheck
-git worktree remove /tmp/verify-TARGET --force
-```
-
-If typecheck fails, stop and investigate before continuing. A broken branch after wave N means all subsequent waves will compound the problem.
-
-## Continuous Backporting Recommendation
-
-Large backport sessions (50+ PRs) are expensive and error-prone. Prefer continuous backporting:
-
-- Backport bug fixes as they merge to main (same day or next day)
-- Use the automation labels immediately after merge
-- Reserve session-style bulk backporting for catching up after gaps
-- When a release branch is created, immediately start the continuous process
-
-## Quick Reference
-
-### Label-Driven Automation (default path)
-
-```bash
-gh api repos/Comfy-Org/ComfyUI_frontend/issues/$PR/labels \
-  -f "labels[]=needs-backport" -f "labels[]=TARGET_BRANCH"
-# Wait 3 min, check: gh pr list --base TARGET_BRANCH --state open
-```
-
-### Manual Worktree Cherry-Pick (conflict fallback)
-
-```bash
-git worktree add /tmp/backport-$BRANCH origin/$BRANCH
-cd /tmp/backport-$BRANCH
-git checkout -b backport-$PR-to-$BRANCH origin/$BRANCH
-git cherry-pick -m 1 $MERGE_SHA
-# Resolve conflicts, push, create PR, merge
-```
-
-### PR Title Convention
-
-```
-[backport TARGET_BRANCH] Original Title (#ORIGINAL_PR)
-```

.claude/skills/backport-management/reference/analysis.md

@@ -1,68 +0,0 @@
-# Analysis & Decision Framework
-
-## Categorization
-
-| Category             | Criteria                                                                                                  | Action                                                                     |
-| -------------------- | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| **MUST**             | User-facing bug, crash, data corruption, security. Clear breakage that users will hit.                    | Backport (with deps if needed)                                             |
-| **SHOULD**           | UX improvement, minor bug, small dep chain. No user-visible breakage if skipped, but improves experience. | Backport if clean cherry-pick; defer if conflict resolution is non-trivial |
-| **SKIP**             | CI/tooling, test-only, lint rules, cosmetic, dep refresh                                                  | Skip with documented reason                                                |
-| **NEEDS DISCUSSION** | Large dep chain, unclear risk/benefit, touches core types                                                 | Flag for human                                                             |
-
-### MUST vs SHOULD Decision Guide
-
-When unsure, ask: "If a user on this stable branch reports this issue, would we consider it a bug?"
-
-- **Yes** → MUST. The fix addresses broken behavior.
-- **No, but it's noticeably better** → SHOULD. The fix is a quality-of-life improvement.
-- **No, and it's cosmetic or internal** → SKIP.
-
-For SHOULD items with conflicts: if conflict resolution requires more than trivial accept-theirs patterns (content conflicts in business logic, not just imports), downgrade to SKIP or escalate to NEEDS DISCUSSION.
-
-## Branch Scope Filtering
-
-**Before categorizing, filter by branch scope:**
-
-| Target branch | Skip if PR is...                                                    |
-| ------------- | ------------------------------------------------------------------- |
-| `core/*`      | Cloud-only (app mode, cloud auth, cloud billing, cloud-specific UI) |
-| `cloud/*`     | Local-only features not present on cloud branch                     |
-
-Cloud-only PRs backported to `core/*` are wasted effort — `core/*` branches serve local/self-hosted users who never see cloud features. Check PR titles, descriptions, and files changed for cloud-specific indicators.
-
-## Features Not on Stable Branches
-
-Check before backporting — these don't exist on older branches:
-
-- **Painter** (`src/extensions/core/painter.ts`) — not on core/1.40
-- **GLSLShader** — not on core/1.40
-- **App builder** — check per branch
-- **appModeStore.ts** — not on core/1.40
-
-## Dep Refresh PRs
-
-Always SKIP on stable branches. Risk of transitive dependency regressions outweighs audit cleanup benefit. If a specific CVE fix is needed, cherry-pick that individual fix instead.
-
-## Revert Pairs
-
-If PR A is reverted by PR B:
-
-- Skip BOTH A and B
-- If a fixed version exists (PR C), backport only C
-
-## Dependency Analysis
-
-```bash
-# Find other PRs that touched the same files
-gh pr view $PR --json files --jq '.files[].path' | while read f; do
-  git log --oneline origin/TARGET..$MERGE_SHA -- "$f"
-done
-```
-
-## Human Review Checkpoint
-
-Present decisions.md before execution. Include:
-
-1. All MUST/SHOULD/SKIP categorizations with rationale
-2. Questions for human (feature existence, scope, deps)
-3. Estimated effort per branch

.claude/skills/backport-management/reference/discovery.md

@@ -1,42 +0,0 @@
-# Discovery — Candidate Collection
-
-## Source 1: Slack Backport-Checker Bot
-
-Use `slackdump` skill to export `#frontend-releases` channel (C09K9TPU2G7):
-
-```bash
-slackdump export -o ~/slack-exports/frontend-releases.zip C09K9TPU2G7
-```
-
-Parse bot messages for PRs flagged "Might need backport" per release version.
-
-## Source 2: Git Log Gap Analysis
-
-```bash
-# Count gap
-git log --oneline origin/TARGET..origin/main | wc -l
-
-# List gap commits
-git log --oneline origin/TARGET..origin/main
-
-# Check if a PR is already on target
-git log --oneline origin/TARGET --grep="#PR_NUMBER"
-
-# Check for existing backport PRs
-gh pr list --base TARGET --state all --search "backport PR_NUMBER"
-```
-
-## Source 3: GitHub PR Details
-
-```bash
-# Get merge commit SHA
-gh pr view $PR --json mergeCommit,title --jq '"Title: \(.title)\nMerge: \(.mergeCommit.oid)"'
-
-# Get files changed
-gh pr view $PR --json files --jq '.files[].path'
-```
-
-## Output: candidate_list.md
-
-Table per target branch:
-| PR# | Title | Category | Flagged by Bot? | Decision |

.claude/skills/backport-management/reference/execution.md

@@ -1,150 +0,0 @@
-# Execution Workflow
-
-## Per-Branch Execution Order
-
-1. Smallest gap first (validation run)
-2. Medium gap next (quick win)
-3. Largest gap last (main effort)
-
-## Step 1: Label-Driven Automation (Batch)
-
-```bash
-# Add labels to all candidates for a target branch
-for pr in $PR_LIST; do
-  gh api repos/Comfy-Org/ComfyUI_frontend/issues/$pr/labels \
-    -f "labels[]=needs-backport" -f "labels[]=TARGET_BRANCH" --silent
-  sleep 2
-done
-
-# Wait 3 minutes for automation
-sleep 180
-
-# Check which got auto-PRs
-gh pr list --base TARGET_BRANCH --state open --limit 50 --json number,title
-```
-
-## Step 2: Review & Merge Clean Auto-PRs
-
-```bash
-for pr in $AUTO_PRS; do
-  # Check size
-  gh pr view $pr --json title,additions,deletions,changedFiles \
-    --jq '"Files: \(.changedFiles), +\(.additions)/-\(.deletions)"'
-  # Admin merge
-  gh pr merge $pr --squash --admin
-  sleep 3
-done
-```
-
-## Step 3: Manual Worktree for Conflicts
-
-```bash
-git fetch origin TARGET_BRANCH
-git worktree add /tmp/backport-TARGET origin/TARGET_BRANCH
-cd /tmp/backport-TARGET
-
-for PR in ${CONFLICT_PRS[@]}; do
-  # Refresh target ref so each branch is based on current HEAD
-  git fetch origin TARGET_BRANCH
-  git checkout origin/TARGET_BRANCH
-
-  git checkout -b backport-$PR-to-TARGET origin/TARGET_BRANCH
-  git cherry-pick -m 1 $MERGE_SHA
-
-  # If conflict — NEVER skip based on file count alone!
-  # Categorize conflicts first: binary PNGs, modify/delete, content, add/add
-  # See SKILL.md Conflict Triage table for resolution per type.
-
-  # Resolve all conflicts, then:
-  git add .
-  GIT_EDITOR=true git cherry-pick --continue
-
-  git push origin backport-$PR-to-TARGET
-  NEW_PR=$(gh pr create --base TARGET_BRANCH --head backport-$PR-to-TARGET \
-    --title "[backport TARGET] TITLE (#$PR)" \
-    --body "Backport of #$PR..." | grep -oP '\d+$')
-  gh pr merge $NEW_PR --squash --admin
-  sleep 3
-done
-
-# Cleanup
-cd -
-git worktree remove /tmp/backport-TARGET --force
-```
-
-**⚠️ Human review for conflict resolutions:** When admin-merging a PR where you manually resolved conflicts (especially content conflicts beyond trivial accept-theirs), pause and present the resolution diff to the human for review before merging. Trivial resolutions (binary snapshots, modify/delete, locale key additions) can proceed without review.
-
-## Step 4: Wave Verification
-
-After completing all PRs in a wave for a target branch:
-
-```bash
-git fetch origin TARGET_BRANCH
-git worktree add /tmp/verify-TARGET origin/TARGET_BRANCH
-cd /tmp/verify-TARGET
-source ~/.nvm/nvm.sh && nvm use 24 && pnpm install && pnpm typecheck
-git worktree remove /tmp/verify-TARGET --force
-```
-
-If verification fails, stop and fix before proceeding to the next wave. Do not compound problems across waves.
-
-## Conflict Resolution Patterns
-
-### 1. Content Conflicts (accept theirs)
-
-```python
-import re
-pattern = r'<<<<<<< HEAD\n(.*?)=======\n(.*?)>>>>>>> [^\n]+\n?'
-content = re.sub(pattern, r'\2', content, flags=re.DOTALL)
-```
-
-### 2. Modify/Delete (two cases!)
-
-```bash
-# Case A: PR introduces NEW files not on target → keep them
-git add $FILE
-
-# Case B: Target REMOVED files the PR modifies → drop them
-git rm $FILE
-```
-
-### 3. Binary Files (snapshots)
-
-```bash
-git checkout --theirs $FILE && git add $FILE
-```
-
-### 4. Locale Files
-
-Usually adding new i18n keys — accept theirs, validate JSON:
-
-```bash
-python3 -c "import json; json.load(open('src/locales/en/main.json'))" && echo "Valid"
-```
-
-## Merge Conflicts After Other Merges
-
-When merging multiple PRs to the same branch, later PRs may conflict with earlier merges:
-
-```bash
-git fetch origin TARGET_BRANCH
-git rebase origin/TARGET_BRANCH
-# Resolve new conflicts
-git push --force origin backport-$PR-to-TARGET
-sleep 20  # Wait for GitHub to recompute merge state
-gh pr merge $PR --squash --admin
-```
-
-## Lessons Learned
-
-1. **Automation reports more conflicts than reality** — `cherry-pick -m 1` with git auto-merge handles many "conflicts" the automation can't
-2. **Never skip based on conflict file count** — 12 or 27 conflicts can be trivial (snapshots, new files). Categorize first: binary PNGs, modify/delete, content, add/add.
-3. **Modify/delete goes BOTH ways** — if the PR introduces new files (not on target), `git add` them. If target deleted files the PR modifies, `git rm`.
-4. **Binary snapshot PNGs** — always `git checkout --theirs && git add`. Never skip a PR just because it has many snapshot conflicts.
-5. **Batch label additions need 2s delay** between API calls to avoid rate limits
-6. **Merging 6+ PRs rapidly** can cause later PRs to become unmergeable — wait 20-30s for GitHub to recompute merge state
-7. **appModeStore.ts, painter files, GLSLShader files** don't exist on core/1.40 — `git rm` these
-8. **Always validate JSON** after resolving locale file conflicts
-9. **Dep refresh PRs** — skip on stable branches. Risk of transitive dep regressions outweighs audit cleanup. Cherry-pick individual CVE fixes instead.
-10. **Verify after each wave** — run `pnpm typecheck` on the target branch after merging a batch. Catching breakage early prevents compounding errors.
-11. **Cloud-only PRs don't belong on core/\* branches** — app mode, cloud auth, and cloud-specific UI changes are irrelevant to local users. Always check PR scope against branch scope before backporting.

.claude/skills/backport-management/reference/logging.md

@@ -1,96 +0,0 @@
-# Logging & Session Reports
-
-## During Execution
-
-Maintain `execution-log.md` with per-branch tables:
-
-```markdown
-| PR#   | Title | Status                            | Backport PR | Notes   |
-| ----- | ----- | --------------------------------- | ----------- | ------- |
-| #XXXX | Title | ✅ Merged / ⏭️ Skip / ⏸️ Deferred | #YYYY       | Details |
-```
-
-## Wave Verification Log
-
-Track verification results per wave:
-
-```markdown
-## Wave N Verification — TARGET_BRANCH
-
-- PRs merged: #A, #B, #C
-- Typecheck: ✅ Pass / ❌ Fail
-- Issues found: (if any)
-- Human review needed: (list any non-trivial conflict resolutions)
-```
-
-## Session Report Template
-
-```markdown
-# Backport Session Report
-
-## Summary
-
-| Branch | Candidates | Merged | Skipped | Deferred | Rate |
-| ------ | ---------- | ------ | ------- | -------- | ---- |
-
-## Deferred Items (Needs Human)
-
-| PR# | Title | Branch | Issue |
-
-## Conflict Resolutions Requiring Review
-
-| PR# | Branch | Conflict Type | Resolution Summary |
-
-## Automation Performance
-
-| Metric                      | Value |
-| --------------------------- | ----- |
-| Auto success rate           | X%    |
-| Manual resolution rate      | X%    |
-| Overall clean rate          | X%    |
-| Wave verification pass rate | X%    |
-
-## Process Recommendations
-
-- Were there clusters of related PRs that should have been backported together?
-- Any PRs that should have been backported sooner (continuous backporting candidates)?
-- Feature branches that need tracking for future sessions?
-```
-
-## Final Deliverable: Visual Summary
-
-At session end, generate a **mermaid diagram** showing all backported PRs organized by target branch and category (MUST/SHOULD), plus a summary table. Present this to the user as the final output.
-
-```mermaid
-graph TD
-    subgraph branch1["☁️ cloud/X.XX — N PRs"]
-        C1["#XXXX title"]
-        C2["#XXXX title"]
-    end
-
-    subgraph branch2must["🔴 core/X.XX MUST — N PRs"]
-        M1["#XXXX title"]
-    end
-
-    subgraph branch2should["🟡 core/X.XX SHOULD — N PRs"]
-        S1["#XXXX-#XXXX N auto-merged"]
-        S2["#XXXX-#XXXX N manual picks"]
-    end
-
-    classDef cloudStyle fill:#1a3a5c,stroke:#4da6ff,color:#e0f0ff
-    classDef coreStyle fill:#1a4a2e,stroke:#4dff88,color:#e0ffe8
-    classDef mustStyle fill:#5c1a1a,stroke:#ff4d4d,color:#ffe0e0
-    classDef shouldStyle fill:#4a3a1a,stroke:#ffcc4d,color:#fff5e0
-```
-
-Use the `mermaid` tool to render this diagram and present it alongside the summary table as the session's final deliverable.
-
-## Files to Track
-
-- `candidate_list.md` — all candidates per branch
-- `decisions.md` — MUST/SHOULD/SKIP with rationale
-- `wave-plan.md` — execution order
-- `execution-log.md` — real-time status
-- `backport-session-report.md` — final summary
-
-All in `~/temp/backport-session/`.

browser_tests/assets/nodes/load_image_with_ksampler.json

@@ -1,47 +0,0 @@
-{
-  "last_node_id": 2,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "LoadImage",
-      "pos": [50, 50],
-      "size": [315, 314],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        { "name": "IMAGE", "type": "IMAGE", "links": null },
-        { "name": "MASK", "type": "MASK", "links": null }
-      ],
-      "properties": { "Node name for S&R": "LoadImage" },
-      "widgets_values": ["example.png", "image"]
-    },
-    {
-      "id": 2,
-      "type": "KSampler",
-      "pos": [500, 50],
-      "size": [315, 262],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [
-        { "name": "model", "type": "MODEL", "link": null },
-        { "name": "positive", "type": "CONDITIONING", "link": null },
-        { "name": "negative", "type": "CONDITIONING", "link": null },
-        { "name": "latent_image", "type": "LATENT", "link": null }
-      ],
-      "outputs": [{ "name": "LATENT", "type": "LATENT", "links": null }],
-      "properties": { "Node name for S&R": "KSampler" },
-      "widgets_values": [0, "randomize", 20, 8, "euler", "normal", 1]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "config": {},
-  "extra": {
-    "ds": { "offset": [0, 0], "scale": 1 }
-  },
-  "version": 0.4
-}

browser_tests/tests/dialog.spec.ts

@@ -333,7 +333,7 @@ test.describe('Settings', () => {
     await editKeybindingButton.click()
 
     // Set new keybinding
-    const input = comfyPage.page.getByPlaceholder('Enter your keybind')
+    const input = comfyPage.page.getByPlaceholder('Press keys for new binding')
     await input.press('Alt+n')
 
     const requestPromise = comfyPage.page.waitForRequest(
@@ -345,7 +345,7 @@ test.describe('Settings', () => {
 
     // Save keybinding
     const saveButton = comfyPage.page
-      .getByLabel('Modify keybinding')
+      .getByLabel('New Blank Workflow')
       .getByText('Save')
     await saveButton.click()
 

browser_tests/tests/imagePastePriority.spec.ts

@@ -1,58 +0,0 @@
-import { expect } from '@playwright/test'
-
-import { comfyPageFixture as test } from '../fixtures/ComfyPage'
-
-test.describe(
-  'Image paste priority over stale node metadata',
-  { tag: ['@node'] },
-  () => {
-    test('Should not paste copied node when a LoadImage node is selected and clipboard has stale node metadata', async ({
-      comfyPage
-    }) => {
-      await comfyPage.workflow.loadWorkflow('nodes/load_image_with_ksampler')
-
-      const initialCount = await comfyPage.nodeOps.getGraphNodesCount()
-      expect(initialCount).toBe(2)
-
-      // Copy the KSampler node (puts data-metadata in clipboard)
-      const ksamplerNodes =
-        await comfyPage.nodeOps.getNodeRefsByType('KSampler')
-      await ksamplerNodes[0].copy()
-
-      // Select the LoadImage node
-      const loadImageNodes =
-        await comfyPage.nodeOps.getNodeRefsByType('LoadImage')
-      await loadImageNodes[0].click('title')
-
-      // Simulate pasting when clipboard has stale node metadata (text/html
-      // with data-metadata) but no image file items. This replicates the bug
-      // scenario: user copied a node, then copied a web image (which replaces
-      // clipboard files but may leave stale text/html with node metadata).
-      await comfyPage.page.evaluate(() => {
-        const nodeData = { nodes: [{ type: 'KSampler', id: 99 }] }
-        const base64 = btoa(JSON.stringify(nodeData))
-        const html =
-          '<meta charset="utf-8"><div><span data-metadata="' +
-          base64 +
-          '"></span></div><span style="white-space:pre-wrap;">Text</span>'
-
-        const dataTransfer = new DataTransfer()
-        dataTransfer.setData('text/html', html)
-
-        const event = new ClipboardEvent('paste', {
-          clipboardData: dataTransfer,
-          bubbles: true,
-          cancelable: true
-        })
-        document.dispatchEvent(event)
-      })
-
-      await comfyPage.nextFrame()
-
-      // Node count should remain the same — stale node metadata should NOT
-      // be deserialized when a media node is selected.
-      const finalCount = await comfyPage.nodeOps.getGraphNodesCount()
-      expect(finalCount).toBe(initialCount)
-    })
-  }
-)

src/components/bottomPanel/BottomPanel.vue

@@ -25,13 +25,15 @@
                   class: {
                     'p-3 rounded-lg': true,
                     'pointer-events-none':
-                      bottomPanelStore.bottomPanelTabs.length === 1,
-                    'bg-secondary-background text-secondary-foreground':
-                      x.context.active &&
-                      bottomPanelStore.bottomPanelTabs.length > 1,
-                    'text-muted-foreground':
+                      bottomPanelStore.bottomPanelTabs.length === 1
+                  },
+                  style: {
+                    color: 'var(--fg-color)',
+                    backgroundColor:
                       !x.context.active ||
-                      bottomPanelStore.bottomPanelTabs.length <= 1
+                      bottomPanelStore.bottomPanelTabs.length === 1
+                        ? ''
+                        : 'var(--bg-color)'
                   }
                 })
               "
@@ -125,8 +127,4 @@ const closeBottomPanel = () => {
 :deep(.p-tablist-active-bar) {
   display: none;
 }
-
-:deep(.p-tab-active) {
-  color: inherit;
-}
 </style>

src/components/dialog/content/setting/KeybindingPanel.vue

@@ -59,15 +59,7 @@
         :pt="{ bodyCell: 'p-1 min-h-8' }"
       >
         <template #body="slotProps">
-          <div
-            class="flex items-center gap-1.5 truncate"
-            :title="slotProps.data.id"
-          >
-            <i
-              v-if="slotProps.data.keybinding?.combo.isBrowserReserved"
-              v-tooltip="$t('g.browserReservedKeybindingTooltip')"
-              class="icon-[lucide--triangle-alert] shrink-0 text-warning-background"
-            />
+          <div class="truncate" :title="slotProps.data.id">
             {{ slotProps.data.label }}
           </div>
         </template>
@@ -101,6 +93,44 @@
       </Column>
     </DataTable>
 
+    <Dialog
+      v-model:visible="editDialogVisible"
+      class="min-w-96"
+      modal
+      :header="currentEditingCommand?.label"
+      @hide="cancelEdit"
+    >
+      <div>
+        <InputText
+          ref="keybindingInput"
+          class="mb-2 text-center"
+          :model-value="newBindingKeyCombo?.toString() ?? ''"
+          :placeholder="$t('g.pressKeysForNewBinding')"
+          autocomplete="off"
+          fluid
+          @keydown.stop.prevent="captureKeybinding"
+        />
+        <Message v-if="existingKeybindingOnCombo" severity="warn">
+          {{ $t('g.keybindingAlreadyExists') }}
+          <Tag
+            severity="secondary"
+            :value="existingKeybindingOnCombo.commandId"
+          />
+        </Message>
+      </div>
+      <template #footer>
+        <Button
+          :variant="existingKeybindingOnCombo ? 'destructive' : 'primary'"
+          autofocus
+          @click="saveKeybinding"
+        >
+          <i
+            :class="existingKeybindingOnCombo ? 'pi pi-pencil' : 'pi pi-check'"
+          />
+          {{ existingKeybindingOnCombo ? $t('g.overwrite') : $t('g.save') }}
+        </Button>
+      </template>
+    </Dialog>
     <Button
       v-tooltip="$t('g.resetAllKeybindingsTooltip')"
       class="mt-4 w-full"
@@ -117,14 +147,18 @@
 import { FilterMatchMode } from '@primevue/core/api'
 import Column from 'primevue/column'
 import DataTable from 'primevue/datatable'
+import Dialog from 'primevue/dialog'
+import InputText from 'primevue/inputtext'
+import Message from 'primevue/message'
+import Tag from 'primevue/tag'
 import { useToast } from 'primevue/usetoast'
-import { computed, ref } from 'vue'
+import { computed, ref, watchEffect } from 'vue'
 import { useI18n } from 'vue-i18n'
 
 import SearchInput from '@/components/ui/search-input/SearchInput.vue'
 import Button from '@/components/ui/button/Button.vue'
-import { useEditKeybindingDialog } from '@/composables/useEditKeybindingDialog'
-import type { KeybindingImpl } from '@/platform/keybindings/keybinding'
+import { KeyComboImpl } from '@/platform/keybindings/keyCombo'
+import { KeybindingImpl } from '@/platform/keybindings/keybinding'
 import { useKeybindingService } from '@/platform/keybindings/keybindingService'
 import { useKeybindingStore } from '@/platform/keybindings/keybindingStore'
 import { useCommandStore } from '@/stores/commandStore'
@@ -161,16 +195,50 @@ const commandsData = computed<ICommandData[]>(() => {
 })
 
 const selectedCommandData = ref<ICommandData | null>(null)
-const editKeybindingDialog = useEditKeybindingDialog()
+const editDialogVisible = ref(false)
+const newBindingKeyCombo = ref<KeyComboImpl | null>(null)
+const currentEditingCommand = ref<ICommandData | null>(null)
+const keybindingInput = ref<InstanceType<typeof InputText> | null>(null)
+
+const existingKeybindingOnCombo = computed<KeybindingImpl | null>(() => {
+  if (!currentEditingCommand.value) {
+    return null
+  }
+
+  // If the new keybinding is the same as the current editing command, then don't show the error
+  if (
+    currentEditingCommand.value.keybinding?.combo?.equals(
+      newBindingKeyCombo.value
+    )
+  ) {
+    return null
+  }
+
+  if (!newBindingKeyCombo.value) {
+    return null
+  }
+
+  return keybindingStore.getKeybinding(newBindingKeyCombo.value)
+})
 
 function editKeybinding(commandData: ICommandData) {
-  editKeybindingDialog.show({
-    commandId: commandData.id,
-    commandLabel: commandData.label,
-    currentCombo: commandData.keybinding?.combo ?? null
-  })
+  currentEditingCommand.value = commandData
+  newBindingKeyCombo.value = commandData.keybinding
+    ? commandData.keybinding.combo
+    : null
+  editDialogVisible.value = true
 }
 
+watchEffect(() => {
+  if (editDialogVisible.value) {
+    // nextTick doesn't work here, so we use a timeout instead
+    setTimeout(() => {
+      // @ts-expect-error - $el is an internal property of the InputText component
+      keybindingInput.value?.$el?.focus()
+    }, 300)
+  }
+})
+
 async function removeKeybinding(commandData: ICommandData) {
   if (commandData.keybinding) {
     keybindingStore.unsetKeybinding(commandData.keybinding)
@@ -178,6 +246,40 @@ async function removeKeybinding(commandData: ICommandData) {
   }
 }
 
+async function captureKeybinding(event: KeyboardEvent) {
+  // Allow the use of keyboard shortcuts when adding keyboard shortcuts
+  if (!event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey) {
+    switch (event.key) {
+      case 'Escape':
+        cancelEdit()
+        return
+      case 'Enter':
+        await saveKeybinding()
+        return
+    }
+  }
+  const keyCombo = KeyComboImpl.fromEvent(event)
+  newBindingKeyCombo.value = keyCombo
+}
+
+function cancelEdit() {
+  editDialogVisible.value = false
+  currentEditingCommand.value = null
+  newBindingKeyCombo.value = null
+}
+
+async function saveKeybinding() {
+  const commandId = currentEditingCommand.value?.id
+  const combo = newBindingKeyCombo.value
+  cancelEdit()
+  if (!combo || commandId == undefined) return
+
+  const updated = keybindingStore.updateKeybindingOnCommand(
+    new KeybindingImpl({ commandId, combo })
+  )
+  if (updated) await keybindingService.persistUserKeybindings()
+}
+
 async function resetKeybinding(commandData: ICommandData) {
   if (keybindingStore.resetKeybindingForCommand(commandData.id)) {
     await keybindingService.persistUserKeybindings()

src/components/dialog/content/setting/keybinding/EditKeybindingContent.vue

@@ -1,56 +0,0 @@
-<template>
-  <div class="flex w-96 flex-col border-t border-border-default px-4">
-    <p class="mb-4 text-sm text-muted-foreground">
-      {{ $t('g.setAKeybindingForTheFollowing') }}
-    </p>
-    <div class="mb-4 text-sm text-base-foreground">
-      {{ commandLabel }}
-    </div>
-
-    <input
-      class="text-foreground mb-4 w-full rounded-sm border border-border-default bg-secondary-background px-3 py-2 text-center shadow-none focus:outline-none"
-      :value="dialogState.newCombo?.toString() ?? ''"
-      :placeholder="$t('g.enterYourKeybind')"
-      :aria-label="$t('g.enterYourKeybind')"
-      autocomplete="off"
-      autofocus
-      @keydown.stop.prevent="captureKeybinding"
-    />
-    <div class="min-h-12">
-      <p
-        v-if="dialogState.newCombo?.isBrowserReserved"
-        class="m-0 text-sm text-destructive-background"
-      >
-        {{ $t('g.browserReservedKeybinding') }}
-      </p>
-      <p
-        v-else-if="existingKeybindingOnCombo"
-        class="m-0 text-sm text-destructive-background"
-      >
-        {{ $t('g.keybindingAlreadyExists') }}
-        {{ existingKeybindingOnCombo.commandId }}
-      </p>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import type { KeybindingImpl } from '@/platform/keybindings/keybinding'
-import { KeyComboImpl } from '@/platform/keybindings/keyCombo'
-
-import type { EditKeybindingDialogState } from '@/composables/useEditKeybindingDialog'
-
-const { dialogState, onUpdateCombo, existingKeybindingOnCombo } = defineProps<{
-  dialogState: EditKeybindingDialogState
-  commandLabel: string
-  onUpdateCombo: (combo: KeyComboImpl) => void
-  existingKeybindingOnCombo: KeybindingImpl | null
-}>()
-
-function captureKeybinding(event: KeyboardEvent) {
-  if (!event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey) {
-    if (event.key === 'Escape') return
-  }
-  onUpdateCombo(KeyComboImpl.fromEvent(event))
-}
-</script>

src/components/dialog/content/setting/keybinding/EditKeybindingFooter.vue

@@ -1,72 +0,0 @@
-<template>
-  <div class="flex w-full justify-end gap-2 px-4 py-2">
-    <Button
-      variant="textonly"
-      size="md"
-      class="text-muted-foreground"
-      @click="handleCancel"
-    >
-      {{ $t('g.cancel') }}
-    </Button>
-    <Button
-      :variant="
-        existingKeybindingOnCombo
-          ? 'destructive'
-          : dialogState.newCombo?.isBrowserReserved
-            ? 'secondary'
-            : 'primary'
-      "
-      size="md"
-      :disabled="!dialogState.newCombo"
-      class="px-4 py-2"
-      @click="handleSave"
-    >
-      {{
-        existingKeybindingOnCombo
-          ? $t('g.overwrite')
-          : dialogState.newCombo?.isBrowserReserved
-            ? $t('g.saveAnyway')
-            : $t('g.save')
-      }}
-    </Button>
-  </div>
-</template>
-
-<script setup lang="ts">
-import type { Reactive } from 'vue'
-
-import Button from '@/components/ui/button/Button.vue'
-import { KeybindingImpl } from '@/platform/keybindings/keybinding'
-import { useKeybindingService } from '@/platform/keybindings/keybindingService'
-import { useKeybindingStore } from '@/platform/keybindings/keybindingStore'
-import { useDialogStore } from '@/stores/dialogStore'
-
-import type { EditKeybindingDialogState } from '@/composables/useEditKeybindingDialog'
-import { DIALOG_KEY } from '@/composables/useEditKeybindingDialog'
-
-const { dialogState, existingKeybindingOnCombo } = defineProps<{
-  dialogState: Reactive<EditKeybindingDialogState>
-  existingKeybindingOnCombo: KeybindingImpl | null
-}>()
-
-const keybindingStore = useKeybindingStore()
-const keybindingService = useKeybindingService()
-const dialogStore = useDialogStore()
-
-function handleCancel() {
-  dialogStore.closeDialog({ key: DIALOG_KEY })
-}
-
-async function handleSave() {
-  const combo = dialogState.newCombo
-  const commandId = dialogState.commandId
-  if (!combo || !commandId) return
-
-  dialogStore.closeDialog({ key: DIALOG_KEY })
-
-  const updated = keybindingStore.updateKeybindingOnCommand(
-    new KeybindingImpl({ commandId, combo })
-  )
-  if (updated) await keybindingService.persistUserKeybindings()
-}
-</script>

src/components/dialog/content/setting/keybinding/EditKeybindingHeader.vue

@@ -1,5 +0,0 @@
-<template>
-  <div class="flex w-full items-center gap-2 p-4">
-    <p class="m-0 font-semibold">{{ $t('g.modifyKeybinding') }}</p>
-  </div>
-</template>

src/components/ui/chart/useChart.ts

@@ -1,179 +0,0 @@
-import type { ChartData, ChartOptions, ChartType } from 'chart.js'
-import {
-  BarController,
-  BarElement,
-  CategoryScale,
-  Chart,
-  Filler,
-  Legend,
-  LinearScale,
-  LineController,
-  LineElement,
-  PointElement,
-  Tooltip
-} from 'chart.js'
-import { merge } from 'es-toolkit'
-import { onBeforeUnmount, onMounted, ref, watch } from 'vue'
-
-import type { Ref } from 'vue'
-
-Chart.register(
-  BarController,
-  BarElement,
-  CategoryScale,
-  Filler,
-  Legend,
-  LinearScale,
-  LineController,
-  LineElement,
-  PointElement,
-  Tooltip
-)
-
-function getCssVar(name: string): string {
-  return getComputedStyle(document.documentElement)
-    .getPropertyValue(name)
-    .trim()
-}
-
-function getDefaultOptions(type: ChartType): ChartOptions {
-  const foreground = getCssVar('--color-base-foreground') || '#ffffff'
-  const muted = getCssVar('--color-muted-foreground') || '#8a8a8a'
-
-  return {
-    responsive: true,
-    maintainAspectRatio: false,
-    plugins: {
-      legend: {
-        align: 'start',
-        labels: {
-          color: foreground,
-          usePointStyle: true,
-          pointStyle: 'circle',
-          boxWidth: 8,
-          boxHeight: 8,
-          padding: 16,
-          font: { family: 'Inter', size: 11 },
-          generateLabels(chart) {
-            const datasets = chart.data.datasets
-            return datasets.map((dataset, i) => {
-              const color =
-                (dataset as { borderColor?: string }).borderColor ??
-                (dataset as { backgroundColor?: string }).backgroundColor ??
-                '#888'
-              return {
-                text: dataset.label ?? '',
-                fillStyle: color as string,
-                strokeStyle: color as string,
-                lineWidth: 0,
-                pointStyle: 'circle' as const,
-                hidden: !chart.isDatasetVisible(i),
-                datasetIndex: i
-              }
-            })
-          }
-        }
-      },
-      tooltip: {
-        enabled: true
-      }
-    },
-    elements: {
-      point: {
-        radius: 0,
-        hoverRadius: 4
-      }
-    },
-    scales: {
-      x: {
-        ticks: {
-          color: muted,
-          font: { family: 'Inter', size: 11 },
-          padding: 8
-        },
-        grid: {
-          display: true,
-          color: muted + '33',
-          drawTicks: false
-        },
-        border: { display: true, color: muted }
-      },
-      y: {
-        ticks: {
-          color: muted,
-          font: { family: 'Inter', size: 11 },
-          padding: 4
-        },
-        grid: {
-          display: false,
-          drawTicks: false
-        },
-        border: { display: true, color: muted }
-      }
-    },
-    ...(type === 'bar' && {
-      datasets: {
-        bar: {
-          borderRadius: { topLeft: 4, topRight: 4 },
-          borderSkipped: false,
-          barPercentage: 0.6,
-          categoryPercentage: 0.8
-        }
-      }
-    })
-  }
-}
-
-export function useChart(
-  canvasRef: Ref<HTMLCanvasElement | null>,
-  type: Ref<ChartType>,
-  data: Ref<ChartData>,
-  options?: Ref<ChartOptions | undefined>
-) {
-  const chartInstance = ref<Chart | null>(null)
-
-  function createChart() {
-    if (!canvasRef.value) return
-
-    chartInstance.value?.destroy()
-
-    const defaults = getDefaultOptions(type.value)
-    const merged = options?.value
-      ? merge(defaults, options.value)
-      : defaults
-
-    chartInstance.value = new Chart(canvasRef.value, {
-      type: type.value,
-      data: data.value,
-      options: merged
-    })
-  }
-
-  onMounted(createChart)
-
-  watch(
-    [type, data, options ?? ref(undefined)],
-    ([nextType], [previousType]) => {
-      if (!chartInstance.value) return
-
-      if (nextType !== previousType) {
-        createChart()
-        return
-      }
-
-      chartInstance.value.data = data.value
-      chartInstance.value.options = options?.value
-        ? merge(getDefaultOptions(type.value), options.value)
-        : getDefaultOptions(type.value)
-      chartInstance.value.update()
-    },
-    { deep: true }
-  )
-
-  onBeforeUnmount(() => {
-    chartInstance.value?.destroy()
-    chartInstance.value = null
-  })
-
-  return { chartInstance }
-}

src/composables/useEditKeybindingDialog.ts

@@ -1,60 +0,0 @@
-import { computed, reactive } from 'vue'
-
-import EditKeybindingContent from '@/components/dialog/content/setting/keybinding/EditKeybindingContent.vue'
-import EditKeybindingFooter from '@/components/dialog/content/setting/keybinding/EditKeybindingFooter.vue'
-import EditKeybindingHeader from '@/components/dialog/content/setting/keybinding/EditKeybindingHeader.vue'
-import type { KeyComboImpl } from '@/platform/keybindings/keyCombo'
-import { useKeybindingStore } from '@/platform/keybindings/keybindingStore'
-import { useDialogService } from '@/services/dialogService'
-
-export const DIALOG_KEY = 'edit-keybinding'
-
-export interface EditKeybindingDialogState {
-  commandId: string
-  newCombo: KeyComboImpl | null
-  currentCombo: KeyComboImpl | null
-}
-
-export function useEditKeybindingDialog() {
-  const { showSmallLayoutDialog } = useDialogService()
-  const keybindingStore = useKeybindingStore()
-
-  function show(options: {
-    commandId: string
-    commandLabel: string
-    currentCombo: KeyComboImpl | null
-  }) {
-    const dialogState = reactive<EditKeybindingDialogState>({
-      commandId: options.commandId,
-      newCombo: options.currentCombo,
-      currentCombo: options.currentCombo
-    })
-
-    const existingKeybindingOnCombo = computed(() => {
-      if (!dialogState.newCombo) return null
-      if (dialogState.currentCombo?.equals(dialogState.newCombo)) return null
-      return keybindingStore.getKeybinding(dialogState.newCombo)
-    })
-
-    function onUpdateCombo(combo: KeyComboImpl) {
-      dialogState.newCombo = combo
-    }
-
-    showSmallLayoutDialog({
-      key: DIALOG_KEY,
-      headerComponent: EditKeybindingHeader,
-      footerComponent: EditKeybindingFooter,
-      component: EditKeybindingContent,
-      props: {
-        dialogState,
-        onUpdateCombo,
-        commandLabel: options.commandLabel,
-        existingKeybindingOnCombo
-      },
-      headerProps: {},
-      footerProps: { dialogState, existingKeybindingOnCombo }
-    })
-  }
-
-  return { show }
-}

src/composables/usePaste.test.ts

@@ -595,34 +595,6 @@ describe('usePaste', () => {
       )
     })
   })
-
-  it('should skip node metadata paste when a media node is selected', async () => {
-    const mockNode = createMockLGraphNode({
-      is_selected: true,
-      pasteFile: vi.fn(),
-      pasteFiles: vi.fn()
-    })
-    mockCanvas.current_node = mockNode
-    vi.mocked(isImageNode).mockReturnValue(true)
-
-    usePaste()
-
-    const nodeData = { nodes: [{ type: 'KSampler' }] }
-    const encoded = btoa(JSON.stringify(nodeData))
-    const html = `<div data-metadata="${encoded}"></div>`
-
-    const dataTransfer = new DataTransfer()
-    dataTransfer.setData('text/html', html)
-    dataTransfer.setData('text/plain', 'some text')
-
-    const event = new ClipboardEvent('paste', { clipboardData: dataTransfer })
-    document.dispatchEvent(event)
-
-    await vi.waitFor(() => {
-      expect(mockCanvas._deserializeItems).not.toHaveBeenCalled()
-      expect(mockCanvas.pasteFromClipboard).toHaveBeenCalled()
-    })
-  })
 })
 
 describe('cloneDataTransfer', () => {

src/composables/usePaste.ts

@@ -229,10 +229,7 @@ export const usePaste = () => {
         return
       }
     }
-
-    const isMediaNodeSelected =
-      isImageNodeSelected || isVideoNodeSelected || isAudioNodeSelected
-    if (!isMediaNodeSelected && pasteClipboardItems(data)) return
+    if (pasteClipboardItems(data)) return
 
     // No image found. Look for node data
     data = data.getData('text/plain')

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

@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 import {
   LGraph,
+  LGraphEventMode,
   LGraphNode,
   ExecutableNodeDTO
 } from '@/lib/litegraph/src/litegraph'
@@ -477,3 +478,120 @@ describe.skip('ExecutableNodeDTO Scale Testing', () => {
     }
   })
 })
+
+describe('Muted node output resolution', () => {
+  it('returns undefined when node mode is NEVER', () => {
+    const graph = new LGraph()
+    const node = new LGraphNode('Muted Node')
+    node.addOutput('out', 'number')
+    node.mode = LGraphEventMode.NEVER
+    graph.add(node)
+
+    const dto = new ExecutableNodeDTO(node, [], new Map(), undefined)
+    const result = dto.resolveOutput(0, 'number', new Set())
+    expect(result).toBeUndefined()
+  })
+
+  it('does not throw when inner nodes are not registered for muted subgraph', () => {
+    const graph = new LGraph()
+    const node = new LGraphNode('Muted Subgraph')
+    node.addOutput('out', 'number')
+    graph.add(node)
+    node.mode = LGraphEventMode.NEVER
+    // Simulate a subgraph node that would throw if _resolveSubgraphOutput ran
+    vi.spyOn(node, 'isSubgraphNode').mockReturnValue(true)
+
+    const dto = new ExecutableNodeDTO(node, [], new Map(), undefined)
+    expect(() => dto.resolveOutput(0, 'number', new Set())).not.toThrow()
+    expect(dto.resolveOutput(0, 'number', new Set())).toBeUndefined()
+  })
+
+  it('resolveInput to a muted upstream node resolves undefined', () => {
+    const graph = new LGraph()
+
+    const upstream = new LGraphNode('Upstream')
+    upstream.addOutput('out', 'number')
+    upstream.mode = LGraphEventMode.NEVER
+    graph.add(upstream)
+
+    const downstream = new LGraphNode('Downstream')
+    downstream.addInput('in', 'number')
+    graph.add(downstream)
+
+    downstream.connect(0, upstream, 0)
+
+    const nodesByExecutionId = new Map()
+    const upstreamDto = new ExecutableNodeDTO(
+      upstream,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    const downstreamDto = new ExecutableNodeDTO(
+      downstream,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    nodesByExecutionId.set(upstreamDto.id, upstreamDto)
+    nodesByExecutionId.set(downstreamDto.id, downstreamDto)
+
+    const result = downstreamDto.resolveInput(0)
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('Bypass node output resolution', () => {
+  it('bypasses through matching input when mode is BYPASS', () => {
+    const graph = new LGraph()
+
+    const source = new LGraphNode('Source')
+    source.addOutput('out', 'number')
+    graph.add(source)
+
+    const bypass = new LGraphNode('Bypass')
+    bypass.addInput('in', 'number')
+    bypass.addOutput('out', 'number')
+    bypass.mode = LGraphEventMode.BYPASS
+    graph.add(bypass)
+
+    source.connect(0, bypass, 0)
+
+    const nodesByExecutionId = new Map()
+    const sourceDto = new ExecutableNodeDTO(
+      source,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    const bypassDto = new ExecutableNodeDTO(
+      bypass,
+      [],
+      nodesByExecutionId,
+      undefined
+    )
+    nodesByExecutionId.set(sourceDto.id, sourceDto)
+    nodesByExecutionId.set(bypassDto.id, bypassDto)
+
+    const result = bypassDto.resolveOutput(0, 'number', new Set())
+    expect(result).toBeDefined()
+    expect(result?.node).toBe(sourceDto)
+  })
+})
+
+describe('ALWAYS mode node output resolution', () => {
+  it('resolves to itself when mode is ALWAYS', () => {
+    const graph = new LGraph()
+    const node = new LGraphNode('Normal Node')
+    node.addOutput('out', 'number')
+    node.mode = LGraphEventMode.ALWAYS
+    graph.add(node)
+
+    const dto = new ExecutableNodeDTO(node, [], new Map(), undefined)
+    const result = dto.resolveOutput(0, 'number', new Set())
+    expect(result).toBeDefined()
+    expect(result?.node).toBe(dto)
+    expect(result?.origin_id).toBe(dto.id)
+    expect(result?.origin_slot).toBe(0)
+  })
+})

src/lib/litegraph/src/subgraph/ExecutableNodeDTO.ts

@@ -266,6 +266,9 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
     }
     visited.add(uniqueId)
 
+    // Muted nodes produce no output
+    if (this.mode === LGraphEventMode.NEVER) return
+
     // Upstreamed: Bypass nodes are bypassed using the first input with matching type
     if (this.mode === LGraphEventMode.BYPASS) {
       // Bypass nodes by finding first input with matching type

src/locales/en/main.json

@@ -110,7 +110,6 @@
     "delete": "Delete",
     "rename": "Rename",
     "save": "Save",
-    "saveAnyway": "Save Anyway",
     "saving": "Saving",
     "no": "No",
     "cancel": "Cancel",
@@ -121,6 +120,7 @@
     "showRightPanel": "Show right panel",
     "hideRightPanel": "Hide right panel",
     "or": "or",
+    "pressKeysForNewBinding": "Press keys for new binding",
     "defaultBanner": "default banner",
     "enableOrDisablePack": "Enable or disable pack",
     "openManager": "Open Manager",
@@ -265,11 +265,6 @@
     "multiSelectDropdown": "Multi-select dropdown",
     "singleSelectDropdown": "Single-select dropdown",
     "progressCountOf": "of",
-    "modifyKeybinding": "Modify keybinding",
-    "setAKeybindingForTheFollowing": "Set a keybinding for the following:",
-    "enterYourKeybind": "Enter your keybind",
-    "browserReservedKeybinding": "This shortcut is reserved by some browsers and may have unexpected results.",
-    "browserReservedKeybindingTooltip": "This shortcut conflicts with browser-reserved shortcuts",
     "keybindingAlreadyExists": "Keybinding already exists on",
     "commandProhibited": "Command {command} is prohibited. Contact an administrator for more information.",
     "startRecording": "Start Recording",

src/platform/keybindings/keyCombo.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { KeyComboImpl } from './keyCombo'
-
-describe('KeyComboImpl', () => {
-  describe('isBrowserReserved', () => {
-    it.each([
-      { key: 't', ctrl: true, label: 'Ctrl + t' },
-      { key: 'w', ctrl: true, label: 'Ctrl + w' },
-      { key: 'F12', label: 'F12' },
-      { key: 'n', ctrl: true, shift: true, label: 'Ctrl + Shift + n' },
-      { key: 'r', ctrl: true, label: 'Ctrl + r' },
-      { key: 'F5', label: 'F5' }
-    ])('returns true for $label', ({ key, ctrl, shift }) => {
-      const combo = new KeyComboImpl({
-        key,
-        ctrl: ctrl ?? false,
-        alt: false,
-        shift: shift ?? false
-      })
-      expect(combo.isBrowserReserved).toBe(true)
-    })
-
-    it.each([
-      { key: 'k', ctrl: true, label: 'Ctrl + k' },
-      { key: 's', alt: true, label: 'Alt + s' },
-      { key: 'z', ctrl: true, label: 'Ctrl + z' },
-      { key: 'F6', label: 'F6' }
-    ])('returns false for $label', ({ key, ctrl, alt }) => {
-      const combo = new KeyComboImpl({
-        key,
-        ctrl: ctrl ?? false,
-        alt: alt ?? false,
-        shift: false
-      })
-      expect(combo.isBrowserReserved).toBe(false)
-    })
-  })
-})

src/platform/keybindings/keyCombo.ts

@@ -1,6 +1,6 @@
 import { toRaw } from 'vue'
 
-import { RESERVED_BY_BROWSER, RESERVED_BY_TEXT_INPUT } from './reserved'
+import { RESERVED_BY_TEXT_INPUT } from './reserved'
 import type { KeyCombo } from './types'
 
 export class KeyComboImpl implements KeyCombo {
@@ -61,15 +61,11 @@ export class KeyComboImpl implements KeyCombo {
     return this.shift && this.modifierCount === 1
   }
 
-  get isBrowserReserved(): boolean {
-    return RESERVED_BY_BROWSER.has(toNormalizedString(this))
-  }
-
   get isReservedByTextInput(): boolean {
     return (
       !this.hasModifier ||
       this.isShiftOnly ||
-      RESERVED_BY_TEXT_INPUT.has(toNormalizedString(this))
+      RESERVED_BY_TEXT_INPUT.has(this.toString())
     )
   }
 
@@ -88,12 +84,3 @@ export class KeyComboImpl implements KeyCombo {
     return sequences
   }
 }
-
-function toNormalizedString(combo: KeyComboImpl): string {
-  const sequences: string[] = []
-  if (combo.ctrl) sequences.push('Ctrl')
-  if (combo.alt) sequences.push('Alt')
-  if (combo.shift) sequences.push('Shift')
-  sequences.push(combo.key.length === 1 ? combo.key.toLowerCase() : combo.key)
-  return sequences.join(' + ')
-}

src/platform/keybindings/reserved.ts

@@ -1,28 +1,3 @@
-export const RESERVED_BY_BROWSER = new Set([
-  'Ctrl + t', // New tab (all browsers)
-  'Ctrl + w', // Close tab (all browsers)
-  'Ctrl + n', // New window (all browsers)
-  'Ctrl + Shift + n', // New incognito/private window (all browsers)
-  'Ctrl + Tab', // Next tab (all browsers)
-  'Ctrl + Shift + Tab', // Previous tab (all browsers)
-  'Ctrl + Shift + Delete', // Clear browsing data (Chrome, Edge, Firefox)
-  'Ctrl + h', // History (all browsers)
-  'Ctrl + j', // Downloads (Chrome, Edge)
-  'Ctrl + d', // Bookmark current page (all browsers)
-  'Ctrl + Shift + b', // Toggle bookmarks bar (Chrome, Edge)
-  'Ctrl + Shift + o', // Bookmarks manager (Chrome, Edge)
-  'Ctrl + Shift + i', // DevTools (all browsers)
-  'Ctrl + Shift + j', // DevTools console (Chrome, Edge)
-  'F5', // Reload page (all browsers)
-  'Ctrl + F5', // Hard reload (all browsers)
-  'Ctrl + r', // Reload page (all browsers)
-  'Ctrl + Shift + r', // Hard reload (all browsers)
-  'F7', // Caret browsing (Firefox, Edge)
-  'F11', // Toggle fullscreen (all browsers)
-  'F12', // DevTools (all browsers)
-  'Alt + F4' // Close window (Windows, all browsers)
-])
-
 export const RESERVED_BY_TEXT_INPUT = new Set([
   'Ctrl + a',
   'Ctrl + c',

src/stores/nodeOutputStore.test.ts

@@ -151,110 +151,6 @@ describe('nodeOutputStore restoreOutputs', () => {
   })
 })
 
-describe('nodeOutputStore input preview preservation', () => {
-  beforeEach(() => {
-    setActivePinia(createTestingPinia({ stubActions: false }))
-    vi.clearAllMocks()
-    app.nodeOutputs = {}
-    app.nodePreviewImages = {}
-  })
-
-  it('should preserve input preview when execution sends empty output', () => {
-    const store = useNodeOutputStore()
-    const executionId = '3'
-
-    const inputPreview = createMockOutputs([
-      { filename: 'example.png', subfolder: '', type: 'input' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, inputPreview)
-
-    expect(store.nodeOutputs[executionId]?.images).toHaveLength(1)
-
-    const emptyExecutionOutput = createMockOutputs()
-    store.setNodeOutputsByExecutionId(executionId, emptyExecutionOutput)
-
-    expect(store.nodeOutputs[executionId]?.images).toHaveLength(1)
-    expect(store.nodeOutputs[executionId]?.images?.[0].filename).toBe(
-      'example.png'
-    )
-  })
-
-  it('should preserve input preview when execution sends output with empty images array', () => {
-    const store = useNodeOutputStore()
-    const executionId = '3'
-
-    const inputPreview = createMockOutputs([
-      { filename: 'example.png', subfolder: '', type: 'input' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, inputPreview)
-
-    const emptyImagesOutput = createMockOutputs([])
-    store.setNodeOutputsByExecutionId(executionId, emptyImagesOutput)
-
-    expect(store.nodeOutputs[executionId]?.images).toHaveLength(1)
-    expect(store.nodeOutputs[executionId]?.images?.[0].type).toBe('input')
-  })
-
-  it('should allow execution output with images to overwrite input preview', () => {
-    const store = useNodeOutputStore()
-    const executionId = '3'
-
-    const inputPreview = createMockOutputs([
-      { filename: 'example.png', subfolder: '', type: 'input' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, inputPreview)
-
-    const executionOutput = createMockOutputs([
-      { filename: 'output.png', subfolder: '', type: 'output' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, executionOutput)
-
-    expect(store.nodeOutputs[executionId]?.images).toHaveLength(1)
-    expect(store.nodeOutputs[executionId]?.images?.[0].filename).toBe(
-      'output.png'
-    )
-  })
-
-  it('should not preserve non-input outputs from being overwritten', () => {
-    const store = useNodeOutputStore()
-    const executionId = '4'
-
-    const tempOutput = createMockOutputs([
-      { filename: 'temp.png', subfolder: '', type: 'temp' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, tempOutput)
-
-    const emptyOutput = createMockOutputs()
-    store.setNodeOutputsByExecutionId(executionId, emptyOutput)
-
-    expect(store.nodeOutputs[executionId]?.images).toBeUndefined()
-  })
-
-  it('should pass through non-image fields while preserving input preview images', () => {
-    const store = useNodeOutputStore()
-    const executionId = '5'
-
-    const inputPreview = createMockOutputs([
-      { filename: 'example.png', subfolder: '', type: 'input' }
-    ])
-    store.setNodeOutputsByExecutionId(executionId, inputPreview)
-
-    const videoOutput: ExecutedWsMessage['output'] = {
-      video: [{ filename: 'output.mp4', subfolder: '', type: 'output' }]
-    }
-    store.setNodeOutputsByExecutionId(executionId, videoOutput)
-
-    expect(store.nodeOutputs[executionId]?.images).toHaveLength(1)
-    expect(store.nodeOutputs[executionId]?.images?.[0].filename).toBe(
-      'example.png'
-    )
-    expect(store.nodeOutputs[executionId]?.video).toHaveLength(1)
-    expect(store.nodeOutputs[executionId]?.video?.[0].filename).toBe(
-      'output.mp4'
-    )
-  })
-})
-
 describe('nodeOutputStore getPreviewParam', () => {
   beforeEach(() => {
     setActivePinia(createTestingPinia({ stubActions: false }))

src/stores/nodeOutputStore.ts

@@ -126,22 +126,6 @@ export const useNodeOutputStore = defineStore('nodeOutput', () => {
     })
   }
 
-  /**
-   * Check if an output contains input-type preview images (from upload widgets).
-   * These are synthetic previews set by LoadImage/LoadVideo widgets, not
-   * execution results from the backend.
-   */
-  function isInputPreviewOutput(
-    output: ExecutedWsMessage['output'] | ResultItem | undefined
-  ): boolean {
-    const images = (output as ExecutedWsMessage['output'] | undefined)?.images
-    return (
-      Array.isArray(images) &&
-      images.length > 0 &&
-      images.every((i) => i?.type === 'input')
-    )
-  }
-
   /**
    * Internal function to set outputs by NodeLocatorId.
    * Handles the merge logic when needed.
@@ -156,26 +140,6 @@ export const useNodeOutputStore = defineStore('nodeOutput', () => {
     // (e.g., two LoadImage nodes selecting the same image)
     if (outputs == null) return
 
-    // Preserve input preview images (from upload widgets) when execution
-    // sends outputs with no images. Without this guard, execution results
-    // overwrite the upload widget's preview, causing LoadImage/LoadVideo
-    // nodes to lose their preview after execution + tab switch.
-    // Note: intentional preview clears go through setNodeOutputs (widget
-    // path), not setNodeOutputsByExecutionId, so this guard does not
-    // interfere with user-initiated clears.
-    const incomingImages = (outputs as ExecutedWsMessage['output']).images
-    const hasIncomingImages =
-      Array.isArray(incomingImages) && incomingImages.length > 0
-    if (
-      !hasIncomingImages &&
-      isInputPreviewOutput(app.nodeOutputs[nodeLocatorId])
-    ) {
-      outputs = {
-        ...outputs,
-        images: app.nodeOutputs[nodeLocatorId].images
-      }
-    }
-
     if (options.merge) {
       const existingOutput = app.nodeOutputs[nodeLocatorId]
       if (existingOutput && outputs) {

src/utils/executableGroupNodeDto.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  LGraph,
+  LGraphEventMode,
+  LGraphNode
+} from '@/lib/litegraph/src/litegraph'
+
+import { ExecutableGroupNodeDTO } from './executableGroupNodeDto'
+
+describe('ExecutableGroupNodeDTO muted output resolution', () => {
+  it('returns undefined when node mode is NEVER', () => {
+    const graph = new LGraph()
+    const node = new LGraphNode('Muted Group')
+    node.addOutput('out', 'number')
+    node.mode = LGraphEventMode.NEVER
+    graph.add(node)
+
+    const dto = new ExecutableGroupNodeDTO(node, [], new Map(), undefined)
+    const result = dto.resolveOutput(0, 'number', new Set())
+    expect(result).toBeUndefined()
+  })
+})

src/utils/executableGroupNodeDto.ts

@@ -24,6 +24,9 @@ export class ExecutableGroupNodeDTO extends ExecutableNodeDTO {
   }
 
   override resolveOutput(slot: number, type: ISlotType, visited: Set<string>) {
+    // Muted nodes produce no output
+    if (this.mode === LGraphEventMode.NEVER) return
+
     // Temporary duplication: Bypass nodes are bypassed using the first input with matching type
     if (this.mode === LGraphEventMode.BYPASS) {
       const { inputs } = this