[release] Increment version to 1.26.8 (#5263)

Co-authored-by: benceruleanlu <162923238+benceruleanlu@users.noreply.github.com>

.github/workflows/chromatic.yaml

@@ -12,9 +12,6 @@ jobs:
     runs-on: ubuntu-latest
     # Only run for PRs from version-bump-* branches or manual triggers
     if: github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'version-bump-')
-    permissions:
-      pull-requests: write
-      issues: write
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -32,29 +29,6 @@ jobs:
           node-version: '20'
           cache: 'pnpm'
 
-      - name: Get current time
-        id: current-time
-        run: echo "time=$(date -u '+%m/%d/%Y, %I:%M:%S %p')" >> $GITHUB_OUTPUT
-
-      - name: Comment PR - Build Started
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- STORYBOOK_BUILD_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: append
-          body: |
-            <!-- STORYBOOK_BUILD_STATUS -->
-            ## 🎨 Storybook Build Status
-
-            🔄 **Building Storybook and running visual tests...**
-
-            ⏳ Build started at: ${{ steps.current-time.outputs.time }} UTC
-
-            ---
-            *This comment will be updated when the build completes*
 
       - name: Cache tool outputs
         uses: actions/cache@v4
@@ -81,37 +55,3 @@ jobs:
           autoAcceptChanges: 'main' # Auto-accept changes on main branch
           exitOnceUploaded: true # Don't wait for UI tests to complete
 
-      - name: Get completion time
-        id: completion-time
-        if: always()
-        run: echo "time=$(date -u '+%m/%d/%Y, %I:%M:%S %p')" >> $GITHUB_OUTPUT
-
-      - name: Comment PR - Build Complete
-        if: github.event_name == 'pull_request' && always()
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- STORYBOOK_BUILD_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: replace
-          body: |
-            <!-- STORYBOOK_BUILD_STATUS -->
-            ## 🎨 Storybook Build Status
-
-            ${{ steps.chromatic.outcome == 'success' && '✅' || '❌' }} **${{ steps.chromatic.outcome == 'success' && 'Build completed successfully!' || 'Build failed!' }}**
-
-            ⏰ Completed at: ${{ steps.completion-time.outputs.time }} UTC
-
-            ### 📊 Build Summary
-            - **Components**: ${{ steps.chromatic.outputs.componentCount || '0' }}
-            - **Stories**: ${{ steps.chromatic.outputs.testCount || '0' }}
-            - **Visual changes**: ${{ steps.chromatic.outputs.changeCount || '0' }}
-            - **Errors**: ${{ steps.chromatic.outputs.errorCount || '0' }}
-
-            ### 🔗 Links
-            ${{ steps.chromatic.outputs.buildUrl && format('- [📸 View Chromatic Build]({0})', steps.chromatic.outputs.buildUrl) || '' }}
-            ${{ steps.chromatic.outputs.storybookUrl && format('- [📖 Preview Storybook]({0})', steps.chromatic.outputs.storybookUrl) || '' }}
-
-            ---
-            ${{ steps.chromatic.outcome == 'success' && '🎉 Your Storybook is ready for review!' || '⚠️ Please check the workflow logs for error details.' }}

.github/workflows/i18n.yaml

@@ -25,6 +25,13 @@ jobs:
         key: i18n-tools-cache-${{ runner.os }}-${{ hashFiles('ComfyUI_frontend/pnpm-lock.yaml') }}
         restore-keys: |
           i18n-tools-cache-${{ runner.os }}-
+    - name: Cache Playwright browsers
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/ms-playwright
+        key: playwright-browsers-${{ runner.os }}-${{ hashFiles('ComfyUI_frontend/pnpm-lock.yaml') }}
+        restore-keys: |
+          playwright-browsers-${{ runner.os }}-
     - name: Install Playwright Browsers
       run: npx playwright install chromium --with-deps
       working-directory: ComfyUI_frontend
@@ -34,7 +41,7 @@ jobs:
       run: pnpm dev:electron &
       working-directory: ComfyUI_frontend
     - name: Update en.json
-      run: pnpm collect-i18n -- scripts/collect-i18n-general.ts
+      run: pnpm collect-i18n
       env:
         PLAYWRIGHT_TEST_URL: http://localhost:5173
       working-directory: ComfyUI_frontend

.github/workflows/lint-and-format.yaml

@@ -16,7 +16,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          ref: ${{ github.event.pull_request.head.sha }}
+          ref: ${{ github.event.pull_request.head.ref }}
           fetch-depth: 0
 
       - name: Install pnpm

.github/workflows/pr-playwright-deploy.yaml

@@ -0,0 +1,280 @@
+name: PR Playwright Deploy and Comment
+
+on:
+  workflow_run:
+    workflows: ["Tests CI"]
+    types: [requested, completed]
+
+env:
+  DATE_FORMAT: '+%m/%d/%Y, %I:%M:%S %p'
+
+jobs:
+  deploy-reports:
+    runs-on: ubuntu-latest
+    if: github.repository == 'Comfy-Org/ComfyUI_frontend' && github.event.workflow_run.event == 'pull_request' && github.event.action == 'completed'
+    permissions:
+      actions: read
+    strategy:
+      fail-fast: false
+      matrix:
+        browser: [chromium, chromium-2x, chromium-0.5x, mobile-chrome]
+    steps:
+      - name: Get PR info
+        id: pr-info
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data: pullRequests } = await github.rest.pulls.list({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              head: `${context.repo.owner}:${context.payload.workflow_run.head_branch}`,
+            });
+            
+            if (pullRequests.length === 0) {
+              console.log('No open PR found for this branch');
+              return { number: null, sanitized_branch: null };
+            }
+            
+            const pr = pullRequests[0];
+            const branchName = context.payload.workflow_run.head_branch;
+            const sanitizedBranch = branchName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/--+/g, '-').replace(/^-|-$/g, '');
+            
+            return {
+              number: pr.number,
+              sanitized_branch: sanitizedBranch
+            };
+
+      - name: Set project name
+        if: fromJSON(steps.pr-info.outputs.result).number != null
+        id: project-name
+        run: |
+          if [ "${{ matrix.browser }}" = "chromium-0.5x" ]; then
+            echo "name=comfyui-playwright-chromium-0-5x" >> $GITHUB_OUTPUT
+          else
+            echo "name=comfyui-playwright-${{ matrix.browser }}" >> $GITHUB_OUTPUT
+          fi
+          echo "branch=${{ fromJSON(steps.pr-info.outputs.result).sanitized_branch }}" >> $GITHUB_OUTPUT
+
+      - name: Download playwright report
+        if: fromJSON(steps.pr-info.outputs.result).number != null
+        uses: actions/download-artifact@v4
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+          name: playwright-report-${{ matrix.browser }}
+          path: playwright-report
+
+      - name: Install Wrangler
+        if: fromJSON(steps.pr-info.outputs.result).number != null
+        run: npm install -g wrangler
+
+      - name: Deploy to Cloudflare Pages (${{ matrix.browser }})
+        if: fromJSON(steps.pr-info.outputs.result).number != null
+        id: cloudflare-deploy
+        continue-on-error: true
+        run: |
+          # Retry logic for wrangler deploy (3 attempts)
+          RETRY_COUNT=0
+          MAX_RETRIES=3
+          SUCCESS=false
+          
+          while [ $RETRY_COUNT -lt $MAX_RETRIES ] && [ $SUCCESS = false ]; do
+            RETRY_COUNT=$((RETRY_COUNT + 1))
+            echo "Deployment attempt $RETRY_COUNT of $MAX_RETRIES..."
+            
+            if npx wrangler pages deploy playwright-report --project-name=${{ steps.project-name.outputs.name }} --branch=${{ steps.project-name.outputs.branch }}; then
+              SUCCESS=true
+              echo "Deployment successful on attempt $RETRY_COUNT"
+            else
+              echo "Deployment failed on attempt $RETRY_COUNT"
+              if [ $RETRY_COUNT -lt $MAX_RETRIES ]; then
+                echo "Retrying in 10 seconds..."
+                sleep 10
+              fi
+            fi
+          done
+          
+          if [ $SUCCESS = false ]; then
+            echo "All deployment attempts failed"
+            exit 1
+          fi
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+  comment-tests-starting:
+    runs-on: ubuntu-latest
+    if: github.repository == 'Comfy-Org/ComfyUI_frontend' && github.event.workflow_run.event == 'pull_request' && github.event.action == 'requested'
+    permissions:
+      pull-requests: write
+      actions: read
+    steps:
+      - name: Get PR number
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data: pullRequests } = await github.rest.pulls.list({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              head: `${context.repo.owner}:${context.payload.workflow_run.head_branch}`,
+            });
+
+            if (pullRequests.length === 0) {
+              console.log('No open PR found for this branch');
+              return null;
+            }
+
+            return pullRequests[0].number;
+
+      - name: Get completion time
+        id: completion-time
+        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
+
+      - name: Generate comment body for start
+        if: steps.pr.outputs.result != 'null'
+        id: comment-body-start
+        run: |
+          echo "<!-- PLAYWRIGHT_TEST_STATUS -->" > comment.md
+          echo "## 🎭 Playwright Test Results" >> comment.md
+          echo "" >> comment.md
+          echo "<img alt='comfy-loading-gif' src='https://github.com/user-attachments/assets/755c86ee-e445-4ea8-bc2c-cca85df48686' width='14px' height='14px' style='vertical-align: middle; margin-right: 4px;' /> **Tests are starting...** " >> comment.md
+          echo "" >> comment.md
+          echo "⏰ Started at: ${{ steps.completion-time.outputs.time }} UTC" >> comment.md
+          echo "" >> comment.md
+          echo "### 🚀 Running Tests" >> comment.md
+          echo "- 🧪 **chromium**: Running tests..." >> comment.md
+          echo "- 🧪 **chromium-0.5x**: Running tests..." >> comment.md
+          echo "- 🧪 **chromium-2x**: Running tests..." >> comment.md
+          echo "- 🧪 **mobile-chrome**: Running tests..." >> comment.md
+          echo "" >> comment.md
+          echo "---" >> comment.md
+          echo "⏱️ Please wait while tests are running across all browsers..." >> comment.md
+
+      - name: Comment PR - Tests Started
+        if: steps.pr.outputs.result != 'null'
+        uses: edumserrano/find-create-or-update-comment@82880b65c8a3a6e4c70aa05a204995b6c9696f53 # v3.0.0
+        with:
+          issue-number: ${{ steps.pr.outputs.result }}
+          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
+          comment-author: 'github-actions[bot]'
+          edit-mode: replace
+          body-path: comment.md
+
+  comment-tests-completed:
+    runs-on: ubuntu-latest
+    needs: deploy-reports
+    if: github.repository == 'Comfy-Org/ComfyUI_frontend' && github.event.workflow_run.event == 'pull_request' && github.event.action == 'completed' && always()
+    permissions:
+      pull-requests: write
+      actions: read
+    steps:
+      - name: Get PR number
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data: pullRequests } = await github.rest.pulls.list({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              head: `${context.repo.owner}:${context.payload.workflow_run.head_branch}`,
+            });
+
+            if (pullRequests.length === 0) {
+              console.log('No open PR found for this branch');
+              return null;
+            }
+
+            return pullRequests[0].number;
+
+      - name: Download all deployment info
+        if: steps.pr.outputs.result != 'null'
+        uses: actions/download-artifact@v4
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+          pattern: deployment-info-*
+          merge-multiple: true
+          path: deployment-info
+
+      - name: Get completion time
+        id: completion-time
+        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
+
+      - name: Generate comment body for completion
+        if: steps.pr.outputs.result != 'null'
+        id: comment-body-completed
+        run: |
+          echo "<!-- PLAYWRIGHT_TEST_STATUS -->" > comment.md
+          echo "## 🎭 Playwright Test Results" >> comment.md
+          echo "" >> comment.md
+
+          # Check if all tests passed
+          ALL_PASSED=true
+          for file in deployment-info/*.txt; do
+            if [ -f "$file" ]; then
+              browser=$(basename "$file" .txt)
+              info=$(cat "$file")
+              exit_code=$(echo "$info" | cut -d'|' -f2)
+              if [ "$exit_code" != "0" ]; then
+                ALL_PASSED=false
+                break
+              fi
+            fi
+          done
+
+          if [ "$ALL_PASSED" = "true" ]; then
+            echo "✅ **All tests passed across all browsers!**" >> comment.md
+          else
+            echo "❌ **Some tests failed!**" >> comment.md
+          fi
+
+          echo "" >> comment.md
+          echo "⏰ Completed at: ${{ steps.completion-time.outputs.time }} UTC" >> comment.md
+          echo "" >> comment.md
+          echo "### 📊 Test Reports by Browser" >> comment.md
+
+          for file in deployment-info/*.txt; do
+            if [ -f "$file" ]; then
+              browser=$(basename "$file" .txt)
+              info=$(cat "$file")
+              exit_code=$(echo "$info" | cut -d'|' -f2)
+              url=$(echo "$info" | cut -d'|' -f3)
+              
+              # Validate URLs before using them in comments
+              sanitized_url=$(echo "$url" | grep -E '^https://[a-z0-9.-]+\.pages\.dev(/.*)?$' || echo "INVALID_URL")
+              if [ "$sanitized_url" = "INVALID_URL" ]; then
+                echo "Invalid deployment URL detected: $url"
+                url="#" # Use safe fallback
+              fi
+              
+              if [ "$exit_code" = "0" ]; then
+                status="✅"
+              else
+                status="❌"
+              fi
+              
+              echo "- $status **$browser**: [View Report]($url)" >> comment.md
+            fi
+          done
+
+          echo "" >> comment.md
+          echo "---" >> comment.md
+          if [ "$ALL_PASSED" = "true" ]; then
+            echo "🎉 Your tests are passing across all browsers!" >> comment.md
+          else
+            echo "⚠️ Please check the test reports for details on failures." >> comment.md
+          fi
+
+      - name: Comment PR - Tests Complete
+        if: steps.pr.outputs.result != 'null'
+        uses: edumserrano/find-create-or-update-comment@82880b65c8a3a6e4c70aa05a204995b6c9696f53 # v3.0.0
+        with:
+          issue-number: ${{ steps.pr.outputs.result }}
+          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
+          comment-author: 'github-actions[bot]'
+          edit-mode: replace
+          body-path: comment.md

.github/workflows/pr-storybook-comment.yaml

@@ -0,0 +1,126 @@
+name: PR Storybook Comment
+
+on:
+  workflow_run:
+    workflows: ['Chromatic']
+    types: [requested, completed]
+
+jobs:
+  comment-storybook:
+    runs-on: ubuntu-latest
+    if: >-
+      github.repository == 'Comfy-Org/ComfyUI_frontend'
+      && github.event.workflow_run.event == 'pull_request'
+      && startsWith(github.event.workflow_run.head_branch, 'version-bump-')
+    permissions:
+      pull-requests: write
+      actions: read
+    steps:
+      - name: Get PR number
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data: pullRequests } = await github.rest.pulls.list({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              head: `${context.repo.owner}:${context.payload.workflow_run.head_branch}`,
+            });
+
+            if (pullRequests.length === 0) {
+              console.log('No open PR found for this branch');
+              return null;
+            }
+
+            return pullRequests[0].number;
+
+      - name: Log when no PR found
+        if: steps.pr.outputs.result == 'null'
+        run: |
+          echo "⚠️ No open PR found for branch: ${{ github.event.workflow_run.head_branch }}"
+          echo "Workflow run ID: ${{ github.event.workflow_run.id }}"
+          echo "Repository: ${{ github.event.workflow_run.repository.full_name }}"
+          echo "Event: ${{ github.event.workflow_run.event }}"
+
+      - name: Get workflow run details
+        if: steps.pr.outputs.result != 'null' && github.event.action == 'completed'
+        id: workflow-run
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const run = await github.rest.actions.getWorkflowRun({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: context.payload.workflow_run.id,
+            });
+
+            return {
+              conclusion: run.data.conclusion,
+              html_url: run.data.html_url
+            };
+
+      - name: Get completion time
+        id: completion-time
+        run: echo "time=$(date -u '+%m/%d/%Y, %I:%M:%S %p')" >> $GITHUB_OUTPUT
+
+      - name: Comment PR - Storybook Started
+        if: steps.pr.outputs.result != 'null' && github.event.action == 'requested'
+        uses: edumserrano/find-create-or-update-comment@82880b65c8a3a6e4c70aa05a204995b6c9696f53 # v3.0.0
+        with:
+          issue-number: ${{ steps.pr.outputs.result }}
+          body-includes: '<!-- STORYBOOK_BUILD_STATUS -->'
+          comment-author: 'github-actions[bot]'
+          edit-mode: replace
+          body: |
+            <!-- STORYBOOK_BUILD_STATUS -->
+            ## 🎨 Storybook Build Status
+
+            <img alt='comfy-loading-gif' src='https://github.com/user-attachments/assets/755c86ee-e445-4ea8-bc2c-cca85df48686' width='14px' height='14px' style='vertical-align: middle; margin-right: 4px;' /> **Build is starting...** 
+
+            ⏰ Started at: ${{ steps.completion-time.outputs.time }} UTC
+
+            ### 🚀 Building Storybook
+            - 📦 Installing dependencies...
+            - 🔧 Building Storybook components...
+            - 🎨 Running Chromatic visual tests...
+
+            ---
+            ⏱️ Please wait while the Storybook build is in progress...
+
+      - name: Comment PR - Storybook Complete
+        if: steps.pr.outputs.result != 'null' && github.event.action == 'completed'
+        uses: edumserrano/find-create-or-update-comment@82880b65c8a3a6e4c70aa05a204995b6c9696f53 # v3.0.0
+        with:
+          issue-number: ${{ steps.pr.outputs.result }}
+          body-includes: '<!-- STORYBOOK_BUILD_STATUS -->'
+          comment-author: 'github-actions[bot]'
+          edit-mode: replace
+          body: |
+            <!-- STORYBOOK_BUILD_STATUS -->
+            ## 🎨 Storybook Build Status
+
+            ${{
+              fromJSON(steps.workflow-run.outputs.result).conclusion == 'success' && '✅'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'skipped' && '⏭️'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'cancelled' && '🚫'
+              || '❌'
+            }} **${{
+              fromJSON(steps.workflow-run.outputs.result).conclusion == 'success' && 'Build completed successfully!'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'skipped' && 'Build skipped.'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'cancelled' && 'Build cancelled.'
+              || 'Build failed!'
+            }}**
+
+            ⏰ Completed at: ${{ steps.completion-time.outputs.time }} UTC
+
+            ### 🔗 Links
+            - [📊 View Workflow Run](${{ fromJSON(steps.workflow-run.outputs.result).html_url }})
+
+            ---
+            ${{
+              fromJSON(steps.workflow-run.outputs.result).conclusion == 'success' && '🎉 Your Storybook is ready for review!'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'skipped' && 'ℹ️ Chromatic was skipped for this PR.'
+              || fromJSON(steps.workflow-run.outputs.result).conclusion == 'cancelled' && 'ℹ️ The Chromatic run was cancelled.'
+              || '⚠️ Please check the workflow logs for error details.'
+            }}

.github/workflows/test-browser-exp.yaml

@@ -11,6 +11,13 @@ jobs:
     if: github.event.label.name == 'New Browser Test Expectations'
     steps:
     - uses: Comfy-Org/ComfyUI_frontend_setup_action@v3
+    - name: Cache Playwright browsers
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/ms-playwright
+        key: playwright-browsers-${{ runner.os }}-${{ hashFiles('ComfyUI_frontend/pnpm-lock.yaml') }}
+        restore-keys: |
+          playwright-browsers-${{ runner.os }}-
     - name: Install Playwright Browsers
       run: npx playwright install chromium --with-deps
       working-directory: ComfyUI_frontend

.github/workflows/test-ui.yaml

@@ -7,15 +7,11 @@ on:
     branches-ignore:
       [wip/*, draft/*, temp/*, vue-nodes-migration, sno-playwright-*]
 
-env:
-  DATE_FORMAT: '+%m/%d/%Y, %I:%M:%S %p'
-
 jobs:
   setup:
     runs-on: ubuntu-latest
     outputs:
       cache-key: ${{ steps.cache-key.outputs.key }}
-      sanitized-branch: ${{ steps.branch-info.outputs.sanitized }}
     steps:
       - name: Checkout ComfyUI
         uses: actions/checkout@v4
@@ -48,29 +44,6 @@ jobs:
           cache: 'pnpm'
           cache-dependency-path: 'ComfyUI_frontend/pnpm-lock.yaml'
 
-      - name: Get current time
-        id: current-time
-        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
-
-      - name: Comment PR - Tests Started
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: append
-          body: |
-            <!-- PLAYWRIGHT_TEST_STATUS -->
-
-            ---
-
-            <img alt='comfy-loading-gif' src="https://github.com/user-attachments/assets/755c86ee-e445-4ea8-bc2c-cca85df48686" width="14px" height="14px" style="vertical-align: middle; margin-left: 4px;" />
-            <bold>[${{ steps.current-time.outputs.time }} UTC] Preparing browser tests across multiple browsers...</bold>
-
-            ---
-            *This comment will be updated when tests complete*
 
       - name: Cache tool outputs
         uses: actions/cache@v4
@@ -94,14 +67,6 @@ jobs:
         id: cache-key
         run: echo "key=$(date +%s)" >> $GITHUB_OUTPUT
 
-      - name: Generate sanitized branch name
-        id: branch-info
-        run: |
-          # Get branch name and sanitize it for Cloudflare branch names
-          BRANCH_NAME="${{ github.head_ref || github.ref_name }}"
-          SANITIZED_BRANCH=$(echo "$BRANCH_NAME" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9-]/-/g' | sed 's/--*/-/g' | sed 's/^-\|-$//g')
-          echo "sanitized=${SANITIZED_BRANCH}" >> $GITHUB_OUTPUT
-
       - name: Save cache
         uses: actions/cache/save@5a3ec84eff668545956fd18022155c47e93e2684
         with:
@@ -114,8 +79,6 @@ jobs:
     needs: setup
     runs-on: ubuntu-latest
     permissions:
-      pull-requests: write
-      issues: write
       contents: read
     strategy:
       fail-fast: false
@@ -144,32 +107,6 @@ jobs:
           python-version: '3.10'
           cache: 'pip'
 
-      - name: Get current time
-        id: current-time
-        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
-
-      - name: Set project name
-        id: project-name
-        run: |
-          if [ "${{ matrix.browser }}" = "chromium-0.5x" ]; then
-            echo "name=comfyui-playwright-chromium-0-5x" >> $GITHUB_OUTPUT
-          else
-            echo "name=comfyui-playwright-${{ matrix.browser }}" >> $GITHUB_OUTPUT
-          fi
-          echo "branch=${{ needs.setup.outputs.sanitized-branch }}" >> $GITHUB_OUTPUT
-
-      - name: Comment PR - Browser Test Started
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: append
-          body: |
-            <img alt='comfy-loading-gif' src="https://github.com/user-attachments/assets/755c86ee-e445-4ea8-bc2c-cca85df48686" width="14px" height="14px" style="vertical-align: middle; margin-left: 4px;" />
-            <bold>${{ matrix.browser }}</bold>: Running tests...
 
       - name: Install requirements
         run: |
@@ -198,9 +135,6 @@ jobs:
         run: npx playwright install chromium --with-deps
         working-directory: ComfyUI_frontend
 
-      - name: Install Wrangler
-        run: pnpm install -g wrangler
-
       - name: Run Playwright tests (${{ matrix.browser }})
         id: playwright
         run: npx playwright test --project=${{ matrix.browser }} --reporter=html
@@ -213,181 +147,3 @@ jobs:
           path: ComfyUI_frontend/playwright-report/
           retention-days: 30
 
-      - name: Deploy to Cloudflare Pages (${{ matrix.browser }})
-        id: cloudflare-deploy
-        if: always()
-        continue-on-error: true
-        run: |
-          # Retry logic for wrangler deploy (3 attempts)
-          RETRY_COUNT=0
-          MAX_RETRIES=3
-          SUCCESS=false
-          
-          while [ $RETRY_COUNT -lt $MAX_RETRIES ] && [ $SUCCESS = false ]; do
-            RETRY_COUNT=$((RETRY_COUNT + 1))
-            echo "Deployment attempt $RETRY_COUNT of $MAX_RETRIES..."
-            
-            if npx wrangler pages deploy ComfyUI_frontend/playwright-report --project-name=${{ steps.project-name.outputs.name }} --branch=${{ steps.project-name.outputs.branch }}; then
-              SUCCESS=true
-              echo "Deployment successful on attempt $RETRY_COUNT"
-            else
-              echo "Deployment failed on attempt $RETRY_COUNT"
-              if [ $RETRY_COUNT -lt $MAX_RETRIES ]; then
-                echo "Retrying in 10 seconds..."
-                sleep 10
-              fi
-            fi
-          done
-          
-          if [ $SUCCESS = false ]; then
-            echo "All deployment attempts failed"
-            exit 1
-          fi
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
-          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
-
-      - name: Save deployment info for summary
-        if: always()
-        run: |
-          mkdir -p deployment-info
-          # Use step conclusion to determine test result
-          if [ "${{ steps.playwright.conclusion }}" = "success" ]; then
-            EXIT_CODE="0"
-          else
-            EXIT_CODE="1"
-          fi
-          DEPLOYMENT_URL="${{ steps.cloudflare-deploy.outputs.deployment-url || steps.cloudflare-deploy.outputs.url || format('https://{0}.{1}.pages.dev', steps.project-name.outputs.branch, steps.project-name.outputs.name) }}"
-          echo "${{ matrix.browser }}|${EXIT_CODE}|${DEPLOYMENT_URL}" > deployment-info/${{ matrix.browser }}.txt
-
-      - name: Upload deployment info
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: deployment-info-${{ matrix.browser }}
-          path: deployment-info/
-          retention-days: 1
-
-      - name: Get completion time
-        id: completion-time
-        if: always()
-        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
-
-      - name: Comment PR - Browser Test Complete
-        if: always() && github.event_name == 'pull_request'
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: append
-          body: |
-            ${{ steps.playwright.conclusion == 'success' && '✅' || '❌' }} **${{ matrix.browser }}**: ${{ steps.playwright.conclusion == 'success' && 'Tests passed!' || 'Tests failed!' }} [View Report](${{ steps.cloudflare-deploy.outputs.deployment-url || format('https://{0}.{1}.pages.dev', steps.project-name.outputs.branch, steps.project-name.outputs.name) }})
-
-  comment-summary:
-    needs: playwright-tests
-    runs-on: ubuntu-latest
-    if: always() && github.event_name == 'pull_request'
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Download all deployment info
-        uses: actions/download-artifact@v4
-        with:
-          pattern: deployment-info-*
-          merge-multiple: true
-          path: deployment-info
-
-      - name: Get completion time
-        id: completion-time
-        run: echo "time=$(date -u '${{ env.DATE_FORMAT }}')" >> $GITHUB_OUTPUT
-
-      - name: Generate comment body
-        id: comment-body
-        run: |
-          echo "<!-- PLAYWRIGHT_TEST_STATUS -->" > comment.md
-          echo "## 🎭 Playwright Test Results" >> comment.md
-          echo "" >> comment.md
-
-          # Check if all tests passed
-          ALL_PASSED=true
-          for file in deployment-info/*.txt; do
-            if [ -f "$file" ]; then
-              browser=$(basename "$file" .txt)
-              info=$(cat "$file")
-              exit_code=$(echo "$info" | cut -d'|' -f2)
-              if [ "$exit_code" != "0" ]; then
-                ALL_PASSED=false
-                break
-              fi
-            fi
-          done
-
-          if [ "$ALL_PASSED" = "true" ]; then
-            echo "✅ **All tests passed across all browsers!**" >> comment.md
-          else
-            echo "❌ **Some tests failed!**" >> comment.md
-          fi
-
-          echo "" >> comment.md
-          echo "⏰ Completed at: ${{ steps.completion-time.outputs.time }} UTC" >> comment.md
-          echo "" >> comment.md
-          echo "### 📊 Test Reports by Browser" >> comment.md
-
-          for file in deployment-info/*.txt; do
-            if [ -f "$file" ]; then
-              browser=$(basename "$file" .txt)
-              info=$(cat "$file")
-              exit_code=$(echo "$info" | cut -d'|' -f2)
-              url=$(echo "$info" | cut -d'|' -f3)
-              
-              if [ "$exit_code" = "0" ]; then
-                status="✅"
-              else
-                status="❌"
-              fi
-              
-              echo "- $status **$browser**: [View Report]($url)" >> comment.md
-            fi
-          done
-
-          echo "" >> comment.md
-          echo "---" >> comment.md
-          if [ "$ALL_PASSED" = "true" ]; then
-            echo "🎉 Your tests are passing across all browsers!" >> comment.md
-          else
-            echo "⚠️ Please check the test reports for details on failures." >> comment.md
-          fi
-
-      - name: Comment PR - Tests Complete
-        continue-on-error: true
-        uses: edumserrano/find-create-or-update-comment@v3
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          body-includes: '<!-- PLAYWRIGHT_TEST_STATUS -->'
-          comment-author: 'github-actions[bot]'
-          edit-mode: replace
-          body-path: comment.md
-
-      - name: Check test results and fail if needed
-        run: |
-          # Check if all tests passed and fail the job if not
-          ALL_PASSED=true
-          for file in deployment-info/*.txt; do
-            if [ -f "$file" ]; then
-              info=$(cat "$file")
-              exit_code=$(echo "$info" | cut -d'|' -f2)
-              if [ "$exit_code" != "0" ]; then
-                ALL_PASSED=false
-                break
-              fi
-            fi
-          done
-
-          if [ "$ALL_PASSED" = "false" ]; then
-            echo "❌ Tests failed in one or more browsers. Failing the CI job."
-            exit 1
-          else
-            echo "✅ All tests passed across all browsers!"
-          fi

.storybook/preview-head.html

@@ -4,17 +4,26 @@
     transition: background-color 0.3s ease, color 0.3s ease;
   }
 
-  /* Light theme default */
-  body {
-    background-color: #ffffff;
-    color: #1a1a1a;
+  /* Light theme default - with explicit color to override media queries */
+  body:not(.dark-theme) {
+    background-color: #fff !important;
+    color: #000 !important;
+  }
+
+  /* Override browser dark mode preference for light theme */
+  @media (prefers-color-scheme: dark) {
+    body:not(.dark-theme) {
+      color: #000 !important;
+      --fg-color: #000 !important;
+      --bg-color: #fff !important;
+    }
   }
 
   /* Dark theme styles */
   body.dark-theme,
   .dark-theme body {
-    background-color: #0a0a0a;
-    color: #e5e5e5;
+    background-color: #202020;
+    color: #fff;
   }
 
   /* Ensure Storybook canvas follows theme */
@@ -24,11 +33,33 @@
 
   .dark-theme .sb-show-main,
   .dark-theme .docs-story {
-    background-color: #0a0a0a !important;
+    background-color: #202020 !important;
   }
 
-  /* Fix for Storybook controls panel in dark mode */
-  .dark-theme .docblock-argstable-body {
-    color: #e5e5e5;
+  /* CSS Variables for theme consistency */
+  body:not(.dark-theme) {
+    --fg-color: #000;
+    --bg-color: #fff;
+    --content-bg: #e0e0e0;
+    --content-fg: #000;
+    --content-hover-bg: #adadad;
+    --content-hover-fg: #000;
+  }
+
+  body.dark-theme {
+    --fg-color: #fff;
+    --bg-color: #202020;
+    --content-bg: #4e4e4e;
+    --content-fg: #fff;
+    --content-hover-bg: #222;
+    --content-hover-fg: #fff;
+  }
+
+  /* Override Storybook's problematic & selector styles */
+  /* Reset only the specific properties that Storybook injects */
+  #storybook-root li+li,
+  #storybook-docs li+li {
+    margin: inherit;
+    padding: inherit;
   }
 </style>

CLAUDE.md

@@ -82,6 +82,44 @@ When referencing Comfy-Org repos:
 2. Use GitHub API for branches/PRs/metadata
 3. Curl GitHub website if needed
 
+## Settings and Feature Flags Quick Reference
+
+### Settings Usage
+```typescript
+const settingStore = useSettingStore()
+const value = settingStore.get('Comfy.SomeSetting')     // Get setting
+await settingStore.set('Comfy.SomeSetting', newValue)   // Update setting
+```
+
+### Dynamic Defaults
+```typescript
+{
+  id: 'Comfy.Example.Setting',
+  defaultValue: () => window.innerWidth < 1024 ? 'small' : 'large'  // Runtime context
+}
+```
+
+### Version-Based Defaults
+```typescript
+{
+  id: 'Comfy.Example.Feature',
+  defaultValue: 'legacy',
+  defaultsByInstallVersion: { '1.25.0': 'enhanced' }  // Gradual rollout
+}
+```
+
+### Feature Flags
+```typescript
+if (api.serverSupportsFeature('feature_name')) {  // Check capability
+  // Use enhanced feature
+}
+const value = api.getServerFeature('config_name', defaultValue)  // Get config
+```
+
+**Documentation:**
+- Settings system: `docs/SETTINGS.md`
+- Feature flags system: `docs/FEATURE_FLAGS.md`
+
 ## Common Pitfalls
 
 - NEVER use `any` type - use proper TypeScript types
@@ -89,6 +127,3 @@ When referencing Comfy-Org repos:
 - NEVER use `--no-verify` flag when committing
 - NEVER delete or disable tests to make them pass
 - NEVER circumvent quality checks
-- NEVER use `dark:` prefix - always use `dark-theme:` for dark mode styles, for example: `dark-theme:text-white dark-theme:bg-black`
-- NEVER use `:class="[]"` to merge class names - always use `import { cn } from '@/utils/tailwindUtil'`, for example: `<div :class="cn('bg-red-500', { 'bg-blue-500': condition })" />`
-

CODEOWNERS

@@ -14,4 +14,4 @@
 /src/extensions/core/load3d.ts @jtydhr88 @Comfy-Org/comfy_frontend_devs
 
 # Mask Editor extension
-/src/extensions/core/maskeditor.ts @trsommer @Comfy-Org/comfy_frontend_devs
+/src/extensions/core/maskeditor.ts @brucew4yn3rp @trsommer @Comfy-Org/comfy_frontend_devs

CONTRIBUTING.md

@@ -17,7 +17,7 @@ Have another idea? Drop into Discord or open an issue, and let's chat!
 ### Prerequisites & Technology Stack
 
 - **Required Software**:
-  - Node.js (v16 or later; v24 strongly recommended) and pnpm
+  - Node.js (v18 or later to build; v24 for vite dev server) and pnpm
   - Git for version control
   - A running ComfyUI backend instance
   

browser_tests/fixtures/utils/vueNodeFixtures.ts

@@ -1,131 +0,0 @@
-import type { Locator, Page } from '@playwright/test'
-
-import type { NodeReference } from './litegraphUtils'
-
-/**
- * VueNodeFixture provides Vue-specific testing utilities for interacting with
- * Vue node components. It bridges the gap between litegraph node references
- * and Vue UI components.
- */
-export class VueNodeFixture {
-  constructor(
-    private readonly nodeRef: NodeReference,
-    private readonly page: Page
-  ) {}
-
-  /**
-   * Get the node's header element using data-testid
-   */
-  async getHeader(): Promise<Locator> {
-    const nodeId = this.nodeRef.id
-    return this.page.locator(`[data-testid="node-header-${nodeId}"]`)
-  }
-
-  /**
-   * Get the node's title element
-   */
-  async getTitleElement(): Promise<Locator> {
-    const header = await this.getHeader()
-    return header.locator('[data-testid="node-title"]')
-  }
-
-  /**
-   * Get the current title text
-   */
-  async getTitle(): Promise<string> {
-    const titleElement = await this.getTitleElement()
-    return (await titleElement.textContent()) || ''
-  }
-
-  /**
-   * Set a new title by double-clicking and entering text
-   */
-  async setTitle(newTitle: string): Promise<void> {
-    const titleElement = await this.getTitleElement()
-    await titleElement.dblclick()
-
-    const input = (await this.getHeader()).locator(
-      '[data-testid="node-title-input"]'
-    )
-    await input.fill(newTitle)
-    await input.press('Enter')
-  }
-
-  /**
-   * Cancel title editing
-   */
-  async cancelTitleEdit(): Promise<void> {
-    const titleElement = await this.getTitleElement()
-    await titleElement.dblclick()
-
-    const input = (await this.getHeader()).locator(
-      '[data-testid="node-title-input"]'
-    )
-    await input.press('Escape')
-  }
-
-  /**
-   * Check if the title is currently being edited
-   */
-  async isEditingTitle(): Promise<boolean> {
-    const header = await this.getHeader()
-    const input = header.locator('[data-testid="node-title-input"]')
-    return await input.isVisible()
-  }
-
-  /**
-   * Get the collapse/expand button
-   */
-  async getCollapseButton(): Promise<Locator> {
-    const header = await this.getHeader()
-    return header.locator('[data-testid="node-collapse-button"]')
-  }
-
-  /**
-   * Toggle the node's collapsed state
-   */
-  async toggleCollapse(): Promise<void> {
-    const button = await this.getCollapseButton()
-    await button.click()
-  }
-
-  /**
-   * Get the collapse icon element
-   */
-  async getCollapseIcon(): Promise<Locator> {
-    const button = await this.getCollapseButton()
-    return button.locator('i')
-  }
-
-  /**
-   * Get the collapse icon's CSS classes
-   */
-  async getCollapseIconClass(): Promise<string> {
-    const icon = await this.getCollapseIcon()
-    return (await icon.getAttribute('class')) || ''
-  }
-
-  /**
-   * Check if the collapse button is visible
-   */
-  async isCollapseButtonVisible(): Promise<boolean> {
-    const button = await this.getCollapseButton()
-    return await button.isVisible()
-  }
-
-  /**
-   * Get the node's body/content element
-   */
-  async getBody(): Promise<Locator> {
-    const nodeId = this.nodeRef.id
-    return this.page.locator(`[data-testid="node-body-${nodeId}"]`)
-  }
-
-  /**
-   * Check if the node body is visible (not collapsed)
-   */
-  async isBodyVisible(): Promise<boolean> {
-    const body = await this.getBody()
-    return await body.isVisible()
-  }
-}

browser_tests/tests/dialog.spec.ts

@@ -59,18 +59,6 @@ test.describe('Execution error', () => {
     const executionError = comfyPage.page.locator('.comfy-error-report')
     await expect(executionError).toBeVisible()
   })
-
-  test('Can display Issue Report form', async ({ comfyPage }) => {
-    await comfyPage.loadWorkflow('nodes/execution_error')
-    await comfyPage.queueButton.click()
-    await comfyPage.nextFrame()
-
-    await comfyPage.page.getByLabel('Help Fix This').click()
-    const issueReportForm = comfyPage.page.getByText(
-      'Submit Error Report (Optional)'
-    )
-    await expect(issueReportForm).toBeVisible()
-  })
 })
 
 test.describe('Missing models warning', () => {
@@ -303,37 +291,16 @@ test.describe('Settings', () => {
   })
 })
 
-test.describe('Feedback dialog', () => {
-  test('Should open from topmenu help command', async ({ comfyPage }) => {
-    // Open feedback dialog from top menu
+test.describe('Support', () => {
+  test('Should open external zendesk link', async ({ comfyPage }) => {
     await comfyPage.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.menu.topbar.triggerTopbarCommand(['Help', 'Feedback'])
+    const pagePromise = comfyPage.page.context().waitForEvent('page')
+    await comfyPage.menu.topbar.triggerTopbarCommand(['Help', 'Support'])
+    const newPage = await pagePromise
 
-    // Verify feedback dialog content is visible
-    const feedbackHeader = comfyPage.page.getByRole('heading', {
-      name: 'Feedback'
-    })
-    await expect(feedbackHeader).toBeVisible()
-  })
-
-  test('Should close when close button clicked', async ({ comfyPage }) => {
-    // Open feedback dialog
-    await comfyPage.setSetting('Comfy.UseNewMenu', 'Top')
-    await comfyPage.menu.topbar.triggerTopbarCommand(['Help', 'Feedback'])
-
-    const feedbackHeader = comfyPage.page.getByRole('heading', {
-      name: 'Feedback'
-    })
-
-    // Close feedback dialog
-    await comfyPage.page
-      .getByLabel('', { exact: true })
-      .getByLabel('Close')
-      .click()
-    await feedbackHeader.waitFor({ state: 'hidden' })
-
-    // Verify dialog is closed
-    await expect(feedbackHeader).not.toBeVisible()
+    await newPage.waitForLoadState('networkidle')
+    await expect(newPage).toHaveURL(/.*support\.comfy\.org.*/)
+    await newPage.close()
   })
 })
 

browser_tests/tests/vueNodes/NodeHeader.spec.ts

@@ -1,138 +0,0 @@
-import {
-  comfyExpect as expect,
-  comfyPageFixture as test
-} from '../../fixtures/ComfyPage'
-import { VueNodeFixture } from '../../fixtures/utils/vueNodeFixtures'
-
-test.describe('NodeHeader', () => {
-  test.beforeEach(async ({ comfyPage }) => {
-    await comfyPage.setSetting('Comfy.UseNewMenu', 'Enabled')
-    await comfyPage.setSetting('Comfy.Graph.CanvasMenu', false)
-    await comfyPage.setSetting('Comfy.EnableTooltips', true)
-    await comfyPage.setup()
-    // Load single SaveImage node workflow (positioned below menu bar)
-    await comfyPage.loadWorkflow('single_save_image_node')
-  })
-
-  test('displays node title', async ({ comfyPage }) => {
-    // Get the single SaveImage node from the workflow
-    const nodes = await comfyPage.getNodeRefsByType('SaveImage')
-    expect(nodes.length).toBeGreaterThanOrEqual(1)
-
-    const node = nodes[0]
-    const vueNode = new VueNodeFixture(node, comfyPage.page)
-
-    const title = await vueNode.getTitle()
-    expect(title).toBe('Save Image')
-
-    // Verify title is visible in the header
-    const header = await vueNode.getHeader()
-    await expect(header).toContainText('Save Image')
-  })
-
-  test('allows title renaming', async ({ comfyPage }) => {
-    // Get the single SaveImage node from the workflow
-    const nodes = await comfyPage.getNodeRefsByType('SaveImage')
-    const node = nodes[0]
-    const vueNode = new VueNodeFixture(node, comfyPage.page)
-
-    // Test renaming with Enter
-    await vueNode.setTitle('My Custom Sampler')
-    const newTitle = await vueNode.getTitle()
-    expect(newTitle).toBe('My Custom Sampler')
-
-    // Verify the title is displayed
-    const header = await vueNode.getHeader()
-    await expect(header).toContainText('My Custom Sampler')
-
-    // Test cancel with Escape
-    const titleElement = await vueNode.getTitleElement()
-    await titleElement.dblclick()
-    await comfyPage.nextFrame()
-
-    // Type a different value but cancel
-    const input = (await vueNode.getHeader()).locator(
-      '[data-testid="node-title-input"]'
-    )
-    await input.fill('This Should Be Cancelled')
-    await input.press('Escape')
-    await comfyPage.nextFrame()
-
-    // Title should remain as the previously saved value
-    const titleAfterCancel = await vueNode.getTitle()
-    expect(titleAfterCancel).toBe('My Custom Sampler')
-  })
-
-  test('handles node collapsing', async ({ comfyPage }) => {
-    // Get the single SaveImage node from the workflow
-    const nodes = await comfyPage.getNodeRefsByType('SaveImage')
-    const node = nodes[0]
-    const vueNode = new VueNodeFixture(node, comfyPage.page)
-
-    // Initially should not be collapsed
-    expect(await node.isCollapsed()).toBe(false)
-    const body = await vueNode.getBody()
-    await expect(body).toBeVisible()
-
-    // Collapse the node
-    await vueNode.toggleCollapse()
-    expect(await node.isCollapsed()).toBe(true)
-
-    // Verify node content is hidden
-    const collapsedSize = await node.getSize()
-    await expect(body).not.toBeVisible()
-
-    // Expand again
-    await vueNode.toggleCollapse()
-    expect(await node.isCollapsed()).toBe(false)
-    await expect(body).toBeVisible()
-
-    // Size should be restored
-    const expandedSize = await node.getSize()
-    expect(expandedSize.height).toBeGreaterThanOrEqual(collapsedSize.height)
-  })
-
-  test('shows collapse/expand icon state', async ({ comfyPage }) => {
-    // Get the single SaveImage node from the workflow
-    const nodes = await comfyPage.getNodeRefsByType('SaveImage')
-    const node = nodes[0]
-    const vueNode = new VueNodeFixture(node, comfyPage.page)
-
-    // Check initial expanded state icon
-    let iconClass = await vueNode.getCollapseIconClass()
-    expect(iconClass).toContain('pi-chevron-down')
-
-    // Collapse and check icon
-    await vueNode.toggleCollapse()
-    iconClass = await vueNode.getCollapseIconClass()
-    expect(iconClass).toContain('pi-chevron-right')
-
-    // Expand and check icon
-    await vueNode.toggleCollapse()
-    iconClass = await vueNode.getCollapseIconClass()
-    expect(iconClass).toContain('pi-chevron-down')
-  })
-
-  test('preserves title when collapsing/expanding', async ({ comfyPage }) => {
-    // Get the single SaveImage node from the workflow
-    const nodes = await comfyPage.getNodeRefsByType('SaveImage')
-    const node = nodes[0]
-    const vueNode = new VueNodeFixture(node, comfyPage.page)
-
-    // Set custom title
-    await vueNode.setTitle('Test Sampler')
-    expect(await vueNode.getTitle()).toBe('Test Sampler')
-
-    // Collapse
-    await vueNode.toggleCollapse()
-    expect(await vueNode.getTitle()).toBe('Test Sampler')
-
-    // Expand
-    await vueNode.toggleCollapse()
-    expect(await vueNode.getTitle()).toBe('Test Sampler')
-
-    // Verify title is still displayed
-    const header = await vueNode.getHeader()
-    await expect(header).toContainText('Test Sampler')
-  })
-})

docs/SETTINGS.md

@@ -0,0 +1,293 @@
+# Settings System
+
+## Overview
+
+ComfyUI frontend uses a comprehensive settings system for user preferences with support for dynamic defaults, version-based rollouts, and environment-aware configuration.
+
+### Settings Architecture
+- Settings are defined as `SettingParams` in `src/constants/coreSettings.ts`
+- Registered at app startup, loaded/saved via `useSettingStore` (Pinia)
+- Persisted per user via backend `/settings` endpoint
+- If a value hasn't been set by the user, the store returns the computed default
+
+```typescript
+// From src/stores/settingStore.ts:105-122
+function getDefaultValue<K extends keyof Settings>(
+  key: K
+): Settings[K] | undefined {
+  const param = getSettingById(key)
+  if (param === undefined) return
+
+  const versionedDefault = getVersionedDefaultValue(key, param)
+  if (versionedDefault) {
+    return versionedDefault
+  }
+
+  return typeof param.defaultValue === 'function'
+    ? param.defaultValue()
+    : param.defaultValue
+}
+```
+
+### Settings Registration Process
+
+Settings are registered after server values are loaded:
+
+```typescript
+// From src/components/graph/GraphCanvas.vue:311-315
+CORE_SETTINGS.forEach((setting) => {
+  settingStore.addSetting(setting)
+})
+
+await newUserService().initializeIfNewUser(settingStore)
+```
+
+## Dynamic and Environment-Based Defaults
+
+### Computed Defaults
+You can compute defaults dynamically using function defaults that access runtime context:
+
+```typescript
+// From src/constants/coreSettings.ts:94-101
+{
+  id: 'Comfy.Sidebar.Size',
+  // Default to small if the window is less than 1536px(2xl) wide
+  defaultValue: () => (window.innerWidth < 1536 ? 'small' : 'normal')
+}
+```
+
+```typescript
+// From src/constants/coreSettings.ts:306
+{
+  id: 'Comfy.Locale',
+  defaultValue: () => navigator.language.split('-')[0] || 'en'
+}
+```
+
+### Version-Based Defaults
+You can vary defaults by installed frontend version using `defaultsByInstallVersion`:
+
+```typescript
+// From src/stores/settingStore.ts:129-150
+function getVersionedDefaultValue<K extends keyof Settings, TValue = Settings[K]>(
+  key: K, 
+  param: SettingParams<TValue> | undefined
+): TValue | null {
+  const defaultsByInstallVersion = param?.defaultsByInstallVersion
+  if (defaultsByInstallVersion && key !== 'Comfy.InstalledVersion') {
+    const installedVersion = get('Comfy.InstalledVersion')
+    if (installedVersion) {
+      const sortedVersions = Object.keys(defaultsByInstallVersion).sort(
+        (a, b) => compareVersions(b, a)
+      )
+      for (const version of sortedVersions) {
+        if (!isSemVer(version)) continue
+        if (compareVersions(installedVersion, version) >= 0) {
+          const versionedDefault = defaultsByInstallVersion[version]
+          return typeof versionedDefault === 'function'
+            ? versionedDefault()
+            : versionedDefault
+        }
+      }
+    }
+  }
+  return null
+}
+```
+
+Example versioned defaults from codebase:
+
+```typescript
+// From src/constants/coreSettings.ts:38-40
+{
+  id: 'Comfy.Graph.LinkReleaseAction',
+  defaultValue: LinkReleaseTriggerAction.CONTEXT_MENU,
+  defaultsByInstallVersion: {
+    '1.24.1': LinkReleaseTriggerAction.SEARCH_BOX
+  }
+}
+
+// Another versioned default example
+{
+  id: 'Comfy.Graph.LinkReleaseAction.Shift',
+  defaultValue: LinkReleaseTriggerAction.SEARCH_BOX,
+  defaultsByInstallVersion: {
+    '1.24.1': LinkReleaseTriggerAction.CONTEXT_MENU
+  }
+}
+```
+
+### Real Examples from Codebase
+
+Here are actual settings showing different patterns:
+
+```typescript
+// Number setting with validation
+{
+  id: 'LiteGraph.Node.TooltipDelay',
+  name: 'Tooltip Delay',
+  type: 'number',
+  attrs: {
+    min: 100,
+    max: 3000,
+    step: 50
+  },
+  defaultValue: 500,
+  versionAdded: '1.9.0'
+}
+
+// Hidden system setting for tracking
+{
+  id: 'Comfy.InstalledVersion',
+  name: 'The frontend version that was running when the user first installed ComfyUI',
+  type: 'hidden',
+  defaultValue: null,
+  versionAdded: '1.24.0'
+}
+
+// Slider with complex tooltip
+{
+  id: 'LiteGraph.Canvas.LowQualityRenderingZoomThreshold',
+  name: 'Low quality rendering zoom threshold',
+  tooltip: 'Zoom level threshold for performance mode. Lower values (0.1) = quality at all zoom levels. Higher values (1.0) = performance mode even when zoomed in.',
+  type: 'slider',
+  attrs: {
+    min: 0.1,
+    max: 1.0,
+    step: 0.05
+  },
+  defaultValue: 0.5
+}
+```
+
+### New User Version Capture
+
+The initial installed version is captured for new users to ensure versioned defaults remain stable:
+
+```typescript
+// From src/services/newUserService.ts:49-53
+await settingStore.set(
+  'Comfy.InstalledVersion',
+  __COMFYUI_FRONTEND_VERSION__
+)
+```
+
+## Practical Patterns for Environment-Based Defaults
+
+### Dynamic Default Patterns
+```typescript
+// Device-based default
+{
+  id: 'Comfy.Example.MobileDefault',
+  type: 'boolean',
+  defaultValue: () => /Mobile/i.test(navigator.userAgent)
+}
+
+// Environment-based default
+{
+  id: 'Comfy.Example.DevMode',
+  type: 'boolean',
+  defaultValue: () => import.meta.env.DEV
+}
+
+// Window size based
+{
+  id: 'Comfy.Example.CompactUI',
+  type: 'boolean',
+  defaultValue: () => window.innerWidth < 1024
+}
+```
+
+### Version-Based Rollout Pattern
+```typescript
+{
+  id: 'Comfy.Example.NewFeature',
+  type: 'combo',
+  options: ['legacy', 'enhanced'],
+  defaultValue: 'legacy',
+  defaultsByInstallVersion: {
+    '1.25.0': 'enhanced'
+  }
+}
+```
+
+## Settings Persistence and Access
+
+### API Interaction
+Values are stored per user via the backend. The store writes through API and falls back to defaults when not set:
+
+```typescript
+// From src/stores/settingStore.ts:73-75
+onChange(settingsById.value[key], newValue, oldValue)
+settingValues.value[key] = newValue
+await api.storeSetting(key, newValue)
+```
+
+### Usage in Components
+```typescript
+const settingStore = useSettingStore()
+
+// Get setting value (returns computed default if not set by user)
+const value = settingStore.get('Comfy.SomeSetting')
+
+// Update setting value
+await settingStore.set('Comfy.SomeSetting', newValue)
+```
+
+
+## Advanced Settings Features
+
+### Migration and Backward Compatibility
+
+Settings support migration from deprecated values:
+
+```typescript
+// From src/stores/settingStore.ts:68-69, 172-175
+const newValue = tryMigrateDeprecatedValue(
+  settingsById.value[key],
+  clonedValue
+)
+
+// Migration happens during addSetting for existing values:
+if (settingValues.value[setting.id] !== undefined) {
+  settingValues.value[setting.id] = tryMigrateDeprecatedValue(
+    setting,
+    settingValues.value[setting.id]
+  )
+}
+```
+
+### onChange Callbacks
+
+Settings can define onChange callbacks that receive the setting definition, new value, and old value:
+
+```typescript
+// From src/stores/settingStore.ts:73, 177
+onChange(settingsById.value[key], newValue, oldValue)  // During set()
+onChange(setting, get(setting.id), undefined)         // During addSetting()
+```
+
+### Settings UI and Categories
+
+Settings are automatically grouped for UI based on their `category` or derived from `id`:
+
+```typescript
+{
+  id: 'Comfy.Sidebar.Size',
+  category: ['Appearance', 'Sidebar', 'Size'],
+  // UI will group this under Appearance > Sidebar > Size
+}
+```
+
+## Related Documentation
+
+- Feature flag system: `docs/FEATURE_FLAGS.md`
+- Settings schema for backend: `src/schemas/apiSchema.ts` (zSettings)
+- Server configuration (separate from user settings): `src/constants/serverConfig.ts`
+
+## Summary
+
+- **Settings**: User preferences with dynamic/versioned defaults, persisted per user
+- **Environment Defaults**: Use function defaults to read runtime context (window, navigator, env)
+- **Version Rollouts**: Use `defaultsByInstallVersion` for gradual feature releases
+- **API Interaction**: Settings persist to `/settings` endpoint via `storeSetting()`

docs/SETTINGS_SEQUENCE_DIAGRAM.md

@@ -0,0 +1,82 @@
+# Settings and Feature Flags Sequence Diagram
+
+This diagram shows the flow of settings initialization, default resolution, persistence, and feature flags exchange.
+
+This diagram accurately reflects the actual implementation in the ComfyUI frontend codebase.
+
+```mermaid
+sequenceDiagram
+    participant User as User
+    participant Vue as Vue Component
+    participant Store as SettingStore (Pinia)
+    participant API as ComfyApi (WebSocket/REST)
+    participant Backend as Backend
+    participant NewUserSvc as NewUserService
+
+    Note over Vue,Store: App startup (GraphCanvas.vue)
+    Vue->>Store: loadSettingValues()
+    Store->>API: getSettings()
+    API->>Backend: GET /settings
+    Backend-->>API: settings map (per-user)
+    API-->>Store: settings map
+    Store-->>Vue: loaded
+
+    Vue->>Store: register CORE_SETTINGS (addSetting for each)
+    loop For each setting registration
+      Store->>Store: tryMigrateDeprecatedValue(existing value)
+      Store->>Store: onChange(setting, currentValue, undefined)
+    end
+
+    Note over Vue,NewUserSvc: New user detection
+    Vue->>NewUserSvc: initializeIfNewUser(settingStore)
+    NewUserSvc->>NewUserSvc: checkIsNewUser(settingStore)
+    alt New user detected
+      NewUserSvc->>Store: set("Comfy.InstalledVersion", __COMFYUI_FRONTEND_VERSION__)
+      Store->>Store: tryMigrateDeprecatedValue(newValue)
+      Store->>Store: onChange(setting, newValue, oldValue)
+      Store->>API: storeSetting(key, newValue)
+      API->>Backend: POST /settings/{id}
+    else Existing user
+      Note over NewUserSvc: Skip setting installed version
+    end
+
+    Note over Vue,Store: Component reads a setting
+    Vue->>Store: get(key)
+    Store->>Store: exists(key)?
+    alt User value exists
+      Store-->>Vue: return stored user value
+    else Not set by user
+      Store->>Store: getVersionedDefaultValue(key)
+      alt Versioned default matched (defaultsByInstallVersion)
+        Store-->>Vue: return versioned default
+      else No version match
+        Store->>Store: evaluate defaultValue (function or constant)
+        Note over Store: defaultValue can use window size,<br/>locale, env, etc.
+        Store-->>Vue: return computed default
+      end
+    end
+
+    Note over User,Store: User updates a setting
+    User->>Vue: changes setting in UI
+    Vue->>Store: set(key, newValue)
+    Store->>Store: tryMigrateDeprecatedValue(newValue)
+    Store->>Store: check if newValue === oldValue (early return if same)
+    Store->>Store: onChange(setting, newValue, oldValue)
+    Store->>Store: update settingValues[key]
+    Store->>API: storeSetting(key, newValue)
+    API->>Backend: POST /settings/{id}
+    Backend-->>API: 200 OK
+    API-->>Store: ack
+
+    Note over API,Backend: Feature Flags WebSocket Exchange
+    API->>Backend: WS connect
+    API->>Backend: send { type: "feature_flags", data: clientFeatureFlags.json }
+    Backend-->>API: WS send { type: "feature_flags", data: server flags }
+    API->>API: store serverFeatureFlags = data
+
+    Note over Vue,API: Feature flag consumption in UI/logic
+    Vue->>API: serverSupportsFeature(name)
+    API-->>Vue: boolean (true only if flag === true)
+    Vue->>API: getServerFeature(name, default)
+    API-->>Vue: value or default
+```

docs/adr/0002-crdt-based-layout-system.md

@@ -1,111 +0,0 @@
-# 2. CRDT-Based Layout System
-
-Date: 2024-08-16
-
-## Status
-
-Accepted
-
-## Context
-
-ComfyUI's node graph editor faces fundamental architectural limitations that prevent us from achieving our product goals:
-
-### The Problem
-
-In the current system, each node manages its own position directly within LiteGraph. This creates several critical issues:
-
-1. **Performance Degradation**: Every UI update requires traversing the entire graph to detect changes. With graphs containing 100+ nodes, this polling-based approach causes visible lag during interactions.
-
-2. **Snap-Back Hell**: Multiple systems (LiteGraph canvas, Vue widgets, drag handlers) fight over node positions. Users experience frustrating "snap-back" where nodes jump between positions during drag operations.
-
-3. **No Collaboration Path**: Direct mutation of node positions makes real-time collaboration impossible. There's no way to merge concurrent edits from multiple users without conflicts.
-
-4. **Limited Renderer Options**: Position data is tightly coupled to LiteGraph's canvas renderer, blocking us from implementing WebGL rendering for large graphs or accessibility-focused DOM rendering.
-
-5. **Missing Features**: Without a proper event system, we can't implement undo/redo, animation systems, or viewport culling efficiently.
-
-### Why Now?
-
-- User complaints about performance with large workflows are increasing
-- The AI art community expects real-time collaboration (see Figma, Miro)
-- Accessibility requirements demand alternative rendering modes
-- The technical debt is compounding with each new feature
-
-## Decision
-
-We will implement a centralized layout tree using CRDT (Conflict-free Replicated Data Types) as the single source of truth for all spatial data.
-
-### Key Design Choices
-
-1. **CRDT-Based Layout Tree**: Use Yjs to maintain a centralized tree structure that owns all node positions, sizes, and spatial relationships.
-
-2. **Command Pattern**: Every position change is an explicit command/operation rather than direct mutation. This enables:
-   - Precise operation history for undo/redo
-   - Automatic conflict resolution for concurrent edits
-   - Event stream for observers without polling
-
-3. **Unidirectional Data Flow**: 
-   ```
-   User Input → Layout Commands → CRDT Tree → Renderers
-   ```
-   LiteGraph becomes a pure renderer that receives position updates, never mutates them.
-
-4. **Spatial Indexing**: The tree structure naturally supports a QuadTree spatial index for O(log n) viewport queries instead of O(n) full scans.
-
-### Why CRDT?
-
-CRDTs solve our core problems elegantly:
-- **Local-First**: Works perfectly for single-user while being collaboration-ready
-- **Automatic Conflict Resolution**: No more snap-back from competing updates
-- **Event-Driven**: Changes propagate through observers, not polling
-- **Memory Efficient**: Only changed portions of the tree are updated
-
-### Implementation Approach
-
-Phase 1: Build alongside existing system
-- Layout tree observes LiteGraph changes initially
-- Gradually migrate interactions to command pattern
-- Maintain full backwards compatibility
-
-Phase 2: Invert control
-- Layout tree becomes source of truth
-- LiteGraph receives updates via one-way sync
-- Enable alternative renderers
-
-## Consequences
-
-### Positive
-
-- **10x Performance**: Viewport culling and spatial indexing eliminate full graph traversals
-- **Multiplayer Ready**: CRDT foundation enables real-time collaboration without architecture changes
-- **Undo/Redo**: Command pattern makes history trivial to implement
-- **Renderer Flexibility**: Clean separation allows WebGL, DOM, or hybrid rendering
-- **Developer Experience**: Clear data flow and event system simplify debugging
-
-### Negative
-
-- **Learning Curve**: Team needs to understand CRDT concepts and command pattern
-- **Migration Complexity**: Existing code must be carefully migrated to new system
-- **Initial Memory Overhead**: ~30KB for Yjs library + operation history storage
-
-### Mitigations
-
-- Provide clear migration guides and examples
-- Build compatibility layer for gradual migration
-- Implement operation history pruning for long-running sessions
-
-## Notes
-
-This architecture aligns with modern state management patterns seen in Figma, Linear, and other collaborative tools. The investment in CRDT infrastructure pays dividends across multiple feature areas and positions ComfyUI as a modern, collaborative AI workflow tool.
-
-The command pattern also opens doors for:
-- Macro recording and playback
-- Automated testing of UI interactions  
-- Remote control via API
-- AI-assisted layout optimization
-
-## References
-
-- [Yjs Documentation](https://docs.yjs.dev/)
-- [CRDTs: The Hard Parts](https://martin.kleppmann.com/2020/07/06/crdt-hard-parts-hydra.html)
-- [Figma's Multiplayer Technology](https://www.figma.com/blog/how-figmas-multiplayer-technology-works/)

docs/adr/README.md

@@ -11,8 +11,7 @@ An Architecture Decision Record captures an important architectural decision mad
 | ADR | Title | Status | Date |
 |-----|-------|--------|------|
 | [0001](0001-merge-litegraph-into-frontend.md) | Merge LiteGraph.js into ComfyUI Frontend | Accepted | 2025-08-05 |
-| [0002](0002-crdt-based-layout-system.md) | CRDT-Based Layout System | Accepted | 2024-08-16 |
-| [0003](0003-monorepo-conversion.md) | Restructure as a Monorepo | Proposed | 2025-08-25 |
+| [0002](0002-monorepo-conversion.md) | Restructure as a Monorepo | Proposed | 2025-08-25 |
 
 ## Creating a New ADR
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@comfyorg/comfyui-frontend",
   "private": true,
-  "version": "1.26.7",
+  "version": "1.26.8",
   "type": "module",
   "repository": "https://github.com/Comfy-Org/ComfyUI_frontend",
   "homepage": "https://comfy.org",
@@ -31,10 +31,10 @@
     "knip": "knip --cache",
     "knip:no-cache": "knip",
     "locale": "lobe-i18n locale",
-    "collect-i18n": "nx e2e --config=playwright.i18n.config.ts",
+    "collect-i18n": "npx playwright test --config=playwright.i18n.config.ts",
     "json-schema": "tsx scripts/generate-json-schema.ts",
     "storybook": "nx storybook -p 6006",
-    "build-storybook": "nx build-storybook"
+    "build-storybook": "storybook build"
   },
   "devDependencies": {
     "@eslint/js": "^9.8.0",
@@ -129,8 +129,6 @@
     "@xterm/xterm": "^5.5.0",
     "algoliasearch": "^5.21.0",
     "axios": "^1.8.2",
-    "chart.js": "^4.5.0",
-    "clsx": "^2.1.1",
     "dompurify": "^3.2.5",
     "dotenv": "^16.4.5",
     "es-toolkit": "^1.39.9",
@@ -147,14 +145,12 @@
     "primeicons": "^7.0.0",
     "primevue": "^4.2.5",
     "semver": "^7.7.2",
-    "tailwind-merge": "^2.6.0",
     "three": "^0.170.0",
     "tiptap-markdown": "^0.8.10",
     "vue": "^3.5.13",
     "vue-i18n": "^9.14.3",
     "vue-router": "^4.4.3",
     "vuefire": "^3.2.1",
-    "yjs": "^13.6.27",
     "zod": "^3.23.8",
     "zod-validation-error": "^3.3.0"
   }

playwright.config.ts

@@ -1,39 +1,31 @@
 import { defineConfig, devices } from '@playwright/test'
 
-/**
- * Read environment variables from file.
- * https://github.com/motdotla/dotenv
- */
-// import dotenv from 'dotenv';
-// dotenv.config({ path: path.resolve(__dirname, '.env') });
-
-/**
- * See https://playwright.dev/docs/test-configuration.
- */
 export default defineConfig({
   testDir: './browser_tests',
-  /* Run tests in files in parallel */
   fullyParallel: true,
-  /* Fail the build on CI if you accidentally left test.only in the source code. */
   forbidOnly: !!process.env.CI,
-  /* Retry on CI only - increased for better flaky test handling */
-  retries: process.env.CI ? 3 : 0,
-  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
   reporter: 'html',
-  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  // /* // Toggle for [LOCAL] testing.
+  retries: process.env.CI ? 3 : 0,
   use: {
-    /* Base URL to use in actions like `await page.goto('/')`. */
-    // baseURL: 'http://127.0.0.1:3000',
-
-    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
     trace: 'on-first-retry'
   },
-  /* Path to global setup file. Exported function runs once before all the tests */
+  /*/ // [LOCAL]
+  // VERY HELPFUL: Skip screenshot tests locally
+  // grep: process.env.CI ? undefined : /^(?!.*screenshot).*$/,
+  timeout: 30_000, // Longer timeout for breakpoints
+  retries: 0, // No retries while debugging. Increase if writing new tests. that may be flaky.
+  workers: 4, // Single worker for easier debugging. Increase to match CPU cores if you want to run a lot of tests in parallel.
+
+  use: {
+    trace: 'on', // Always capture traces (CI uses 'on-first-retry')
+    video: 'on' // Always record video (CI uses 'retain-on-failure')
+  },
+  //*/
+
   globalSetup: './browser_tests/globalSetup.ts',
-  /* Path to global teardown file. Exported function runs once after all the tests */
   globalTeardown: './browser_tests/globalTeardown.ts',
 
-  /* Configure projects for major browsers */
   projects: [
     {
       name: 'chromium',

playwright.i18n.config.ts

@@ -1,6 +1,6 @@
-import { PlaywrightTestConfig } from '@playwright/test'
+import { defineConfig } from '@playwright/test'
 
-const config: PlaywrightTestConfig = {
+export default defineConfig({
   testDir: './scripts',
   use: {
     baseURL: 'http://localhost:5173',
@@ -9,6 +9,4 @@ const config: PlaywrightTestConfig = {
   reporter: 'list',
   timeout: 60000,
   testMatch: /collect-i18n-.*\.ts/
-}
-
-export default config
+})

pnpm-lock.yaml

@@ -83,12 +83,6 @@ importers:
       axios:
         specifier: ^1.8.2
         version: 1.11.0
-      chart.js:
-        specifier: ^4.5.0
-        version: 4.5.0
-      clsx:
-        specifier: ^2.1.1
-        version: 2.1.1
       dompurify:
         specifier: ^3.2.5
         version: 3.2.5
@@ -137,9 +131,6 @@ importers:
       semver:
         specifier: ^7.7.2
         version: 7.7.2
-      tailwind-merge:
-        specifier: ^2.6.0
-        version: 2.6.0
       three:
         specifier: ^0.170.0
         version: 0.170.0
@@ -158,9 +149,6 @@ importers:
       vuefire:
         specifier: ^3.2.1
         version: 3.2.1(consola@3.4.2)(firebase@11.6.0)(vue@3.5.13(typescript@5.9.2))
-      yjs:
-        specifier: ^13.6.27
-        version: 13.6.27
       zod:
         specifier: ^3.23.8
         version: 3.24.1
@@ -1719,9 +1707,6 @@ packages:
   '@jridgewell/trace-mapping@0.3.30':
     resolution: {integrity: sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==}
 
-  '@kurkle/color@0.3.4':
-    resolution: {integrity: sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w==}
-
   '@lobehub/cli-ui@1.13.0':
     resolution: {integrity: sha512-7kXm84dc6yiniEFb/KRZv5H4g43n+xKTSpKSczlv54DY3tHSuZjBARyI/UDxFVgn7ezWYAIFuphzs0hSdhs6hw==}
     engines: {node: '>=18'}
@@ -3235,10 +3220,6 @@ packages:
   charenc@0.0.2:
     resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==}
 
-  chart.js@4.5.0:
-    resolution: {integrity: sha512-aYeC/jDgSEx8SHWZvANYMioYMZ2KX02W6f6uVfyteuCGcadDLcYVHdfdygsTQkQ4TKn5lghoojAsPj5pu0SnvQ==}
-    engines: {pnpm: '>=8'}
-
   check-error@2.1.1:
     resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==}
     engines: {node: '>= 16'}
@@ -3287,10 +3268,6 @@ packages:
     resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
     engines: {node: '>=0.8'}
 
-  clsx@2.1.1:
-    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
-    engines: {node: '>=6'}
-
   code-excerpt@4.0.0:
     resolution: {integrity: sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -4503,9 +4480,6 @@ packages:
   isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
-  isomorphic.js@0.2.5:
-    resolution: {integrity: sha512-PIeMbHqMt4DnUP3MA/Flc0HElYjMXArsw1qwJZcm9sqR8mq3l8NYizFMty0pWwE/tzIGH3EKK5+jes5mAr85yw==}
-
   jackspeak@3.4.0:
     resolution: {integrity: sha512-JVYhQnN59LVPFCEcVa2C3CrEKYacvjRfqIQl+h8oi91aLYQVWRYbxjPcv1bUiUy/kLmQaANrYfNMCO3kuEDHfw==}
     engines: {node: '>=14'}
@@ -4667,11 +4641,6 @@ packages:
     resolution: {integrity: sha512-vzaalVBmFLnMaedq0QAsBAaXsWahzRpvnIBdBjj7y+7EKTS6lnziU2y/PsU2c6rV5qYj2B5IDw0uNJ9peXD0vw==}
     deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
 
-  lib0@0.2.114:
-    resolution: {integrity: sha512-gcxmNFzA4hv8UYi8j43uPlQ7CGcyMJ2KQb5kZASw6SnAKAf10hK12i2fjrS3Cl/ugZa5Ui6WwIu1/6MIXiHttQ==}
-    engines: {node: '>=16'}
-    hasBin: true
-
   lie@3.3.0:
     resolution: {integrity: sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==}
 
@@ -6080,9 +6049,6 @@ packages:
     resolution: {integrity: sha512-JJoOEKTfL1urb1mDoEblhD9NhEbWmq9jHEMEnxoC4ujUaZ4itA8vKgwkFAyNClgxplLi9tsUKX+EduK0p/l7sg==}
     engines: {node: ^14.18.0 || >=16.0.0}
 
-  tailwind-merge@2.6.0:
-    resolution: {integrity: sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA==}
-
   tailwindcss@3.4.4:
     resolution: {integrity: sha512-ZoyXOdJjISB7/BcLTR6SEsLgKtDStYyYZVLsUtWChO4Ps20CBad7lfJKVDiejocV4ME1hLmyY0WJE3hSDcmQ2A==}
     engines: {node: '>=14.0.0'}
@@ -6773,10 +6739,6 @@ packages:
     resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
     engines: {node: '>=12'}
 
-  yjs@13.6.27:
-    resolution: {integrity: sha512-OIDwaflOaq4wC6YlPBy2L6ceKeKuF7DeTxx+jPzv1FHn9tCZ0ZwSRnUBxD05E3yed46fv/FWJbvR+Ud7x0L7zw==}
-    engines: {node: '>=16.0.0', npm: '>=8.0.0'}
-
   yocto-queue@0.1.0:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
@@ -8427,8 +8389,6 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
-  '@kurkle/color@0.3.4': {}
-
   '@lobehub/cli-ui@1.13.0(@types/react@19.1.9)':
     dependencies:
       arr-rotate: 1.0.0
@@ -10287,10 +10247,6 @@ snapshots:
 
   charenc@0.0.2: {}
 
-  chart.js@4.5.0:
-    dependencies:
-      '@kurkle/color': 0.3.4
-
   check-error@2.1.1: {}
 
   chokidar@3.6.0:
@@ -10338,8 +10294,6 @@ snapshots:
 
   clone@1.0.4: {}
 
-  clsx@2.1.1: {}
-
   code-excerpt@4.0.0:
     dependencies:
       convert-to-spaces: 2.0.1
@@ -11609,8 +11563,6 @@ snapshots:
 
   isexe@2.0.0: {}
 
-  isomorphic.js@0.2.5: {}
-
   jackspeak@3.4.0:
     dependencies:
       '@isaacs/cliui': 8.0.2
@@ -11776,10 +11728,6 @@ snapshots:
 
   lex@1.7.9: {}
 
-  lib0@0.2.114:
-    dependencies:
-      isomorphic.js: 0.2.5
-
   lie@3.3.0:
     dependencies:
       immediate: 3.0.6
@@ -13557,8 +13505,6 @@ snapshots:
       '@pkgr/core': 0.1.2
       tslib: 2.8.1
 
-  tailwind-merge@2.6.0: {}
-
   tailwindcss@3.4.4:
     dependencies:
       '@alloc/quick-lru': 5.2.0
@@ -14263,10 +14209,6 @@ snapshots:
       y18n: 5.0.8
       yargs-parser: 21.1.1
 
-  yjs@13.6.27:
-    dependencies:
-      lib0: 0.2.114
-
   yocto-queue@0.1.0: {}
 
   yoctocolors@2.1.1: {}

src/assets/css/style.css

@@ -1,66 +1,10 @@
 @layer primevue, tailwind-utilities;
 
 @layer tailwind-utilities {
-  /* Set default values to prevent some styles from not working properly. */
-  *, ::before, ::after {
-    --tw-border-spacing-x: 0;
-    --tw-border-spacing-y: 0;
-    --tw-translate-x: 0;
-    --tw-translate-y: 0;
-    --tw-rotate: 0;
-    --tw-skew-x: 0;
-    --tw-skew-y: 0;
-    --tw-scale-x: 1;
-    --tw-scale-y: 1;
-    --tw-pan-x: ;
-    --tw-pan-y: ;
-    --tw-pinch-zoom: ;
-    --tw-scroll-snap-strictness: proximity;
-    --tw-gradient-from-position: ;
-    --tw-gradient-via-position: ;
-    --tw-gradient-to-position: ;
-    --tw-ordinal: ;
-    --tw-slashed-zero: ;
-    --tw-numeric-figure: ;
-    --tw-numeric-spacing: ;
-    --tw-numeric-fraction: ;
-    --tw-ring-inset: ;
-    --tw-ring-offset-width: 0px;
-    --tw-ring-offset-color: #fff;
-    --tw-ring-color: rgb(66 153 225 / 0.5);
-    --tw-ring-offset-shadow: 0 0 #0000;
-    --tw-ring-shadow: 0 0 #0000;
-    --tw-shadow: 0 0 #0000;
-    --tw-shadow-colored: 0 0 #0000;
-    --tw-blur: ;
-    --tw-brightness: ;
-    --tw-contrast: ;
-    --tw-grayscale: ;
-    --tw-hue-rotate: ;
-    --tw-invert: ;
-    --tw-saturate: ;
-    --tw-sepia: ;
-    --tw-drop-shadow: ;
-    --tw-backdrop-blur: ;
-    --tw-backdrop-brightness: ;
-    --tw-backdrop-contrast: ;
-    --tw-backdrop-grayscale: ;
-    --tw-backdrop-hue-rotate: ;
-    --tw-backdrop-invert: ;
-    --tw-backdrop-opacity: ;
-    --tw-backdrop-saturate: ;
-    --tw-backdrop-sepia: ;
-    --tw-contain-size: ;
-    --tw-contain-layout: ;
-    --tw-contain-paint: ;
-    --tw-contain-style: ;
-  }
-
   @tailwind components;
   @tailwind utilities;
 }
 
-
 :root {
   --fg-color: #000;
   --bg-color: #fff;
@@ -83,7 +27,7 @@
   --content-fg: #000;
   --content-hover-bg: #adadad;
   --content-hover-fg: #000;
-
+  
   /* Code styling colors for help menu*/
   --code-text-color: rgba(0, 122, 255, 1);
   --code-bg-color: rgba(96, 165, 250, 0.2);
@@ -190,188 +134,6 @@ body {
   border: thin solid;
 }
 
-/* Shared markdown content styling for consistent rendering across components */
-.comfy-markdown-content {
-  /* Typography */
-  font-size: 0.875rem; /* text-sm */
-  line-height: 1.6;
-  word-wrap: break-word;
-}
-
-/* Headings */
-.comfy-markdown-content h1 {
-  font-size: 22px; /* text-[22px] */
-  font-weight: 700; /* font-bold */
-  margin-top: 2rem; /* mt-8 */
-  margin-bottom: 1rem; /* mb-4 */
-}
-
-.comfy-markdown-content h1:first-child {
-  margin-top: 0; /* first:mt-0 */
-}
-
-.comfy-markdown-content h2 {
-  font-size: 18px; /* text-[18px] */
-  font-weight: 700; /* font-bold */
-  margin-top: 2rem; /* mt-8 */
-  margin-bottom: 1rem; /* mb-4 */
-}
-
-.comfy-markdown-content h2:first-child {
-  margin-top: 0; /* first:mt-0 */
-}
-
-.comfy-markdown-content h3 {
-  font-size: 16px; /* text-[16px] */
-  font-weight: 700; /* font-bold */
-  margin-top: 2rem; /* mt-8 */
-  margin-bottom: 1rem; /* mb-4 */
-}
-
-.comfy-markdown-content h3:first-child {
-  margin-top: 0; /* first:mt-0 */
-}
-
-.comfy-markdown-content h4,
-.comfy-markdown-content h5,
-.comfy-markdown-content h6 {
-  margin-top: 2rem; /* mt-8 */
-  margin-bottom: 1rem; /* mb-4 */
-}
-
-.comfy-markdown-content h4:first-child,
-.comfy-markdown-content h5:first-child,
-.comfy-markdown-content h6:first-child {
-  margin-top: 0; /* first:mt-0 */
-}
-
-/* Paragraphs */
-.comfy-markdown-content p {
-  margin: 0 0 0.5em;
-}
-
-.comfy-markdown-content p:last-child {
-  margin-bottom: 0;
-}
-
-/* First child reset */
-.comfy-markdown-content *:first-child {
-  margin-top: 0; /* mt-0 */
-}
-
-/* Lists */
-.comfy-markdown-content ul,
-.comfy-markdown-content ol {
-  padding-left: 2rem; /* pl-8 */
-  margin: 0.5rem 0; /* my-2 */
-}
-
-/* Nested lists */
-.comfy-markdown-content ul ul,
-.comfy-markdown-content ol ol,
-.comfy-markdown-content ul ol,
-.comfy-markdown-content ol ul {
-  padding-left: 1.5rem; /* pl-6 */
-  margin: 0.5rem 0; /* my-2 */
-}
-
-.comfy-markdown-content li {
-  margin: 0.5rem 0; /* my-2 */
-}
-
-/* Code */
-.comfy-markdown-content code {
-  color: var(--code-text-color);
-  background-color: var(--code-bg-color);
-  border-radius: 0.25rem; /* rounded */
-  padding: 0.125rem 0.375rem; /* px-1.5 py-0.5 */
-  font-family: monospace;
-}
-
-.comfy-markdown-content pre {
-  background-color: var(--code-block-bg-color);
-  border-radius: 0.25rem; /* rounded */
-  padding: 1rem; /* p-4 */
-  margin: 1rem 0; /* my-4 */
-  overflow-x: auto; /* overflow-x-auto */
-}
-
-.comfy-markdown-content pre code {
-  background-color: transparent; /* bg-transparent */
-  padding: 0; /* p-0 */
-  color: var(--p-text-color);
-}
-
-/* Tables */
-.comfy-markdown-content table {
-  width: 100%; /* w-full */
-  border-collapse: collapse; /* border-collapse */
-}
-
-.comfy-markdown-content th,
-.comfy-markdown-content td {
-  padding: 0.5rem; /* px-2 py-2 */
-}
-
-.comfy-markdown-content th {
-  color: var(--fg-color);
-}
-
-.comfy-markdown-content td {
-  color: var(--drag-text);
-}
-
-.comfy-markdown-content tr {
-  border-bottom: 1px solid var(--content-bg);
-}
-
-.comfy-markdown-content tr:last-child {
-  border-bottom: none;
-}
-
-.comfy-markdown-content thead {
-  border-bottom: 1px solid var(--p-text-color);
-}
-
-/* Links */
-.comfy-markdown-content a {
-  color: var(--drag-text);
-  text-decoration: underline;
-}
-
-/* Media */
-.comfy-markdown-content img,
-.comfy-markdown-content video {
-  max-width: 100%; /* max-w-full */
-  height: auto; /* h-auto */
-  display: block; /* block */
-  margin-bottom: 1rem; /* mb-4 */
-}
-
-/* Blockquotes */
-.comfy-markdown-content blockquote {
-  border-left: 3px solid var(--p-primary-color, var(--primary-bg));
-  padding-left: 0.75em;
-  margin: 0.5em 0;
-  opacity: 0.8;
-}
-
-/* Horizontal rule */
-.comfy-markdown-content hr {
-  border: none;
-  border-top: 1px solid var(--p-border-color, var(--border-color));
-  margin: 1em 0;
-}
-
-/* Strong and emphasis */
-.comfy-markdown-content strong {
-  font-weight: bold;
-}
-
-.comfy-markdown-content em {
-  font-style: italic;
-}
-
 .comfy-modal {
   display: none; /* Hidden by default */
   position: fixed; /* Stay in place */
@@ -876,92 +638,3 @@ audio.comfy-audio.empty-audio-widget {
   width: calc(100vw - env(titlebar-area-width, 100vw));
 }
 /* End of [Desktop] Electron window specific styles */
-
-/* Vue Node LOD (Level of Detail) System */
-/* These classes control rendering detail based on zoom level */
-
-/* Minimal LOD (zoom <= 0.4) - Title only for performance */
-.lg-node--lod-minimal {
-  min-height: 32px;
-  transition: min-height 0.2s ease;
-  /* Performance optimizations */
-  text-shadow: none;
-  backdrop-filter: none;
-}
-
-.lg-node--lod-minimal .lg-node-body {
-  display: none !important;
-}
-
-/* Reduced LOD (0.4 < zoom <= 0.8) - Essential widgets, simplified styling */
-.lg-node--lod-reduced {
-  transition: opacity 0.1s ease;
-  /* Performance optimizations */
-  text-shadow: none;
-}
-
-.lg-node--lod-reduced .lg-widget-label,
-.lg-node--lod-reduced .lg-slot-label {
-  display: none;
-}
-
-.lg-node--lod-reduced .lg-slot {
-  opacity: 0.6;
-  font-size: 0.75rem;
-}
-
-.lg-node--lod-reduced .lg-widget {
-  margin: 2px 0;
-  font-size: 0.875rem;
-}
-
-/* Full LOD (zoom > 0.8) - Complete detail rendering */
-.lg-node--lod-full {
-  /* Uses default styling - no overrides needed */
-}
-
-/* Smooth transitions between LOD levels */
-.lg-node {
-  transition: min-height 0.2s ease;
-  /* Disable text selection on all nodes */
-  user-select: none;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-}
-
-.lg-node .lg-slot,
-.lg-node .lg-widget {
-  transition: opacity 0.1s ease, font-size 0.1s ease;
-}
-
-/* Performance optimization during canvas interaction */
-.transform-pane--interacting .lg-node * {
-  transition: none !important;
-}
-
-.transform-pane--interacting .lg-node {
-  will-change: transform;
-}
-
-/* Global performance optimizations for LOD */
-.lg-node--lod-minimal,
-.lg-node--lod-reduced {
-  /* Remove ALL expensive paint effects */
-  box-shadow: none !important;
-  filter: none !important;
-  backdrop-filter: none !important;
-  text-shadow: none !important;
-  -webkit-mask-image: none !important;
-  mask-image: none !important;
-  clip-path: none !important;
-}
-
-/* Reduce paint complexity for minimal LOD */
-.lg-node--lod-minimal {
-  /* Skip complex borders */
-  border-radius: 0 !important;
-  /* Use solid colors only */
-  background-image: none !important;
-}
-

src/components/breadcrumb/SubgraphBreadcrumbItem.vue

@@ -107,6 +107,7 @@ const rename = async (
   }
 }
 
+const isRoot = props.item.key === 'root'
 const menuItems = computed<MenuItem[]>(() => {
   return [
     {
@@ -120,7 +121,27 @@ const menuItems = computed<MenuItem[]>(() => {
       command: async () => {
         await workflowService.duplicateWorkflow(workflowStore.activeWorkflow!)
       },
-      visible: props.item.key === 'root'
+      visible: isRoot
+    },
+    {
+      separator: true,
+      visible: isRoot
+    },
+    {
+      label: t('menuLabels.Save'),
+      icon: 'pi pi-save',
+      command: async () => {
+        await useCommandStore().execute('Comfy.SaveWorkflow')
+      },
+      visible: isRoot
+    },
+    {
+      label: t('menuLabels.Save As'),
+      icon: 'pi pi-save',
+      command: async () => {
+        await useCommandStore().execute('Comfy.SaveWorkflowAs')
+      },
+      visible: isRoot
     },
     {
       separator: true
@@ -134,7 +155,7 @@ const menuItems = computed<MenuItem[]>(() => {
     },
     {
       separator: true,
-      visible: props.item.key === 'root'
+      visible: isRoot
     },
     {
       label: t('breadcrumbsMenu.deleteWorkflow'),
@@ -142,7 +163,7 @@ const menuItems = computed<MenuItem[]>(() => {
       command: async () => {
         await workflowService.deleteWorkflow(workflowStore.activeWorkflow!)
       },
-      visible: props.item.key === 'root'
+      visible: isRoot
     }
   ]
 })

src/components/button/MoreButton.stories.ts

@@ -24,22 +24,22 @@ export const Basic: Story = {
         <MoreButton>
           <template #default="{ close }">
             <IconTextButton
-              type="secondary"
+              type="transparent"
               label="Settings"
               @click="() => { close() }"
             >
               <template #icon>
-                <Download />
+                <Download :size="16" />
               </template>
             </IconTextButton>
 
             <IconTextButton
-              type="primary"
+              type="transparent"
               label="Profile"
               @click="() => { close() }"
             >
               <template #icon>
-                <ScrollText />
+                <ScrollText :size="16" />
               </template>
             </IconTextButton>
           </template>

src/components/common/EditableText.spec.ts

@@ -68,73 +68,4 @@ describe('EditableText', () => {
     // @ts-expect-error fixme ts strict error
     expect(wrapper.emitted('edit')[0]).toEqual(['Test Text'])
   })
-
-  it('cancels editing on escape key', async () => {
-    const wrapper = mountComponent({
-      modelValue: 'Original Text',
-      isEditing: true
-    })
-
-    // Change the input value
-    await wrapper.findComponent(InputText).setValue('Modified Text')
-
-    // Press escape
-    await wrapper.findComponent(InputText).trigger('keyup.escape')
-
-    // Should emit cancel event
-    expect(wrapper.emitted('cancel')).toBeTruthy()
-
-    // Should NOT emit edit event
-    expect(wrapper.emitted('edit')).toBeFalsy()
-
-    // Input value should be reset to original
-    expect(wrapper.findComponent(InputText).props()['modelValue']).toBe(
-      'Original Text'
-    )
-  })
-
-  it('does not save changes when escape is pressed and blur occurs', async () => {
-    const wrapper = mountComponent({
-      modelValue: 'Original Text',
-      isEditing: true
-    })
-
-    // Change the input value
-    await wrapper.findComponent(InputText).setValue('Modified Text')
-
-    // Press escape (which triggers blur internally)
-    await wrapper.findComponent(InputText).trigger('keyup.escape')
-
-    // Manually trigger blur to simulate the blur that happens after escape
-    await wrapper.findComponent(InputText).trigger('blur')
-
-    // Should emit cancel but not edit
-    expect(wrapper.emitted('cancel')).toBeTruthy()
-    expect(wrapper.emitted('edit')).toBeFalsy()
-  })
-
-  it('saves changes on enter but not on escape', async () => {
-    // Test Enter key saves changes
-    const enterWrapper = mountComponent({
-      modelValue: 'Original Text',
-      isEditing: true
-    })
-    await enterWrapper.findComponent(InputText).setValue('Saved Text')
-    await enterWrapper.findComponent(InputText).trigger('keyup.enter')
-    // Trigger blur that happens after enter
-    await enterWrapper.findComponent(InputText).trigger('blur')
-    expect(enterWrapper.emitted('edit')).toBeTruthy()
-    // @ts-expect-error fixme ts strict error
-    expect(enterWrapper.emitted('edit')[0]).toEqual(['Saved Text'])
-
-    // Test Escape key cancels changes with a fresh wrapper
-    const escapeWrapper = mountComponent({
-      modelValue: 'Original Text',
-      isEditing: true
-    })
-    await escapeWrapper.findComponent(InputText).setValue('Cancelled Text')
-    await escapeWrapper.findComponent(InputText).trigger('keyup.escape')
-    expect(escapeWrapper.emitted('cancel')).toBeTruthy()
-    expect(escapeWrapper.emitted('edit')).toBeFalsy()
-  })
 })

src/components/common/EditableText.vue

@@ -14,12 +14,10 @@
       fluid
       :pt="{
         root: {
-          onBlur: finishEditing,
-          ...inputAttrs
+          onBlur: finishEditing
         }
       }"
       @keyup.enter="blurInputElement"
-      @keyup.escape="cancelEditing"
       @click.stop
     />
   </div>
@@ -29,41 +27,21 @@
 import InputText from 'primevue/inputtext'
 import { nextTick, ref, watch } from 'vue'
 
-const {
-  modelValue,
-  isEditing = false,
-  inputAttrs = {}
-} = defineProps<{
+const { modelValue, isEditing = false } = defineProps<{
   modelValue: string
   isEditing?: boolean
-  inputAttrs?: Record<string, any>
 }>()
 
-const emit = defineEmits(['update:modelValue', 'edit', 'cancel'])
+const emit = defineEmits(['update:modelValue', 'edit'])
 const inputValue = ref<string>(modelValue)
 const inputRef = ref<InstanceType<typeof InputText> | undefined>()
-const isCanceling = ref(false)
 
 const blurInputElement = () => {
   // @ts-expect-error - $el is an internal property of the InputText component
   inputRef.value?.$el.blur()
 }
 const finishEditing = () => {
-  // Don't save if we're canceling
-  if (!isCanceling.value) {
-    emit('edit', inputValue.value)
-  }
-  isCanceling.value = false
-}
-const cancelEditing = () => {
-  // Set canceling flag to prevent blur from saving
-  isCanceling.value = true
-  // Reset to original value
-  inputValue.value = modelValue
-  // Emit cancel event
-  emit('cancel')
-  // Blur the input to exit edit mode
-  blurInputElement()
+  emit('edit', inputValue.value)
 }
 watch(
   () => isEditing,

src/components/dialog/content/ErrorDialogContent.vue

@@ -21,16 +21,9 @@
         @click="showReport"
       />
       <Button
-        v-show="!sendReportOpen"
-        text
-        :label="$t('issueReport.helpFix')"
-        @click="showSendReport"
-      />
-      <Button
-        v-if="authStore.currentUser"
         v-show="!reportOpen"
         text
-        :label="$t('issueReport.contactSupportTitle')"
+        :label="$t('issueReport.helpFix')"
         @click="showContactSupport"
       />
     </div>
@@ -41,16 +34,6 @@
       </ScrollPanel>
       <Divider />
     </template>
-    <ReportIssuePanel
-      v-if="sendReportOpen"
-      :title="$t('issueReport.submitErrorReport')"
-      :error-type="error.reportType ?? 'unknownError'"
-      :extra-fields="[stackTraceField]"
-      :tags="{
-        exceptionMessage: error.exceptionMessage,
-        nodeType: error.nodeType ?? 'UNKNOWN'
-      }"
-    />
     <div class="flex gap-4 justify-end">
       <FindIssueButton
         :error-message="error.exceptionMessage"
@@ -81,18 +64,12 @@ import { useCopyToClipboard } from '@/composables/useCopyToClipboard'
 import { api } from '@/scripts/api'
 import { app } from '@/scripts/app'
 import { useCommandStore } from '@/stores/commandStore'
-import { useFirebaseAuthStore } from '@/stores/firebaseAuthStore'
 import { useSystemStatsStore } from '@/stores/systemStatsStore'
-import type { ReportField } from '@/types/issueReportTypes'
 import {
   type ErrorReportData,
   generateErrorReport
 } from '@/utils/errorReportUtil'
 
-import ReportIssuePanel from './error/ReportIssuePanel.vue'
-
-const authStore = useFirebaseAuthStore()
-
 const { error } = defineProps<{
   error: Omit<ErrorReportData, 'workflow' | 'systemStats' | 'serverLogs'> & {
     /**
@@ -114,10 +91,6 @@ const reportOpen = ref(false)
 const showReport = () => {
   reportOpen.value = true
 }
-const sendReportOpen = ref(false)
-const showSendReport = () => {
-  sendReportOpen.value = true
-}
 const toast = useToast()
 const { t } = useI18n()
 const systemStatsStore = useSystemStatsStore()
@@ -126,15 +99,6 @@ const title = computed<string>(
   () => error.nodeType ?? error.exceptionType ?? t('errorDialog.defaultTitle')
 )
 
-const stackTraceField = computed<ReportField>(() => {
-  return {
-    label: t('issueReport.stackTrace'),
-    value: 'StackTrace',
-    optIn: true,
-    getData: () => error.traceback
-  }
-})
-
 const showContactSupport = async () => {
   await useCommandStore().execute('Comfy.ContactSupport')
 }

src/components/dialog/content/IssueReportDialogContent.vue

@@ -1,33 +0,0 @@
-<template>
-  <div class="p-2 h-full" aria-labelledby="issue-report-title">
-    <Panel
-      :pt="{
-        root: 'border-none',
-        content: 'p-0'
-      }"
-    >
-      <template #header>
-        <header class="flex flex-col items-center w-full">
-          <h2 id="issue-report-title" class="text-4xl">
-            {{ title }}
-          </h2>
-          <span v-if="subtitle" class="text-muted mt-0">{{ subtitle }}</span>
-        </header>
-      </template>
-      <ReportIssuePanel v-bind="panelProps" :pt="{ root: 'border-none' }" />
-    </Panel>
-  </div>
-</template>
-
-<script setup lang="ts">
-import Panel from 'primevue/panel'
-
-import ReportIssuePanel from '@/components/dialog/content/error/ReportIssuePanel.vue'
-import type { IssueReportPanelProps } from '@/types/issueReportTypes'
-
-defineProps<{
-  title: string
-  subtitle?: string
-  panelProps: IssueReportPanelProps
-}>()
-</script>

src/components/dialog/content/error/ReportIssuePanel.spec.ts

@@ -1,338 +0,0 @@
-import { Form } from '@primevue/forms'
-import { mount } from '@vue/test-utils'
-import { createPinia, setActivePinia } from 'pinia'
-import Checkbox from 'primevue/checkbox'
-import PrimeVue from 'primevue/config'
-import InputText from 'primevue/inputtext'
-import Textarea from 'primevue/textarea'
-import Tooltip from 'primevue/tooltip'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { createI18n } from 'vue-i18n'
-
-import enMesages from '@/locales/en/main.json'
-import { IssueReportPanelProps } from '@/types/issueReportTypes'
-
-import ReportIssuePanel from './ReportIssuePanel.vue'
-
-const DEFAULT_FIELDS = ['Workflow', 'Logs', 'Settings', 'SystemStats']
-const CUSTOM_FIELDS = [
-  {
-    label: 'Custom Field',
-    value: 'CustomField',
-    optIn: true,
-    getData: () => 'mock data'
-  }
-]
-
-async function getSubmittedContext() {
-  const { captureMessage } = (await import('@sentry/core')) as any
-  return captureMessage.mock.calls[0][1]
-}
-
-async function submitForm(wrapper: any) {
-  await wrapper.findComponent(Form).trigger('submit')
-  return getSubmittedContext()
-}
-
-async function findAndUpdateCheckbox(
-  wrapper: any,
-  value: string,
-  checked = true
-) {
-  const checkbox = wrapper
-    .findAllComponents(Checkbox)
-    .find((c: any) => c.props('value') === value)
-  if (!checkbox) throw new Error(`Checkbox with value "${value}" not found`)
-
-  await checkbox.vm.$emit('update:modelValue', checked)
-  return checkbox
-}
-
-const i18n = createI18n({
-  legacy: false,
-  locale: 'en',
-  messages: {
-    en: enMesages
-  }
-})
-
-vi.mock('primevue/usetoast', () => ({
-  useToast: vi.fn(() => ({
-    add: vi.fn()
-  }))
-}))
-
-vi.mock('@/scripts/api', () => ({
-  api: {
-    getLogs: vi.fn().mockResolvedValue('mock logs'),
-    getSystemStats: vi.fn().mockResolvedValue('mock stats'),
-    getSettings: vi.fn().mockResolvedValue('mock settings'),
-    fetchApi: vi.fn().mockResolvedValue({
-      json: vi.fn().mockResolvedValue({}),
-      text: vi.fn().mockResolvedValue('')
-    }),
-    apiURL: vi.fn().mockReturnValue('https://test.com')
-  }
-}))
-
-vi.mock('@/scripts/app', () => ({
-  app: {
-    graph: {
-      asSerialisable: vi.fn().mockReturnValue({})
-    }
-  }
-}))
-
-vi.mock('@sentry/core', () => ({
-  captureMessage: vi.fn()
-}))
-
-vi.mock('@primevue/forms', () => ({
-  Form: {
-    name: 'Form',
-    template:
-      '<form @submit.prevent="onSubmit"><slot :values="formValues" /></form>',
-    props: ['resolver'],
-    data() {
-      return {
-        formValues: {}
-      }
-    },
-    methods: {
-      onSubmit() {
-        // @ts-expect-error fixme ts strict error
-        this.$emit('submit', {
-          valid: true,
-          // @ts-expect-error fixme ts strict error
-          values: this.formValues
-        })
-      },
-      updateFieldValue(name: string, value: any) {
-        // @ts-expect-error fixme ts strict error
-        this.formValues[name] = value
-      }
-    }
-  },
-  FormField: {
-    name: 'FormField',
-    template:
-      '<div><slot :modelValue="modelValue" @update:modelValue="updateValue" /></div>',
-    props: ['name'],
-    data() {
-      return {
-        modelValue: ''
-      }
-    },
-    methods: {
-      // @ts-expect-error fixme ts strict error
-      updateValue(value) {
-        // @ts-expect-error fixme ts strict error
-        this.modelValue = value
-        // @ts-expect-error fixme ts strict error
-        let parent = this.$parent
-        while (parent && parent.$options.name !== 'Form') {
-          parent = parent.$parent
-        }
-        if (parent) {
-          // @ts-expect-error fixme ts strict error
-          parent.updateFieldValue(this.name, value)
-        }
-      }
-    }
-  }
-}))
-
-vi.mock('@/stores/firebaseAuthStore', () => ({
-  useFirebaseAuthStore: () => ({
-    currentUser: {
-      email: 'test@example.com'
-    }
-  })
-}))
-
-describe('ReportIssuePanel', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    const pinia = createPinia()
-    setActivePinia(pinia)
-  })
-
-  const mountComponent = (props: IssueReportPanelProps, options = {}): any => {
-    return mount(ReportIssuePanel, {
-      global: {
-        plugins: [PrimeVue, i18n, createPinia()],
-        directives: { tooltip: Tooltip }
-      },
-      props,
-      ...options
-    })
-  }
-
-  it('renders the panel with all required components', () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-    expect(wrapper.find('.p-panel').exists()).toBe(true)
-    expect(wrapper.findAllComponents(Checkbox).length).toBe(6)
-    expect(wrapper.findComponent(InputText).exists()).toBe(true)
-    expect(wrapper.findComponent(Textarea).exists()).toBe(true)
-  })
-
-  it('updates selection when checkboxes are selected', async () => {
-    const wrapper = mountComponent({
-      errorType: 'Test Error'
-    })
-
-    const checkboxes = wrapper.findAllComponents(Checkbox)
-
-    for (const field of DEFAULT_FIELDS) {
-      const checkbox = checkboxes.find(
-        // @ts-expect-error fixme ts strict error
-        (checkbox) => checkbox.props('value') === field
-      )
-      expect(checkbox).toBeDefined()
-
-      await checkbox?.vm.$emit('update:modelValue', [field])
-      expect(wrapper.vm.selection).toContain(field)
-    }
-  })
-
-  it('updates contactInfo when input is changed', async () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-    const input = wrapper.findComponent(InputText)
-
-    await input.vm.$emit('update:modelValue', 'test@example.com')
-    const context = await submitForm(wrapper)
-    expect(context.user.email).toBe('test@example.com')
-  })
-
-  it('updates additional details when textarea is changed', async () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-    const textarea = wrapper.findComponent(Textarea)
-
-    await textarea.vm.$emit('update:modelValue', 'This is a test detail.')
-    const context = await submitForm(wrapper)
-    expect(context.extra.details).toBe('This is a test detail.')
-  })
-
-  it('set contact preferences back to false if email is removed', async () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-    const input = wrapper.findComponent(InputText)
-
-    // Set a valid email, enabling the contact preferences to be changed
-    await input.vm.$emit('update:modelValue', 'name@example.com')
-
-    // Enable both contact preferences
-    for (const pref of ['followUp', 'notifyOnResolution']) {
-      await findAndUpdateCheckbox(wrapper, pref)
-    }
-
-    // Change the email back to empty
-    await input.vm.$emit('update:modelValue', '')
-    const context = await submitForm(wrapper)
-
-    // Check that the contact preferences are back to false automatically
-    expect(context.tags.followUp).toBe(false)
-    expect(context.tags.notifyOnResolution).toBe(false)
-  })
-
-  it('renders with overridden default fields', () => {
-    const wrapper = mountComponent({
-      errorType: 'Test Error',
-      defaultFields: ['Settings']
-    })
-
-    // Filter out the contact preferences checkboxes
-    const fieldCheckboxes = wrapper.findAllComponents(Checkbox).filter(
-      // @ts-expect-error fixme ts strict error
-      (checkbox) =>
-        !['followUp', 'notifyOnResolution'].includes(checkbox.props('value'))
-    )
-    expect(fieldCheckboxes.length).toBe(1)
-    expect(fieldCheckboxes.at(0)?.props('value')).toBe('Settings')
-  })
-
-  it('renders additional fields when extraFields prop is provided', () => {
-    const wrapper = mountComponent({
-      errorType: 'Test Error',
-      extraFields: CUSTOM_FIELDS
-    })
-    const customCheckbox = wrapper
-      .findAllComponents(Checkbox)
-      // @ts-expect-error fixme ts strict error
-      .find((checkbox) => checkbox.props('value') === 'CustomField')
-    expect(customCheckbox).toBeDefined()
-  })
-
-  it('allows custom fields to be selected', async () => {
-    const wrapper = mountComponent({
-      errorType: 'Test Error',
-      extraFields: CUSTOM_FIELDS
-    })
-
-    await findAndUpdateCheckbox(wrapper, 'CustomField')
-    const context = await submitForm(wrapper)
-    expect(context.extra.CustomField).toBe('mock data')
-  })
-
-  it('does not submit unchecked fields', async () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-    const textarea = wrapper.findComponent(Textarea)
-
-    // Set details but don't check any field checkboxes
-    await textarea.vm.$emit(
-      'update:modelValue',
-      'Report with only text but no fields selected'
-    )
-    const context = await submitForm(wrapper)
-
-    // Verify none of the optional fields were included
-    for (const field of DEFAULT_FIELDS) {
-      expect(context.extra[field]).toBeUndefined()
-    }
-  })
-
-  it.each([
-    {
-      checkbox: 'Logs',
-      apiMethod: 'getLogs',
-      expectedKey: 'Logs',
-      mockValue: 'mock logs'
-    },
-    {
-      checkbox: 'SystemStats',
-      apiMethod: 'getSystemStats',
-      expectedKey: 'SystemStats',
-      mockValue: 'mock stats'
-    },
-    {
-      checkbox: 'Settings',
-      apiMethod: 'getSettings',
-      expectedKey: 'Settings',
-      mockValue: 'mock settings'
-    }
-  ])(
-    'submits $checkbox data when checkbox is selected',
-    async ({ checkbox, apiMethod, expectedKey, mockValue }) => {
-      const wrapper = mountComponent({ errorType: 'Test Error' })
-
-      const { api } = (await import('@/scripts/api')) as any
-      vi.spyOn(api, apiMethod).mockResolvedValue(mockValue)
-
-      await findAndUpdateCheckbox(wrapper, checkbox)
-      const context = await submitForm(wrapper)
-      expect(context.extra[expectedKey]).toBe(mockValue)
-    }
-  )
-
-  it('submits workflow when the Workflow checkbox is selected', async () => {
-    const wrapper = mountComponent({ errorType: 'Test Error' })
-
-    const { app } = (await import('@/scripts/app')) as any
-    const mockWorkflow = { nodes: [], edges: [] }
-    vi.spyOn(app.graph, 'asSerialisable').mockReturnValue(mockWorkflow)
-
-    await findAndUpdateCheckbox(wrapper, 'Workflow')
-    const context = await submitForm(wrapper)
-
-    expect(context.extra.Workflow).toEqual(mockWorkflow)
-  })
-})

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

@@ -1,348 +0,0 @@
-<template>
-  <Form
-    v-slot="$form"
-    :resolver="zodResolver(issueReportSchema)"
-    @submit="submit"
-  >
-    <Panel :pt="$attrs.pt as any">
-      <template #header>
-        <div class="flex items-center gap-2">
-          <span class="font-bold">{{ title }}</span>
-        </div>
-      </template>
-      <template #footer>
-        <div class="flex justify-end gap-4">
-          <Button
-            v-tooltip="!submitted ? $t('g.reportIssueTooltip') : undefined"
-            :label="submitted ? $t('g.reportSent') : $t('g.reportIssue')"
-            :severity="submitted ? 'secondary' : 'primary'"
-            :icon="submitted ? 'pi pi-check' : 'pi pi-send'"
-            :disabled="submitted"
-            type="submit"
-          />
-        </div>
-      </template>
-      <div class="p-4 mt-2 border border-round surface-border shadow-1">
-        <div class="flex flex-col gap-6">
-          <FormField
-            v-slot="$field"
-            name="contactInfo"
-            :initial-value="authStore.currentUser?.email"
-          >
-            <div class="self-stretch inline-flex justify-start items-center">
-              <label for="contactInfo" class="pb-2 pt-0 opacity-80">{{
-                $t('issueReport.email')
-              }}</label>
-            </div>
-            <InputText
-              id="contactInfo"
-              v-bind="$field"
-              class="w-full"
-              :placeholder="$t('issueReport.provideEmail')"
-            />
-            <Message
-              v-if="$field?.error && $field.touched && $field.value !== ''"
-              severity="error"
-              size="small"
-              variant="simple"
-            >
-              {{ t('issueReport.validation.invalidEmail') }}
-            </Message>
-          </FormField>
-
-          <FormField v-slot="$field" name="helpType">
-            <div class="flex flex-col gap-2">
-              <div
-                class="self-stretch inline-flex justify-start items-center gap-2.5"
-              >
-                <label for="helpType" class="pb-2 pt-0 opacity-80">{{
-                  $t('issueReport.whatDoYouNeedHelpWith')
-                }}</label>
-              </div>
-              <Dropdown
-                v-bind="$field"
-                v-model="$field.value"
-                :options="helpTypes"
-                option-label="label"
-                option-value="value"
-                :placeholder="$t('issueReport.selectIssue')"
-                class="w-full"
-              />
-              <Message
-                v-if="$field?.error"
-                severity="error"
-                size="small"
-                variant="simple"
-              >
-                {{ t('issueReport.validation.selectIssueType') }}
-              </Message>
-            </div>
-          </FormField>
-
-          <div class="flex flex-col gap-2">
-            <div
-              class="self-stretch inline-flex justify-start items-center gap-2.5"
-            >
-              <span class="pb-2 pt-0 opacity-80">{{
-                $t('issueReport.whatCanWeInclude')
-              }}</span>
-            </div>
-            <div class="flex flex-row gap-3">
-              <div v-for="field in fields" :key="field.value">
-                <FormField
-                  v-if="field.optIn"
-                  v-slot="$field"
-                  :name="field.value"
-                  class="flex space-x-1"
-                >
-                  <Checkbox
-                    v-bind="$field"
-                    v-model="selection"
-                    :input-id="field.value"
-                    :value="field.value"
-                  />
-                  <label :for="field.value">{{ field.label }}</label>
-                </FormField>
-              </div>
-            </div>
-          </div>
-          <div class="flex flex-col gap-2">
-            <FormField v-slot="$field" name="details">
-              <div
-                class="self-stretch inline-flex justify-start items-center gap-2.5"
-              >
-                <label for="details" class="pb-2 pt-0 opacity-80">{{
-                  $t('issueReport.describeTheProblem')
-                }}</label>
-              </div>
-              <Textarea
-                v-bind="$field"
-                id="details"
-                class="w-full"
-                rows="5"
-                :placeholder="$t('issueReport.provideAdditionalDetails')"
-                :aria-label="$t('issueReport.provideAdditionalDetails')"
-              />
-              <Message
-                v-if="$field?.error && $field.touched"
-                severity="error"
-                size="small"
-                variant="simple"
-              >
-                {{
-                  $field.value
-                    ? t('issueReport.validation.maxLength')
-                    : t('issueReport.validation.descriptionRequired')
-                }}
-              </Message>
-            </FormField>
-          </div>
-
-          <div class="flex flex-col gap-3 mt-2">
-            <div v-for="checkbox in contactCheckboxes" :key="checkbox.value">
-              <FormField
-                v-slot="$field"
-                :name="checkbox.value"
-                class="flex space-x-1"
-              >
-                <Checkbox
-                  v-bind="$field"
-                  v-model="contactPrefs"
-                  :input-id="checkbox.value"
-                  :value="checkbox.value"
-                  :disabled="
-                    $form.contactInfo?.error || !$form.contactInfo?.value
-                  "
-                />
-                <label :for="checkbox.value">{{ checkbox.label }}</label>
-              </FormField>
-            </div>
-          </div>
-        </div>
-      </div>
-    </Panel>
-  </Form>
-</template>
-
-<script setup lang="ts">
-import { Form, FormField, type FormSubmitEvent } from '@primevue/forms'
-import { zodResolver } from '@primevue/forms/resolvers/zod'
-import type { CaptureContext, User } from '@sentry/core'
-import { captureMessage } from '@sentry/core'
-import _ from 'es-toolkit/compat'
-import { cloneDeep } from 'es-toolkit/compat'
-import Button from 'primevue/button'
-import Checkbox from 'primevue/checkbox'
-import Dropdown from 'primevue/dropdown'
-import InputText from 'primevue/inputtext'
-import Message from 'primevue/message'
-import Panel from 'primevue/panel'
-import Textarea from 'primevue/textarea'
-import { useToast } from 'primevue/usetoast'
-import { computed, ref } from 'vue'
-import { useI18n } from 'vue-i18n'
-
-import {
-  type IssueReportFormData,
-  issueReportSchema
-} from '@/schemas/issueReportSchema'
-import { api } from '@/scripts/api'
-import { app } from '@/scripts/app'
-import { useFirebaseAuthStore } from '@/stores/firebaseAuthStore'
-import type {
-  DefaultField,
-  IssueReportPanelProps,
-  ReportField
-} from '@/types/issueReportTypes'
-import { isElectron } from '@/utils/envUtil'
-import { generateUUID } from '@/utils/formatUtil'
-
-const DEFAULT_ISSUE_NAME = 'User reported issue'
-
-const props = defineProps<IssueReportPanelProps>()
-const { defaultFields = ['Workflow', 'Logs', 'SystemStats', 'Settings'] } =
-  props
-
-const { t } = useI18n()
-const toast = useToast()
-const authStore = useFirebaseAuthStore()
-
-const selection = ref<string[]>([])
-const contactPrefs = ref<string[]>([])
-const submitted = ref(false)
-
-const contactCheckboxes = [
-  { label: t('issueReport.contactFollowUp'), value: 'followUp' },
-  { label: t('issueReport.notifyResolve'), value: 'notifyOnResolution' }
-]
-
-const helpTypes = [
-  {
-    label: t('issueReport.helpTypes.billingPayments'),
-    value: 'billingPayments'
-  },
-  {
-    label: t('issueReport.helpTypes.loginAccessIssues'),
-    value: 'loginAccessIssues'
-  },
-  { label: t('issueReport.helpTypes.giveFeedback'), value: 'giveFeedback' },
-  { label: t('issueReport.helpTypes.bugReport'), value: 'bugReport' },
-  { label: t('issueReport.helpTypes.somethingElse'), value: 'somethingElse' }
-]
-
-const defaultFieldsConfig: ReportField[] = [
-  {
-    label: t('issueReport.systemStats'),
-    value: 'SystemStats',
-    getData: () => api.getSystemStats(),
-    optIn: true
-  },
-  {
-    label: t('g.workflow'),
-    value: 'Workflow',
-    getData: () => cloneDeep(app.graph.asSerialisable()),
-    optIn: true
-  },
-  {
-    label: t('g.logs'),
-    value: 'Logs',
-    getData: () => api.getLogs(),
-    optIn: true
-  },
-  {
-    label: t('g.settings'),
-    value: 'Settings',
-    getData: () => api.getSettings(),
-    optIn: true
-  }
-]
-
-const fields = computed(() => [
-  ...defaultFieldsConfig.filter(({ value }) =>
-    defaultFields.includes(value as DefaultField)
-  ),
-  ...(props.extraFields ?? [])
-])
-
-const createUser = (formData: IssueReportFormData): User => ({
-  email: formData.contactInfo || undefined
-})
-
-const createExtraData = async (formData: IssueReportFormData) => {
-  const result: Record<string, unknown> = {}
-  const isChecked = (fieldValue: string) => formData[fieldValue]
-
-  await Promise.all(
-    fields.value
-      .filter((field) => !field.optIn || isChecked(field.value))
-      .map(async (field) => {
-        try {
-          result[field.value] = await field.getData()
-        } catch (error) {
-          console.error(`Failed to collect ${field.value}:`, error)
-          result[field.value] = { error: String(error) }
-        }
-      })
-  )
-
-  return result
-}
-
-const createCaptureContext = async (
-  formData: IssueReportFormData
-): Promise<CaptureContext> => {
-  return {
-    user: createUser(formData),
-    level: 'error',
-    tags: {
-      errorType: props.errorType,
-      helpType: formData.helpType,
-      followUp: formData.contactInfo ? formData.followUp : false,
-      notifyOnResolution: formData.contactInfo
-        ? formData.notifyOnResolution
-        : false,
-      isElectron: isElectron(),
-      ..._.mapValues(props.tags, (tag) => _.trim(tag).replace(/[\n\r\t]/g, ' '))
-    },
-    extra: {
-      details: formData.details,
-      ...(await createExtraData(formData))
-    }
-  }
-}
-
-const generateUniqueTicketId = (type: string) => `${type}-${generateUUID()}`
-
-const submit = async (event: FormSubmitEvent) => {
-  if (event.valid) {
-    try {
-      const captureContext = await createCaptureContext(event.values)
-
-      // If it's billing or access issue, generate unique id to be used by customer service ticketing
-      const isValidContactInfo = event.values.contactInfo?.length
-      const isCustomerServiceIssue =
-        isValidContactInfo &&
-        ['billingPayments', 'loginAccessIssues'].includes(
-          event.values.helpType || ''
-        )
-      const issueName = isCustomerServiceIssue
-        ? `ticket-${generateUniqueTicketId(event.values.helpType || '')}`
-        : DEFAULT_ISSUE_NAME
-      captureMessage(issueName, captureContext)
-      submitted.value = true
-      toast.add({
-        severity: 'success',
-        summary: t('g.reportSent'),
-        life: 3000
-      })
-    } catch (error) {
-      toast.add({
-        severity: 'error',
-        summary: t('g.error'),
-        detail: error instanceof Error ? error.message : String(error),
-        life: 3000
-      })
-    }
-  }
-}
-</script>

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

@@ -112,12 +112,12 @@ import Divider from 'primevue/divider'
 import Skeleton from 'primevue/skeleton'
 import TabPanel from 'primevue/tabpanel'
 import { computed, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
 
 import UserCredit from '@/components/common/UserCredit.vue'
 import UsageLogsTable from '@/components/dialog/content/setting/UsageLogsTable.vue'
 import { useFirebaseAuthActions } from '@/composables/auth/useFirebaseAuthActions'
 import { useDialogService } from '@/services/dialogService'
+import { useCommandStore } from '@/stores/commandStore'
 import { useFirebaseAuthStore } from '@/stores/firebaseAuthStore'
 import { formatMetronomeCurrency } from '@/utils/formatUtil'
 
@@ -128,10 +128,10 @@ interface CreditHistoryItemData {
   isPositive: boolean
 }
 
-const { t } = useI18n()
 const dialogService = useDialogService()
 const authStore = useFirebaseAuthStore()
 const authActions = useFirebaseAuthActions()
+const commandStore = useCommandStore()
 const loading = computed(() => authStore.loading)
 const balanceLoading = computed(() => authStore.isFetchingBalance)
 
@@ -160,15 +160,8 @@ const handleCreditsHistoryClick = async () => {
   await authActions.accessBillingPortal()
 }
 
-const handleMessageSupport = () => {
-  dialogService.showIssueReportDialog({
-    title: t('issueReport.contactSupportTitle'),
-    subtitle: t('issueReport.contactSupportDescription'),
-    panelProps: {
-      errorType: 'BillingSupport',
-      defaultFields: ['Workflow', 'Logs', 'SystemStats', 'Settings']
-    }
-  })
+const handleMessageSupport = async () => {
+  await commandStore.execute('Comfy.ContactSupport')
 }
 
 const handleFaqClick = () => {

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

@@ -57,14 +57,23 @@
           class="w-8 h-8 mt-4"
           style="--pc-spinner-color: #000"
         />
-        <Button
-          v-else
-          class="mt-4 w-32"
-          severity="secondary"
-          :label="$t('auth.signOut.signOut')"
-          icon="pi pi-sign-out"
-          @click="handleSignOut"
-        />
+        <div v-else class="mt-4 flex flex-col gap-2">
+          <Button
+            class="w-32"
+            severity="secondary"
+            :label="$t('auth.signOut.signOut')"
+            icon="pi pi-sign-out"
+            @click="handleSignOut"
+          />
+          <Button
+            v-if="!isApiKeyLogin"
+            class="w-32"
+            severity="danger"
+            :label="$t('auth.deleteAccount.deleteAccount')"
+            icon="pi pi-trash"
+            @click="handleDeleteAccount"
+          />
+        </div>
       </div>
 
       <!-- Login Section -->
@@ -100,6 +109,7 @@ const dialogService = useDialogService()
 const {
   loading,
   isLoggedIn,
+  isApiKeyLogin,
   isEmailProvider,
   userDisplayName,
   userEmail,
@@ -107,6 +117,7 @@ const {
   providerName,
   providerIcon,
   handleSignOut,
-  handleSignIn
+  handleSignIn,
+  handleDeleteAccount
 } = useCurrentUser()
 </script>

src/components/graph/GraphCanvas.vue

@@ -31,55 +31,6 @@
     class="w-full h-full touch-none"
   />
 
-  <!-- TransformPane for Vue node rendering (development) -->
-  <TransformPane
-    v-if="transformPaneEnabled && canvasStore.canvas && comfyAppReady"
-    :canvas="canvasStore.canvas as LGraphCanvas"
-    :viewport="canvasViewport"
-    :show-debug-overlay="showPerformanceOverlay"
-    @raf-status-change="rafActive = $event"
-    @transform-update="handleTransformUpdate"
-  >
-    <!-- Vue nodes rendered based on graph nodes -->
-    <VueGraphNode
-      v-for="nodeData in nodesToRender"
-      :key="nodeData.id"
-      :node-data="nodeData"
-      :position="nodePositions.get(nodeData.id)"
-      :size="nodeSizes.get(nodeData.id)"
-      :selected="nodeData.selected"
-      :readonly="false"
-      :executing="executionStore.executingNodeId === nodeData.id"
-      :error="
-        executionStore.lastExecutionError?.node_id === nodeData.id
-          ? 'Execution error'
-          : null
-      "
-      :zoom-level="canvasStore.canvas?.ds?.scale || 1"
-      :data-node-id="nodeData.id"
-      @node-click="handleNodeSelect"
-      @update:collapsed="handleNodeCollapse"
-      @update:title="handleNodeTitleUpdate"
-    />
-  </TransformPane>
-
-  <!-- Debug Panel (Development Only) -->
-  <VueNodeDebugPanel
-    v-if="debugPanelVisible"
-    v-model:debug-override-vue-nodes="debugOverrideVueNodes"
-    v-model:show-performance-overlay="showPerformanceOverlay"
-    :canvas-viewport="canvasViewport"
-    :vue-nodes-count="vueNodesCount"
-    :nodes-in-viewport="nodesInViewport"
-    :performance-metrics="performanceMetrics"
-    :current-f-p-s="currentFPS"
-    :last-transform-time="lastTransformTime"
-    :raf-active="rafActive"
-    :is-dev-mode-enabled="isDevModeEnabled"
-    :should-render-vue-nodes="shouldRenderVueNodes"
-    :transform-pane-enabled="transformPaneEnabled"
-  />
-
   <NodeTooltip v-if="tooltipEnabled" />
   <NodeSearchboxPopover ref="nodeSearchboxPopoverRef" />
 
@@ -88,23 +39,13 @@
   <template v-if="comfyAppReady">
     <TitleEditor />
     <SelectionToolbox v-if="selectionToolboxEnabled" />
-    <!-- Render legacy DOM widgets only when Vue nodes are disabled -->
-    <DomWidgets v-if="!shouldRenderVueNodes" />
+    <DomWidgets />
   </template>
 </template>
 
 <script setup lang="ts">
 import { useEventListener, whenever } from '@vueuse/core'
-import {
-  computed,
-  onMounted,
-  onUnmounted,
-  reactive,
-  ref,
-  shallowRef,
-  watch,
-  watchEffect
-} from 'vue'
+import { computed, onMounted, ref, shallowRef, watch, watchEffect } from 'vue'
 
 import LiteGraphCanvasSplitterOverlay from '@/components/LiteGraphCanvasSplitterOverlay.vue'
 import BottomPanel from '@/components/bottomPanel/BottomPanel.vue'
@@ -114,23 +55,14 @@ import MiniMap from '@/components/graph/MiniMap.vue'
 import NodeTooltip from '@/components/graph/NodeTooltip.vue'
 import SelectionToolbox from '@/components/graph/SelectionToolbox.vue'
 import TitleEditor from '@/components/graph/TitleEditor.vue'
-import TransformPane from '@/components/graph/TransformPane.vue'
-import VueNodeDebugPanel from '@/components/graph/debug/VueNodeDebugPanel.vue'
 import NodeSearchboxPopover from '@/components/searchbox/NodeSearchBoxPopover.vue'
 import SideToolbar from '@/components/sidebar/SideToolbar.vue'
 import SecondRowWorkflowTabs from '@/components/topbar/SecondRowWorkflowTabs.vue'
-import { useTransformState } from '@/composables/element/useTransformState'
 import { useChainCallback } from '@/composables/functional/useChainCallback'
-import { useGraphNodeManager } from '@/composables/graph/useGraphNodeManager'
-import type {
-  NodeState,
-  VueNodeData
-} from '@/composables/graph/useGraphNodeManager'
 import { useNodeBadge } from '@/composables/node/useNodeBadge'
 import { useCanvasDrop } from '@/composables/useCanvasDrop'
 import { useContextMenuTranslation } from '@/composables/useContextMenuTranslation'
 import { useCopy } from '@/composables/useCopy'
-import { useFeatureFlags } from '@/composables/useFeatureFlags'
 import { useGlobalLitegraph } from '@/composables/useGlobalLitegraph'
 import { useLitegraphSettings } from '@/composables/useLitegraphSettings'
 import { usePaste } from '@/composables/usePaste'
@@ -138,14 +70,7 @@ import { useWorkflowAutoSave } from '@/composables/useWorkflowAutoSave'
 import { useWorkflowPersistence } from '@/composables/useWorkflowPersistence'
 import { CORE_SETTINGS } from '@/constants/coreSettings'
 import { i18n, t } from '@/i18n'
-import type { LGraphCanvas, LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { layoutStore } from '@/renderer/core/layout/store/LayoutStore'
-import { useLayout } from '@/renderer/core/layout/sync/useLayout'
-import { useLayoutSync } from '@/renderer/core/layout/sync/useLayoutSync'
-import { useLinkLayoutSync } from '@/renderer/core/layout/sync/useLinkLayoutSync'
-import { useSlotLayoutSync } from '@/renderer/core/layout/sync/useSlotLayoutSync'
-import { LayoutSource } from '@/renderer/core/layout/types'
-import VueGraphNode from '@/renderer/extensions/vueNodes/components/LGraphNode.vue'
+import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { UnauthorizedError, api } from '@/scripts/api'
 import { app as comfyApp } from '@/scripts/app'
 import { ChangeTracker } from '@/scripts/changeTracker'
@@ -177,7 +102,6 @@ const workspaceStore = useWorkspaceStore()
 const canvasStore = useCanvasStore()
 const executionStore = useExecutionStore()
 const toastStore = useToastStore()
-const { mutations: layoutMutations } = useLayout()
 const betaMenuEnabled = computed(
   () => settingStore.get('Comfy.UseNewMenu') !== 'Disabled'
 )
@@ -194,405 +118,6 @@ const selectionToolboxEnabled = computed(() =>
 
 const minimapEnabled = computed(() => settingStore.get('Comfy.Minimap.Visible'))
 
-// Feature flags
-const { shouldRenderVueNodes, isDevModeEnabled } = useFeatureFlags()
-
-// TransformPane enabled when Vue nodes are enabled OR debug override
-const debugOverrideVueNodes = ref(false)
-// Persist debug panel visibility in settings so core commands can toggle it
-const debugPanelVisible = computed({
-  get: () => settingStore.get('Comfy.VueNodes.DebugPanel.Visible') ?? false,
-  set: (v: boolean) => {
-    void settingStore.set('Comfy.VueNodes.DebugPanel.Visible', v)
-  }
-})
-const transformPaneEnabled = computed(
-  () => shouldRenderVueNodes.value || debugOverrideVueNodes.value
-)
-// Account for browser zoom/DPI scaling
-const getActualViewport = () => {
-  // Get the actual canvas element dimensions which account for zoom
-  const canvas = canvasRef.value
-  if (canvas) {
-    return {
-      width: canvas.clientWidth,
-      height: canvas.clientHeight
-    }
-  }
-  // Fallback to window dimensions
-  return {
-    width: window.innerWidth,
-    height: window.innerHeight
-  }
-}
-
-const canvasViewport = ref(getActualViewport())
-
-// Debug metrics - use shallowRef for frequently updating values
-const vueNodesCount = shallowRef(0)
-const nodesInViewport = shallowRef(0)
-const currentFPS = shallowRef(0)
-const lastTransformTime = shallowRef(0)
-const rafActive = shallowRef(false)
-
-// Rendering options
-const showPerformanceOverlay = ref(false)
-
-// FPS tracking
-let lastTime = performance.now()
-let frameCount = 0
-let fpsRafId: number | null = null
-
-const updateFPS = () => {
-  frameCount++
-  const currentTime = performance.now()
-  if (currentTime >= lastTime + 1000) {
-    currentFPS.value = Math.round(
-      (frameCount * 1000) / (currentTime - lastTime)
-    )
-    frameCount = 0
-    lastTime = currentTime
-  }
-  if (transformPaneEnabled.value) {
-    fpsRafId = requestAnimationFrame(updateFPS)
-  }
-}
-
-// Start FPS tracking when TransformPane is enabled
-watch(transformPaneEnabled, (enabled) => {
-  if (enabled) {
-    fpsRafId = requestAnimationFrame(updateFPS)
-  } else {
-    // Stop FPS tracking
-    if (fpsRafId !== null) {
-      cancelAnimationFrame(fpsRafId)
-      fpsRafId = null
-    }
-  }
-})
-
-// Update viewport on resize
-useEventListener(window, 'resize', () => {
-  canvasViewport.value = getActualViewport()
-})
-
-// Also update when canvas is ready
-watch(canvasRef, () => {
-  if (canvasRef.value) {
-    canvasViewport.value = getActualViewport()
-  }
-})
-
-// Vue node lifecycle management - initialize after graph is ready
-let nodeManager: ReturnType<typeof useGraphNodeManager> | null = null
-let cleanupNodeManager: (() => void) | null = null
-
-// Slot layout sync management
-let slotSync: ReturnType<typeof useSlotLayoutSync> | null = null
-let linkSync: ReturnType<typeof useLinkLayoutSync> | null = null
-const vueNodeData = ref<ReadonlyMap<string, VueNodeData>>(new Map())
-const nodeState = ref<ReadonlyMap<string, NodeState>>(new Map())
-const nodePositions = ref<ReadonlyMap<string, { x: number; y: number }>>(
-  new Map()
-)
-const nodeSizes = ref<ReadonlyMap<string, { width: number; height: number }>>(
-  new Map()
-)
-let detectChangesInRAF = () => {}
-const performanceMetrics = reactive({
-  frameTime: 0,
-  updateTime: 0,
-  nodeCount: 0,
-  culledCount: 0,
-  adaptiveQuality: false
-})
-
-// Initialize node manager when graph becomes available
-// Add a reactivity trigger to force computed re-evaluation
-const nodeDataTrigger = ref(0)
-
-const initializeNodeManager = () => {
-  if (!comfyApp.graph || nodeManager) return
-  nodeManager = useGraphNodeManager(comfyApp.graph)
-  cleanupNodeManager = nodeManager.cleanup
-  // Use the manager's reactive maps directly
-  vueNodeData.value = nodeManager.vueNodeData
-  nodeState.value = nodeManager.nodeState
-  nodePositions.value = nodeManager.nodePositions
-  nodeSizes.value = nodeManager.nodeSizes
-  detectChangesInRAF = nodeManager.detectChangesInRAF
-  Object.assign(performanceMetrics, nodeManager.performanceMetrics)
-
-  // Initialize layout system with existing nodes
-  const nodes = comfyApp.graph._nodes.map((node: any) => ({
-    id: node.id.toString(),
-    pos: node.pos,
-    size: node.size
-  }))
-  layoutStore.initializeFromLiteGraph(nodes)
-
-  // Seed reroutes into the Layout Store so hit-testing uses the new path
-  for (const reroute of comfyApp.graph.reroutes.values()) {
-    const [x, y] = reroute.pos
-    const parent = reroute.parentId ?? undefined
-    const linkIds = Array.from(reroute.linkIds)
-    layoutMutations.createReroute(reroute.id, { x, y }, parent, linkIds)
-  }
-
-  // Seed existing links into the Layout Store (topology only)
-  for (const link of comfyApp.graph._links.values()) {
-    layoutMutations.createLink(
-      link.id,
-      link.origin_id,
-      link.origin_slot,
-      link.target_id,
-      link.target_slot
-    )
-  }
-
-  // Initialize layout sync (one-way: Layout Store → LiteGraph)
-  const { startSync } = useLayoutSync()
-  startSync(canvasStore.canvas)
-
-  // Initialize slot layout sync for hit detection
-  slotSync = useSlotLayoutSync()
-  if (canvasStore.canvas) {
-    slotSync.start(canvasStore.canvas as LGraphCanvas)
-  }
-
-  // Initialize link layout sync for event-driven updates
-  linkSync = useLinkLayoutSync()
-  if (canvasStore.canvas) {
-    linkSync.start(canvasStore.canvas as LGraphCanvas)
-  }
-
-  // Force computed properties to re-evaluate
-  nodeDataTrigger.value++
-}
-
-const disposeNodeManagerAndSyncs = () => {
-  if (!nodeManager) return
-  try {
-    cleanupNodeManager?.()
-  } catch {
-    /* empty */
-  }
-  nodeManager = null
-  cleanupNodeManager = null
-
-  // Clean up slot layout sync
-  if (slotSync) {
-    slotSync.stop()
-    slotSync = null
-  }
-
-  // Clean up link layout sync
-  if (linkSync) {
-    linkSync.stop()
-    linkSync = null
-  }
-
-  // Reset reactive maps to inert defaults
-  vueNodeData.value = new Map()
-  nodeState.value = new Map()
-  nodePositions.value = new Map()
-  nodeSizes.value = new Map()
-  // Reset metrics
-  performanceMetrics.frameTime = 0
-  performanceMetrics.updateTime = 0
-  performanceMetrics.nodeCount = 0
-  performanceMetrics.culledCount = 0
-}
-
-// Watch for transformPaneEnabled to gate the node manager lifecycle
-watch(
-  () => transformPaneEnabled.value && Boolean(comfyApp.graph),
-  (enabled) => {
-    if (enabled) {
-      initializeNodeManager()
-    } else {
-      disposeNodeManagerAndSyncs()
-    }
-  },
-  { immediate: true }
-)
-
-// Transform state for viewport culling
-const { syncWithCanvas } = useTransformState()
-
-// Replace problematic computed property with proper reactive system
-const nodesToRender = computed(() => {
-  // Access performanceMetrics to trigger on RAF updates
-  void performanceMetrics.updateTime
-  // Access trigger to force re-evaluation after nodeManager initialization
-  void nodeDataTrigger.value
-
-  if (!comfyApp.graph || !transformPaneEnabled.value) {
-    return []
-  }
-
-  const allNodes = Array.from(vueNodeData.value.values())
-
-  // Apply viewport culling - check if node bounds intersect with viewport
-  if (nodeManager && canvasStore.canvas && comfyApp.canvas) {
-    const canvas = canvasStore.canvas
-    const manager = nodeManager
-
-    // Ensure transform is synced before checking visibility
-    syncWithCanvas(comfyApp.canvas)
-
-    const ds = canvas.ds
-
-    // Access transform time to make this reactive to transform changes
-    void lastTransformTime.value
-
-    // Work in screen space - viewport is simply the canvas element size
-    const viewport_width = canvas.canvas.width
-    const viewport_height = canvas.canvas.height
-
-    // Add margin that represents a constant distance in canvas space
-    // Convert canvas units to screen pixels by multiplying by scale
-    const canvasMarginDistance = 200 // Fixed margin in canvas units
-    const margin_x = canvasMarginDistance * ds.scale
-    const margin_y = canvasMarginDistance * ds.scale
-
-    const filtered = allNodes.filter((nodeData) => {
-      const node = manager.getNode(nodeData.id)
-      if (!node) return false
-
-      // Transform node position to screen space (same as DOM widgets)
-      const screen_x = (node.pos[0] + ds.offset[0]) * ds.scale
-      const screen_y = (node.pos[1] + ds.offset[1]) * ds.scale
-      const screen_width = node.size[0] * ds.scale
-      const screen_height = node.size[1] * ds.scale
-
-      // Check if node bounds intersect with expanded viewport (in screen space)
-      const isVisible = !(
-        screen_x + screen_width < -margin_x ||
-        screen_x > viewport_width + margin_x ||
-        screen_y + screen_height < -margin_y ||
-        screen_y > viewport_height + margin_y
-      )
-
-      return isVisible
-    })
-
-    return filtered
-  }
-
-  return allNodes
-})
-
-// Remove side effects from computed - use watchers instead
-watch(
-  () => vueNodeData.value.size,
-  (count) => {
-    vueNodesCount.value = count
-  },
-  { immediate: true }
-)
-
-watch(
-  () => nodesToRender.value.length,
-  (count) => {
-    nodesInViewport.value = count
-  }
-)
-
-// Update performance metrics when node counts change
-watch(
-  () => [vueNodeData.value.size, nodesToRender.value.length],
-  ([totalNodes, visibleNodes]) => {
-    performanceMetrics.nodeCount = totalNodes
-    performanceMetrics.culledCount = totalNodes - visibleNodes
-  }
-)
-
-// Integrate change detection with TransformPane RAF
-// Track previous transform to detect changes
-let lastScale = 1
-let lastOffsetX = 0
-let lastOffsetY = 0
-
-const handleTransformUpdate = (time: number) => {
-  lastTransformTime.value = time
-
-  // Sync transform state only when it changes (avoids reflows)
-  if (comfyApp.canvas?.ds) {
-    const currentScale = comfyApp.canvas.ds.scale
-    const currentOffsetX = comfyApp.canvas.ds.offset[0]
-    const currentOffsetY = comfyApp.canvas.ds.offset[1]
-
-    if (
-      currentScale !== lastScale ||
-      currentOffsetX !== lastOffsetX ||
-      currentOffsetY !== lastOffsetY
-    ) {
-      syncWithCanvas(comfyApp.canvas)
-      lastScale = currentScale
-      lastOffsetX = currentOffsetX
-      lastOffsetY = currentOffsetY
-    }
-  }
-
-  // Detect node changes during transform updates
-  detectChangesInRAF()
-
-  // Update performance metrics
-  performanceMetrics.frameTime = time
-
-  void nodesToRender.value.length
-}
-
-// Node event handlers
-const handleNodeSelect = (event: PointerEvent, nodeData: VueNodeData) => {
-  if (!canvasStore.canvas || !nodeManager) return
-
-  const node = nodeManager.getNode(nodeData.id)
-  if (!node) return
-
-  if (!event.ctrlKey && !event.metaKey) {
-    canvasStore.canvas.deselectAllNodes()
-  }
-
-  canvasStore.canvas.selectNode(node)
-
-  // Bring node to front when clicked (similar to LiteGraph behavior)
-  // Skip if node is pinned
-  if (!node.flags?.pinned) {
-    layoutMutations.setSource(LayoutSource.Vue)
-    layoutMutations.bringNodeToFront(nodeData.id)
-  }
-  node.selected = true
-
-  canvasStore.updateSelectedItems()
-}
-
-// Handle node collapse state changes
-const handleNodeCollapse = (nodeId: string, collapsed: boolean) => {
-  if (!nodeManager) return
-
-  const node = nodeManager.getNode(nodeId)
-  if (!node) return
-
-  // Use LiteGraph's collapse method if the state needs to change
-  const currentCollapsed = node.flags?.collapsed ?? false
-  if (currentCollapsed !== collapsed) {
-    node.collapse()
-  }
-}
-
-// Handle node title updates
-const handleNodeTitleUpdate = (nodeId: string, newTitle: string) => {
-  if (!nodeManager) return
-
-  const node = nodeManager.getNode(nodeId)
-  if (!node) return
-
-  // Update the node title in LiteGraph for persistence
-  node.title = newTitle
-}
-
 watchEffect(() => {
   nodeDefStore.showDeprecated = settingStore.get('Comfy.Node.ShowDeprecated')
 })
@@ -744,7 +269,7 @@ const loadCustomNodesI18n = async () => {
       i18n.global.mergeLocaleMessage(locale, message)
     })
   } catch (error) {
-    // Ignore i18n loading errors - not critical
+    console.error('Failed to load custom nodes i18n', error)
   }
 }
 
@@ -761,7 +286,6 @@ onMounted(async () => {
   useCopy()
   usePaste()
   useWorkflowAutoSave()
-  useFeatureFlags() // This will automatically sync Vue nodes flag with LiteGraph
 
   comfyApp.vueAppReady = true
 
@@ -774,6 +298,9 @@ onMounted(async () => {
     await settingStore.loadSettingValues()
   } catch (error) {
     if (error instanceof UnauthorizedError) {
+      console.log(
+        'Failed loading user settings, user unauthorized, cleaning local Comfy.userId'
+      )
       localStorage.removeItem('Comfy.userId')
       localStorage.removeItem('Comfy.userName')
       window.location.reload()
@@ -799,32 +326,6 @@ onMounted(async () => {
 
   comfyAppReady.value = true
 
-  // Set up a one-time listener for when the first node is added
-  // This handles the case where Vue nodes are enabled but the graph starts empty
-  // TODO: Replace this with a reactive graph mutations observer when available
-  if (
-    transformPaneEnabled.value &&
-    comfyApp.graph &&
-    !nodeManager &&
-    comfyApp.graph._nodes.length === 0
-  ) {
-    const originalOnNodeAdded = comfyApp.graph.onNodeAdded
-    comfyApp.graph.onNodeAdded = function (node: any) {
-      // Restore original handler
-      comfyApp.graph.onNodeAdded = originalOnNodeAdded
-
-      // Initialize node manager if needed
-      if (transformPaneEnabled.value && !nodeManager) {
-        initializeNodeManager()
-      }
-
-      // Call original handler
-      if (originalOnNodeAdded) {
-        originalOnNodeAdded.call(this, node)
-      }
-    }
-  }
-
   comfyApp.canvas.onSelectionChange = useChainCallback(
     comfyApp.canvas.onSelectionChange,
     () => canvasStore.updateSelectedItems()
@@ -865,30 +366,4 @@ onMounted(async () => {
 
   emit('ready')
 })
-
-onUnmounted(() => {
-  // Clean up FPS tracking
-  if (fpsRafId !== null) {
-    cancelAnimationFrame(fpsRafId)
-    fpsRafId = null
-  }
-
-  // Clean up node manager
-  if (nodeManager) {
-    nodeManager.cleanup()
-    nodeManager = null
-  }
-
-  // Clean up slot layout sync
-  if (slotSync) {
-    slotSync.stop()
-    slotSync = null
-  }
-
-  // Clean up link layout sync
-  if (linkSync) {
-    linkSync.stop()
-    linkSync = null
-  }
-})
 </script>

src/components/graph/TransformPane.spec.ts

@@ -1,438 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { nextTick, ref } from 'vue'
-
-import TransformPane from './TransformPane.vue'
-
-// Mock the transform state composable
-const mockTransformState = {
-  camera: ref({ x: 0, y: 0, z: 1 }),
-  transformStyle: ref({
-    transform: 'scale(1) translate(0px, 0px)',
-    transformOrigin: '0 0'
-  }),
-  syncWithCanvas: vi.fn(),
-  canvasToScreen: vi.fn(),
-  screenToCanvas: vi.fn(),
-  isNodeInViewport: vi.fn()
-}
-
-vi.mock('@/composables/element/useTransformState', () => ({
-  useTransformState: () => mockTransformState
-}))
-
-// Mock requestAnimationFrame/cancelAnimationFrame
-global.requestAnimationFrame = vi.fn((cb) => {
-  setTimeout(cb, 16)
-  return 1
-})
-global.cancelAnimationFrame = vi.fn()
-
-describe('TransformPane', () => {
-  let wrapper: ReturnType<typeof mount>
-  let mockCanvas: any
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-
-    // Create mock canvas with LiteGraph interface
-    mockCanvas = {
-      canvas: {
-        addEventListener: vi.fn(),
-        removeEventListener: vi.fn()
-      },
-      ds: {
-        offset: [0, 0],
-        scale: 1
-      }
-    }
-
-    // Reset mock transform state
-    mockTransformState.camera.value = { x: 0, y: 0, z: 1 }
-    mockTransformState.transformStyle.value = {
-      transform: 'scale(1) translate(0px, 0px)',
-      transformOrigin: '0 0'
-    }
-  })
-
-  afterEach(() => {
-    if (wrapper) {
-      wrapper.unmount()
-    }
-  })
-
-  describe('component mounting', () => {
-    it('should mount successfully with minimal props', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      expect(wrapper.exists()).toBe(true)
-      expect(wrapper.find('.transform-pane').exists()).toBe(true)
-    })
-
-    it('should apply transform style from composable', () => {
-      mockTransformState.transformStyle.value = {
-        transform: 'scale(2) translate(100px, 50px)',
-        transformOrigin: '0 0'
-      }
-
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      const transformPane = wrapper.find('.transform-pane')
-      const style = transformPane.attributes('style')
-      expect(style).toContain('transform: scale(2) translate(100px, 50px)')
-    })
-
-    it('should render slot content', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        },
-        slots: {
-          default: '<div class="test-content">Test Node</div>'
-        }
-      })
-
-      expect(wrapper.find('.test-content').exists()).toBe(true)
-      expect(wrapper.find('.test-content').text()).toBe('Test Node')
-    })
-  })
-
-  describe('debug overlay', () => {
-    it('should not show debug overlay by default', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      expect(wrapper.find('.viewport-debug-overlay').exists()).toBe(false)
-    })
-
-    it('should show debug overlay when enabled', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas,
-          viewport: { width: 1920, height: 1080 },
-          showDebugOverlay: true
-        }
-      })
-
-      expect(wrapper.find('.viewport-debug-overlay').exists()).toBe(true)
-    })
-
-    it('should display viewport dimensions in debug overlay', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas,
-          viewport: { width: 1280, height: 720 },
-          showDebugOverlay: true
-        }
-      })
-
-      const debugOverlay = wrapper.find('.viewport-debug-overlay')
-      expect(debugOverlay.text()).toContain('Viewport: 1280x720')
-    })
-
-    it('should include device pixel ratio in debug overlay', () => {
-      // Mock device pixel ratio
-      Object.defineProperty(window, 'devicePixelRatio', {
-        writable: true,
-        value: 2
-      })
-
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas,
-          viewport: { width: 1920, height: 1080 },
-          showDebugOverlay: true
-        }
-      })
-
-      const debugOverlay = wrapper.find('.viewport-debug-overlay')
-      expect(debugOverlay.text()).toContain('DPR: 2')
-    })
-  })
-
-  describe('RAF synchronization', () => {
-    it('should start RAF sync on mount', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-
-      // Should emit RAF status change to true
-      expect(wrapper.emitted('rafStatusChange')).toBeTruthy()
-      expect(wrapper.emitted('rafStatusChange')?.[0]).toEqual([true])
-    })
-
-    it('should call syncWithCanvas during RAF updates', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-
-      // Allow RAF to execute
-      await new Promise((resolve) => setTimeout(resolve, 20))
-
-      expect(mockTransformState.syncWithCanvas).toHaveBeenCalledWith(mockCanvas)
-    })
-
-    it('should emit transform update timing', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-
-      // Allow RAF to execute
-      await new Promise((resolve) => setTimeout(resolve, 20))
-
-      expect(wrapper.emitted('transformUpdate')).toBeTruthy()
-      const updateEvent = wrapper.emitted('transformUpdate')?.[0]
-      expect(typeof updateEvent?.[0]).toBe('number')
-      expect(updateEvent?.[0]).toBeGreaterThanOrEqual(0)
-    })
-
-    it('should stop RAF sync on unmount', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-      wrapper.unmount()
-
-      expect(wrapper.emitted('rafStatusChange')).toBeTruthy()
-      const events = wrapper.emitted('rafStatusChange') as any[]
-      expect(events[events.length - 1]).toEqual([false])
-      expect(global.cancelAnimationFrame).toHaveBeenCalled()
-    })
-  })
-
-  describe('canvas event listeners', () => {
-    it('should add event listeners to canvas on mount', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-
-      expect(mockCanvas.canvas.addEventListener).toHaveBeenCalledWith(
-        'wheel',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.addEventListener).toHaveBeenCalledWith(
-        'pointerdown',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.addEventListener).toHaveBeenCalledWith(
-        'pointerup',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.addEventListener).toHaveBeenCalledWith(
-        'pointercancel',
-        expect.any(Function),
-        expect.any(Object)
-      )
-    })
-
-    it('should remove event listeners on unmount', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      await nextTick()
-      wrapper.unmount()
-
-      expect(mockCanvas.canvas.removeEventListener).toHaveBeenCalledWith(
-        'wheel',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.removeEventListener).toHaveBeenCalledWith(
-        'pointerdown',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.removeEventListener).toHaveBeenCalledWith(
-        'pointerup',
-        expect.any(Function),
-        expect.any(Object)
-      )
-      expect(mockCanvas.canvas.removeEventListener).toHaveBeenCalledWith(
-        'pointercancel',
-        expect.any(Function),
-        expect.any(Object)
-      )
-    })
-  })
-
-  describe('interaction state management', () => {
-    it('should apply interacting class during interactions', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      // Simulate interaction start by checking internal state
-      // Note: This tests the CSS class application logic
-      const transformPane = wrapper.find('.transform-pane')
-
-      // Initially should not have interacting class
-      expect(transformPane.classes()).not.toContain(
-        'transform-pane--interacting'
-      )
-    })
-
-    it('should handle pointer events for node delegation', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      const transformPane = wrapper.find('.transform-pane')
-
-      // Simulate pointer down - we can't test the exact delegation logic
-      // in unit tests due to vue-test-utils limitations, but we can verify
-      // the event handler is set up correctly
-      await transformPane.trigger('pointerdown')
-
-      // The test passes if no errors are thrown during event handling
-      expect(transformPane.exists()).toBe(true)
-    })
-  })
-
-  describe('transform state integration', () => {
-    it('should provide transform utilities to child components', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      // The component should provide transform state via Vue's provide/inject
-      // This is tested indirectly through the composable integration
-      expect(mockTransformState.syncWithCanvas).toBeDefined()
-      expect(mockTransformState.canvasToScreen).toBeDefined()
-      expect(mockTransformState.screenToCanvas).toBeDefined()
-    })
-  })
-
-  describe('error handling', () => {
-    it('should handle null canvas gracefully', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: undefined
-        }
-      })
-
-      expect(wrapper.exists()).toBe(true)
-      expect(wrapper.find('.transform-pane').exists()).toBe(true)
-    })
-
-    it('should handle missing canvas properties', () => {
-      const incompleteCanvas = {} as any
-
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: incompleteCanvas
-        }
-      })
-
-      expect(wrapper.exists()).toBe(true)
-      // Should not throw errors during mount
-    })
-  })
-
-  describe('performance optimizations', () => {
-    it('should use contain CSS property for layout optimization', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        }
-      })
-
-      const transformPane = wrapper.find('.transform-pane')
-
-      // This test verifies the CSS contains the performance optimization
-      // Note: In JSDOM, computed styles might not reflect all CSS properties
-      expect(transformPane.element.className).toContain('transform-pane')
-    })
-
-    it('should disable pointer events on container but allow on children', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas
-        },
-        slots: {
-          default: '<div data-node-id="test">Test Node</div>'
-        }
-      })
-
-      const transformPane = wrapper.find('.transform-pane')
-
-      // The CSS should handle pointer events optimization
-      // This is primarily a CSS concern, but we verify the structure
-      expect(transformPane.exists()).toBe(true)
-      expect(wrapper.find('[data-node-id="test"]').exists()).toBe(true)
-    })
-  })
-
-  describe('viewport prop handling', () => {
-    it('should handle missing viewport prop', () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas,
-          showDebugOverlay: true
-        }
-      })
-
-      // Should not crash when viewport is undefined
-      expect(wrapper.exists()).toBe(true)
-    })
-
-    it('should update debug overlay when viewport changes', async () => {
-      wrapper = mount(TransformPane, {
-        props: {
-          canvas: mockCanvas,
-          viewport: { width: 800, height: 600 },
-          showDebugOverlay: true
-        }
-      })
-
-      expect(wrapper.text()).toContain('800x600')
-
-      await wrapper.setProps({
-        viewport: { width: 1920, height: 1080 }
-      })
-
-      expect(wrapper.text()).toContain('1920x1080')
-    })
-  })
-})

src/components/graph/TransformPane.vue

@@ -1,137 +0,0 @@
-<!-- eslint-disable @intlify/vue-i18n/no-raw-text -->
-<template>
-  <div
-    class="transform-pane"
-    :class="{ 'transform-pane--interacting': isInteracting }"
-    :style="transformStyle"
-    @pointerdown="handlePointerDown"
-  >
-    <!-- Vue nodes will be rendered here -->
-    <slot />
-
-    <!-- DEV ONLY: Viewport bounds visualization -->
-    <div
-      v-if="props.showDebugOverlay"
-      class="viewport-debug-overlay"
-      :style="{
-        position: 'absolute',
-        left: '10px',
-        top: '10px',
-        border: '2px solid red',
-        width: (props.viewport?.width || 0) - 20 + 'px',
-        height: (props.viewport?.height || 0) - 20 + 'px',
-        pointerEvents: 'none',
-        opacity: 0.5
-      }"
-    >
-      <div
-        style="
-          position: absolute;
-          top: 0;
-          left: 0;
-          background: red;
-          color: white;
-          padding: 2px 5px;
-          font-size: 10px;
-        "
-      >
-        Viewport: {{ props.viewport?.width }}x{{ props.viewport?.height }} DPR:
-        {{ devicePixelRatio }}
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed, provide } from 'vue'
-
-import { useTransformState } from '@/composables/element/useTransformState'
-import { useCanvasTransformSync } from '@/composables/graph/useCanvasTransformSync'
-import { useTransformSettling } from '@/composables/graph/useTransformSettling'
-import { LGraphCanvas } from '@/lib/litegraph/src/litegraph'
-
-interface TransformPaneProps {
-  canvas?: LGraphCanvas
-  viewport?: { width: number; height: number }
-  showDebugOverlay?: boolean
-}
-
-const props = defineProps<TransformPaneProps>()
-
-// Get device pixel ratio for display
-const devicePixelRatio = window.devicePixelRatio || 1
-
-// Transform state management
-const {
-  camera,
-  transformStyle,
-  syncWithCanvas,
-  canvasToScreen,
-  screenToCanvas,
-  isNodeInViewport
-} = useTransformState()
-
-// Transform settling detection for re-rasterization optimization
-const canvasElement = computed(() => props.canvas?.canvas)
-const { isTransforming } = useTransformSettling(canvasElement, {
-  settleDelay: 200,
-  trackPan: true
-})
-
-// Use isTransforming for the CSS class (aliased for clarity)
-const isInteracting = isTransforming
-
-// Provide transform utilities to child components
-provide('transformState', {
-  camera,
-  canvasToScreen,
-  screenToCanvas,
-  isNodeInViewport
-})
-
-// Event delegation for node interactions
-const handlePointerDown = (event: PointerEvent) => {
-  const target = event.target as HTMLElement
-  const nodeElement = target.closest('[data-node-id]')
-
-  if (nodeElement) {
-    // TODO: Emit event for node interaction
-    // Node interaction with nodeId will be handled in future implementation
-  }
-}
-
-// Canvas transform synchronization
-const emit = defineEmits<{
-  rafStatusChange: [active: boolean]
-  transformUpdate: [time: number]
-}>()
-
-useCanvasTransformSync(props.canvas, syncWithCanvas, {
-  onStart: () => emit('rafStatusChange', true),
-  onUpdate: (duration) => emit('transformUpdate', duration),
-  onStop: () => emit('rafStatusChange', false)
-})
-</script>
-
-<style scoped>
-.transform-pane {
-  position: absolute;
-  inset: 0;
-  contain: layout style paint;
-  transform-origin: 0 0;
-  pointer-events: none;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-}
-
-.transform-pane--interacting {
-  will-change: transform;
-}
-
-/* Allow pointer events on nodes */
-.transform-pane :deep([data-node-id]) {
-  pointer-events: auto;
-}
-</style>

src/components/graph/debug/VueNodeDebugPanel.vue

@@ -1,165 +0,0 @@
-<!-- eslint-disable @intlify/vue-i18n/no-raw-text -->
-<template>
-  <!-- TransformPane Debug Controls -->
-  <div
-    class="fixed top-20 right-4 bg-surface-0 dark-theme:bg-surface-800 p-4 rounded-lg shadow-lg border border-surface-300 dark-theme:border-surface-600 z-50 pointer-events-auto w-80"
-    style="contain: layout style"
-  >
-    <h3 class="font-bold mb-2 text-sm">TransformPane Debug</h3>
-    <div class="space-y-2 text-xs">
-      <div>
-        <label class="flex items-center gap-2">
-          <input v-model="debugOverrideVueNodes" type="checkbox" />
-          <span>Enable TransformPane</span>
-        </label>
-      </div>
-
-      <!-- Canvas Metrics -->
-      <div
-        class="pt-2 border-t border-surface-200 dark-theme:border-surface-700"
-      >
-        <h4 class="font-semibold mb-1">Canvas State</h4>
-        <p class="text-muted">
-          Status: {{ canvasStore.canvas ? 'Ready' : 'Not Ready' }}
-        </p>
-        <p class="text-muted">
-          Viewport: {{ Math.round(canvasViewport.width) }}x{{
-            Math.round(canvasViewport.height)
-          }}
-        </p>
-        <template v-if="canvasStore.canvas?.ds">
-          <p class="text-muted">
-            Offset: ({{ Math.round(canvasStore.canvas.ds.offset[0]) }},
-            {{ Math.round(canvasStore.canvas.ds.offset[1]) }})
-          </p>
-          <p class="text-muted">
-            Scale: {{ canvasStore.canvas.ds.scale?.toFixed(3) || 1 }}
-          </p>
-        </template>
-      </div>
-
-      <!-- Node Metrics -->
-      <div
-        class="pt-2 border-t border-surface-200 dark-theme:border-surface-700"
-      >
-        <h4 class="font-semibold mb-1">Graph Metrics</h4>
-        <p class="text-muted">
-          Total Nodes: {{ comfyApp.graph?.nodes?.length || 0 }}
-        </p>
-        <p class="text-muted">
-          Selected Nodes: {{ canvasStore.canvas?.selectedItems?.size || 0 }}
-        </p>
-        <p class="text-muted">Vue Nodes Rendered: {{ vueNodesCount }}</p>
-        <p class="text-muted">Nodes in Viewport: {{ nodesInViewport }}</p>
-        <p class="text-muted">
-          Culled Nodes: {{ performanceMetrics.culledCount }}
-        </p>
-        <p class="text-muted">
-          Cull Percentage:
-          {{
-            Math.round(
-              ((vueNodesCount - nodesInViewport) / Math.max(vueNodesCount, 1)) *
-                100
-            )
-          }}%
-        </p>
-      </div>
-
-      <!-- Performance Metrics -->
-      <div
-        class="pt-2 border-t border-surface-200 dark-theme:border-surface-700"
-      >
-        <h4 class="font-semibold mb-1">Performance</h4>
-        <p v-memo="[currentFPS]" class="text-muted">FPS: {{ currentFPS }}</p>
-        <p v-memo="[Math.round(lastTransformTime)]" class="text-muted">
-          Transform Update: {{ Math.round(lastTransformTime) }}ms
-        </p>
-        <p
-          v-memo="[Math.round(performanceMetrics.updateTime)]"
-          class="text-muted"
-        >
-          Lifecycle Update: {{ Math.round(performanceMetrics.updateTime) }}ms
-        </p>
-        <p v-memo="[rafActive]" class="text-muted">
-          RAF Active: {{ rafActive ? 'Yes' : 'No' }}
-        </p>
-        <p v-memo="[performanceMetrics.adaptiveQuality]" class="text-muted">
-          Adaptive Quality:
-          {{ performanceMetrics.adaptiveQuality ? 'On' : 'Off' }}
-        </p>
-      </div>
-
-      <!-- Feature Flags Status -->
-      <div
-        v-if="isDevModeEnabled"
-        class="pt-2 border-t border-surface-200 dark-theme:border-surface-700"
-      >
-        <h4 class="font-semibold mb-1">Feature Flags</h4>
-        <p class="text-muted text-xs">
-          Vue Nodes: {{ shouldRenderVueNodes ? 'Enabled' : 'Disabled' }}
-        </p>
-        <p class="text-muted text-xs">
-          Dev Mode: {{ isDevModeEnabled ? 'Enabled' : 'Disabled' }}
-        </p>
-      </div>
-
-      <!-- Performance Options -->
-      <div
-        v-if="transformPaneEnabled"
-        class="pt-2 border-t border-surface-200 dark-theme:border-surface-700"
-      >
-        <h4 class="font-semibold mb-1">Debug Options</h4>
-        <label class="flex items-center gap-2">
-          <input v-model="showPerformanceOverlay" type="checkbox" />
-          <span>Show Performance Overlay</span>
-        </label>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed } from 'vue'
-
-import { app as comfyApp } from '@/scripts/app'
-import { useCanvasStore } from '@/stores/graphStore'
-
-interface Props {
-  debugOverrideVueNodes: boolean
-  canvasViewport: { width: number; height: number }
-  vueNodesCount: number
-  nodesInViewport: number
-  performanceMetrics: {
-    culledCount: number
-    updateTime: number
-    adaptiveQuality: boolean
-  }
-  currentFPS: number
-  lastTransformTime: number
-  rafActive: boolean
-  isDevModeEnabled: boolean
-  shouldRenderVueNodes: boolean
-  transformPaneEnabled: boolean
-  showPerformanceOverlay: boolean
-}
-
-interface Emits {
-  (e: 'update:debugOverrideVueNodes', value: boolean): void
-  (e: 'update:showPerformanceOverlay', value: boolean): void
-}
-
-const props = defineProps<Props>()
-const emit = defineEmits<Emits>()
-
-const canvasStore = useCanvasStore()
-
-const debugOverrideVueNodes = computed({
-  get: () => props.debugOverrideVueNodes,
-  set: (value: boolean) => emit('update:debugOverrideVueNodes', value)
-})
-
-const showPerformanceOverlay = computed({
-  get: () => props.showPerformanceOverlay,
-  set: (value: boolean) => emit('update:showPerformanceOverlay', value)
-})
-</script>

src/components/helpcenter/HelpCenterMenuContent.vue

@@ -277,7 +277,7 @@ const menuItems = computed<MenuItem[]>(() => {
       icon: 'pi pi-question-circle',
       label: t('helpCenter.helpFeedback'),
       action: () => {
-        void commandStore.execute('Comfy.Feedback')
+        void commandStore.execute('Comfy.ContactSupport')
         emit('close')
       }
     },

src/components/input/MultiSelect.stories.ts

@@ -1,9 +1,23 @@
 import type { Meta, StoryObj } from '@storybook/vue3-vite'
+import type { MultiSelectProps } from 'primevue/multiselect'
 import { ref } from 'vue'
 
 import MultiSelect from './MultiSelect.vue'
 
-const meta: Meta<typeof MultiSelect> = {
+// Combine our component props with PrimeVue MultiSelect props
+// Since we use v-bind="$attrs", all PrimeVue props are available
+interface ExtendedProps extends Partial<MultiSelectProps> {
+  // Our custom props
+  label?: string
+  showSearchBox?: boolean
+  showSelectedCount?: boolean
+  showClearButton?: boolean
+  searchPlaceholder?: string
+  // Override modelValue type to match our Option type
+  modelValue?: Array<{ name: string; value: string }>
+}
+
+const meta: Meta<ExtendedProps> = {
   title: 'Components/Input/MultiSelect',
   component: MultiSelect,
   tags: ['autodocs'],
@@ -13,7 +27,35 @@ const meta: Meta<typeof MultiSelect> = {
     },
     options: {
       control: 'object'
+    },
+    showSearchBox: {
+      control: 'boolean',
+      description: 'Toggle searchBar visibility'
+    },
+    showSelectedCount: {
+      control: 'boolean',
+      description: 'Toggle selected count visibility'
+    },
+    showClearButton: {
+      control: 'boolean',
+      description: 'Toggle clear button visibility'
+    },
+    searchPlaceholder: {
+      control: 'text'
     }
+  },
+  args: {
+    label: 'Select',
+    options: [
+      { name: 'Vue', value: 'vue' },
+      { name: 'React', value: 'react' },
+      { name: 'Angular', value: 'angular' },
+      { name: 'Svelte', value: 'svelte' }
+    ],
+    showSearchBox: false,
+    showSelectedCount: false,
+    showClearButton: false,
+    searchPlaceholder: 'Search...'
   }
 }
 
@@ -25,7 +67,7 @@ export const Default: Story = {
     components: { MultiSelect },
     setup() {
       const selected = ref([])
-      const options = [
+      const options = args.options || [
         { name: 'Vue', value: 'vue' },
         { name: 'React', value: 'react' },
         { name: 'Angular', value: 'angular' },
@@ -38,8 +80,11 @@ export const Default: Story = {
         <MultiSelect 
           v-model="selected" 
           :options="options"
-          label="Select Frameworks"
-          v-bind="args"
+          :label="args.label"
+          :showSearchBox="args.showSearchBox"
+          :showSelectedCount="args.showSelectedCount"
+          :showClearButton="args.showClearButton"
+          :searchPlaceholder="args.searchPlaceholder"
         />
         <div class="mt-4 p-3 bg-gray-50 dark-theme:bg-zinc-800 rounded">
           <p class="text-sm">Selected: {{ selected.length > 0 ? selected.map(s => s.name).join(', ') : 'None' }}</p>
@@ -50,10 +95,10 @@ export const Default: Story = {
 }
 
 export const WithPreselectedValues: Story = {
-  render: () => ({
+  render: (args) => ({
     components: { MultiSelect },
     setup() {
-      const options = [
+      const options = args.options || [
         { name: 'JavaScript', value: 'js' },
         { name: 'TypeScript', value: 'ts' },
         { name: 'Python', value: 'python' },
@@ -61,25 +106,43 @@ export const WithPreselectedValues: Story = {
         { name: 'Rust', value: 'rust' }
       ]
       const selected = ref([options[0], options[1]])
-      return { selected, options }
+      return { selected, options, args }
     },
     template: `
       <div>
         <MultiSelect 
           v-model="selected" 
           :options="options"
-          label="Select Languages"
+          :label="args.label"
+          :showSearchBox="args.showSearchBox"
+          :showSelectedCount="args.showSelectedCount"
+          :showClearButton="args.showClearButton"
+          :searchPlaceholder="args.searchPlaceholder"
         />
         <div class="mt-4 p-3 bg-gray-50 dark-theme:bg-zinc-800 rounded">
           <p class="text-sm">Selected: {{ selected.map(s => s.name).join(', ') }}</p>
         </div>
       </div>
     `
-  })
+  }),
+  args: {
+    label: 'Select Languages',
+    options: [
+      { name: 'JavaScript', value: 'js' },
+      { name: 'TypeScript', value: 'ts' },
+      { name: 'Python', value: 'python' },
+      { name: 'Go', value: 'go' },
+      { name: 'Rust', value: 'rust' }
+    ],
+    showSearchBox: false,
+    showSelectedCount: false,
+    showClearButton: false,
+    searchPlaceholder: 'Search...'
+  }
 }
 
 export const MultipleSelectors: Story = {
-  render: () => ({
+  render: (args) => ({
     components: { MultiSelect },
     setup() {
       const frameworkOptions = ref([
@@ -114,7 +177,8 @@ export const MultipleSelectors: Story = {
         tagOptions,
         selectedFrameworks,
         selectedProjects,
-        selectedTags
+        selectedTags,
+        args
       }
     },
     template: `
@@ -124,22 +188,34 @@ export const MultipleSelectors: Story = {
             v-model="selectedFrameworks" 
             :options="frameworkOptions"
             label="Select Frameworks"
+            :showSearchBox="args.showSearchBox"
+            :showSelectedCount="args.showSelectedCount"
+            :showClearButton="args.showClearButton"
+            :searchPlaceholder="args.searchPlaceholder"
           />
           <MultiSelect 
             v-model="selectedProjects" 
             :options="projectOptions"
             label="Select Projects"
+            :showSearchBox="args.showSearchBox"
+            :showSelectedCount="args.showSelectedCount"
+            :showClearButton="args.showClearButton"
+            :searchPlaceholder="args.searchPlaceholder"
           />
           <MultiSelect 
             v-model="selectedTags" 
             :options="tagOptions"
             label="Select Tags"
+            :showSearchBox="args.showSearchBox"
+            :showSelectedCount="args.showSelectedCount"
+            :showClearButton="args.showClearButton"
+            :searchPlaceholder="args.searchPlaceholder"
           />
         </div>
         
         <div class="p-4 bg-gray-50 dark-theme:bg-zinc-800 rounded">
-          <h4 class="font-medium mb-2">Current Selection:</h4>
-          <div class="space-y-1 text-sm">
+          <h4 class="font-medium mt-0">Current Selection:</h4>
+          <div class="flex flex-col text-sm">
             <p>Frameworks: {{ selectedFrameworks.length > 0 ? selectedFrameworks.map(s => s.name).join(', ') : 'None' }}</p>
             <p>Projects: {{ selectedProjects.length > 0 ? selectedProjects.map(s => s.name).join(', ') : 'None' }}</p>
             <p>Tags: {{ selectedTags.length > 0 ? selectedTags.map(s => s.name).join(', ') : 'None' }}</p>
@@ -147,5 +223,54 @@ export const MultipleSelectors: Story = {
         </div>
       </div>
     `
-  })
+  }),
+  args: {
+    showSearchBox: false,
+    showSelectedCount: false,
+    showClearButton: false,
+    searchPlaceholder: 'Search...'
+  }
+}
+
+export const WithSearchBox: Story = {
+  ...Default,
+  args: {
+    ...Default.args,
+    showSearchBox: true
+  }
+}
+
+export const WithSelectedCount: Story = {
+  ...Default,
+  args: {
+    ...Default.args,
+    showSelectedCount: true
+  }
+}
+
+export const WithClearButton: Story = {
+  ...Default,
+  args: {
+    ...Default.args,
+    showClearButton: true
+  }
+}
+
+export const AllHeaderFeatures: Story = {
+  ...Default,
+  args: {
+    ...Default.args,
+    showSearchBox: true,
+    showSelectedCount: true,
+    showClearButton: true
+  }
+}
+
+export const CustomSearchPlaceholder: Story = {
+  ...Default,
+  args: {
+    ...Default.args,
+    showSearchBox: true,
+    searchPlaceholder: 'Filter packages...'
+  }
 }

src/components/input/MultiSelect.vue

@@ -1,93 +1,104 @@
 <template>
-  <div class="relative inline-block">
-    <MultiSelect
-      v-model="selectedItems"
-      :options="options"
-      option-label="name"
-      unstyled
-      :placeholder="label"
-      :max-selected-labels="0"
-      :pt="pt"
+  <!-- 
+    Note: Unlike SingleSelect, we don't need an explicit options prop because:
+    1. Our value template only shows a static label (not dynamic based on selection)
+    2. We display a count badge instead of actual selected labels
+    3. All PrimeVue props (including options) are passed via v-bind="$attrs"
+    
+    option-label="name" is required because our option template directly accesses option.name
+    max-selected-labels="0" is required to show count badge instead of selected item labels
+  -->
+  <MultiSelect
+    v-model="selectedItems"
+    v-bind="$attrs"
+    option-label="name"
+    unstyled
+    :max-selected-labels="0"
+    :pt="pt"
+  >
+    <template
+      v-if="showSearchBox || showSelectedCount || showClearButton"
+      #header
     >
-      <template
-        v-if="hasSearchBox || showSelectedCount || hasClearButton"
-        #header
-      >
-        <div class="p-2 flex flex-col gap-y-4 pb-0">
-          <SearchBox
-            v-if="hasSearchBox"
-            v-model="searchQuery"
-            :has-border="true"
-            :place-holder="searchPlaceholder"
-          />
-          <div class="flex items-center justify-between">
-            <span
-              v-if="showSelectedCount"
-              class="text-sm text-neutral-400 dark-theme:text-zinc-500 px-1"
-            >
-              {{
-                selectedCount > 0
-                  ? $t('g.itemsSelected', { selectedCount })
-                  : $t('g.itemSelected', { selectedCount })
-              }}
-            </span>
-            <TextButton
-              v-if="hasClearButton"
-              :label="$t('g.clearAll')"
-              type="transparent"
-              size="fit-content"
-              class="text-sm !text-blue-500 !dark-theme:text-blue-600"
-              @click.stop="selectedItems = []"
-            />
-          </div>
-          <div class="h-px bg-zinc-200 dark-theme:bg-zinc-700"></div>
-        </div>
-      </template>
-
-      <!-- Trigger value (keep text scale identical) -->
-      <template #value>
-        <span class="text-sm text-zinc-700 dark-theme:text-gray-200">
-          {{ label }}
-        </span>
-      </template>
-
-      <!-- Chevron size identical to current -->
-      <template #dropdownicon>
-        <i-lucide:chevron-down class="text-lg text-neutral-400" />
-      </template>
-
-      <!-- Custom option row: square checkbox + label (unchanged layout/colors) -->
-      <template #option="slotProps">
-        <div class="flex items-center gap-2">
-          <div
-            class="flex h-4 w-4 p-0.5 flex-shrink-0 items-center justify-center rounded border-[3px] transition-all duration-200"
-            :class="
-              slotProps.selected
-                ? 'border-blue-400 bg-blue-400 dark-theme:border-blue-500 dark-theme:bg-blue-500'
-                : 'border-neutral-300 dark-theme:border-zinc-600 bg-neutral-100 dark-theme:bg-zinc-700'
-            "
+      <div class="p-2 flex flex-col pb-0">
+        <SearchBox
+          v-if="showSearchBox"
+          v-model="searchQuery"
+          :class="showSelectedCount || showClearButton ? 'mb-2' : ''"
+          :show-order="true"
+          :place-holder="searchPlaceholder"
+        />
+        <div
+          v-if="showSelectedCount || showClearButton"
+          class="mt-2 flex items-center justify-between"
+        >
+          <span
+            v-if="showSelectedCount"
+            class="text-sm text-neutral-400 dark-theme:text-zinc-500 px-1"
           >
-            <i-lucide:check
-              v-if="slotProps.selected"
-              class="text-xs text-bold text-white"
-            />
-          </div>
-          <span>{{ slotProps.option.name }}</span>
+            {{
+              selectedCount > 0
+                ? $t('g.itemsSelected', { selectedCount })
+                : $t('g.itemSelected', { selectedCount })
+            }}
+          </span>
+          <TextButton
+            v-if="showClearButton"
+            :label="$t('g.clearAll')"
+            type="transparent"
+            size="fit-content"
+            class="text-sm !text-blue-500 !dark-theme:text-blue-600"
+            @click.stop="selectedItems = []"
+          />
         </div>
-      </template>
-    </MultiSelect>
+        <div class="mt-4 h-px bg-zinc-200 dark-theme:bg-zinc-700"></div>
+      </div>
+    </template>
 
-    <!-- Selected count badge -->
-    <div
-      v-if="selectedCount > 0"
-      class="pointer-events-none absolute -right-2 -top-2 z-10 flex h-5 w-5 items-center justify-center rounded-full bg-blue-400 dark-theme:bg-blue-500 text-xs font-semibold text-white"
-    >
-      {{ selectedCount }}
-    </div>
-  </div>
+    <!-- Trigger value (keep text scale identical) -->
+    <template #value>
+      <span class="text-sm text-zinc-700 dark-theme:text-gray-200">
+        {{ label }}
+      </span>
+      <span
+        v-if="selectedCount > 0"
+        class="pointer-events-none absolute -right-2 -top-2 z-10 flex h-5 w-5 items-center justify-center rounded-full bg-blue-400 dark-theme:bg-blue-500 text-xs font-semibold text-white"
+      >
+        {{ selectedCount }}
+      </span>
+    </template>
+
+    <!-- Chevron size identical to current -->
+    <template #dropdownicon>
+      <i-lucide:chevron-down class="text-lg text-neutral-400" />
+    </template>
+
+    <!-- Custom option row: square checkbox + label (unchanged layout/colors) -->
+    <template #option="slotProps">
+      <div class="flex items-center gap-2">
+        <div
+          class="flex h-4 w-4 p-0.5 flex-shrink-0 items-center justify-center rounded transition-all duration-200"
+          :class="
+            slotProps.selected
+              ? 'border-[3px] border-blue-400 bg-blue-400 dark-theme:border-blue-500 dark-theme:bg-blue-500'
+              : 'border-[1px] border-neutral-300 dark-theme:border-zinc-600 bg-neutral-100 dark-theme:bg-zinc-700'
+          "
+        >
+          <i-lucide:check
+            v-if="slotProps.selected"
+            class="text-xs text-bold text-white"
+          />
+        </div>
+        <Button class="border-none outline-none bg-transparent" unstyled>{{
+          slotProps.option.name
+        }}</Button>
+      </div>
+    </template>
+  </MultiSelect>
 </template>
 
 <script setup lang="ts">
+import Button from 'primevue/button'
 import MultiSelect, {
   MultiSelectPassThroughMethodOptions
 } from 'primevue/multiselect'
@@ -99,26 +110,29 @@ import TextButton from '../button/TextButton.vue'
 
 type Option = { name: string; value: string }
 
+defineOptions({
+  inheritAttrs: false
+})
+
 interface Props {
   /** Input label shown on the trigger button */
   label?: string
-  /** Static options for the multiselect (when not using async search) */
-  options: Option[]
   /** Show search box in the panel header */
-  hasSearchBox?: boolean
+  showSearchBox?: boolean
   /** Show selected count text in the panel header */
   showSelectedCount?: boolean
   /** Show "Clear all" action in the panel header */
-  hasClearButton?: boolean
+  showClearButton?: boolean
   /** Placeholder for the search input */
   searchPlaceholder?: string
+  // Note: options prop is intentionally omitted.
+  // It's passed via $attrs to maximize PrimeVue API compatibility
 }
 const {
   label,
-  options,
-  hasSearchBox = false,
+  showSearchBox = false,
   showSelectedCount = false,
-  hasClearButton = false,
+  showClearButton = false,
   searchPlaceholder = 'Search...'
 } = defineProps<Props>()
 
@@ -131,7 +145,7 @@ const selectedCount = computed(() => selectedItems.value.length)
 const pt = computed(() => ({
   root: ({ props }: MultiSelectPassThroughMethodOptions) => ({
     class: [
-      'relative inline-flex cursor-pointer select-none w-full',
+      'relative inline-flex cursor-pointer select-none',
       'rounded-lg bg-white dark-theme:bg-zinc-800 text-neutral dark-theme:text-white',
       'transition-all duration-200 ease-in-out',
       'border-[2.5px] border-solid',
@@ -153,7 +167,7 @@ const pt = computed(() => ({
   },
   header: () => ({
     class:
-      hasSearchBox || showSelectedCount || hasClearButton ? 'block' : 'hidden'
+      showSearchBox || showSelectedCount || showClearButton ? 'block' : 'hidden'
   }),
   // Overlay & list visuals unchanged
   overlay:
@@ -161,9 +175,17 @@ const pt = computed(() => ({
   list: {
     class: 'flex flex-col gap-1 p-0 list-none border-none text-xs'
   },
-  // Option row hover tone identical
-  option:
-    'flex gap-1 items-center p-2 hover:bg-neutral-100/50 dark-theme:hover:bg-zinc-700/50',
+  // Option row hover and focus tone
+  option: ({ context }: MultiSelectPassThroughMethodOptions) => ({
+    class: [
+      'flex gap-1 items-center p-2',
+      'hover:bg-neutral-100/50 dark-theme:hover:bg-zinc-700/50',
+      // Add focus/highlight state for keyboard navigation
+      {
+        'bg-neutral-100/50 dark-theme:bg-zinc-700/50': context?.focused
+      }
+    ]
+  }),
   // Hide built-in checkboxes entirely via PT (no :deep)
   pcHeaderCheckbox: {
     root: { class: 'hidden' },

src/components/input/SearchBox.stories.ts

@@ -10,7 +10,15 @@ const meta: Meta<typeof SearchBox> = {
   argTypes: {
     placeHolder: {
       control: 'text'
+    },
+    showBorder: {
+      control: 'boolean',
+      description: 'Toggle border prop'
     }
+  },
+  args: {
+    placeHolder: 'Search...',
+    showBorder: false
   }
 }
 
@@ -25,9 +33,23 @@ export const Default: Story = {
       return { searchText, args }
     },
     template: `
-      <div>
-        <SearchBox v-model:="searchQuery" />
+      <div style="max-width: 320px;">
+        <SearchBox v-bind="args" v-model="searchText" />
       </div>
     `
   })
 }
+
+export const WithBorder: Story = {
+  ...Default,
+  args: {
+    showBorder: true
+  }
+}
+
+export const NoBorder: Story = {
+  ...Default,
+  args: {
+    showBorder: false
+  }
+}

src/components/input/SearchBox.vue

@@ -15,19 +15,20 @@
 import InputText from 'primevue/inputtext'
 import { computed } from 'vue'
 
-const { placeHolder, hasBorder = false } = defineProps<{
+const { placeHolder, showBorder = false } = defineProps<{
   placeHolder?: string
-  hasBorder?: boolean
+  showBorder?: boolean
 }>()
-const searchQuery = defineModel<string>('')
+// defineModel without arguments uses 'modelValue' as the prop name
+const searchQuery = defineModel<string>()
 
 const wrapperStyle = computed(() => {
-  return hasBorder
+  return showBorder
     ? 'flex w-full items-center rounded gap-2 bg-white dark-theme:bg-zinc-800 p-1 border border-solid border-zinc-200 dark-theme:border-zinc-700'
     : 'flex w-full items-center rounded px-2 py-1.5 gap-2 bg-white dark-theme:bg-zinc-800'
 })
 
 const iconColorStyle = computed(() => {
-  return !hasBorder ? 'text-neutral' : 'text-zinc-300 dark-theme:text-zinc-700'
+  return !showBorder ? 'text-neutral' : 'text-zinc-300 dark-theme:text-zinc-700'
 })
 </script>

src/components/input/SingleSelect.stories.ts

@@ -4,12 +4,24 @@ import { ref } from 'vue'
 
 import SingleSelect from './SingleSelect.vue'
 
+// SingleSelect already includes options prop, so no need to extend
 const meta: Meta<typeof SingleSelect> = {
   title: 'Components/Input/SingleSelect',
   component: SingleSelect,
   tags: ['autodocs'],
   argTypes: {
-    label: { control: 'text' }
+    label: { control: 'text' },
+    options: { control: 'object' }
+  },
+  args: {
+    label: 'Sorting Type',
+    options: [
+      { name: 'Popular', value: 'popular' },
+      { name: 'Newest', value: 'newest' },
+      { name: 'Oldest', value: 'oldest' },
+      { name: 'A → Z', value: 'az' },
+      { name: 'Z → A', value: 'za' }
+    ]
   }
 }
 
@@ -29,19 +41,18 @@ export const Default: Story = {
     components: { SingleSelect },
     setup() {
       const selected = ref<string | null>(null)
-      const options = sampleOptions
+      const options = args.options || sampleOptions
       return { selected, options, args }
     },
     template: `
       <div>
-        <SingleSelect v-model="selected" :options="options" :label="args.label || 'Sorting Type'" />
+        <SingleSelect v-model="selected" :options="options" :label="args.label" />
         <div class="mt-4 p-3 bg-gray-50 dark-theme:bg-zinc-800 rounded">
           <p class="text-sm">Selected: {{ selected ?? 'None' }}</p>
         </div>
       </div>
     `
-  }),
-  args: { label: 'Sorting Type' }
+  })
 }
 
 export const WithIcon: Story = {

src/components/input/SingleSelect.vue

@@ -1,58 +1,73 @@
 <template>
-  <div class="relative inline-flex items-center">
-    <Select
-      v-model="selectedItem"
-      :options="options"
-      option-label="name"
-      option-value="value"
-      unstyled
-      :placeholder="label"
-      :pt="pt"
-    >
-      <!-- Trigger value -->
-      <template #value="slotProps">
-        <div class="flex items-center gap-2 text-sm">
-          <slot name="icon" />
-          <span
-            v-if="slotProps.value !== null && slotProps.value !== undefined"
-            class="text-zinc-700 dark-theme:text-gray-200"
-          >
-            {{ getLabel(slotProps.value) }}
-          </span>
-          <span v-else class="text-zinc-700 dark-theme:text-gray-200">
-            {{ label }}
-          </span>
-        </div>
-      </template>
+  <!-- 
+    Note: We explicitly pass options here (not just via $attrs) because:
+    1. Our custom value template needs options to look up labels from values
+    2. PrimeVue's value slot only provides 'value' and 'placeholder', not the selected item's label
+    3. We need to maintain the icon slot functionality in the value template
+    
+    option-label="name" is required because our option template directly accesses option.name
+  -->
+  <Select
+    v-model="selectedItem"
+    v-bind="$attrs"
+    :options="options"
+    option-label="name"
+    option-value="value"
+    unstyled
+    :pt="pt"
+  >
+    <!-- Trigger value -->
+    <template #value="slotProps">
+      <div class="flex items-center gap-2 text-sm">
+        <slot name="icon" />
+        <span
+          v-if="slotProps.value !== null && slotProps.value !== undefined"
+          class="text-zinc-700 dark-theme:text-gray-200"
+        >
+          {{ getLabel(slotProps.value) }}
+        </span>
+        <span v-else class="text-zinc-700 dark-theme:text-gray-200">
+          {{ label }}
+        </span>
+      </div>
+    </template>
 
-      <!-- Trigger caret -->
-      <template #dropdownicon>
-        <i-lucide:chevron-down
-          class="text-base text-neutral-400 dark-theme:text-gray-300"
+    <!-- Trigger caret -->
+    <template #dropdownicon>
+      <i-lucide:chevron-down
+        class="text-base text-neutral-400 dark-theme:text-gray-300"
+      />
+    </template>
+
+    <!-- Option row -->
+    <template #option="{ option, selected }">
+      <div class="flex items-center justify-between gap-3 w-full">
+        <span class="truncate">{{ option.name }}</span>
+        <i-lucide:check
+          v-if="selected"
+          class="text-neutral-900 dark-theme:text-white"
         />
-      </template>
-
-      <!-- Option row -->
-      <template #option="{ option, selected }">
-        <div class="flex items-center justify-between gap-3 w-full">
-          <span class="truncate">{{ option.name }}</span>
-          <i-lucide:check
-            v-if="selected"
-            class="text-neutral-900 dark-theme:text-white"
-          />
-        </div>
-      </template>
-    </Select>
-  </div>
+      </div>
+    </template>
+  </Select>
 </template>
 
 <script setup lang="ts">
 import Select, { SelectPassThroughMethodOptions } from 'primevue/select'
 import { computed } from 'vue'
 
+defineOptions({
+  inheritAttrs: false
+})
+
 const { label, options } = defineProps<{
   label?: string
-  options: {
+  /**
+   * Required for displaying the selected item's label.
+   * Cannot rely on $attrs alone because we need to access options
+   * in getLabel() to map values to their display names.
+   */
+  options?: {
     name: string
     value: string
   }[]
@@ -60,8 +75,14 @@ const { label, options } = defineProps<{
 
 const selectedItem = defineModel<string | null>({ required: true })
 
+/**
+ * Maps a value to its display label.
+ * Necessary because PrimeVue's value slot doesn't provide the selected item's label,
+ * only the raw value. We need this to show the correct text when an item is selected.
+ */
 const getLabel = (val: string | null | undefined) => {
   if (val == null) return label ?? ''
+  if (!options) return label ?? ''
   const found = options.find((o) => o.value === val)
   return found ? found.name : label ?? ''
 }
@@ -77,7 +98,7 @@ const pt = computed(() => ({
   }: SelectPassThroughMethodOptions<{ name: string; value: string }>) => ({
     class: [
       // container
-      'relative inline-flex w-full cursor-pointer select-none items-center',
+      'relative inline-flex cursor-pointer select-none items-center',
       // trigger surface
       'rounded-md',
       'bg-transparent text-neutral dark-theme:text-white',
@@ -115,7 +136,9 @@ const pt = computed(() => ({
       'flex items-center justify-between gap-3 px-3 py-2',
       'hover:bg-neutral-100/50 dark-theme:hover:bg-zinc-700/50',
       // Selected state + check icon
-      { 'bg-neutral-100/50 dark-theme:bg-zinc-700/50': context.selected }
+      { 'bg-neutral-100/50 dark-theme:bg-zinc-700/50': context.selected },
+      // Add focus state for keyboard navigation
+      { 'bg-neutral-100/50 dark-theme:bg-zinc-700/50': context.focused }
     ]
   }),
   optionLabel: {

src/components/topbar/CurrentUserPopover.spec.ts

@@ -41,11 +41,13 @@ afterAll(() => {
 })
 
 // Mock the useCurrentUser composable
+const mockHandleSignOut = vi.fn()
 vi.mock('@/composables/auth/useCurrentUser', () => ({
   useCurrentUser: vi.fn(() => ({
     userPhotoUrl: 'https://example.com/avatar.jpg',
     userDisplayName: 'Test User',
-    userEmail: 'test@example.com'
+    userEmail: 'test@example.com',
+    handleSignOut: mockHandleSignOut
   }))
 }))
 
@@ -155,8 +157,8 @@ describe('CurrentUserPopover', () => {
     // Click the logout button
     await logoutButton.trigger('click')
 
-    // Verify logout was called
-    expect(mockLogout).toHaveBeenCalled()
+    // Verify handleSignOut was called
+    expect(mockHandleSignOut).toHaveBeenCalled()
 
     // Verify close event was emitted
     expect(wrapper.emitted('close')).toBeTruthy()

src/components/topbar/CurrentUserPopover.vue

@@ -88,7 +88,8 @@ const emit = defineEmits<{
   close: []
 }>()
 
-const { userDisplayName, userEmail, userPhotoUrl } = useCurrentUser()
+const { userDisplayName, userEmail, userPhotoUrl, handleSignOut } =
+  useCurrentUser()
 const authActions = useFirebaseAuthActions()
 const dialogService = useDialogService()
 
@@ -103,7 +104,7 @@ const handleTopUp = () => {
 }
 
 const handleLogout = async () => {
-  await authActions.logout()
+  await handleSignOut()
   emit('close')
 }
 

src/components/widget/SampleModelSelector.vue

@@ -12,7 +12,7 @@
     </template>
 
     <template #header>
-      <SearchBox v-model:="searchQuery" class="max-w-[384px]" />
+      <SearchBox v-model="searchQuery" class="max-w-[384px]" />
     </template>
 
     <template #header-right-area>
@@ -59,12 +59,13 @@
       <div class="relative px-6 pt-2 pb-4 flex gap-2">
         <MultiSelect
           v-model="selectedFrameworks"
+          v-model:search-query="searchText"
           class="w-[250px]"
-          :has-search-box="true"
-          :show-selected-count="true"
-          :has-clear-button="true"
           label="Select Frameworks"
           :options="frameworkOptions"
+          :show-search-box="true"
+          :show-selected-count="true"
+          :show-clear-button="true"
         />
         <MultiSelect
           v-model="selectedProjects"
@@ -135,7 +136,7 @@
 </template>
 
 <script setup lang="ts">
-import { provide, ref } from 'vue'
+import { provide, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 
 import IconButton from '@/components/button/IconButton.vue'
@@ -201,9 +202,18 @@ const { onClose } = defineProps<{
 provide(OnCloseKey, onClose)
 
 const searchQuery = ref<string>('')
+const searchText = ref<string>('')
 const selectedFrameworks = ref([])
 const selectedProjects = ref([])
 const selectedSort = ref<string>('popular')
 
 const selectedNavItem = ref<string | null>('installed')
+
+watch(searchText, (newQuery) => {
+  console.log('searchText:', searchText.value, newQuery)
+})
+
+watch(searchQuery, (newQuery) => {
+  console.log('searchQuery:', searchQuery.value, newQuery)
+})
 </script>

src/components/widget/layout/BaseWidget.stories.ts

@@ -240,6 +240,9 @@ const createStoryTemplate = (args: StoryArgs) => ({
               v-model="selectedFrameworks"
               label="Select Frameworks"
               :options="frameworkOptions"
+              :has-search-box="true"
+              :show-selected-count="true"
+              :has-clear-button="true"
             />
             <MultiSelect
               v-model="selectedProjects"

src/composables/auth/useCurrentUser.ts

@@ -1,5 +1,8 @@
 import { computed } from 'vue'
 
+import { useFirebaseAuthActions } from '@/composables/auth/useFirebaseAuthActions'
+import { t } from '@/i18n'
+import { useDialogService } from '@/services/dialogService'
 import { useApiKeyAuthStore } from '@/stores/apiKeyAuthStore'
 import { useCommandStore } from '@/stores/commandStore'
 import { useFirebaseAuthStore } from '@/stores/firebaseAuthStore'
@@ -8,6 +11,8 @@ export const useCurrentUser = () => {
   const authStore = useFirebaseAuthStore()
   const commandStore = useCommandStore()
   const apiKeyStore = useApiKeyAuthStore()
+  const dialogService = useDialogService()
+  const { deleteAccount } = useFirebaseAuthActions()
 
   const firebaseUser = computed(() => authStore.currentUser)
   const isApiKeyLogin = computed(() => apiKeyStore.isAuthenticated)
@@ -85,6 +90,18 @@ export const useCurrentUser = () => {
     await commandStore.execute('Comfy.User.OpenSignInDialog')
   }
 
+  const handleDeleteAccount = async () => {
+    const confirmed = await dialogService.confirm({
+      title: t('auth.deleteAccount.confirmTitle'),
+      message: t('auth.deleteAccount.confirmMessage'),
+      type: 'delete'
+    })
+
+    if (confirmed) {
+      await deleteAccount()
+    }
+  }
+
   return {
     loading: authStore.loading,
     isLoggedIn,
@@ -96,6 +113,7 @@ export const useCurrentUser = () => {
     providerName,
     providerIcon,
     handleSignOut,
-    handleSignIn
+    handleSignIn,
+    handleDeleteAccount
   }
 }

src/composables/auth/useFirebaseAuthActions.ts

@@ -135,6 +135,16 @@ export const useFirebaseAuthActions = () => {
     reportError
   )
 
+  const deleteAccount = wrapWithErrorHandlingAsync(async () => {
+    await authStore.deleteAccount()
+    toastStore.add({
+      severity: 'success',
+      summary: t('auth.deleteAccount.success'),
+      detail: t('auth.deleteAccount.successDetail'),
+      life: 5000
+    })
+  }, reportError)
+
   return {
     logout,
     sendPasswordReset,
@@ -146,6 +156,7 @@ export const useFirebaseAuthActions = () => {
     signInWithEmail,
     signUpWithEmail,
     updatePassword,
+    deleteAccount,
     accessError
   }
 }

src/composables/element/useTransformState.ts

@@ -1,242 +0,0 @@
-/**
- * Composable for managing transform state synchronized with LiteGraph canvas
- *
- * This composable is a critical part of the hybrid rendering architecture that
- * allows Vue components to render in perfect alignment with LiteGraph's canvas.
- *
- * ## Core Concept
- *
- * LiteGraph uses a canvas for rendering connections, grid, and handling interactions.
- * Vue components need to render nodes on top of this canvas. The challenge is
- * synchronizing the coordinate systems:
- *
- * - LiteGraph: Uses canvas coordinates with its own transform matrix
- * - Vue/DOM: Uses screen coordinates with CSS transforms
- *
- * ## Solution: Transform Container Pattern
- *
- * Instead of transforming individual nodes (O(n) complexity), we:
- * 1. Mirror LiteGraph's transform matrix to a single CSS container
- * 2. Place all Vue nodes as children with simple absolute positioning
- * 3. Achieve O(1) transform updates regardless of node count
- *
- * ## Coordinate Systems
- *
- * - **Canvas coordinates**: LiteGraph's internal coordinate system
- * - **Screen coordinates**: Browser's viewport coordinate system
- * - **Transform sync**: camera.x/y/z mirrors canvas.ds.offset/scale
- *
- * ## Performance Benefits
- *
- * - GPU acceleration via CSS transforms
- * - No layout thrashing (only transform changes)
- * - Efficient viewport culling calculations
- * - Scales to 1000+ nodes while maintaining 60 FPS
- *
- * @example
- * ```typescript
- * const { camera, transformStyle, canvasToScreen } = useTransformState()
- *
- * // In template
- * <div :style="transformStyle">
- *   <NodeComponent
- *     v-for="node in nodes"
- *     :style="{ left: node.x + 'px', top: node.y + 'px' }"
- *   />
- * </div>
- *
- * // Convert coordinates
- * const screenPos = canvasToScreen({ x: nodeX, y: nodeY })
- * ```
- */
-import { computed, reactive, readonly } from 'vue'
-
-import type { LGraphCanvas } from '../../lib/litegraph/src/litegraph'
-
-export interface Point {
-  x: number
-  y: number
-}
-
-export interface Camera {
-  x: number
-  y: number
-  z: number // scale/zoom
-}
-
-export const useTransformState = () => {
-  // Reactive state mirroring LiteGraph's canvas transform
-  const camera = reactive<Camera>({
-    x: 0,
-    y: 0,
-    z: 1
-  })
-
-  // Computed transform string for CSS
-  const transformStyle = computed(() => ({
-    transform: `scale(${camera.z}) translate(${camera.x}px, ${camera.y}px)`,
-    transformOrigin: '0 0'
-  }))
-
-  /**
-   * Synchronizes Vue's reactive camera state with LiteGraph's canvas transform
-   *
-   * Called every frame via RAF to ensure Vue components stay aligned with canvas.
-   * This is the heart of the hybrid rendering system - it bridges the gap between
-   * LiteGraph's canvas transforms and Vue's reactive system.
-   *
-   * @param canvas - LiteGraph canvas instance with DragAndScale (ds) transform state
-   */
-  const syncWithCanvas = (canvas: LGraphCanvas) => {
-    if (!canvas || !canvas.ds) return
-
-    // Mirror LiteGraph's transform state to Vue's reactive state
-    // ds.offset = pan offset, ds.scale = zoom level
-    camera.x = canvas.ds.offset[0]
-    camera.y = canvas.ds.offset[1]
-    camera.z = canvas.ds.scale || 1
-  }
-
-  /**
-   * Converts canvas coordinates to screen coordinates
-   *
-   * Applies the same transform that LiteGraph uses for rendering.
-   * Essential for positioning Vue components to align with canvas elements.
-   *
-   * Formula: screen = canvas * scale + offset
-   *
-   * @param point - Point in canvas coordinate system
-   * @returns Point in screen coordinate system
-   */
-  const canvasToScreen = (point: Point): Point => {
-    return {
-      x: point.x * camera.z + camera.x,
-      y: point.y * camera.z + camera.y
-    }
-  }
-
-  /**
-   * Converts screen coordinates to canvas coordinates
-   *
-   * Inverse of canvasToScreen. Useful for hit testing and converting
-   * mouse events back to canvas space.
-   *
-   * Formula: canvas = (screen - offset) / scale
-   *
-   * @param point - Point in screen coordinate system
-   * @returns Point in canvas coordinate system
-   */
-  const screenToCanvas = (point: Point): Point => {
-    return {
-      x: (point.x - camera.x) / camera.z,
-      y: (point.y - camera.y) / camera.z
-    }
-  }
-
-  // Get node's screen bounds for culling
-  const getNodeScreenBounds = (
-    pos: ArrayLike<number>,
-    size: ArrayLike<number>
-  ): DOMRect => {
-    const topLeft = canvasToScreen({ x: pos[0], y: pos[1] })
-    const width = size[0] * camera.z
-    const height = size[1] * camera.z
-
-    return new DOMRect(topLeft.x, topLeft.y, width, height)
-  }
-
-  // Helper: Calculate zoom-adjusted margin for viewport culling
-  const calculateAdjustedMargin = (baseMargin: number): number => {
-    if (camera.z < 0.1) return Math.min(baseMargin * 5, 2.0)
-    if (camera.z > 3.0) return Math.max(baseMargin * 0.5, 0.05)
-    return baseMargin
-  }
-
-  // Helper: Check if node is too small to be visible at current zoom
-  const isNodeTooSmall = (nodeSize: ArrayLike<number>): boolean => {
-    const nodeScreenSize = Math.max(nodeSize[0], nodeSize[1]) * camera.z
-    return nodeScreenSize < 4
-  }
-
-  // Helper: Calculate expanded viewport bounds with margin
-  const getExpandedViewportBounds = (
-    viewport: { width: number; height: number },
-    margin: number
-  ) => {
-    const marginX = viewport.width * margin
-    const marginY = viewport.height * margin
-    return {
-      left: -marginX,
-      right: viewport.width + marginX,
-      top: -marginY,
-      bottom: viewport.height + marginY
-    }
-  }
-
-  // Helper: Test if node intersects with viewport bounds
-  const testViewportIntersection = (
-    screenPos: { x: number; y: number },
-    nodeSize: ArrayLike<number>,
-    bounds: { left: number; right: number; top: number; bottom: number }
-  ): boolean => {
-    const nodeRight = screenPos.x + nodeSize[0] * camera.z
-    const nodeBottom = screenPos.y + nodeSize[1] * camera.z
-
-    return !(
-      nodeRight < bounds.left ||
-      screenPos.x > bounds.right ||
-      nodeBottom < bounds.top ||
-      screenPos.y > bounds.bottom
-    )
-  }
-
-  // Check if node is within viewport with frustum and size-based culling
-  const isNodeInViewport = (
-    nodePos: ArrayLike<number>,
-    nodeSize: ArrayLike<number>,
-    viewport: { width: number; height: number },
-    margin: number = 0.2
-  ): boolean => {
-    // Early exit for tiny nodes
-    if (isNodeTooSmall(nodeSize)) return false
-
-    const screenPos = canvasToScreen({ x: nodePos[0], y: nodePos[1] })
-    const adjustedMargin = calculateAdjustedMargin(margin)
-    const bounds = getExpandedViewportBounds(viewport, adjustedMargin)
-
-    return testViewportIntersection(screenPos, nodeSize, bounds)
-  }
-
-  // Get viewport bounds in canvas coordinates (for spatial index queries)
-  const getViewportBounds = (
-    viewport: { width: number; height: number },
-    margin: number = 0.2
-  ) => {
-    const marginX = viewport.width * margin
-    const marginY = viewport.height * margin
-
-    const topLeft = screenToCanvas({ x: -marginX, y: -marginY })
-    const bottomRight = screenToCanvas({
-      x: viewport.width + marginX,
-      y: viewport.height + marginY
-    })
-
-    return {
-      x: topLeft.x,
-      y: topLeft.y,
-      width: bottomRight.x - topLeft.x,
-      height: bottomRight.y - topLeft.y
-    }
-  }
-
-  return {
-    camera: readonly(camera),
-    transformStyle,
-    syncWithCanvas,
-    canvasToScreen,
-    screenToCanvas,
-    getNodeScreenBounds,
-    isNodeInViewport,
-    getViewportBounds
-  }
-}

src/composables/graph/README.md

@@ -1,211 +0,0 @@
-# Graph Composables - Reactive Layout System
-
-This directory contains composables for the reactive layout system, enabling Vue nodes to handle their own interactions while maintaining synchronization with LiteGraph.
-
-## Composable Architecture
-
-```mermaid
-graph TB
-    subgraph "Composables"
-        URL[useReactiveLayout<br/>- Singleton Management<br/>- Service Access]
-        UVNI[useVueNodeInteraction<br/>- Node Dragging<br/>- CSS Transforms]
-        ULGS[useLiteGraphSync<br/>- Bidirectional Sync<br/>- Position Updates]
-    end
-
-    subgraph "Services"
-        LT[ReactiveLayoutTree]
-        HT[ReactiveHitTester]
-    end
-
-    subgraph "Components"
-        GC[GraphCanvas]
-        VN[Vue Nodes]
-        TP[TransformPane]
-    end
-
-    URL --> LT
-    URL --> HT
-    UVNI --> URL
-    ULGS --> URL
-    
-    GC --> ULGS
-    VN --> UVNI
-    TP --> URL
-</mermaid>
-
-## Interaction Flow
-
-```mermaid
-sequenceDiagram
-    participant User
-    participant VueNode
-    participant UVNI as useVueNodeInteraction
-    participant LT as LayoutTree
-    participant LG as LiteGraph
-
-    User->>VueNode: pointerdown
-    VueNode->>UVNI: startDrag(event)
-    UVNI->>UVNI: Set drag state
-    UVNI->>UVNI: Capture pointer
-    
-    User->>VueNode: pointermove
-    VueNode->>UVNI: handleDrag(event)
-    UVNI->>UVNI: Calculate delta
-    UVNI->>VueNode: Update CSS transform
-    Note over VueNode: Visual feedback only
-    
-    User->>VueNode: pointerup
-    VueNode->>UVNI: endDrag(event)
-    UVNI->>LT: updateNodePosition(finalPos)
-    LT->>LG: Trigger reactive sync
-    LG->>LG: Update canvas
-```
-
-## useReactiveLayout
-
-Singleton management for the reactive layout system.
-
-```mermaid
-classDiagram
-    class useReactiveLayout {
-        +layoutTree: ComputedRef~ReactiveLayoutTree~
-        +hitTester: ComputedRef~ReactiveHitTester~
-        +nodePositions: ComputedRef~Map~
-        +nodeBounds: ComputedRef~Map~
-        +selectedNodes: ComputedRef~Set~
-        -initialize(): void
-    }
-
-    class Singleton {
-        <<pattern>>
-        Shared across all components
-    }
-
-    useReactiveLayout --> Singleton : implements
-```
-
-## useVueNodeInteraction
-
-Handles individual node interactions with CSS transforms.
-
-```mermaid
-flowchart LR
-    subgraph "Drag State"
-        DS[isDragging<br/>dragDelta<br/>dragStartPos]
-    end
-    
-    subgraph "Event Handlers"
-        SD[startDrag]
-        HD[handleDrag]
-        ED[endDrag]
-    end
-    
-    subgraph "Computed Styles"
-        NS[nodeStyle<br/>- position<br/>- dimensions<br/>- z-index]
-        DGS[dragStyle<br/>- transform<br/>- transition]
-    end
-    
-    SD --> DS
-    HD --> DS
-    ED --> DS
-    
-    DS --> NS
-    DS --> DGS
-```
-
-### Transform Calculation
-
-```mermaid
-graph TB
-    subgraph "Mouse Delta"
-        MD[event.clientX/Y - startMouse]
-    end
-    
-    subgraph "Canvas Transform"
-        CT[screenToCanvas conversion]
-    end
-    
-    subgraph "Drag Delta"
-        DD[Canvas-space delta]
-    end
-    
-    subgraph "CSS Transform"
-        CSS[translate(deltaX, deltaY)]
-    end
-    
-    MD --> CT
-    CT --> DD
-    DD --> CSS
-```
-
-## useLiteGraphSync
-
-Bidirectional synchronization between LiteGraph and the reactive layout tree.
-
-```mermaid
-stateDiagram-v2
-    [*] --> Initialize
-    
-    Initialize --> SyncFromLiteGraph
-    SyncFromLiteGraph --> WatchLayoutTree
-    
-    state WatchLayoutTree {
-        [*] --> Listening
-        Listening --> PositionChanged: Layout tree update
-        PositionChanged --> UpdateLiteGraph
-        UpdateLiteGraph --> TriggerRedraw
-        TriggerRedraw --> Listening
-    }
-    
-    state SyncFromLiteGraph {
-        [*] --> ReadNodes
-        ReadNodes --> UpdateLayoutTree
-        UpdateLayoutTree --> [*]
-    }
-```
-
-## Integration Example
-
-```typescript
-// In GraphCanvas.vue
-const { initializeSync } = useLiteGraphSync()
-onMounted(() => {
-  initializeSync() // Start bidirectional sync
-})
-
-// In LGraphNode.vue
-const {
-  isDragging,
-  startDrag,
-  handleDrag,
-  endDrag,
-  dragStyle,
-  updatePosition
-} = useVueNodeInteraction(props.nodeData.id)
-
-// Template
-<div
-  :style="[
-    {
-      transform: `translate(${position.x}px, ${position.y}px)`,
-      // ... other styles
-    },
-    dragStyle // Applied during drag
-  ]"
-  @pointerdown="handlePointerDown"
-  @pointermove="handlePointerMove"
-  @pointerup="handlePointerUp"
->
-```
-
-## Performance Considerations
-
-1. **CSS Transforms During Drag**: No layout recalculation, GPU accelerated
-2. **Batch Position Updates**: Layout tree updates trigger single LiteGraph sync
-3. **Reactive Efficiency**: Vue's computed properties cache results
-4. **Spatial Indexing**: QuadTree integration for fast hit testing
-
-## Future Migration Path
-
-Currently: Vue nodes use CSS transforms, commit to layout tree on drag end
-Future: Each renderer owns complete interaction handling and layout state

src/composables/graph/useCanvasTransformSync.ts

@@ -1,115 +0,0 @@
-import { onUnmounted, ref } from 'vue'
-
-import type { LGraphCanvas } from '../../lib/litegraph/src/litegraph'
-
-export interface CanvasTransformSyncOptions {
-  /**
-   * Whether to automatically start syncing when canvas is available
-   * @default true
-   */
-  autoStart?: boolean
-}
-
-export interface CanvasTransformSyncCallbacks {
-  /**
-   * Called when sync starts
-   */
-  onStart?: () => void
-  /**
-   * Called after each sync update with timing information
-   */
-  onUpdate?: (duration: number) => void
-  /**
-   * Called when sync stops
-   */
-  onStop?: () => void
-}
-
-/**
- * Manages requestAnimationFrame-based synchronization with LiteGraph canvas transforms.
- *
- * This composable provides a clean way to sync Vue transform state with LiteGraph canvas
- * on every frame. It handles RAF lifecycle management, provides performance timing,
- * and ensures proper cleanup.
- *
- * The sync function typically reads canvas.ds (draw state) properties like offset and scale
- * to keep Vue components aligned with the canvas coordinate system.
- *
- * @example
- * ```ts
- * const { isActive, startSync, stopSync } = useCanvasTransformSync(
- *   canvas,
- *   (canvas) => syncWithCanvas(canvas),
- *   {
- *     onStart: () => emit('rafStatusChange', true),
- *     onUpdate: (time) => emit('transformUpdate', time),
- *     onStop: () => emit('rafStatusChange', false)
- *   }
- * )
- * ```
- */
-export function useCanvasTransformSync(
-  canvas: LGraphCanvas | undefined | null,
-  syncFn: (canvas: LGraphCanvas) => void,
-  callbacks: CanvasTransformSyncCallbacks = {},
-  options: CanvasTransformSyncOptions = {}
-) {
-  const { autoStart = true } = options
-  const { onStart, onUpdate, onStop } = callbacks
-
-  const isActive = ref(false)
-  let rafId: number | null = null
-
-  const startSync = () => {
-    if (isActive.value || !canvas) return
-
-    isActive.value = true
-    onStart?.()
-
-    const sync = () => {
-      if (!isActive.value || !canvas) return
-
-      try {
-        const startTime = performance.now()
-        syncFn(canvas)
-        const endTime = performance.now()
-
-        onUpdate?.(endTime - startTime)
-      } catch (error) {
-        console.warn('Canvas transform sync error:', error)
-      }
-
-      rafId = requestAnimationFrame(sync)
-    }
-
-    sync()
-  }
-
-  const stopSync = () => {
-    if (!isActive.value) return
-
-    if (rafId !== null) {
-      cancelAnimationFrame(rafId)
-      rafId = null
-    }
-
-    isActive.value = false
-    onStop?.()
-  }
-
-  // Auto-start if canvas is available and autoStart is enabled
-  if (autoStart && canvas) {
-    startSync()
-  }
-
-  // Clean up on unmount
-  onUnmounted(() => {
-    stopSync()
-  })
-
-  return {
-    isActive,
-    startSync,
-    stopSync
-  }
-}

src/composables/graph/useEventForwarding.ts

@@ -1,186 +0,0 @@
-import { useCanvasStore } from '@/stores/graphStore'
-
-import type { LGraphCanvas } from '../../lib/litegraph/src/litegraph'
-
-export function useEventForwarding() {
-  const canvasStore = useCanvasStore()
-
-  // Track active drag operation
-  let isDragging = false
-  let dragCleanup: (() => void) | null = null
-  // Store last known position for escape key handling
-  const lastPointerPosition = { x: 0, y: 0 }
-
-  function createSyntheticPointerEvent(
-    originalEvent: PointerEvent,
-    eventType: string
-  ): PointerEvent {
-    // Only copy properties that LiteGraph actually uses
-    return new PointerEvent(eventType, {
-      bubbles: true,
-      cancelable: true,
-      view: window,
-      // Position properties
-      clientX: originalEvent.clientX,
-      clientY: originalEvent.clientY,
-      // Modifier keys
-      ctrlKey: originalEvent.ctrlKey,
-      shiftKey: originalEvent.shiftKey,
-      altKey: originalEvent.altKey,
-      metaKey: originalEvent.metaKey,
-      // Button state
-      button: originalEvent.button,
-      buttons: originalEvent.buttons,
-      // Pointer tracking
-      pointerId: originalEvent.pointerId,
-      isPrimary: originalEvent.isPrimary,
-      pointerType: originalEvent.pointerType
-    })
-  }
-
-  function forwardPointerEvent(
-    originalEvent: PointerEvent,
-    eventType: 'down' | 'move' | 'up'
-  ) {
-    const canvas: LGraphCanvas | null = canvasStore.getCanvas()
-    if (!canvas) {
-      console.warn('No canvas available for event forwarding')
-      return
-    }
-
-    // Prevent original event from bubbling to canvas
-    originalEvent.stopPropagation()
-    originalEvent.preventDefault()
-
-    // Create synthetic event
-    const syntheticEvent = createSyntheticPointerEvent(
-      originalEvent,
-      `pointer${eventType}`
-    )
-
-    // Create a mutable copy of the event for LiteGraph to modify
-    const mutableEvent = syntheticEvent as PointerEvent & {
-      canvasX?: number
-      canvasY?: number
-      deltaX?: number
-      deltaY?: number
-      safeOffsetX?: number
-      safeOffsetY?: number
-    }
-
-    // Let LiteGraph adjust coordinates to graph space
-    // Using 'as any' to bypass TypeScript assertion limitations
-    ;(canvas.adjustMouseEvent as any)(mutableEvent)
-
-    // Forward to appropriate handler
-    switch (eventType) {
-      case 'down':
-        canvas.processMouseDown(mutableEvent)
-        break
-      case 'move':
-        canvas.processMouseMove(mutableEvent)
-        break
-      case 'up':
-        canvas.processMouseUp(mutableEvent)
-        break
-    }
-  }
-
-  // Pre-create event handlers to avoid recreating on each pointerdown
-  const handlePointerMove = (e: PointerEvent) => {
-    if (!isDragging) return
-    // Update last known position
-    lastPointerPosition.x = e.clientX
-    lastPointerPosition.y = e.clientY
-    forwardPointerEvent(e, 'move')
-  }
-
-  const handlePointerUp = (e: PointerEvent) => {
-    if (!isDragging) return
-
-    isDragging = false
-    forwardPointerEvent(e, 'up')
-
-    // Clean up listeners
-    if (dragCleanup) {
-      dragCleanup()
-      dragCleanup = null
-    }
-  }
-
-  const handleKeyDown = (e: KeyboardEvent) => {
-    // Handle escape key to cancel drag
-    if (e.key === 'Escape' && isDragging) {
-      isDragging = false
-
-      // Create minimal synthetic cancel event
-      const cancelEvent = new PointerEvent('pointerup', {
-        bubbles: true,
-        cancelable: true,
-        view: window,
-        // Use last known position from the current drag operation
-        clientX: lastPointerPosition.x,
-        clientY: lastPointerPosition.y,
-        button: 0,
-        buttons: 0
-      })
-
-      const canvas: LGraphCanvas | null = canvasStore.getCanvas()
-      if (canvas) {
-        const mutableCancelEvent = cancelEvent as PointerEvent & {
-          canvasX?: number
-          canvasY?: number
-          deltaX?: number
-          deltaY?: number
-          safeOffsetX?: number
-          safeOffsetY?: number
-        }
-        ;(canvas.adjustMouseEvent as any)(mutableCancelEvent)
-        canvas.processMouseUp(mutableCancelEvent)
-      }
-
-      // Clean up
-      if (dragCleanup) {
-        dragCleanup()
-        dragCleanup = null
-      }
-    }
-  }
-
-  function handleSlotPointerDown(originalEvent: PointerEvent) {
-    // Forward the initial pointer down
-    forwardPointerEvent(originalEvent, 'down')
-
-    // Set up drag handling
-    isDragging = true
-    // Initialize last known position
-    lastPointerPosition.x = originalEvent.clientX
-    lastPointerPosition.y = originalEvent.clientY
-
-    // Add global listeners for drag handling
-    document.addEventListener('pointermove', handlePointerMove, true)
-    document.addEventListener('pointerup', handlePointerUp, true)
-    document.addEventListener('keydown', handleKeyDown, true)
-
-    // Store cleanup function
-    dragCleanup = () => {
-      document.removeEventListener('pointermove', handlePointerMove, true)
-      document.removeEventListener('pointerup', handlePointerUp, true)
-      document.removeEventListener('keydown', handleKeyDown, true)
-    }
-  }
-
-  // Cleanup on unmount
-  function cleanup() {
-    isDragging = false
-    if (dragCleanup) {
-      dragCleanup()
-      dragCleanup = null
-    }
-  }
-
-  return {
-    handleSlotPointerDown,
-    cleanup
-  }
-}

src/composables/graph/useGraphNodeManager.ts

@@ -1,810 +0,0 @@
-/**
- * Vue node lifecycle management for LiteGraph integration
- * Provides event-driven reactivity with performance optimizations
- */
-import { nextTick, reactive, readonly } from 'vue'
-
-import { layoutMutations } from '@/renderer/core/layout/operations/LayoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
-import type { WidgetValue } from '@/types/simplifiedWidget'
-import type { SpatialIndexDebugInfo } from '@/types/spatialIndex'
-
-import type { LGraph, LGraphNode } from '../../lib/litegraph/src/litegraph'
-import { type Bounds, QuadTree } from '../../utils/spatial/QuadTree'
-
-export interface NodeState {
-  visible: boolean
-  dirty: boolean
-  lastUpdate: number
-  culled: boolean
-}
-
-export interface NodeMetadata {
-  lastRenderTime: number
-  cachedBounds: DOMRect | null
-  lodLevel: 'high' | 'medium' | 'low'
-  spatialIndex?: QuadTree<string>
-}
-
-export interface PerformanceMetrics {
-  fps: number
-  frameTime: number
-  updateTime: number
-  nodeCount: number
-  culledCount: number
-  callbackUpdateCount: number
-  rafUpdateCount: number
-  adaptiveQuality: boolean
-}
-
-export interface SafeWidgetData {
-  name: string
-  type: string
-  value: WidgetValue
-  options?: Record<string, unknown>
-  callback?: ((value: unknown) => void) | undefined
-}
-
-export interface VueNodeData {
-  id: string
-  title: string
-  type: string
-  mode: number
-  selected: boolean
-  executing: boolean
-  widgets?: SafeWidgetData[]
-  inputs?: unknown[]
-  outputs?: unknown[]
-  flags?: {
-    collapsed?: boolean
-  }
-}
-
-export interface SpatialMetrics {
-  queryTime: number
-  nodesInIndex: number
-}
-
-export interface GraphNodeManager {
-  // Reactive state - safe data extracted from LiteGraph nodes
-  vueNodeData: ReadonlyMap<string, VueNodeData>
-  nodeState: ReadonlyMap<string, NodeState>
-  nodePositions: ReadonlyMap<string, { x: number; y: number }>
-  nodeSizes: ReadonlyMap<string, { width: number; height: number }>
-
-  // Access to original LiteGraph nodes (non-reactive)
-  getNode(id: string): LGraphNode | undefined
-
-  // Lifecycle methods
-  setupEventListeners(): () => void
-  cleanup(): void
-
-  // Update methods
-  scheduleUpdate(
-    nodeId?: string,
-    priority?: 'critical' | 'normal' | 'low'
-  ): void
-  forceSync(): void
-  detectChangesInRAF(): void
-
-  // Spatial queries
-  getVisibleNodeIds(viewportBounds: Bounds): Set<string>
-
-  // Performance
-  performanceMetrics: PerformanceMetrics
-  spatialMetrics: SpatialMetrics
-
-  // Debug
-  getSpatialIndexDebugInfo(): SpatialIndexDebugInfo | null
-}
-
-export const useGraphNodeManager = (graph: LGraph): GraphNodeManager => {
-  // Safe reactive data extracted from LiteGraph nodes
-  const vueNodeData = reactive(new Map<string, VueNodeData>())
-  const nodeState = reactive(new Map<string, NodeState>())
-  const nodePositions = reactive(new Map<string, { x: number; y: number }>())
-  const nodeSizes = reactive(
-    new Map<string, { width: number; height: number }>()
-  )
-
-  // Non-reactive storage for original LiteGraph nodes
-  const nodeRefs = new Map<string, LGraphNode>()
-
-  // WeakMap for heavy data that auto-GCs when nodes are removed
-  const nodeMetadata = new WeakMap<LGraphNode, NodeMetadata>()
-
-  // Performance tracking
-  const performanceMetrics = reactive<PerformanceMetrics>({
-    fps: 0,
-    frameTime: 0,
-    updateTime: 0,
-    nodeCount: 0,
-    culledCount: 0,
-    callbackUpdateCount: 0,
-    rafUpdateCount: 0,
-    adaptiveQuality: false
-  })
-
-  // Spatial indexing using QuadTree
-  const spatialIndex = new QuadTree<string>(
-    { x: -10000, y: -10000, width: 20000, height: 20000 },
-    { maxDepth: 6, maxItemsPerNode: 4 }
-  )
-  let lastSpatialQueryTime = 0
-
-  // Spatial metrics
-  const spatialMetrics = reactive<SpatialMetrics>({
-    queryTime: 0,
-    nodesInIndex: 0
-  })
-
-  // Update batching
-  const pendingUpdates = new Set<string>()
-  const criticalUpdates = new Set<string>()
-  const lowPriorityUpdates = new Set<string>()
-  let updateScheduled = false
-  let batchTimeoutId: number | null = null
-
-  // Change detection state
-  const lastNodesSnapshot = new Map<
-    string,
-    { pos: [number, number]; size: [number, number] }
-  >()
-
-  const attachMetadata = (node: LGraphNode) => {
-    nodeMetadata.set(node, {
-      lastRenderTime: performance.now(),
-      cachedBounds: null,
-      lodLevel: 'high',
-      spatialIndex: undefined
-    })
-  }
-
-  // Extract safe data from LiteGraph node for Vue consumption
-  const extractVueNodeData = (node: LGraphNode): VueNodeData => {
-    // Extract safe widget data
-    const safeWidgets = node.widgets?.map((widget) => {
-      try {
-        // TODO: Use widget.getReactiveData() once TypeScript types are updated
-        let value = widget.value
-
-        // For combo widgets, if value is undefined, use the first option as default
-        if (
-          value === undefined &&
-          widget.type === 'combo' &&
-          widget.options?.values &&
-          Array.isArray(widget.options.values) &&
-          widget.options.values.length > 0
-        ) {
-          value = widget.options.values[0]
-        }
-
-        return {
-          name: widget.name,
-          type: widget.type,
-          value: value,
-          options: widget.options ? { ...widget.options } : undefined,
-          callback: widget.callback
-        }
-      } catch (error) {
-        return {
-          name: widget.name || 'unknown',
-          type: widget.type || 'text',
-          value: undefined, // Already a valid WidgetValue
-          options: undefined,
-          callback: undefined
-        }
-      }
-    })
-
-    return {
-      id: String(node.id),
-      title: node.title || 'Untitled',
-      type: node.type || 'Unknown',
-      mode: node.mode || 0,
-      selected: node.selected || false,
-      executing: false, // Will be updated separately based on execution state
-      widgets: safeWidgets,
-      inputs: node.inputs ? [...node.inputs] : undefined,
-      outputs: node.outputs ? [...node.outputs] : undefined,
-      flags: node.flags ? { ...node.flags } : undefined
-    }
-  }
-
-  // Get access to original LiteGraph node (non-reactive)
-  const getNode = (id: string): LGraphNode | undefined => {
-    return nodeRefs.get(id)
-  }
-
-  /**
-   * Validates that a value is a valid WidgetValue type
-   */
-  const validateWidgetValue = (value: unknown): WidgetValue => {
-    if (value === null || value === undefined || value === void 0) {
-      return undefined
-    }
-    if (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      typeof value === 'boolean'
-    ) {
-      return value
-    }
-    if (typeof value === 'object') {
-      // Check if it's a File array
-      if (Array.isArray(value) && value.every((item) => item instanceof File)) {
-        return value as File[]
-      }
-      // Otherwise it's a generic object
-      return value as object
-    }
-    // If none of the above, return undefined
-    console.warn(`Invalid widget value type: ${typeof value}`, value)
-    return undefined
-  }
-
-  /**
-   * Updates Vue state when widget values change
-   */
-  const updateVueWidgetState = (
-    nodeId: string,
-    widgetName: string,
-    value: unknown
-  ): void => {
-    try {
-      const currentData = vueNodeData.get(nodeId)
-      if (!currentData?.widgets) return
-
-      const updatedWidgets = currentData.widgets.map((w) =>
-        w.name === widgetName ? { ...w, value: validateWidgetValue(value) } : w
-      )
-      vueNodeData.set(nodeId, {
-        ...currentData,
-        widgets: updatedWidgets
-      })
-      performanceMetrics.callbackUpdateCount++
-    } catch (error) {
-      // Ignore widget update errors to prevent cascade failures
-    }
-  }
-
-  /**
-   * Creates a wrapped callback for a widget that maintains LiteGraph/Vue sync
-   */
-  const createWrappedWidgetCallback = (
-    widget: { value?: unknown; name: string }, // LiteGraph widget with minimal typing
-    originalCallback: ((value: unknown) => void) | undefined,
-    nodeId: string
-  ) => {
-    let updateInProgress = false
-
-    return (value: unknown) => {
-      if (updateInProgress) return
-      updateInProgress = true
-
-      try {
-        // 1. Update the widget value in LiteGraph (critical for LiteGraph state)
-        // Validate that the value is of an acceptable type
-        if (
-          value !== null &&
-          value !== undefined &&
-          typeof value !== 'string' &&
-          typeof value !== 'number' &&
-          typeof value !== 'boolean' &&
-          typeof value !== 'object'
-        ) {
-          console.warn(`Invalid widget value type: ${typeof value}`)
-          updateInProgress = false
-          return
-        }
-
-        // Always update widget.value to ensure sync
-        widget.value = value
-
-        // 2. Call the original callback if it exists
-        if (originalCallback) {
-          originalCallback.call(widget, value)
-        }
-
-        // 3. Update Vue state to maintain synchronization
-        updateVueWidgetState(nodeId, widget.name, value)
-      } finally {
-        updateInProgress = false
-      }
-    }
-  }
-
-  /**
-   * Sets up widget callbacks for a node - now with reduced nesting
-   */
-  const setupNodeWidgetCallbacks = (node: LGraphNode) => {
-    if (!node.widgets) return
-
-    const nodeId = String(node.id)
-
-    node.widgets.forEach((widget) => {
-      const originalCallback = widget.callback
-      widget.callback = createWrappedWidgetCallback(
-        widget,
-        originalCallback,
-        nodeId
-      )
-    })
-  }
-
-  // Uncomment when needed for future features
-  // const getNodeMetadata = (node: LGraphNode): NodeMetadata => {
-  //   let metadata = nodeMetadata.get(node)
-  //   if (!metadata) {
-  //     attachMetadata(node)
-  //     metadata = nodeMetadata.get(node)!
-  //   }
-  //   return metadata
-  // }
-
-  const scheduleUpdate = (
-    nodeId?: string,
-    priority: 'critical' | 'normal' | 'low' = 'normal'
-  ) => {
-    if (nodeId) {
-      const state = nodeState.get(nodeId)
-      if (state) state.dirty = true
-
-      // Priority queuing
-      if (priority === 'critical') {
-        criticalUpdates.add(nodeId)
-        flush() // Immediate flush for critical updates
-        return
-      } else if (priority === 'low') {
-        lowPriorityUpdates.add(nodeId)
-      } else {
-        pendingUpdates.add(nodeId)
-      }
-    }
-
-    if (!updateScheduled) {
-      updateScheduled = true
-
-      // Adaptive batching strategy
-      if (pendingUpdates.size > 10) {
-        // Many updates - batch in nextTick
-        void nextTick(() => flush())
-      } else {
-        // Few updates - small delay for more batching
-        batchTimeoutId = window.setTimeout(() => flush(), 4)
-      }
-    }
-  }
-
-  const flush = () => {
-    const startTime = performance.now()
-
-    if (batchTimeoutId !== null) {
-      clearTimeout(batchTimeoutId)
-      batchTimeoutId = null
-    }
-
-    // Clear all pending updates
-    criticalUpdates.clear()
-    pendingUpdates.clear()
-    lowPriorityUpdates.clear()
-    updateScheduled = false
-
-    // Sync with graph state
-    syncWithGraph()
-
-    const endTime = performance.now()
-    performanceMetrics.updateTime = endTime - startTime
-  }
-
-  const syncWithGraph = () => {
-    if (!graph?._nodes) return
-
-    const currentNodes = new Set(graph._nodes.map((n) => String(n.id)))
-
-    // Remove deleted nodes
-    for (const id of Array.from(vueNodeData.keys())) {
-      if (!currentNodes.has(id)) {
-        nodeRefs.delete(id)
-        vueNodeData.delete(id)
-        nodeState.delete(id)
-        nodePositions.delete(id)
-        nodeSizes.delete(id)
-        lastNodesSnapshot.delete(id)
-        spatialIndex.remove(id)
-      }
-    }
-
-    // Add/update existing nodes
-    graph._nodes.forEach((node) => {
-      const id = String(node.id)
-
-      // Store non-reactive reference
-      nodeRefs.set(id, node)
-
-      // Set up widget callbacks BEFORE extracting data (critical order)
-      setupNodeWidgetCallbacks(node)
-
-      // Extract and store safe data for Vue
-      vueNodeData.set(id, extractVueNodeData(node))
-
-      if (!nodeState.has(id)) {
-        nodeState.set(id, {
-          visible: true,
-          dirty: false,
-          lastUpdate: performance.now(),
-          culled: false
-        })
-        nodePositions.set(id, { x: node.pos[0], y: node.pos[1] })
-        nodeSizes.set(id, { width: node.size[0], height: node.size[1] })
-        attachMetadata(node)
-
-        // Add to spatial index
-        const bounds: Bounds = {
-          x: node.pos[0],
-          y: node.pos[1],
-          width: node.size[0],
-          height: node.size[1]
-        }
-        spatialIndex.insert(id, bounds, id)
-      }
-    })
-
-    // Update performance metrics
-    performanceMetrics.nodeCount = vueNodeData.size
-    performanceMetrics.culledCount = Array.from(nodeState.values()).filter(
-      (s) => s.culled
-    ).length
-  }
-
-  // Most performant: Direct position sync without re-setting entire node
-  // Query visible nodes using QuadTree spatial index
-  const getVisibleNodeIds = (viewportBounds: Bounds): Set<string> => {
-    const startTime = performance.now()
-
-    // Use QuadTree for fast spatial query
-    const results: string[] = spatialIndex.query(viewportBounds)
-    const visibleIds = new Set(results)
-
-    lastSpatialQueryTime = performance.now() - startTime
-    spatialMetrics.queryTime = lastSpatialQueryTime
-
-    return visibleIds
-  }
-
-  /**
-   * Detects position changes for a single node and updates reactive state
-   */
-  const detectPositionChanges = (node: LGraphNode, id: string): boolean => {
-    const currentPos = nodePositions.get(id)
-
-    if (
-      !currentPos ||
-      currentPos.x !== node.pos[0] ||
-      currentPos.y !== node.pos[1]
-    ) {
-      nodePositions.set(id, { x: node.pos[0], y: node.pos[1] })
-
-      // Push position change to layout store
-      // Source is already set to 'canvas' in detectChangesInRAF
-      void layoutMutations.moveNode(id, { x: node.pos[0], y: node.pos[1] })
-
-      return true
-    }
-    return false
-  }
-
-  /**
-   * Detects size changes for a single node and updates reactive state
-   */
-  const detectSizeChanges = (node: LGraphNode, id: string): boolean => {
-    const currentSize = nodeSizes.get(id)
-
-    if (
-      !currentSize ||
-      currentSize.width !== node.size[0] ||
-      currentSize.height !== node.size[1]
-    ) {
-      nodeSizes.set(id, { width: node.size[0], height: node.size[1] })
-
-      // Push size change to layout store
-      // Source is already set to 'canvas' in detectChangesInRAF
-      void layoutMutations.resizeNode(id, {
-        width: node.size[0],
-        height: node.size[1]
-      })
-
-      return true
-    }
-    return false
-  }
-
-  /**
-   * Updates spatial index for a node if bounds changed
-   */
-  const updateSpatialIndex = (node: LGraphNode, id: string): void => {
-    const bounds: Bounds = {
-      x: node.pos[0],
-      y: node.pos[1],
-      width: node.size[0],
-      height: node.size[1]
-    }
-    spatialIndex.update(id, bounds)
-  }
-
-  /**
-   * Updates performance metrics after change detection
-   */
-  const updatePerformanceMetrics = (
-    startTime: number,
-    positionUpdates: number,
-    sizeUpdates: number
-  ): void => {
-    const endTime = performance.now()
-    performanceMetrics.updateTime = endTime - startTime
-    performanceMetrics.nodeCount = vueNodeData.size
-    performanceMetrics.culledCount = Array.from(nodeState.values()).filter(
-      (state) => state.culled
-    ).length
-    spatialMetrics.nodesInIndex = spatialIndex.size
-
-    if (positionUpdates > 0 || sizeUpdates > 0) {
-      performanceMetrics.rafUpdateCount++
-    }
-  }
-
-  /**
-   * Main RAF change detection function - now simplified with extracted helpers
-   */
-  const detectChangesInRAF = () => {
-    const startTime = performance.now()
-
-    if (!graph?._nodes) return
-
-    let positionUpdates = 0
-    let sizeUpdates = 0
-
-    // Set source for all canvas-driven updates
-    layoutMutations.setSource(LayoutSource.Canvas)
-
-    // Process each node for changes
-    for (const node of graph._nodes) {
-      const id = String(node.id)
-
-      const posChanged = detectPositionChanges(node, id)
-      const sizeChanged = detectSizeChanges(node, id)
-
-      if (posChanged) positionUpdates++
-      if (sizeChanged) sizeUpdates++
-
-      // Update spatial index if geometry changed
-      if (posChanged || sizeChanged) {
-        updateSpatialIndex(node, id)
-      }
-    }
-
-    updatePerformanceMetrics(startTime, positionUpdates, sizeUpdates)
-  }
-
-  /**
-   * Handles node addition to the graph - sets up Vue state and spatial indexing
-   */
-  const handleNodeAdded = (
-    node: LGraphNode,
-    originalCallback?: (node: LGraphNode) => void
-  ) => {
-    const id = String(node.id)
-
-    // Store non-reactive reference to original node
-    nodeRefs.set(id, node)
-
-    // Set up widget callbacks BEFORE extracting data (critical order)
-    setupNodeWidgetCallbacks(node)
-
-    // Extract safe data for Vue (now with proper callbacks)
-    vueNodeData.set(id, extractVueNodeData(node))
-
-    // Set up reactive tracking state
-    nodeState.set(id, {
-      visible: true,
-      dirty: false,
-      lastUpdate: performance.now(),
-      culled: false
-    })
-    nodePositions.set(id, { x: node.pos[0], y: node.pos[1] })
-    nodeSizes.set(id, { width: node.size[0], height: node.size[1] })
-    attachMetadata(node)
-
-    // Add to spatial index for viewport culling
-    const bounds: Bounds = {
-      x: node.pos[0],
-      y: node.pos[1],
-      width: node.size[0],
-      height: node.size[1]
-    }
-    spatialIndex.insert(id, bounds, id)
-
-    // Add node to layout store
-    layoutMutations.setSource(LayoutSource.Canvas)
-    void layoutMutations.createNode(id, {
-      position: { x: node.pos[0], y: node.pos[1] },
-      size: { width: node.size[0], height: node.size[1] },
-      zIndex: node.order || 0,
-      visible: true
-    })
-
-    // Call original callback if provided
-    if (originalCallback) {
-      void originalCallback(node)
-    }
-  }
-
-  /**
-   * Handles node removal from the graph - cleans up all references
-   */
-  const handleNodeRemoved = (
-    node: LGraphNode,
-    originalCallback?: (node: LGraphNode) => void
-  ) => {
-    const id = String(node.id)
-
-    // Remove from spatial index
-    spatialIndex.remove(id)
-
-    // Remove node from layout store
-    layoutMutations.setSource(LayoutSource.Canvas)
-    void layoutMutations.deleteNode(id)
-
-    // Clean up all tracking references
-    nodeRefs.delete(id)
-    vueNodeData.delete(id)
-    nodeState.delete(id)
-    nodePositions.delete(id)
-    nodeSizes.delete(id)
-    lastNodesSnapshot.delete(id)
-
-    // Call original callback if provided
-    if (originalCallback) {
-      originalCallback(node)
-    }
-  }
-
-  /**
-   * Creates cleanup function for event listeners and state
-   */
-  const createCleanupFunction = (
-    originalOnNodeAdded: ((node: LGraphNode) => void) | undefined,
-    originalOnNodeRemoved: ((node: LGraphNode) => void) | undefined,
-    originalOnTrigger: ((action: string, param: unknown) => void) | undefined
-  ) => {
-    return () => {
-      // Restore original callbacks
-      graph.onNodeAdded = originalOnNodeAdded || undefined
-      graph.onNodeRemoved = originalOnNodeRemoved || undefined
-      graph.onTrigger = originalOnTrigger || undefined
-
-      // Clear pending updates
-      if (batchTimeoutId !== null) {
-        clearTimeout(batchTimeoutId)
-        batchTimeoutId = null
-      }
-
-      // Clear all state maps
-      nodeRefs.clear()
-      vueNodeData.clear()
-      nodeState.clear()
-      nodePositions.clear()
-      nodeSizes.clear()
-      lastNodesSnapshot.clear()
-      pendingUpdates.clear()
-      criticalUpdates.clear()
-      lowPriorityUpdates.clear()
-      spatialIndex.clear()
-    }
-  }
-
-  /**
-   * Sets up event listeners - now simplified with extracted handlers
-   */
-  const setupEventListeners = (): (() => void) => {
-    // Store original callbacks
-    const originalOnNodeAdded = graph.onNodeAdded
-    const originalOnNodeRemoved = graph.onNodeRemoved
-    const originalOnTrigger = graph.onTrigger
-
-    // Set up graph event handlers
-    graph.onNodeAdded = (node: LGraphNode) => {
-      handleNodeAdded(node, originalOnNodeAdded)
-    }
-
-    graph.onNodeRemoved = (node: LGraphNode) => {
-      handleNodeRemoved(node, originalOnNodeRemoved)
-    }
-
-    // Listen for property change events from instrumented nodes
-    graph.onTrigger = (action: string, param: unknown) => {
-      if (
-        action === 'node:property:changed' &&
-        param &&
-        typeof param === 'object'
-      ) {
-        const event = param as {
-          nodeId: string | number
-          property: string
-          oldValue: unknown
-          newValue: unknown
-        }
-
-        const nodeId = String(event.nodeId)
-        const currentData = vueNodeData.get(nodeId)
-
-        if (currentData) {
-          if (event.property === 'title') {
-            vueNodeData.set(nodeId, {
-              ...currentData,
-              title: String(event.newValue)
-            })
-          } else if (event.property === 'flags.collapsed') {
-            vueNodeData.set(nodeId, {
-              ...currentData,
-              flags: {
-                ...currentData.flags,
-                collapsed: Boolean(event.newValue)
-              }
-            })
-          }
-        }
-      }
-
-      // Call original trigger handler if it exists
-      if (originalOnTrigger) {
-        originalOnTrigger(action, param)
-      }
-    }
-
-    // Initialize state
-    syncWithGraph()
-
-    // Return cleanup function
-    return createCleanupFunction(
-      originalOnNodeAdded || undefined,
-      originalOnNodeRemoved || undefined,
-      originalOnTrigger || undefined
-    )
-  }
-
-  // Set up event listeners immediately
-  const cleanup = setupEventListeners()
-
-  // Process any existing nodes after event listeners are set up
-  if (graph._nodes && graph._nodes.length > 0) {
-    graph._nodes.forEach((node: LGraphNode) => {
-      if (graph.onNodeAdded) {
-        graph.onNodeAdded(node)
-      }
-    })
-  }
-
-  return {
-    vueNodeData: readonly(vueNodeData) as ReadonlyMap<string, VueNodeData>,
-    nodeState: readonly(nodeState) as ReadonlyMap<string, NodeState>,
-    nodePositions: readonly(nodePositions) as ReadonlyMap<
-      string,
-      { x: number; y: number }
-    >,
-    nodeSizes: readonly(nodeSizes) as ReadonlyMap<
-      string,
-      { width: number; height: number }
-    >,
-    getNode,
-    setupEventListeners,
-    cleanup,
-    scheduleUpdate,
-    forceSync: syncWithGraph,
-    detectChangesInRAF,
-    getVisibleNodeIds,
-    performanceMetrics,
-    spatialMetrics: readonly(spatialMetrics),
-    getSpatialIndexDebugInfo: () => spatialIndex.getDebugInfo()
-  }
-}

src/composables/graph/useSpatialIndex.ts

@@ -1,212 +0,0 @@
-/**
- * Composable for spatial indexing of nodes using QuadTree
- * Integrates with useGraphNodeManager for efficient viewport culling
- */
-import { useDebounceFn } from '@vueuse/core'
-import { computed, reactive, ref } from 'vue'
-
-import { type Bounds, QuadTree } from '@/utils/spatial/QuadTree'
-
-export interface SpatialIndexOptions {
-  worldBounds?: Bounds
-  maxDepth?: number
-  maxItemsPerNode?: number
-  enableDebugVisualization?: boolean
-  updateDebounceMs?: number
-}
-
-interface SpatialMetrics {
-  queryTime: number
-  totalNodes: number
-  visibleNodes: number
-  treeDepth: number
-  rebuildCount: number
-}
-
-export const useSpatialIndex = (options: SpatialIndexOptions = {}) => {
-  // Default world bounds (can be expanded dynamically)
-  const defaultBounds: Bounds = {
-    x: -10000,
-    y: -10000,
-    width: 20000,
-    height: 20000
-  }
-
-  // QuadTree instance
-  const quadTree = ref<QuadTree<string> | null>(null)
-
-  // Performance metrics
-  const metrics = reactive<SpatialMetrics>({
-    queryTime: 0,
-    totalNodes: 0,
-    visibleNodes: 0,
-    treeDepth: 0,
-    rebuildCount: 0
-  })
-
-  // Debug visualization data (unused for now but may be used in future)
-  // const debugBounds = ref<Bounds[]>([])
-
-  // Initialize QuadTree
-  const initialize = (bounds: Bounds = defaultBounds) => {
-    quadTree.value = new QuadTree<string>(bounds, {
-      maxDepth: options.maxDepth ?? 6,
-      maxItemsPerNode: options.maxItemsPerNode ?? 4
-    })
-    metrics.rebuildCount++
-  }
-
-  // Add or update node in spatial index
-  const updateNode = (
-    nodeId: string,
-    position: { x: number; y: number },
-    size: { width: number; height: number }
-  ) => {
-    if (!quadTree.value) {
-      initialize()
-    }
-
-    const bounds: Bounds = {
-      x: position.x,
-      y: position.y,
-      width: size.width,
-      height: size.height
-    }
-
-    // Use insert instead of update - insert handles both new and existing nodes
-    quadTree.value!.insert(nodeId, bounds, nodeId)
-    metrics.totalNodes = quadTree.value!.size
-  }
-
-  // Batch update for multiple nodes
-  const batchUpdate = (
-    updates: Array<{
-      id: string
-      position: { x: number; y: number }
-      size: { width: number; height: number }
-    }>
-  ) => {
-    if (!quadTree.value) {
-      initialize()
-    }
-
-    for (const update of updates) {
-      const bounds: Bounds = {
-        x: update.position.x,
-        y: update.position.y,
-        width: update.size.width,
-        height: update.size.height
-      }
-      // Use insert instead of update - insert handles both new and existing nodes
-      quadTree.value!.insert(update.id, bounds, update.id)
-    }
-
-    metrics.totalNodes = quadTree.value!.size
-  }
-
-  // Remove node from spatial index
-  const removeNode = (nodeId: string) => {
-    if (!quadTree.value) return
-
-    quadTree.value.remove(nodeId)
-    metrics.totalNodes = quadTree.value.size
-  }
-
-  // Query nodes within viewport bounds
-  const queryViewport = (viewportBounds: Bounds): string[] => {
-    if (!quadTree.value) return []
-
-    const startTime = performance.now()
-    const nodeIds = quadTree.value.query(viewportBounds)
-    const queryTime = performance.now() - startTime
-
-    metrics.queryTime = queryTime
-    metrics.visibleNodes = nodeIds.length
-
-    return nodeIds
-  }
-
-  // Get nodes within a radius (for proximity queries)
-  const queryRadius = (
-    center: { x: number; y: number },
-    radius: number
-  ): string[] => {
-    if (!quadTree.value) return []
-
-    const bounds: Bounds = {
-      x: center.x - radius,
-      y: center.y - radius,
-      width: radius * 2,
-      height: radius * 2
-    }
-
-    return quadTree.value.query(bounds)
-  }
-
-  // Clear all nodes
-  const clear = () => {
-    if (!quadTree.value) return
-
-    quadTree.value.clear()
-    metrics.totalNodes = 0
-    metrics.visibleNodes = 0
-  }
-
-  // Rebuild tree (useful after major layout changes)
-  const rebuild = (
-    nodes: Map<
-      string,
-      {
-        position: { x: number; y: number }
-        size: { width: number; height: number }
-      }
-    >
-  ) => {
-    initialize()
-
-    const updates = Array.from(nodes.entries()).map(([id, data]) => ({
-      id,
-      position: data.position,
-      size: data.size
-    }))
-
-    batchUpdate(updates)
-  }
-
-  // Get debug visualization data
-  const getDebugVisualization = () => {
-    if (!quadTree.value || !options.enableDebugVisualization) return null
-
-    return quadTree.value.getDebugInfo()
-  }
-
-  // Debounced update for performance
-  const debouncedUpdateNode = useDebounceFn(
-    updateNode,
-    options.updateDebounceMs ?? 16
-  )
-
-  return {
-    // Core functions
-    initialize,
-    updateNode,
-    batchUpdate,
-    removeNode,
-    queryViewport,
-    queryRadius,
-    clear,
-    rebuild,
-
-    // Debounced version for high-frequency updates
-    debouncedUpdateNode,
-
-    // Metrics
-    metrics: computed(() => metrics),
-
-    // Debug
-    getDebugVisualization,
-
-    // Direct access to QuadTree (for advanced usage)
-    quadTree: computed(() => quadTree.value)
-  }
-}

src/composables/graph/useTransformSettling.ts

@@ -1,151 +0,0 @@
-import { useDebounceFn, useEventListener, useThrottleFn } from '@vueuse/core'
-import { ref } from 'vue'
-import type { MaybeRefOrGetter } from 'vue'
-
-export interface TransformSettlingOptions {
-  /**
-   * Delay in ms before transform is considered "settled" after last interaction
-   * @default 200
-   */
-  settleDelay?: number
-  /**
-   * Whether to track both zoom (wheel) and pan (pointer drag) interactions
-   * @default false
-   */
-  trackPan?: boolean
-  /**
-   * Throttle delay for high-frequency pointermove events (only used when trackPan is true)
-   * @default 16 (~60fps)
-   */
-  pointerMoveThrottle?: number
-  /**
-   * Whether to use passive event listeners (better performance but can't preventDefault)
-   * @default true
-   */
-  passive?: boolean
-}
-
-/**
- * Tracks when canvas transforms (zoom/pan) are actively changing vs settled.
- *
- * This composable helps optimize rendering quality during transformations.
- * When the user is actively zooming or panning, we can reduce rendering quality
- * for better performance. Once the transform "settles" (stops changing), we can
- * trigger high-quality re-rasterization.
- *
- * The settling concept prevents constant quality switching during interactions
- * by waiting for a period of inactivity before considering the transform complete.
- *
- * Uses VueUse's useEventListener for automatic cleanup and useDebounceFn for
- * efficient settle detection.
- *
- * @example
- * ```ts
- * const { isTransforming } = useTransformSettling(canvasRef, {
- *   settleDelay: 200,
- *   trackPan: true
- * })
- *
- * // Use in CSS classes or rendering logic
- * const cssClass = computed(() => ({
- *   'low-quality': isTransforming.value,
- *   'high-quality': !isTransforming.value
- * }))
- * ```
- */
-export function useTransformSettling(
-  target: MaybeRefOrGetter<HTMLElement | null | undefined>,
-  options: TransformSettlingOptions = {}
-) {
-  const {
-    settleDelay = 200,
-    trackPan = false,
-    pointerMoveThrottle = 16,
-    passive = true
-  } = options
-
-  const isTransforming = ref(false)
-  let isPanning = false
-
-  /**
-   * Mark transform as active
-   */
-  const markTransformActive = () => {
-    isTransforming.value = true
-  }
-
-  /**
-   * Mark transform as settled (debounced)
-   */
-  const markTransformSettled = useDebounceFn(() => {
-    isTransforming.value = false
-  }, settleDelay)
-
-  /**
-   * Handle any transform event - mark active then queue settle
-   */
-  const handleTransformEvent = () => {
-    markTransformActive()
-    void markTransformSettled()
-  }
-
-  // Wheel handler
-  const handleWheel = () => {
-    handleTransformEvent()
-  }
-
-  // Pointer handlers for panning
-  const handlePointerDown = () => {
-    if (trackPan) {
-      isPanning = true
-      handleTransformEvent()
-    }
-  }
-
-  // Throttled pointer move handler for performance
-  const handlePointerMove = trackPan
-    ? useThrottleFn(() => {
-        if (isPanning) {
-          handleTransformEvent()
-        }
-      }, pointerMoveThrottle)
-    : undefined
-
-  const handlePointerEnd = () => {
-    if (trackPan) {
-      isPanning = false
-      // Don't immediately stop - let the debounced settle handle it
-    }
-  }
-
-  // Register event listeners with auto-cleanup
-  useEventListener(target, 'wheel', handleWheel, {
-    capture: true,
-    passive
-  })
-
-  if (trackPan) {
-    useEventListener(target, 'pointerdown', handlePointerDown, {
-      capture: true
-    })
-
-    if (handlePointerMove) {
-      useEventListener(target, 'pointermove', handlePointerMove, {
-        capture: true,
-        passive
-      })
-    }
-
-    useEventListener(target, 'pointerup', handlePointerEnd, {
-      capture: true
-    })
-
-    useEventListener(target, 'pointercancel', handlePointerEnd, {
-      capture: true
-    })
-  }
-
-  return {
-    isTransforming
-  }
-}

src/composables/graph/useWidgetValue.ts

@@ -1,155 +0,0 @@
-/**
- * Composable for managing widget value synchronization between Vue and LiteGraph
- * Provides consistent pattern for immediate UI updates and LiteGraph callbacks
- */
-import { type Ref, ref, watch } from 'vue'
-
-import type { SimplifiedWidget, WidgetValue } from '@/types/simplifiedWidget'
-
-export interface UseWidgetValueOptions<
-  T extends WidgetValue = WidgetValue,
-  U = T
-> {
-  /** The widget configuration from LiteGraph */
-  widget: SimplifiedWidget<T>
-  /** The current value from parent component */
-  modelValue: T
-  /** Default value if modelValue is null/undefined */
-  defaultValue: T
-  /** Emit function from component setup */
-  emit: (event: 'update:modelValue', value: T) => void
-  /** Optional value transformer before sending to LiteGraph */
-  transform?: (value: U) => T
-}
-
-export interface UseWidgetValueReturn<
-  T extends WidgetValue = WidgetValue,
-  U = T
-> {
-  /** Local value for immediate UI updates */
-  localValue: Ref<T>
-  /** Handler for user interactions */
-  onChange: (newValue: U) => void
-}
-
-/**
- * Manages widget value synchronization with LiteGraph
- *
- * @example
- * ```vue
- * const { localValue, onChange } = useWidgetValue({
- *   widget: props.widget,
- *   modelValue: props.modelValue,
- *   defaultValue: ''
- * })
- * ```
- */
-export function useWidgetValue<T extends WidgetValue = WidgetValue, U = T>({
-  widget,
-  modelValue,
-  defaultValue,
-  emit,
-  transform
-}: UseWidgetValueOptions<T, U>): UseWidgetValueReturn<T, U> {
-  // Local value for immediate UI updates
-  const localValue = ref<T>(modelValue ?? defaultValue)
-
-  // Handle user changes
-  const onChange = (newValue: U) => {
-    // Handle different PrimeVue component signatures
-    let processedValue: T
-    if (transform) {
-      processedValue = transform(newValue)
-    } else {
-      // Ensure type safety - only cast when types are compatible
-      if (
-        typeof newValue === typeof defaultValue ||
-        newValue === null ||
-        newValue === undefined
-      ) {
-        processedValue = (newValue ?? defaultValue) as T
-      } else {
-        console.warn(
-          `useWidgetValue: Type mismatch for widget ${widget.name}. Expected ${typeof defaultValue}, got ${typeof newValue}`
-        )
-        processedValue = defaultValue
-      }
-    }
-
-    // 1. Update local state for immediate UI feedback
-    localValue.value = processedValue
-
-    // 2. Emit to parent component
-    emit('update:modelValue', processedValue)
-  }
-
-  // Watch for external updates from LiteGraph
-  watch(
-    () => modelValue,
-    (newValue) => {
-      localValue.value = newValue ?? defaultValue
-    }
-  )
-
-  return {
-    localValue: localValue as Ref<T>,
-    onChange
-  }
-}
-
-/**
- * Type-specific helper for string widgets
- */
-export function useStringWidgetValue(
-  widget: SimplifiedWidget<string>,
-  modelValue: string,
-  emit: (event: 'update:modelValue', value: string) => void
-) {
-  return useWidgetValue({
-    widget,
-    modelValue,
-    defaultValue: '',
-    emit,
-    transform: (value: string | undefined) => String(value || '') // Handle undefined from PrimeVue
-  })
-}
-
-/**
- * Type-specific helper for number widgets
- */
-export function useNumberWidgetValue(
-  widget: SimplifiedWidget<number>,
-  modelValue: number,
-  emit: (event: 'update:modelValue', value: number) => void
-) {
-  return useWidgetValue({
-    widget,
-    modelValue,
-    defaultValue: 0,
-    emit,
-    transform: (value: number | number[]) => {
-      // Handle PrimeVue Slider which can emit number | number[]
-      if (Array.isArray(value)) {
-        return value.length > 0 ? value[0] ?? 0 : 0
-      }
-      return Number(value) || 0
-    }
-  })
-}
-
-/**
- * Type-specific helper for boolean widgets
- */
-export function useBooleanWidgetValue(
-  widget: SimplifiedWidget<boolean>,
-  modelValue: boolean,
-  emit: (event: 'update:modelValue', value: boolean) => void
-) {
-  return useWidgetValue({
-    widget,
-    modelValue,
-    defaultValue: false,
-    emit,
-    transform: (value: boolean) => Boolean(value)
-  })
-}

src/composables/node/useNodeCanvasImagePreview.ts

@@ -1,5 +1,5 @@
+import { useImagePreviewWidget } from '@/composables/widgets/useImagePreviewWidget'
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useImagePreviewWidget } from '@/renderer/extensions/vueNodes/widgets/composables/useImagePreviewWidget'
 
 const CANVAS_IMAGE_PREVIEW_WIDGET = '$$canvas-image-preview'
 

src/composables/node/useNodeChatHistory.ts

@@ -1,6 +1,6 @@
 import type ChatHistoryWidget from '@/components/graph/widgets/ChatHistoryWidget.vue'
+import { useChatHistoryWidget } from '@/composables/widgets/useChatHistoryWidget'
 import { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useChatHistoryWidget } from '@/renderer/extensions/vueNodes/widgets/composables/useChatHistoryWidget'
 
 const CHAT_HISTORY_WIDGET_NAME = '$$node-chat-history'
 

src/composables/node/useNodePricing.ts

@@ -1,4 +1,4 @@
-import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
+import type { INodeInputSlot, LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { IComboWidget } from '@/lib/litegraph/src/types/widgets'
 
 /**
@@ -179,6 +179,12 @@ const apiNodeCosts: Record<string, { displayPrice: string | PricingFunction }> =
         const numImagesWidget = node.widgets?.find(
           (w) => w.name === 'num_images'
         ) as IComboWidget
+        const characterInput = node.inputs?.find(
+          (i) => i.name === 'character_image'
+        ) as INodeInputSlot
+        const hasCharacter =
+          typeof characterInput?.link !== 'undefined' &&
+          characterInput.link != null
 
         if (!renderingSpeedWidget)
           return '$0.03-0.08 x num_images/Run (varies with rendering speed & num_images)'
@@ -188,11 +194,23 @@ const apiNodeCosts: Record<string, { displayPrice: string | PricingFunction }> =
 
         const renderingSpeed = String(renderingSpeedWidget.value)
         if (renderingSpeed.toLowerCase().includes('quality')) {
-          basePrice = 0.09
-        } else if (renderingSpeed.toLowerCase().includes('balanced')) {
-          basePrice = 0.06
+          if (hasCharacter) {
+            basePrice = 0.2
+          } else {
+            basePrice = 0.09
+          }
+        } else if (renderingSpeed.toLowerCase().includes('default')) {
+          if (hasCharacter) {
+            basePrice = 0.15
+          } else {
+            basePrice = 0.06
+          }
         } else if (renderingSpeed.toLowerCase().includes('turbo')) {
-          basePrice = 0.03
+          if (hasCharacter) {
+            basePrice = 0.1
+          } else {
+            basePrice = 0.03
+          }
         }
 
         const totalCost = (basePrice * numImages).toFixed(2)
@@ -395,7 +413,12 @@ const apiNodeCosts: Record<string, { displayPrice: string | PricingFunction }> =
         const modeValue = String(modeWidget.value)
 
         // Same pricing matrix as KlingTextToVideoNode
-        if (modeValue.includes('v2-master')) {
+        if (modeValue.includes('v2-1')) {
+          if (modeValue.includes('10s')) {
+            return '$0.98/Run' // pro, 10s
+          }
+          return '$0.49/Run' // pro, 5s default
+        } else if (modeValue.includes('v2-master')) {
           if (modeValue.includes('10s')) {
             return '$2.80/Run'
           }
@@ -1462,7 +1485,7 @@ export const useNodePricing = () => {
       OpenAIGPTImage1: ['quality', 'n'],
       IdeogramV1: ['num_images', 'turbo'],
       IdeogramV2: ['num_images', 'turbo'],
-      IdeogramV3: ['rendering_speed', 'num_images'],
+      IdeogramV3: ['rendering_speed', 'num_images', 'character_image'],
       FluxProKontextProNode: [],
       FluxProKontextMaxNode: [],
       VeoVideoGenerationNode: ['duration_seconds'],

src/composables/node/useNodeProgressText.ts

@@ -1,5 +1,5 @@
+import { useTextPreviewWidget } from '@/composables/widgets/useProgressTextWidget'
 import { LGraphNode } from '@/lib/litegraph/src/litegraph'
-import { useTextPreviewWidget } from '@/renderer/extensions/vueNodes/widgets/composables/useProgressTextWidget'
 
 const TEXT_PREVIEW_WIDGET_NAME = '$$node-text-preview'
 

src/composables/node/useWatchWidget.ts

@@ -75,6 +75,29 @@ export const useComputedWithWidgetWatch = (
         }
       })
     })
+    if (widgetNames && widgetNames.length > widgetsToObserve.length) {
+      //Inputs have been included
+      const indexesToObserve = widgetNames
+        .map((name) =>
+          widgetsToObserve.some((w) => w.name == name)
+            ? -1
+            : node.inputs.findIndex((i) => i.name == name)
+        )
+        .filter((i) => i >= 0)
+      node.onConnectionsChange = useChainCallback(
+        node.onConnectionsChange,
+        (_type: unknown, index: number, isConnected: boolean) => {
+          if (!indexesToObserve.includes(index)) return
+          widgetValues.value = {
+            ...widgetValues.value,
+            [indexesToObserve[index]]: isConnected
+          }
+          if (triggerCanvasRedraw) {
+            node.graph?.setDirtyCanvas(true, true)
+          }
+        }
+      )
+    }
   }
 
   // Returns a function that creates a computed that responds to widget changes.

src/composables/useCoreCommands.ts

@@ -276,33 +276,6 @@ export function useCoreCommands(): ComfyCommand[] {
         app.canvas.setDirty(true, true)
       }
     },
-    {
-      id: 'Experimental.ToggleVueNodes',
-      label: () =>
-        `Experimental: ${
-          useSettingStore().get('Comfy.VueNodes.Enabled') ? 'Disable' : 'Enable'
-        } Vue Nodes`,
-      function: async () => {
-        const settingStore = useSettingStore()
-        const current = settingStore.get('Comfy.VueNodes.Enabled') ?? false
-        await settingStore.set('Comfy.VueNodes.Enabled', !current)
-      }
-    },
-    {
-      id: 'Experimental.ToggleVueNodeDebugPanel',
-      label: () =>
-        `Experimental: ${
-          useSettingStore().get('Comfy.VueNodes.DebugPanel.Visible')
-            ? 'Hide'
-            : 'Show'
-        } Vue Node Debug Panel`,
-      function: async () => {
-        const settingStore = useSettingStore()
-        const current =
-          settingStore.get('Comfy.VueNodes.DebugPanel.Visible') ?? false
-        await settingStore.set('Comfy.VueNodes.DebugPanel.Visible', !current)
-      }
-    },
     {
       id: 'Comfy.Canvas.FitView',
       icon: 'pi pi-expand',
@@ -706,36 +679,13 @@ export function useCoreCommands(): ComfyCommand[] {
           await workflowService.closeWorkflow(workflowStore.activeWorkflow)
       }
     },
-    {
-      id: 'Comfy.Feedback',
-      icon: 'pi pi-megaphone',
-      label: 'Give Feedback',
-      versionAdded: '1.8.2',
-      function: () => {
-        dialogService.showIssueReportDialog({
-          title: t('g.feedback'),
-          subtitle: t('issueReport.feedbackTitle'),
-          panelProps: {
-            errorType: 'Feedback',
-            defaultFields: ['SystemStats', 'Settings']
-          }
-        })
-      }
-    },
     {
       id: 'Comfy.ContactSupport',
       icon: 'pi pi-question',
       label: 'Contact Support',
       versionAdded: '1.17.8',
       function: () => {
-        dialogService.showIssueReportDialog({
-          title: t('issueReport.contactSupportTitle'),
-          subtitle: t('issueReport.contactSupportDescription'),
-          panelProps: {
-            errorType: 'ContactSupport',
-            defaultFields: ['Workflow', 'Logs', 'SystemStats', 'Settings']
-          }
-        })
+        window.open('https://support.comfy.org/', '_blank')
       }
     },
     {

src/composables/useFeatureFlags.ts

@@ -1,70 +0,0 @@
-/**
- * Feature flags composable for Vue node system
- * Provides safe toggles for experimental features
- */
-import { computed, watch } from 'vue'
-
-import { useSettingStore } from '@/stores/settingStore'
-
-import { LiteGraph } from '../lib/litegraph/src/litegraph'
-
-export const useFeatureFlags = () => {
-  const settingStore = useSettingStore()
-
-  /**
-   * Enable Vue-based node rendering
-   * When disabled, falls back to standard LiteGraph canvas rendering
-   */
-  const isVueNodesEnabled = computed(() => {
-    try {
-      // Off by default: ensure Vue nodes are disabled unless explicitly enabled
-      return settingStore.get('Comfy.VueNodes.Enabled') ?? false
-    } catch {
-      return false
-    }
-  })
-
-  /**
-   * Development mode features (debug panel, etc.)
-   * Automatically enabled in development builds
-   */
-  const isDevModeEnabled = computed(() => {
-    try {
-      return (
-        settingStore.get('Comfy.DevMode' as any) ??
-        process.env.NODE_ENV === 'development'
-      )
-    } catch {
-      return process.env.NODE_ENV === 'development'
-    }
-  })
-
-  /**
-   * Check if Vue nodes should be rendered at all
-   * Combines multiple conditions for safety
-   */
-  const shouldRenderVueNodes = computed(
-    () =>
-      isVueNodesEnabled.value &&
-      // Add any other safety conditions here
-      true
-  )
-
-  /**
-   * Sync the Vue nodes feature flag with LiteGraph global settings
-   */
-  const syncVueNodesFlag = () => {
-    LiteGraph.vueNodesMode = isVueNodesEnabled.value
-    console.log('Vue nodes mode:', LiteGraph.vueNodesMode)
-  }
-
-  // Watch for changes and update LiteGraph
-  watch(isVueNodesEnabled, syncVueNodesFlag, { immediate: true })
-
-  return {
-    isVueNodesEnabled,
-    isDevModeEnabled,
-    shouldRenderVueNodes,
-    syncVueNodesFlag
-  }
-}

src/composables/useModelSelectorDialog.ts

@@ -1,4 +1,4 @@
-import ModelSelector from '@/components/widget/ModelSelector.vue'
+import SampleModelSelector from '@/components/widget/SampleModelSelector.vue'
 import { useDialogService } from '@/services/dialogService'
 import { useDialogStore } from '@/stores/dialogStore'
 
@@ -15,7 +15,7 @@ export const useModelSelectorDialog = () => {
   function show() {
     dialogService.showLayoutDialog({
       key: DIALOG_KEY,
-      component: ModelSelector,
+      component: SampleModelSelector,
       props: {
         onClose: hide
       }

src/composables/widgets/useFloatWidget.ts

@@ -1,4 +1,4 @@
-import { clamp } from 'es-toolkit/compat'
+import _ from 'es-toolkit/compat'
 
 import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import type { INumericWidget } from '@/lib/litegraph/src/types/widgets'
@@ -15,7 +15,7 @@ function onFloatValueChange(this: INumericWidget, v: number) {
     const precision =
       this.options.precision ?? Math.max(0, -Math.floor(Math.log10(round)))
     const rounded = Math.round(v / round) * round
-    this.value = clamp(
+    this.value = _.clamp(
       Number(rounded.toFixed(precision)),
       this.options.min ?? -Infinity,
       this.options.max ?? Infinity

src/constants/coreMenuCommands.ts

@@ -23,8 +23,5 @@ export const CORE_MENU_COMMANDS = [
       'Comfy.Help.OpenComfyUIForum'
     ]
   ],
-  [
-    ['Help'],
-    ['Comfy.Help.AboutComfyUI', 'Comfy.Feedback', 'Comfy.ContactSupport']
-  ]
+  [['Help'], ['Comfy.Help.AboutComfyUI', 'Comfy.ContactSupport']]
 ]

src/constants/coreSettings.ts

@@ -928,25 +928,5 @@ export const CORE_SETTINGS: SettingParams[] = [
     name: 'Release seen timestamp',
     type: 'hidden',
     defaultValue: 0
-  },
-
-  /**
-   * Vue Node System Settings
-   */
-  {
-    id: 'Comfy.VueNodes.Enabled',
-    name: 'Enable Vue node rendering (hidden)',
-    type: 'hidden',
-    tooltip:
-      'Render nodes as Vue components instead of canvas. Hidden; toggle via Experimental keybinding.',
-    defaultValue: false,
-    experimental: true
-  },
-  {
-    id: 'Comfy.VueNodes.DebugPanel.Visible',
-    name: 'Vue Nodes Debug Panel Visible (hidden)',
-    type: 'hidden',
-    defaultValue: false,
-    experimental: true
   }
 ]

src/constants/slotColors.ts

@@ -1,30 +0,0 @@
-/**
- * Default colors for node slot types
- * Mirrors LiteGraph's slot_default_color_by_type
- */
-export const SLOT_TYPE_COLORS: Record<string, string> = {
-  number: '#AAD',
-  string: '#DCA',
-  boolean: '#DAA',
-  vec2: '#ADA',
-  vec3: '#ADA',
-  vec4: '#ADA',
-  color: '#DDA',
-  image: '#353',
-  latent: '#858',
-  conditioning: '#FFA',
-  control_net: '#F8F',
-  clip: '#FFD',
-  vae: '#F82',
-  model: '#B98',
-  '*': '#AAA' // Default color
-}
-
-/**
- * Get the color for a slot type
- */
-export function getSlotColor(type?: string | number | null): string {
-  if (!type) return SLOT_TYPE_COLORS['*']
-  const typeStr = String(type).toLowerCase()
-  return SLOT_TYPE_COLORS[typeStr] || SLOT_TYPE_COLORS['*']
-}

src/extensions/core/groupNodeManage.ts

@@ -121,7 +121,7 @@ export class ManageGroupDialog extends ComfyDialog<HTMLDialogElement> {
   getGroupData() {
     this.groupNodeType = LiteGraph.registered_node_types[
       `${PREFIX}${SEPARATOR}` + this.selectedGroup
-    ] as unknown as LGraphNodeConstructor<LGraphNode>
+    ] as LGraphNodeConstructor<LGraphNode>
     this.groupNodeDef = this.groupNodeType.nodeData
     this.groupData = GroupNodeHandler.getGroupData(this.groupNodeType)
   }

src/extensions/core/maskeditor.ts

@@ -1,3 +1,4 @@
+import QuickLRU from '@alloc/quick-lru'
 import { debounce } from 'es-toolkit/compat'
 import _ from 'es-toolkit/compat'
 
@@ -9,6 +10,7 @@ import { ComfyApp } from '../../scripts/app'
 import { $el, ComfyDialog } from '../../scripts/ui'
 import { getStorageValue, setStorageValue } from '../../scripts/utils'
 import { hexToRgb } from '../../utils/colorUtil'
+import { parseToRgb } from '../../utils/colorUtil'
 import { ClipspaceDialog } from './clipspace'
 import {
   imageLayerFilenamesByTimestamp,
@@ -811,7 +813,7 @@ interface Offset {
   y: number
 }
 
-export interface Brush {
+interface Brush {
   type: BrushShape
   size: number
   opacity: number
@@ -2049,9 +2051,16 @@ class BrushTool {
   rgbCtx: CanvasRenderingContext2D | null = null
   initialDraw: boolean = true
 
+  private static brushTextureCache = new QuickLRU<string, HTMLCanvasElement>({
+    maxSize: 8 // Reasonable limit for brush texture variations?
+  })
+
   brushStrokeCanvas: HTMLCanvasElement | null = null
   brushStrokeCtx: CanvasRenderingContext2D | null = null
 
+  private static readonly SMOOTHING_MAX_STEPS = 30
+  private static readonly SMOOTHING_MIN_STEPS = 2
+
   //brush adjustment
   isBrushAdjusting: boolean = false
   brushPreviewGradient: HTMLElement | null = null
@@ -2254,6 +2263,10 @@ class BrushTool {
     }
   }
 
+  private clampSmoothingPrecision(value: number): number {
+    return Math.min(Math.max(value, 1), 100)
+  }
+
   private drawWithBetterSmoothing(point: Point) {
     // Add current point to the smoothing array
     if (!this.smoothingCordsArray) {
@@ -2285,9 +2298,21 @@ class BrushTool {
       totalLength += Math.sqrt(dx * dx + dy * dy)
     }
 
-    const distanceBetweenPoints =
-      (this.brushSettings.size / this.brushSettings.smoothingPrecision) * 6
-    const stepNr = Math.ceil(totalLength / distanceBetweenPoints)
+    const maxSteps = BrushTool.SMOOTHING_MAX_STEPS
+    const minSteps = BrushTool.SMOOTHING_MIN_STEPS
+
+    const smoothing = this.clampSmoothingPrecision(
+      this.brushSettings.smoothingPrecision
+    )
+    const normalizedSmoothing = (smoothing - 1) / 99 // Convert to 0-1 range
+
+    // Optionality to use exponential curve
+    const stepNr = Math.round(
+      Math.round(minSteps + (maxSteps - minSteps) * normalizedSmoothing)
+    )
+
+    // Calculate step distance capped by brush size
+    const distanceBetweenPoints = totalLength / stepNr
 
     let interpolatedPoints = points
 
@@ -2435,101 +2460,205 @@ class BrushTool {
     const hardness = brushSettings.hardness
     const x = point.x
     const y = point.y
-    // Extend the gradient radius beyond the brush size
-    const extendedSize = size * (2 - hardness)
 
+    const brushRadius = size
     const isErasing = maskCtx.globalCompositeOperation === 'destination-out'
     const currentTool = await this.messageBroker.pull('currentTool')
 
-    // handle paint pen
+    // Helper function to get or create cached brush texture
+    const getCachedBrushTexture = (
+      radius: number,
+      hardness: number,
+      color: string,
+      opacity: number
+    ): HTMLCanvasElement => {
+      const cacheKey = `${radius}_${hardness}_${color}_${opacity}`
+
+      if (BrushTool.brushTextureCache.has(cacheKey)) {
+        return BrushTool.brushTextureCache.get(cacheKey)!
+      }
+
+      const tempCanvas = document.createElement('canvas')
+      const tempCtx = tempCanvas.getContext('2d')!
+      const size = radius * 2
+      tempCanvas.width = size
+      tempCanvas.height = size
+
+      const centerX = size / 2
+      const centerY = size / 2
+      const hardRadius = radius * hardness
+
+      const imageData = tempCtx.createImageData(size, size)
+      const data = imageData.data
+      const { r, g, b } = parseToRgb(color)
+
+      // Pre-calculate values to avoid repeated computations
+      const fadeRange = radius - hardRadius
+
+      for (let y = 0; y < size; y++) {
+        const dy = y - centerY
+        for (let x = 0; x < size; x++) {
+          const dx = x - centerX
+          const index = (y * size + x) * 4
+
+          // Calculate square distance (Chebyshev distance)
+          const distFromEdge = Math.max(Math.abs(dx), Math.abs(dy))
+
+          let pixelOpacity = 0
+          if (distFromEdge <= hardRadius) {
+            pixelOpacity = opacity
+          } else if (distFromEdge <= radius) {
+            const fadeProgress = (distFromEdge - hardRadius) / fadeRange
+            pixelOpacity = opacity * (1 - fadeProgress)
+          }
+
+          data[index] = r
+          data[index + 1] = g
+          data[index + 2] = b
+          data[index + 3] = pixelOpacity * 255
+        }
+      }
+
+      tempCtx.putImageData(imageData, 0, 0)
+
+      // Cache the texture
+      BrushTool.brushTextureCache.set(cacheKey, tempCanvas)
+
+      return tempCanvas
+    }
+
+    // RGB brush logic
     if (
       this.activeLayer === 'rgb' &&
       (currentTool === Tools.Eraser || currentTool === Tools.PaintPen)
     ) {
       const rgbaColor = this.formatRgba(this.rgbColor, opacity)
-      let gradient = rgbCtx.createRadialGradient(x, y, 0, x, y, extendedSize)
-      if (hardness === 1) {
-        gradient.addColorStop(0, rgbaColor)
-        gradient.addColorStop(
-          1,
-          this.formatRgba(this.rgbColor, brushSettingsSliderOpacity)
+
+      if (brushType === BrushShape.Rect && hardness < 1) {
+        const brushTexture = getCachedBrushTexture(
+          brushRadius,
+          hardness,
+          rgbaColor,
+          opacity
         )
-      } else {
-        gradient.addColorStop(0, rgbaColor)
-        gradient.addColorStop(hardness, rgbaColor)
-        gradient.addColorStop(1, this.formatRgba(this.rgbColor, 0))
+        rgbCtx.drawImage(brushTexture, x - brushRadius, y - brushRadius)
+        return
       }
+
+      // For max hardness, use solid fill to avoid anti-aliasing
+      if (hardness === 1) {
+        rgbCtx.fillStyle = rgbaColor
+        rgbCtx.beginPath()
+        if (brushType === BrushShape.Rect) {
+          rgbCtx.rect(
+            x - brushRadius,
+            y - brushRadius,
+            brushRadius * 2,
+            brushRadius * 2
+          )
+        } else {
+          rgbCtx.arc(x, y, brushRadius, 0, Math.PI * 2, false)
+        }
+        rgbCtx.fill()
+        return
+      }
+
+      // For soft brushes, use gradient
+      let gradient = rgbCtx.createRadialGradient(x, y, 0, x, y, brushRadius)
+      gradient.addColorStop(0, rgbaColor)
+      gradient.addColorStop(
+        hardness,
+        this.formatRgba(this.rgbColor, opacity * 0.5)
+      )
+      gradient.addColorStop(1, this.formatRgba(this.rgbColor, 0))
+
       rgbCtx.fillStyle = gradient
       rgbCtx.beginPath()
       if (brushType === BrushShape.Rect) {
         rgbCtx.rect(
-          x - extendedSize,
-          y - extendedSize,
-          extendedSize * 2,
-          extendedSize * 2
+          x - brushRadius,
+          y - brushRadius,
+          brushRadius * 2,
+          brushRadius * 2
         )
       } else {
-        rgbCtx.arc(x, y, extendedSize, 0, Math.PI * 2, false)
+        rgbCtx.arc(x, y, brushRadius, 0, Math.PI * 2, false)
       }
       rgbCtx.fill()
       return
     }
 
-    let gradient = maskCtx.createRadialGradient(x, y, 0, x, y, extendedSize)
+    // Mask brush logic
+    if (brushType === BrushShape.Rect && hardness < 1) {
+      const baseColor = isErasing
+        ? `rgba(255, 255, 255, ${opacity})`
+        : `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
+
+      const brushTexture = getCachedBrushTexture(
+        brushRadius,
+        hardness,
+        baseColor,
+        opacity
+      )
+      maskCtx.drawImage(brushTexture, x - brushRadius, y - brushRadius)
+      return
+    }
+
+    // For max hardness, use solid fill to avoid anti-aliasing
     if (hardness === 1) {
+      const solidColor = isErasing
+        ? `rgba(255, 255, 255, ${opacity})`
+        : `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
+
+      maskCtx.fillStyle = solidColor
+      maskCtx.beginPath()
+      if (brushType === BrushShape.Rect) {
+        maskCtx.rect(
+          x - brushRadius,
+          y - brushRadius,
+          brushRadius * 2,
+          brushRadius * 2
+        )
+      } else {
+        maskCtx.arc(x, y, brushRadius, 0, Math.PI * 2, false)
+      }
+      maskCtx.fill()
+      return
+    }
+
+    // For soft brushes, use gradient
+    let gradient = maskCtx.createRadialGradient(x, y, 0, x, y, brushRadius)
+
+    if (isErasing) {
+      gradient.addColorStop(0, `rgba(255, 255, 255, ${opacity})`)
+      gradient.addColorStop(hardness, `rgba(255, 255, 255, ${opacity * 0.5})`)
+      gradient.addColorStop(1, `rgba(255, 255, 255, 0)`)
+    } else {
       gradient.addColorStop(
         0,
-        isErasing
-          ? `rgba(255, 255, 255, ${opacity})`
-          : `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
+        `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
+      )
+      gradient.addColorStop(
+        hardness,
+        `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity * 0.5})`
       )
       gradient.addColorStop(
         1,
-        isErasing
-          ? `rgba(255, 255, 255, ${opacity})`
-          : `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
+        `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, 0)`
       )
-    } else {
-      let softness = 1 - hardness
-      let innerStop = Math.max(0, hardness - softness)
-      let outerStop = size / extendedSize
-
-      if (isErasing) {
-        gradient.addColorStop(0, `rgba(255, 255, 255, ${opacity})`)
-        gradient.addColorStop(innerStop, `rgba(255, 255, 255, ${opacity})`)
-        gradient.addColorStop(outerStop, `rgba(255, 255, 255, ${opacity / 2})`)
-        gradient.addColorStop(1, `rgba(255, 255, 255, 0)`)
-      } else {
-        gradient.addColorStop(
-          0,
-          `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
-        )
-        gradient.addColorStop(
-          innerStop,
-          `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity})`
-        )
-        gradient.addColorStop(
-          outerStop,
-          `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, ${opacity / 2})`
-        )
-        gradient.addColorStop(
-          1,
-          `rgba(${maskColor.r}, ${maskColor.g}, ${maskColor.b}, 0)`
-        )
-      }
     }
 
     maskCtx.fillStyle = gradient
     maskCtx.beginPath()
     if (brushType === BrushShape.Rect) {
       maskCtx.rect(
-        x - extendedSize,
-        y - extendedSize,
-        extendedSize * 2,
-        extendedSize * 2
+        x - brushRadius,
+        y - brushRadius,
+        brushRadius * 2,
+        brushRadius * 2
       )
     } else {
-      maskCtx.arc(x, y, extendedSize, 0, Math.PI * 2, false)
+      maskCtx.arc(x, y, brushRadius, 0, Math.PI * 2, false)
     }
     maskCtx.fill()
   }
@@ -4185,30 +4314,35 @@ class UIManager {
     const centerY = cursorPoint.y + pan_offset.y
     const brush = this.brush
     const hardness = brushSettings.hardness
-    const extendedSize = brushSettings.size * (2 - hardness) * 2 * zoom_ratio
+
+    // Now that brush size is constant, preview is simple
+    const brushRadius = brushSettings.size * zoom_ratio
+    const previewSize = brushRadius * 2
 
     this.brushSizeSlider.value = String(brushSettings.size)
     this.brushHardnessSlider.value = String(hardness)
 
-    brush.style.width = extendedSize + 'px'
-    brush.style.height = extendedSize + 'px'
-    brush.style.left = centerX - extendedSize / 2 + 'px'
-    brush.style.top = centerY - extendedSize / 2 + 'px'
+    brush.style.width = previewSize + 'px'
+    brush.style.height = previewSize + 'px'
+    brush.style.left = centerX - brushRadius + 'px'
+    brush.style.top = centerY - brushRadius + 'px'
 
     if (hardness === 1) {
       this.brushPreviewGradient.style.background = 'rgba(255, 0, 0, 0.5)'
       return
     }
 
-    const opacityStop = hardness / 4 + 0.25
+    // Simplified gradient - hardness controls where the fade starts
+    const midStop = hardness * 100
+    const outerStop = 100
 
     this.brushPreviewGradient.style.background = `
-        radial-gradient(
-            circle,
-            rgba(255, 0, 0, 0.5) 0%,
-            rgba(255, 0, 0, ${opacityStop}) ${hardness * 100}%,
-            rgba(255, 0, 0, 0) 100%
-        )
+      radial-gradient(
+        circle,
+        rgba(255, 0, 0, 0.5) 0%,
+        rgba(255, 0, 0, 0.25) ${midStop}%,
+        rgba(255, 0, 0, 0) ${outerStop}%
+      )
     `
   }
 

src/lib/litegraph/CLAUDE.md

@@ -22,7 +22,7 @@
 
 # Workflow
 
-- Be sure to typecheck when you're done making a series of code changes
+- Be sure to typecheck when you’re done making a series of code changes
 - Prefer running single tests, and not the whole test suite, for performance
 
 # Testing Guidelines

src/lib/litegraph/src/LGraph.ts

@@ -6,8 +6,6 @@ import {
 } from '@/lib/litegraph/src/constants'
 import type { UUID } from '@/lib/litegraph/src/utils/uuid'
 import { createUuidv4, zeroUuid } from '@/lib/litegraph/src/utils/uuid'
-import { layoutMutations } from '@/renderer/core/layout/operations/LayoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
 
 import type { DragAndScaleState } from './DragAndScale'
 import { LGraphCanvas } from './LGraphCanvas'
@@ -1351,16 +1349,6 @@ export class LGraph
       floatingLinkIds
     )
     this.reroutes.set(rerouteId, reroute)
-
-    // Register reroute in Layout Store for spatial tracking
-    layoutMutations.setSource(LayoutSource.Canvas)
-    layoutMutations.createReroute(
-      String(rerouteId),
-      { x: pos[0], y: pos[1] },
-      before.parentId ? String(before.parentId) : undefined,
-      Array.from(linkIds)
-    )
-
     for (const linkId of linkIds) {
       const link = this._links.get(linkId)
       if (!link) continue
@@ -1434,11 +1422,6 @@ export class LGraph
     }
 
     reroutes.delete(id)
-
-    // Delete reroute from Layout Store
-    layoutMutations.setSource(LayoutSource.Canvas)
-    layoutMutations.deleteReroute(id)
-
     // This does not belong here; it should be handled by the caller, or run by a remove-many API.
     // https://github.com/Comfy-Org/litegraph.js/issues/898
     this.setDirtyCanvas(false, true)
@@ -2262,9 +2245,6 @@ export class LGraph
         // Drop broken links, and ignore reroutes with no valid links
         if (!reroute.validateLinks(this._links, this.floatingLinks)) {
           this.reroutes.delete(reroute.id)
-          // Clean up layout store
-          layoutMutations.setSource(LayoutSource.Canvas)
-          layoutMutations.deleteReroute(reroute.id)
         }
       }
 

src/lib/litegraph/src/LGraphCanvas.ts

@@ -2,11 +2,6 @@ import { toString } from 'es-toolkit/compat'
 
 import { PREFIX, SEPARATOR } from '@/constants/groupNodeConstants'
 import { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector'
-import {
-  type LinkRenderContext,
-  LitegraphLinkAdapter
-} from '@/renderer/core/canvas/litegraph/LitegraphLinkAdapter'
-import { layoutStore } from '@/renderer/core/layout/store/LayoutStore'
 
 import { CanvasPointer } from './CanvasPointer'
 import type { ContextMenu } from './ContextMenu'
@@ -56,6 +51,7 @@ import {
   containsRect,
   createBounds,
   distance,
+  findPointOnCurve,
   isInRect,
   isInRectangle,
   isPointInRect,
@@ -239,6 +235,9 @@ export class LGraphCanvas
   static #tmp_area = new Float32Array(4)
   static #margin_area = new Float32Array(4)
   static #link_bounding = new Float32Array(4)
+  static #lTempA: Point = new Float32Array(2)
+  static #lTempB: Point = new Float32Array(2)
+  static #lTempC: Point = new Float32Array(2)
 
   static DEFAULT_BACKGROUND_IMAGE =
     'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAIAAAD/gAIDAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQBJREFUeNrs1rEKwjAUhlETUkj3vP9rdmr1Ysammk2w5wdxuLgcMHyptfawuZX4pJSWZTnfnu/lnIe/jNNxHHGNn//HNbbv+4dr6V+11uF527arU7+u63qfa/bnmh8sWLBgwYJlqRf8MEptXPBXJXa37BSl3ixYsGDBMliwFLyCV/DeLIMFCxYsWLBMwSt4Be/NggXLYMGCBUvBK3iNruC9WbBgwYJlsGApeAWv4L1ZBgsWLFiwYJmCV/AK3psFC5bBggULloJX8BpdwXuzYMGCBctgwVLwCl7Be7MMFixYsGDBsu8FH1FaSmExVfAxBa/gvVmwYMGCZbBg/W4vAQYA5tRF9QYlv/QAAAAASUVORK5CYII='
@@ -640,9 +639,6 @@ export class LGraphCanvas
   /** Set on keydown, keyup. @todo */
   #shiftDown: boolean = false
 
-  /** Link rendering adapter for litegraph-to-canvas integration */
-  linkRenderer: LitegraphLinkAdapter | null = null
-
   /** If true, enable drag zoom. Ctrl+Shift+Drag Up/Down: zoom canvas. */
   dragZoomEnabled: boolean = false
   /** The start position of the drag zoom. */
@@ -704,13 +700,6 @@ export class LGraphCanvas
     this.ds = new DragAndScale(canvas)
     this.pointer = new CanvasPointer(canvas)
 
-    // Initialize link renderer if graph is available
-    if (graph) {
-      this.linkRenderer = new LitegraphLinkAdapter(graph)
-      // Disable layout writes during render
-      this.linkRenderer.enableLayoutStoreWrites = false
-    }
-
     this.linkConnector.events.addEventListener('link-created', () =>
       this.#dirty()
     )
@@ -1804,11 +1793,6 @@ export class LGraphCanvas
     this.clear()
     newGraph.attachCanvas(this)
 
-    // Re-initialize link renderer with new graph
-    this.linkRenderer = new LitegraphLinkAdapter(newGraph)
-    // Disable layout writes during render
-    this.linkRenderer.enableLayoutStoreWrites = false
-
     this.dispatch('litegraph:set-graph', { newGraph, oldGraph: graph })
     this.#dirty()
   }
@@ -2202,22 +2186,11 @@ export class LGraphCanvas
           this.processSelect(node, e, true)
         } else if (this.links_render_mode !== LinkRenderType.HIDDEN_LINK) {
           // Reroutes
-          // Try layout store first, fallback to old method
-          const rerouteLayout = layoutStore.queryRerouteAtPoint({
-            x: e.canvasX,
-            y: e.canvasY
-          })
-
-          let reroute: Reroute | undefined
-          if (rerouteLayout) {
-            reroute = graph.getReroute(rerouteLayout.id)
-          } else {
-            reroute = graph.getRerouteOnPos(
-              e.canvasX,
-              e.canvasY,
-              this.#visibleReroutes
-            )
-          }
+          const reroute = graph.getRerouteOnPos(
+            e.canvasX,
+            e.canvasY,
+            this.#visibleReroutes
+          )
           if (reroute) {
             if (e.altKey) {
               pointer.onClick = (upEvent) => {
@@ -2383,18 +2356,8 @@ export class LGraphCanvas
 
       // Reroutes
       if (this.links_render_mode !== LinkRenderType.HIDDEN_LINK) {
-        // Try layout store first for hit detection
-        const rerouteLayout = layoutStore.queryRerouteAtPoint({ x, y })
-        let foundReroute: Reroute | undefined
-
-        if (rerouteLayout) {
-          foundReroute = graph.getReroute(rerouteLayout.id)
-        }
-
-        // Fallback to checking visible reroutes directly
         for (const reroute of this.#visibleReroutes) {
-          const overReroute =
-            foundReroute === reroute || reroute.containsPoint([x, y])
+          const overReroute = reroute.containsPoint([x, y])
           if (!reroute.isSlotHovered && !overReroute) continue
 
           if (overReroute) {
@@ -2428,32 +2391,16 @@ export class LGraphCanvas
       this.ctx.lineWidth = this.connections_width + 7
       const dpi = Math.max(window?.devicePixelRatio ?? 1, 1)
 
-      // Try layout store for segment hit testing first (more precise)
-      const hitSegment = layoutStore.queryLinkSegmentAtPoint({ x, y }, this.ctx)
-
       for (const linkSegment of this.renderedPaths) {
         const centre = linkSegment._pos
         if (!centre) continue
 
-        // Check if this link segment was hit
-        let isLinkHit =
-          hitSegment &&
-          linkSegment.id ===
-            (linkSegment instanceof Reroute
-              ? hitSegment.rerouteId
-              : hitSegment.linkId)
-
-        if (!isLinkHit && linkSegment.path) {
-          // Fallback to direct path hit testing if not found in layout store
-          isLinkHit = this.ctx.isPointInStroke(
-            linkSegment.path,
-            x * dpi,
-            y * dpi
-          )
-        }
-
         // If we shift click on a link then start a link from that input
-        if ((e.shiftKey || e.altKey) && isLinkHit) {
+        if (
+          (e.shiftKey || e.altKey) &&
+          linkSegment.path &&
+          this.ctx.isPointInStroke(linkSegment.path, x * dpi, y * dpi)
+        ) {
           this.ctx.lineWidth = lineWidth
 
           if (e.shiftKey && !e.altKey) {
@@ -2468,10 +2415,7 @@ export class LGraphCanvas
             pointer.onDragEnd = (e) => this.#processDraggedItems(e)
             return
           }
-        } else if (
-          this.linkMarkerShape !== LinkMarkerShape.None &&
-          isInRectangle(x, y, centre[0] - 4, centre[1] - 4, 8, 8)
-        ) {
+        } else if (isInRectangle(x, y, centre[0] - 4, centre[1] - 4, 8, 8)) {
           this.ctx.lineWidth = lineWidth
 
           pointer.onClick = () => this.showLinkMenu(linkSegment, e)
@@ -3184,27 +3128,8 @@ export class LGraphCanvas
         // For input/output hovering
         // to store the output of isOverNodeInput
         const pos: Point = [0, 0]
-
-        // Try to use layout store for hit testing first, fallback to old method
-        let inputId: number = -1
-        let outputId: number = -1
-
-        const slotLayout = layoutStore.querySlotAtPoint({ x, y })
-        if (slotLayout && slotLayout.nodeId === String(node.id)) {
-          if (slotLayout.type === 'input') {
-            inputId = slotLayout.index
-            pos[0] = slotLayout.position.x
-            pos[1] = slotLayout.position.y
-          } else {
-            outputId = slotLayout.index
-            pos[0] = slotLayout.position.x
-            pos[1] = slotLayout.position.y
-          }
-        } else {
-          // Fallback to old method
-          inputId = isOverNodeInput(node, x, y, pos)
-          outputId = isOverNodeOutput(node, x, y, pos)
-        }
+        const inputId = isOverNodeInput(node, x, y, pos)
+        const outputId = isOverNodeOutput(node, x, y, pos)
         const overWidget = node.getWidgetOnPos(x, y, true) ?? undefined
 
         if (!node.mouseOver) {
@@ -4665,26 +4590,18 @@ export class LGraphCanvas
               : LiteGraph.CONNECTING_LINK_COLOR
 
           // the connection being dragged by the mouse
-          if (this.linkRenderer) {
-            const context = this.buildLinkRenderContext()
-            this.linkRenderer.renderLinkDirect(
-              ctx,
-              pos,
-              highlightPos,
-              null,
-              false,
-              null,
-              colour,
-              fromDirection,
-              dragDirection,
-              context,
-              {
-                disabled: false
-              }
-            )
-          }
+          this.renderLink(
+            ctx,
+            pos,
+            highlightPos,
+            null,
+            false,
+            null,
+            colour,
+            fromDirection,
+            dragDirection
+          )
 
-          ctx.fillStyle = colour
           ctx.beginPath()
           if (connType === LiteGraph.EVENT || connShape === RenderShape.BOX) {
             ctx.rect(pos[0] - 6 + 0.5, pos[1] - 5 + 0.5, 14, 10)
@@ -4757,11 +4674,6 @@ export class LGraphCanvas
 
   /** @returns If the pointer is over a link centre marker, the link segment it belongs to.  Otherwise, `undefined`.  */
   #getLinkCentreOnPos(e: CanvasPointerEvent): LinkSegment | undefined {
-    // Skip hit detection if center markers are disabled
-    if (this.linkMarkerShape === LinkMarkerShape.None) {
-      return undefined
-    }
-
     for (const linkSegment of this.renderedPaths) {
       const centre = linkSegment._pos
       if (!centre) continue
@@ -5087,19 +4999,6 @@ export class LGraphCanvas
   drawNode(node: LGraphNode, ctx: CanvasRenderingContext2D): void {
     this.current_node = node
 
-    // When Vue nodes mode is enabled, LiteGraph should not draw node chrome or widgets.
-    // We still need to keep slot metrics and layout in sync for hit-testing and links.
-    // Interaction system changes coming later, chances are vue nodes mode will be mostly broken on land
-    if (LiteGraph.vueNodesMode) {
-      // Prepare concrete slots and compute layout measures without rendering visuals.
-      node._setConcreteSlots()
-      if (!node.collapsed) {
-        node.arrange()
-      }
-      // Skip all node body/widget/title rendering. Vue overlay handles visuals.
-      return
-    }
-
     const color = node.renderingColor
     const bgcolor = node.renderingBgColor
 
@@ -5813,34 +5712,6 @@ export class LGraphCanvas
     }
   }
 
-  /**
-   * Build LinkRenderContext from canvas properties
-   * Helper method for using LitegraphLinkAdapter
-   */
-  private buildLinkRenderContext(): LinkRenderContext {
-    return {
-      // Canvas settings
-      renderMode: this.links_render_mode,
-      connectionWidth: this.connections_width,
-      renderBorder: this.render_connections_border,
-      lowQuality: this.low_quality,
-      highQualityRender: this.highquality_render,
-      scale: this.ds.scale,
-      linkMarkerShape: this.linkMarkerShape,
-      renderConnectionArrows: this.render_connection_arrows,
-
-      // State
-      highlightedLinks: new Set(Object.keys(this.highlighted_links)),
-
-      // Colors
-      defaultLinkColor: this.default_link_color,
-      linkTypeColors: LGraphCanvas.link_type_colors,
-
-      // Pattern for disabled links
-      disabledPattern: this._pattern
-    }
-  }
-
   /**
    * draws a link between two points
    * @param ctx Canvas 2D rendering context
@@ -5882,27 +5753,333 @@ export class LGraphCanvas
       disabled?: boolean
     } = {}
   ): void {
-    if (this.linkRenderer) {
-      const context = this.buildLinkRenderContext()
-      this.linkRenderer.renderLinkDirect(
-        ctx,
-        a,
-        b,
-        link,
-        skip_border,
-        flow,
-        color,
-        start_dir,
-        end_dir,
-        context,
-        {
-          reroute,
-          startControl,
-          endControl,
-          num_sublines,
-          disabled
+    const linkColour =
+      link != null && this.highlighted_links[link.id]
+        ? '#FFF'
+        : color ||
+          link?.color ||
+          (link?.type != null && LGraphCanvas.link_type_colors[link.type]) ||
+          this.default_link_color
+    const startDir = start_dir || LinkDirection.RIGHT
+    const endDir = end_dir || LinkDirection.LEFT
+
+    const dist =
+      this.links_render_mode == LinkRenderType.SPLINE_LINK &&
+      (!endControl || !startControl)
+        ? distance(a, b)
+        : 0
+
+    // TODO: Subline code below was inserted in the wrong place - should be before this statement
+    if (this.render_connections_border && !this.low_quality) {
+      ctx.lineWidth = this.connections_width + 4
+    }
+    ctx.lineJoin = 'round'
+    num_sublines ||= 1
+    if (num_sublines > 1) ctx.lineWidth = 0.5
+
+    // begin line shape
+    const path = new Path2D()
+
+    /** The link or reroute we're currently rendering */
+    const linkSegment = reroute ?? link
+    if (linkSegment) linkSegment.path = path
+
+    const innerA = LGraphCanvas.#lTempA
+    const innerB = LGraphCanvas.#lTempB
+
+    /** Reference to {@link reroute._pos} if present, or {@link link._pos} if present.  Caches the centre point of the link. */
+    const pos: Point = linkSegment?._pos ?? [0, 0]
+
+    for (let i = 0; i < num_sublines; i++) {
+      const offsety = (i - (num_sublines - 1) * 0.5) * 5
+      innerA[0] = a[0]
+      innerA[1] = a[1]
+      innerB[0] = b[0]
+      innerB[1] = b[1]
+
+      if (this.links_render_mode == LinkRenderType.SPLINE_LINK) {
+        if (endControl) {
+          innerB[0] = b[0] + endControl[0]
+          innerB[1] = b[1] + endControl[1]
+        } else {
+          this.#addSplineOffset(innerB, endDir, dist)
         }
-      )
+        if (startControl) {
+          innerA[0] = a[0] + startControl[0]
+          innerA[1] = a[1] + startControl[1]
+        } else {
+          this.#addSplineOffset(innerA, startDir, dist)
+        }
+        path.moveTo(a[0], a[1] + offsety)
+        path.bezierCurveTo(
+          innerA[0],
+          innerA[1] + offsety,
+          innerB[0],
+          innerB[1] + offsety,
+          b[0],
+          b[1] + offsety
+        )
+
+        // Calculate centre point
+        findPointOnCurve(pos, a, b, innerA, innerB, 0.5)
+
+        if (linkSegment && this.linkMarkerShape === LinkMarkerShape.Arrow) {
+          const justPastCentre = LGraphCanvas.#lTempC
+          findPointOnCurve(justPastCentre, a, b, innerA, innerB, 0.51)
+
+          linkSegment._centreAngle = Math.atan2(
+            justPastCentre[1] - pos[1],
+            justPastCentre[0] - pos[0]
+          )
+        }
+      } else {
+        const l = this.links_render_mode == LinkRenderType.LINEAR_LINK ? 15 : 10
+        switch (startDir) {
+          case LinkDirection.LEFT:
+            innerA[0] += -l
+            break
+          case LinkDirection.RIGHT:
+            innerA[0] += l
+            break
+          case LinkDirection.UP:
+            innerA[1] += -l
+            break
+          case LinkDirection.DOWN:
+            innerA[1] += l
+            break
+        }
+        switch (endDir) {
+          case LinkDirection.LEFT:
+            innerB[0] += -l
+            break
+          case LinkDirection.RIGHT:
+            innerB[0] += l
+            break
+          case LinkDirection.UP:
+            innerB[1] += -l
+            break
+          case LinkDirection.DOWN:
+            innerB[1] += l
+            break
+        }
+        if (this.links_render_mode == LinkRenderType.LINEAR_LINK) {
+          path.moveTo(a[0], a[1] + offsety)
+          path.lineTo(innerA[0], innerA[1] + offsety)
+          path.lineTo(innerB[0], innerB[1] + offsety)
+          path.lineTo(b[0], b[1] + offsety)
+
+          // Calculate centre point
+          pos[0] = (innerA[0] + innerB[0]) * 0.5
+          pos[1] = (innerA[1] + innerB[1]) * 0.5
+
+          if (linkSegment && this.linkMarkerShape === LinkMarkerShape.Arrow) {
+            linkSegment._centreAngle = Math.atan2(
+              innerB[1] - innerA[1],
+              innerB[0] - innerA[0]
+            )
+          }
+        } else if (this.links_render_mode == LinkRenderType.STRAIGHT_LINK) {
+          const midX = (innerA[0] + innerB[0]) * 0.5
+
+          path.moveTo(a[0], a[1])
+          path.lineTo(innerA[0], innerA[1])
+          path.lineTo(midX, innerA[1])
+          path.lineTo(midX, innerB[1])
+          path.lineTo(innerB[0], innerB[1])
+          path.lineTo(b[0], b[1])
+
+          // Calculate centre point
+          pos[0] = midX
+          pos[1] = (innerA[1] + innerB[1]) * 0.5
+
+          if (linkSegment && this.linkMarkerShape === LinkMarkerShape.Arrow) {
+            const diff = innerB[1] - innerA[1]
+            if (Math.abs(diff) < 4) linkSegment._centreAngle = 0
+            else if (diff > 0) linkSegment._centreAngle = Math.PI * 0.5
+            else linkSegment._centreAngle = -(Math.PI * 0.5)
+          }
+        } else {
+          return
+        }
+      }
+    }
+
+    // rendering the outline of the connection can be a little bit slow
+    if (this.render_connections_border && !this.low_quality && !skip_border) {
+      ctx.strokeStyle = 'rgba(0,0,0,0.5)'
+      ctx.stroke(path)
+    }
+
+    ctx.lineWidth = this.connections_width
+    ctx.fillStyle = ctx.strokeStyle = linkColour
+    ctx.stroke(path)
+
+    // render arrow in the middle
+    if (this.ds.scale >= 0.6 && this.highquality_render && linkSegment) {
+      // render arrow
+      if (this.render_connection_arrows) {
+        // compute two points in the connection
+        const posA = this.computeConnectionPoint(a, b, 0.25, startDir, endDir)
+        const posB = this.computeConnectionPoint(a, b, 0.26, startDir, endDir)
+        const posC = this.computeConnectionPoint(a, b, 0.75, startDir, endDir)
+        const posD = this.computeConnectionPoint(a, b, 0.76, startDir, endDir)
+
+        // compute the angle between them so the arrow points in the right direction
+        let angleA = 0
+        let angleB = 0
+        if (this.render_curved_connections) {
+          angleA = -Math.atan2(posB[0] - posA[0], posB[1] - posA[1])
+          angleB = -Math.atan2(posD[0] - posC[0], posD[1] - posC[1])
+        } else {
+          angleB = angleA = b[1] > a[1] ? 0 : Math.PI
+        }
+
+        // render arrow
+        const transform = ctx.getTransform()
+        ctx.translate(posA[0], posA[1])
+        ctx.rotate(angleA)
+        ctx.beginPath()
+        ctx.moveTo(-5, -3)
+        ctx.lineTo(0, +7)
+        ctx.lineTo(+5, -3)
+        ctx.fill()
+        ctx.setTransform(transform)
+
+        ctx.translate(posC[0], posC[1])
+        ctx.rotate(angleB)
+        ctx.beginPath()
+        ctx.moveTo(-5, -3)
+        ctx.lineTo(0, +7)
+        ctx.lineTo(+5, -3)
+        ctx.fill()
+        ctx.setTransform(transform)
+      }
+
+      // Draw link centre marker
+      ctx.beginPath()
+      if (this.linkMarkerShape === LinkMarkerShape.Arrow) {
+        const transform = ctx.getTransform()
+        ctx.translate(pos[0], pos[1])
+        if (linkSegment._centreAngle) ctx.rotate(linkSegment._centreAngle)
+        // The math is off, but it currently looks better in chromium
+        ctx.moveTo(-3.2, -5)
+        ctx.lineTo(+7, 0)
+        ctx.lineTo(-3.2, +5)
+        ctx.setTransform(transform)
+      } else if (
+        this.linkMarkerShape == null ||
+        this.linkMarkerShape === LinkMarkerShape.Circle
+      ) {
+        ctx.arc(pos[0], pos[1], 5, 0, Math.PI * 2)
+      }
+      if (disabled) {
+        const { fillStyle, globalAlpha } = ctx
+        ctx.fillStyle = this._pattern ?? '#797979'
+        ctx.globalAlpha = 0.75
+        ctx.fill()
+        ctx.globalAlpha = globalAlpha
+        ctx.fillStyle = fillStyle
+      }
+      ctx.fill()
+
+      if (LLink._drawDebug) {
+        const { fillStyle, font, globalAlpha, lineWidth, strokeStyle } = ctx
+        ctx.globalAlpha = 1
+        ctx.lineWidth = 4
+        ctx.fillStyle = 'white'
+        ctx.strokeStyle = 'black'
+        ctx.font = '16px Arial'
+
+        const text = String(linkSegment.id)
+        const { width, actualBoundingBoxAscent } = ctx.measureText(text)
+        const x = pos[0] - width * 0.5
+        const y = pos[1] + actualBoundingBoxAscent * 0.5
+        ctx.strokeText(text, x, y)
+        ctx.fillText(text, x, y)
+
+        ctx.font = font
+        ctx.globalAlpha = globalAlpha
+        ctx.lineWidth = lineWidth
+        ctx.fillStyle = fillStyle
+        ctx.strokeStyle = strokeStyle
+      }
+    }
+
+    // render flowing points
+    if (flow) {
+      ctx.fillStyle = linkColour
+      for (let i = 0; i < 5; ++i) {
+        const f = (LiteGraph.getTime() * 0.001 + i * 0.2) % 1
+        const flowPos = this.computeConnectionPoint(a, b, f, startDir, endDir)
+        ctx.beginPath()
+        ctx.arc(flowPos[0], flowPos[1], 5, 0, 2 * Math.PI)
+        ctx.fill()
+      }
+    }
+  }
+
+  /**
+   * Finds a point along a spline represented by a to b, with spline endpoint directions dictacted by start_dir and end_dir.
+   * @param a Start point
+   * @param b End point
+   * @param t Time: distance between points (e.g 0.25 is 25% along the line)
+   * @param start_dir Spline start direction
+   * @param end_dir Spline end direction
+   * @returns The point at {@link t} distance along the spline a-b.
+   */
+  computeConnectionPoint(
+    a: ReadOnlyPoint,
+    b: ReadOnlyPoint,
+    t: number,
+    start_dir: LinkDirection,
+    end_dir: LinkDirection
+  ): Point {
+    start_dir ||= LinkDirection.RIGHT
+    end_dir ||= LinkDirection.LEFT
+
+    const dist = distance(a, b)
+    const pa: Point = [a[0], a[1]]
+    const pb: Point = [b[0], b[1]]
+
+    this.#addSplineOffset(pa, start_dir, dist)
+    this.#addSplineOffset(pb, end_dir, dist)
+
+    const c1 = (1 - t) * (1 - t) * (1 - t)
+    const c2 = 3 * ((1 - t) * (1 - t)) * t
+    const c3 = 3 * (1 - t) * (t * t)
+    const c4 = t * t * t
+
+    const x = c1 * a[0] + c2 * pa[0] + c3 * pb[0] + c4 * b[0]
+    const y = c1 * a[1] + c2 * pa[1] + c3 * pb[1] + c4 * b[1]
+    return [x, y]
+  }
+
+  /**
+   * Modifies an existing point, adding a single-axis offset.
+   * @param point The point to add the offset to
+   * @param direction The direction to add the offset in
+   * @param dist Distance to offset
+   * @param factor Distance is mulitplied by this value.  Default: 0.25
+   */
+  #addSplineOffset(
+    point: Point,
+    direction: LinkDirection,
+    dist: number,
+    factor = 0.25
+  ): void {
+    switch (direction) {
+      case LinkDirection.LEFT:
+        point[0] += dist * -factor
+        break
+      case LinkDirection.RIGHT:
+        point[0] += dist * factor
+        break
+      case LinkDirection.UP:
+        point[1] += dist * -factor
+        break
+      case LinkDirection.DOWN:
+        point[1] += dist * factor
+        break
     }
   }
 
@@ -6109,8 +6286,6 @@ export class LGraphCanvas
               : segment.id
           if (linkId !== undefined) {
             graph.removeLink(linkId)
-            // Clean up layout store
-            layoutStore.deleteLinkLayout(linkId)
           }
           break
         }
@@ -8188,26 +8363,11 @@ export class LGraphCanvas
 
       // Check for reroutes
       if (this.links_render_mode !== LinkRenderType.HIDDEN_LINK) {
-        // Try layout store first, fallback to old method
-        const rerouteLayout = layoutStore.queryRerouteAtPoint({
-          x: event.canvasX,
-          y: event.canvasY
-        })
-
-        let reroute: Reroute | undefined
-        if (rerouteLayout) {
-          console.debug('✅ Using LayoutStore for reroute query', {
-            rerouteLayout
-          })
-          reroute = this.graph.getReroute(rerouteLayout.id)
-        } else {
-          console.debug('⚠️ Falling back to old reroute query method')
-          reroute = this.graph.getRerouteOnPos(
-            event.canvasX,
-            event.canvasY,
-            this.#visibleReroutes
-          )
-        }
+        const reroute = this.graph.getRerouteOnPos(
+          event.canvasX,
+          event.canvasY,
+          this.#visibleReroutes
+        )
         if (reroute) {
           menu_info.unshift(
             {

src/lib/litegraph/src/LGraphNode.ts

@@ -1,13 +1,3 @@
-import { LGraphNodeProperties } from '@/lib/litegraph/src/LGraphNodeProperties'
-import {
-  type SlotPositionContext,
-  calculateInputSlotPos,
-  calculateInputSlotPosFromSlot,
-  calculateOutputSlotPos
-} from '@/renderer/core/canvas/litegraph/SlotCalculations'
-import { layoutMutations } from '@/renderer/core/layout/operations/LayoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
-
 import type { DragAndScale } from './DragAndScale'
 import type { LGraph } from './LGraph'
 import { BadgePosition, LGraphBadge } from './LGraphBadge'
@@ -268,10 +258,6 @@ export class LGraphNode
   properties_info: INodePropertyInfo[] = []
   flags: INodeFlags = {}
   widgets?: IBaseWidget[]
-
-  /** Property manager for this node */
-  changeTracker: LGraphNodeProperties
-
   /**
    * The amount of space available for widgets to grow into.
    * @see {@link layoutWidgets}
@@ -743,37 +729,6 @@ export class LGraphNode
       error: this.#getErrorStrokeStyle,
       selected: this.#getSelectedStrokeStyle
     }
-
-    // Assign onMouseDown implementation
-    this.onMouseDown = (
-      // @ts-expect-error - CanvasPointerEvent type needs fixing
-      e: CanvasPointerEvent,
-      pos: Point,
-      canvas: LGraphCanvas
-    ): boolean => {
-      // Check for title button clicks (only if not collapsed)
-      if (this.title_buttons?.length && !this.flags.collapsed) {
-        // pos contains the offset from the node's position, so we need to use node-relative coordinates
-        const nodeRelativeX = pos[0]
-        const nodeRelativeY = pos[1]
-
-        for (let i = 0; i < this.title_buttons.length; i++) {
-          const button = this.title_buttons[i]
-          if (
-            button.visible &&
-            button.isPointInside(nodeRelativeX, nodeRelativeY)
-          ) {
-            this.onTitleButtonClick(button, canvas)
-            return true // Prevent default behavior
-          }
-        }
-      }
-
-      return false // Allow default behavior
-    }
-
-    // Initialize property manager with tracked properties
-    this.changeTracker = new LGraphNodeProperties(this)
   }
 
   /** Internal callback for subgraph nodes. Do not implement externally. */
@@ -1986,14 +1941,6 @@ export class LGraphNode
   move(deltaX: number, deltaY: number): void {
     if (this.pinned) return
 
-    // If Vue nodes mode is enabled, skip LiteGraph's direct position update
-    // The layout store will handle the movement and sync back to LiteGraph
-    if (LiteGraph.vueNodesMode) {
-      // Vue nodes handle their own dragging through the layout store
-      // This prevents the snap-back issue from conflicting position updates
-      return
-    }
-
     this.pos[0] += deltaX
     this.pos[1] += deltaY
   }
@@ -2844,16 +2791,6 @@ export class LGraphNode
     // add to graph links list
     graph._links.set(link.id, link)
 
-    // Register link in Layout Store for spatial tracking
-    layoutMutations.setSource(LayoutSource.Canvas)
-    layoutMutations.createLink(
-      link.id,
-      this.id,
-      outputIndex,
-      inputNode.id,
-      inputIndex
-    )
-
     // connect in output
     output.links ??= []
     output.links.push(link.id)
@@ -3255,25 +3192,6 @@ export class LGraphNode
     return this.outputs.filter((slot: INodeOutputSlot) => !slot.pos)
   }
 
-  /**
-   * Get the context needed for slot position calculations
-   * @internal
-   */
-  #getSlotPositionContext(): SlotPositionContext {
-    return {
-      nodeX: this.pos[0],
-      nodeY: this.pos[1],
-      nodeWidth: this.size[0],
-      nodeHeight: this.size[1],
-      collapsed: this.flags.collapsed ?? false,
-      collapsedWidth: this._collapsed_width,
-      slotStartY: this.constructor.slot_start_y,
-      inputs: this.inputs,
-      outputs: this.outputs,
-      widgets: this.widgets
-    }
-  }
-
   /**
    * Gets the position of an input slot, in graph co-ordinates.
    *
@@ -3282,7 +3200,7 @@ export class LGraphNode
    * @returns Position of the input slot
    */
   getInputPos(slot: number): Point {
-    return calculateInputSlotPos(this.#getSlotPositionContext(), slot)
+    return this.getInputSlotPos(this.inputs[slot])
   }
 
   /**
@@ -3291,7 +3209,25 @@ export class LGraphNode
    * @returns Position of the centre of the input slot in graph co-ordinates.
    */
   getInputSlotPos(input: INodeInputSlot): Point {
-    return calculateInputSlotPosFromSlot(this.#getSlotPositionContext(), input)
+    const {
+      pos: [nodeX, nodeY]
+    } = this
+
+    if (this.flags.collapsed) {
+      const halfTitle = LiteGraph.NODE_TITLE_HEIGHT * 0.5
+      return [nodeX, nodeY - halfTitle]
+    }
+
+    const { pos } = input
+    if (pos) return [nodeX + pos[0], nodeY + pos[1]]
+
+    // default vertical slots
+    const offsetX = LiteGraph.NODE_SLOT_HEIGHT * 0.5
+    const nodeOffsetY = this.constructor.slot_start_y || 0
+    const slotIndex = this.#defaultVerticalInputs.indexOf(input)
+    const slotY = (slotIndex + 0.7) * LiteGraph.NODE_SLOT_HEIGHT
+
+    return [nodeX + offsetX, nodeY + slotY + nodeOffsetY]
   }
 
   /**
@@ -3302,7 +3238,29 @@ export class LGraphNode
    * @returns Position of the output slot
    */
   getOutputPos(slot: number): Point {
-    return calculateOutputSlotPos(this.#getSlotPositionContext(), slot)
+    const {
+      pos: [nodeX, nodeY],
+      outputs,
+      size: [width]
+    } = this
+
+    if (this.flags.collapsed) {
+      const width = this._collapsed_width || LiteGraph.NODE_COLLAPSED_WIDTH
+      const halfTitle = LiteGraph.NODE_TITLE_HEIGHT * 0.5
+      return [nodeX + width, nodeY - halfTitle]
+    }
+
+    const outputPos = outputs?.[slot]?.pos
+    if (outputPos) return [nodeX + outputPos[0], nodeY + outputPos[1]]
+
+    // default vertical slots
+    const offsetX = LiteGraph.NODE_SLOT_HEIGHT * 0.5
+    const nodeOffsetY = this.constructor.slot_start_y || 0
+    const slotIndex = this.#defaultVerticalOutputs.indexOf(this.outputs[slot])
+    const slotY = (slotIndex + 0.7) * LiteGraph.NODE_SLOT_HEIGHT
+
+    // TODO: Why +1?
+    return [nodeX + width + 1 - offsetX, nodeY + slotY + nodeOffsetY]
   }
 
   /** @inheritdoc */
@@ -3848,33 +3806,12 @@ export class LGraphNode
       ? this.getInputPos(slotIndex)
       : this.getOutputPos(slotIndex)
 
-    if (LiteGraph.vueNodesMode) {
-      // Vue-based slot dimensions
-      const dimensions = LiteGraph.COMFY_VUE_NODE_DIMENSIONS.components
-
-      if (slot.isWidgetInputSlot) {
-        // Widget slots have a 20x20 clickable area centered at the position
-        slot.boundingRect[0] = pos[0] - 10
-        slot.boundingRect[1] = pos[1] - 10
-        slot.boundingRect[2] = 20
-        slot.boundingRect[3] = 20
-      } else {
-        // Regular slots have a 20x20 clickable area for the connector
-        // but the full slot height for vertical spacing
-        slot.boundingRect[0] = pos[0] - 10
-        slot.boundingRect[1] = pos[1] - dimensions.SLOT_HEIGHT / 2
-        slot.boundingRect[2] = 20
-        slot.boundingRect[3] = dimensions.SLOT_HEIGHT
-      }
-    } else {
-      // Traditional LiteGraph dimensions
-      slot.boundingRect[0] = pos[0] - LiteGraph.NODE_SLOT_HEIGHT * 0.5
-      slot.boundingRect[1] = pos[1] - LiteGraph.NODE_SLOT_HEIGHT * 0.5
-      slot.boundingRect[2] = slot.isWidgetInputSlot
-        ? BaseWidget.margin
-        : LiteGraph.NODE_SLOT_HEIGHT
-      slot.boundingRect[3] = LiteGraph.NODE_SLOT_HEIGHT
-    }
+    slot.boundingRect[0] = pos[0] - LiteGraph.NODE_SLOT_HEIGHT * 0.5
+    slot.boundingRect[1] = pos[1] - LiteGraph.NODE_SLOT_HEIGHT * 0.5
+    slot.boundingRect[2] = slot.isWidgetInputSlot
+      ? BaseWidget.margin
+      : LiteGraph.NODE_SLOT_HEIGHT
+    slot.boundingRect[3] = LiteGraph.NODE_SLOT_HEIGHT
   }
 
   #measureSlots(): ReadOnlyRect | null {
@@ -4070,26 +4007,14 @@ export class LGraphNode
     }
     if (!slotByWidgetName.size) return
 
-    // Only set custom pos if not using Vue positioning
-    // Vue positioning calculates widget slot positions dynamically
-    if (!LiteGraph.vueNodesMode) {
-      for (const widget of this.widgets) {
-        const slot = slotByWidgetName.get(widget.name)
-        if (!slot) continue
+    for (const widget of this.widgets) {
+      const slot = slotByWidgetName.get(widget.name)
+      if (!slot) continue
 
-        const actualSlot = this.#concreteInputs[slot.index]
-        const offset = LiteGraph.NODE_SLOT_HEIGHT * 0.5
-        actualSlot.pos = [offset, widget.y + offset]
-        this.#measureSlot(actualSlot, slot.index, true)
-      }
-    } else {
-      // For Vue positioning, just measure the slots without setting pos
-      for (const widget of this.widgets) {
-        const slot = slotByWidgetName.get(widget.name)
-        if (!slot) continue
-
-        this.#measureSlot(this.#concreteInputs[slot.index], slot.index, true)
-      }
+      const actualSlot = this.#concreteInputs[slot.index]
+      const offset = LiteGraph.NODE_SLOT_HEIGHT * 0.5
+      actualSlot.pos = [offset, widget.y + offset]
+      this.#measureSlot(actualSlot, slot.index, true)
     }
   }
 

src/lib/litegraph/src/LGraphNodeProperties.ts

@@ -1,176 +0,0 @@
-import type { LGraphNode } from './LGraphNode'
-
-/**
- * Default properties to track
- */
-const DEFAULT_TRACKED_PROPERTIES: string[] = ['title', 'flags.collapsed']
-
-/**
- * Manages node properties with optional change tracking and instrumentation.
- */
-export class LGraphNodeProperties {
-  /** The node this property manager belongs to */
-  node: LGraphNode
-
-  /** Set of property paths that have been instrumented */
-  #instrumentedPaths = new Set<string>()
-
-  constructor(node: LGraphNode) {
-    this.node = node
-
-    this.#setupInstrumentation()
-  }
-
-  /**
-   * Sets up property instrumentation for all tracked properties
-   */
-  #setupInstrumentation(): void {
-    for (const path of DEFAULT_TRACKED_PROPERTIES) {
-      this.#instrumentProperty(path)
-    }
-  }
-
-  /**
-   * Instruments a single property to track changes
-   */
-  #instrumentProperty(path: string): void {
-    const parts = path.split('.')
-
-    if (parts.length > 1) {
-      this.#ensureNestedPath(path)
-    }
-
-    let targetObject: any = this.node
-    let propertyName = parts[0]
-
-    if (parts.length > 1) {
-      for (let i = 0; i < parts.length - 1; i++) {
-        targetObject = targetObject[parts[i]]
-      }
-      propertyName = parts.at(-1)!
-    }
-
-    const hasProperty = Object.prototype.hasOwnProperty.call(
-      targetObject,
-      propertyName
-    )
-    const currentValue = targetObject[propertyName]
-
-    if (!hasProperty) {
-      let value: any = undefined
-
-      Object.defineProperty(targetObject, propertyName, {
-        get: () => value,
-        set: (newValue: any) => {
-          const oldValue = value
-          value = newValue
-          this.#emitPropertyChange(path, oldValue, newValue)
-
-          // Update enumerable: true for non-undefined values, false for undefined
-          const shouldBeEnumerable = newValue !== undefined
-          const currentDescriptor = Object.getOwnPropertyDescriptor(
-            targetObject,
-            propertyName
-          )
-          if (
-            currentDescriptor &&
-            currentDescriptor.enumerable !== shouldBeEnumerable
-          ) {
-            Object.defineProperty(targetObject, propertyName, {
-              ...currentDescriptor,
-              enumerable: shouldBeEnumerable
-            })
-          }
-        },
-        enumerable: false,
-        configurable: true
-      })
-    } else {
-      Object.defineProperty(
-        targetObject,
-        propertyName,
-        this.#createInstrumentedDescriptor(path, currentValue)
-      )
-    }
-
-    this.#instrumentedPaths.add(path)
-  }
-
-  /**
-   * Creates a property descriptor that emits change events
-   */
-  #createInstrumentedDescriptor(
-    propertyPath: string,
-    initialValue: any
-  ): PropertyDescriptor {
-    let value = initialValue
-
-    return {
-      get: () => value,
-      set: (newValue: any) => {
-        const oldValue = value
-        value = newValue
-        this.#emitPropertyChange(propertyPath, oldValue, newValue)
-      },
-      enumerable: true,
-      configurable: true
-    }
-  }
-
-  /**
-   * Emits a property change event if the node is connected to a graph
-   */
-  #emitPropertyChange(
-    propertyPath: string,
-    oldValue: any,
-    newValue: any
-  ): void {
-    if (oldValue !== newValue && this.node.graph) {
-      this.node.graph.trigger('node:property:changed', {
-        nodeId: this.node.id,
-        property: propertyPath,
-        oldValue,
-        newValue
-      })
-    }
-  }
-
-  /**
-   * Ensures parent objects exist for nested properties
-   */
-  #ensureNestedPath(path: string): void {
-    const parts = path.split('.')
-    let current: any = this.node
-
-    // Create all parent objects except the last property
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i]
-      if (!current[part]) {
-        current[part] = {}
-      }
-      current = current[part]
-    }
-  }
-
-  /**
-   * Checks if a property is being tracked
-   */
-  isTracked(path: string): boolean {
-    return this.#instrumentedPaths.has(path)
-  }
-
-  /**
-   * Gets the list of tracked properties
-   */
-  getTrackedProperties(): string[] {
-    return [...DEFAULT_TRACKED_PROPERTIES]
-  }
-
-  /**
-   * Custom toJSON method for JSON.stringify
-   * Returns undefined to exclude from serialization since we only use defaults
-   */
-  toJSON(): any {
-    return undefined
-  }
-}

src/lib/litegraph/src/LLink.ts

@@ -2,8 +2,6 @@ import {
   SUBGRAPH_INPUT_ID,
   SUBGRAPH_OUTPUT_ID
 } from '@/lib/litegraph/src/constants'
-import { layoutMutations } from '@/renderer/core/layout/operations/LayoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
 
 import type { LGraphNode, NodeId } from './LGraphNode'
 import type { Reroute, RerouteId } from './Reroute'
@@ -16,6 +14,7 @@ import type {
   LinkSegment,
   ReadonlyLinkNetwork
 } from './interfaces'
+import { Subgraph } from './litegraph'
 import type {
   Serialisable,
   SerialisableLLink,
@@ -461,15 +460,19 @@ export class LLink implements LinkSegment, Serialisable<SerialisableLLink> {
       reroute.linkIds.delete(this.id)
       if (!keepReroutes && !reroute.totalLinks) {
         network.reroutes.delete(reroute.id)
-        // Delete reroute from Layout Store
-        layoutMutations.setSource(LayoutSource.Canvas)
-        layoutMutations.deleteReroute(reroute.id)
       }
     }
     network.links.delete(this.id)
-    // Delete link from Layout Store
-    layoutMutations.setSource(LayoutSource.Canvas)
-    layoutMutations.deleteLink(this.id)
+
+    if (this.originIsIoNode && network instanceof Subgraph) {
+      const subgraphInput = network.inputs.at(this.origin_slot)
+      if (!subgraphInput)
+        throw new Error('Invalid link - subgraph input not found')
+
+      subgraphInput.events.dispatch('input-disconnected', {
+        input: subgraphInput
+      })
+    }
   }
 
   /**

src/lib/litegraph/src/LiteGraphGlobal.ts

@@ -24,32 +24,6 @@ import {
 } from './types/globalEnums'
 import { createUuidv4 } from './utils/uuid'
 
-/**
- * Vue node dimensions configuration for the contract between LiteGraph and Vue components.
- * These values ensure both systems can independently calculate node, slot, and widget positions
- * to place them in identical locations.
- *
- * IMPORTANT: These values must match the actual rendered dimensions of Vue components
- * for the positioning contract to work correctly.
- */
-export const COMFY_VUE_NODE_DIMENSIONS = {
-  spacing: {
-    BETWEEN_SLOTS_AND_BODY: 8,
-    BETWEEN_WIDGETS: 8
-  },
-  components: {
-    HEADER_HEIGHT: 34, // 18 header + 16 padding
-    SLOT_HEIGHT: 24,
-    STANDARD_WIDGET_HEIGHT: 30
-  }
-} as const
-
-/**
- * Type for component height keys
- */
-export type ComponentHeightKey =
-  keyof typeof COMFY_VUE_NODE_DIMENSIONS.components
-
 /**
  * The Global Scope. It contains all the registered node classes.
  */
@@ -101,14 +75,6 @@ export class LiteGraphGlobal {
   WIDGET_SECONDARY_TEXT_COLOR = '#999'
   WIDGET_DISABLED_TEXT_COLOR = '#666'
 
-  /**
-   * Vue node dimensions configuration for the contract between LiteGraph and Vue components.
-   * These values ensure both systems can independently calculate node, slot, and widget positions
-   * to place them in identical locations.
-   */
-  // WARNING THIS WILL BE REMOVED IN FAVOR OF THE SLOTS LAYOUT TREE useDomSlotRegistration
-  COMFY_VUE_NODE_DIMENSIONS = COMFY_VUE_NODE_DIMENSIONS
-
   LINK_COLOR = '#9A9'
   EVENT_LINK_COLOR = '#A86'
   CONNECTING_LINK_COLOR = '#AFA'
@@ -364,18 +330,6 @@ export class LiteGraphGlobal {
    */
   saveViewportWithGraph: boolean = true
 
-  /**
-   * Enable Vue nodes mode for rendering and positioning.
-   * When true:
-   * - Nodes will calculate slot positions using Vue component dimensions
-   * - LiteGraph will skip rendering node bodies entirely
-   * - Vue components will handle all node rendering
-   * - LiteGraph continues to render connections, links, and graph background
-   * This should be set by the frontend when the Vue nodes feature is enabled.
-   * @default false
-   */
-  vueNodesMode: boolean = false
-
   // TODO: Remove legacy accessors
   LGraph = LGraph
   LLink = LLink

src/lib/litegraph/src/Reroute.ts

@@ -1,6 +1,3 @@
-import { layoutMutations } from '@/renderer/core/layout/operations/LayoutMutations'
-import { LayoutSource } from '@/renderer/core/layout/types'
-
 import { LGraphBadge } from './LGraphBadge'
 import type { LGraphNode, NodeId } from './LGraphNode'
 import { LLink, type LinkId } from './LLink'
@@ -410,17 +407,8 @@ export class Reroute
 
   /** @inheritdoc */
   move(deltaX: number, deltaY: number) {
-    const previousPos = { x: this.#pos[0], y: this.#pos[1] }
     this.#pos[0] += deltaX
     this.#pos[1] += deltaY
-
-    // Update Layout Store with new position
-    layoutMutations.setSource(LayoutSource.Canvas)
-    layoutMutations.moveReroute(
-      this.id,
-      { x: this.#pos[0], y: this.#pos[1] },
-      previousPos
-    )
   }
 
   /** @inheritdoc */

src/lib/litegraph/src/interfaces.ts

@@ -5,7 +5,6 @@ import type { ContextMenu } from './ContextMenu'
 import type { LGraphNode, NodeId } from './LGraphNode'
 import type { LLink, LinkId } from './LLink'
 import type { Reroute, RerouteId } from './Reroute'
-import { SubgraphInput } from './subgraph/SubgraphInput'
 import type { SubgraphInputNode } from './subgraph/SubgraphInputNode'
 import type { SubgraphOutputNode } from './subgraph/SubgraphOutputNode'
 import type { LinkDirection, RenderShape } from './types/globalEnums'
@@ -472,7 +471,6 @@ export interface DefaultConnectionColors {
 
 export interface ISubgraphInput extends INodeInputSlot {
   _listenerController?: AbortController
-  _subgraphSlot: SubgraphInput
 }
 
 /**

src/lib/litegraph/src/litegraph.ts

@@ -8,7 +8,7 @@ import type { CanvasEventDetail } from './types/events'
 import type { RenderShape, TitleMode } from './types/globalEnums'
 
 // Must remain above LiteGraphGlobal (circular dependency due to abstract factory behaviour in `configure`)
-export { Subgraph, type GraphOrSubgraph } from './subgraph/Subgraph'
+export { Subgraph } from './subgraph/Subgraph'
 
 export const LiteGraph = new LiteGraphGlobal()
 
@@ -134,11 +134,7 @@ export {
 } from './LGraphBadge'
 export { LGraphCanvas, type LGraphCanvasState } from './LGraphCanvas'
 export { LGraphGroup } from './LGraphGroup'
-export { LGraphNode, type NodeId, type NodeProperty } from './LGraphNode'
-export {
-  COMFY_VUE_NODE_DIMENSIONS,
-  type ComponentHeightKey
-} from './LiteGraphGlobal'
+export { LGraphNode, type NodeId } from './LGraphNode'
 export { type LinkId, LLink } from './LLink'
 export { createBounds } from './measure'
 export { Reroute, type RerouteId } from './Reroute'

src/lib/litegraph/src/node/NodeSlot.ts

@@ -73,7 +73,7 @@ export abstract class NodeSlot extends SlotBase implements INodeSlot {
     slot: OptionalProps<INodeSlot, 'boundingRect'>,
     node: LGraphNode
   ) {
-    // @ts-expect-error Workaround: Ensure internal properties are not copied to the slot (_listenerController
+    // Workaround: Ensure internal properties are not copied to the slot (_listenerController
     // https://github.com/Comfy-Org/litegraph.js/issues/1138
     const maybeSubgraphSlot: OptionalProps<
       ISubgraphInput,

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

@@ -141,7 +141,8 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
    */
   resolveInput(
     slot: number,
-    visited = new Set<string>()
+    visited = new Set<string>(),
+    type?: ISlotType
   ): ResolvedInput | undefined {
     const uniqueId = `${this.subgraphNode?.subgraph.id}:${this.node.id}[I]${slot}`
     if (visited.has(uniqueId)) {
@@ -232,7 +233,11 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
         `No output node DTO found for id [${outputNodeExecutionId}]`
       )
 
-    return outputNodeDto.resolveOutput(link.origin_slot, input.type, visited)
+    return outputNodeDto.resolveOutput(
+      link.origin_slot,
+      type ?? input.type,
+      visited
+    )
   }
 
   /**
@@ -284,7 +289,7 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
 
     // Upstreamed: Other virtual nodes are bypassed using the same input/output index (slots must match)
     if (node.isVirtualNode) {
-      if (this.inputs.at(slot)) return this.resolveInput(slot, visited)
+      if (this.inputs.at(slot)) return this.resolveInput(slot, visited, type)
 
       // Fallback check for nodes performing link redirection
       const virtualLink = this.node.getInputLink(slot)

src/lib/litegraph/src/types/widgets.ts

@@ -65,17 +65,6 @@ export type IWidget =
   | ISliderWidget
   | IButtonWidget
   | IKnobWidget
-  | IFileUploadWidget
-  | IColorWidget
-  | IMarkdownWidget
-  | IImageWidget
-  | ITreeSelectWidget
-  | IMultiSelectWidget
-  | IChartWidget
-  | IGalleriaWidget
-  | IImageCompareWidget
-  | ISelectButtonWidget
-  | ITextareaWidget
 
 export interface IBooleanWidget extends IBaseWidget<boolean, 'toggle'> {
   type: 'toggle'
@@ -149,81 +138,6 @@ export interface ICustomWidget extends IBaseWidget<string | object, 'custom'> {
   value: string | object
 }
 
-/** File upload widget for selecting and uploading files */
-export interface IFileUploadWidget extends IBaseWidget<string, 'fileupload'> {
-  type: 'fileupload'
-  value: string
-  label?: string
-}
-
-/** Color picker widget for selecting colors */
-export interface IColorWidget extends IBaseWidget<string, 'color'> {
-  type: 'color'
-  value: string
-}
-
-/** Markdown widget for displaying formatted text */
-export interface IMarkdownWidget extends IBaseWidget<string, 'markdown'> {
-  type: 'markdown'
-  value: string
-}
-
-/** Image display widget */
-export interface IImageWidget extends IBaseWidget<string, 'image'> {
-  type: 'image'
-  value: string
-}
-
-/** Tree select widget for hierarchical selection */
-export interface ITreeSelectWidget
-  extends IBaseWidget<string | string[], 'treeselect'> {
-  type: 'treeselect'
-  value: string | string[]
-}
-
-/** Multi-select widget for selecting multiple options */
-export interface IMultiSelectWidget
-  extends IBaseWidget<string[], 'multiselect'> {
-  type: 'multiselect'
-  value: string[]
-}
-
-/** Chart widget for displaying data visualizations */
-export interface IChartWidget extends IBaseWidget<object, 'chart'> {
-  type: 'chart'
-  value: object
-}
-
-/** Gallery widget for displaying multiple images */
-export interface IGalleriaWidget extends IBaseWidget<string[], 'galleria'> {
-  type: 'galleria'
-  value: string[]
-}
-
-/** Image comparison widget for comparing two images side by side */
-export interface IImageCompareWidget
-  extends IBaseWidget<string[], 'imagecompare'> {
-  type: 'imagecompare'
-  value: string[]
-}
-
-/** Select button widget for selecting from a group of buttons */
-export interface ISelectButtonWidget
-  extends IBaseWidget<
-    string,
-    'selectbutton',
-    RequiredProps<IWidgetOptions<string[]>, 'values'>
-  > {
-  type: 'selectbutton'
-  value: string
-}
-
-/** Textarea widget for multi-line text input */
-export interface ITextareaWidget extends IBaseWidget<string, 'textarea'> {
-  type: 'textarea'
-  value: string
-}
-
 /**
  * Valid widget types.  TS cannot provide easily extensible type safety for this at present.
  * Override linkedWidgets[]

src/lib/litegraph/src/widgets/ChartWidget.ts

@@ -1,50 +0,0 @@
-import type { IChartWidget } from '../types/widgets'
-import {
-  BaseWidget,
-  type DrawWidgetOptions,
-  type WidgetEventOptions
-} from './BaseWidget'
-
-/**
- * Widget for displaying charts and data visualizations
- * This is a widget that only has a Vue widgets implementation
- */
-export class ChartWidget
-  extends BaseWidget<IChartWidget>
-  implements IChartWidget
-{
-  override type = 'chart' as const
-
-  drawWidget(ctx: CanvasRenderingContext2D, options: DrawWidgetOptions): void {
-    const { width } = options
-    const { y, height } = this
-
-    const { fillStyle, strokeStyle, textAlign, textBaseline, font } = ctx
-
-    ctx.fillStyle = this.background_color
-    ctx.fillRect(15, y, width - 30, height)
-
-    ctx.strokeStyle = this.outline_color
-    ctx.strokeRect(15, y, width - 30, height)
-
-    ctx.fillStyle = this.text_color
-    ctx.font = '11px monospace'
-    ctx.textAlign = 'center'
-    ctx.textBaseline = 'middle'
-
-    const text = 'Chart: Vue-only'
-    ctx.fillText(text, width / 2, y + height / 2)
-
-    Object.assign(ctx, {
-      fillStyle,
-      strokeStyle,
-      textAlign,
-      textBaseline,
-      font
-    })
-  }
-
-  onClick(_options: WidgetEventOptions): void {
-    // This is a widget that only has a Vue widgets implementation
-  }
-}

src/lib/litegraph/src/widgets/ColorWidget.ts

@@ -1,50 +0,0 @@
-import type { IColorWidget } from '../types/widgets'
-import {
-  BaseWidget,
-  type DrawWidgetOptions,
-  type WidgetEventOptions
-} from './BaseWidget'
-
-/**
- * Widget for displaying a color picker
- * This is a widget that only has a Vue widgets implementation
- */
-export class ColorWidget
-  extends BaseWidget<IColorWidget>
-  implements IColorWidget
-{
-  override type = 'color' as const
-
-  drawWidget(ctx: CanvasRenderingContext2D, options: DrawWidgetOptions): void {
-    const { width } = options
-    const { y, height } = this
-
-    const { fillStyle, strokeStyle, textAlign, textBaseline, font } = ctx
-
-    ctx.fillStyle = this.background_color
-    ctx.fillRect(15, y, width - 30, height)
-
-    ctx.strokeStyle = this.outline_color
-    ctx.strokeRect(15, y, width - 30, height)
-
-    ctx.fillStyle = this.text_color
-    ctx.font = '11px monospace'
-    ctx.textAlign = 'center'
-    ctx.textBaseline = 'middle'
-
-    const text = 'Color: Vue-only'
-    ctx.fillText(text, width / 2, y + height / 2)
-
-    Object.assign(ctx, {
-      fillStyle,
-      strokeStyle,
-      textAlign,
-      textBaseline,
-      font
-    })
-  }
-
-  onClick(_options: WidgetEventOptions): void {
-    // This is a widget that only has a Vue widgets implementation
-  }
-}

src/lib/litegraph/src/widgets/FileUploadWidget.ts

@@ -1,50 +0,0 @@
-import type { IFileUploadWidget } from '../types/widgets'
-import {
-  BaseWidget,
-  type DrawWidgetOptions,
-  type WidgetEventOptions
-} from './BaseWidget'
-
-/**
- * Widget for handling file uploads
- * This is a widget that only has a Vue widgets implementation
- */
-export class FileUploadWidget
-  extends BaseWidget<IFileUploadWidget>
-  implements IFileUploadWidget
-{
-  override type = 'fileupload' as const
-
-  drawWidget(ctx: CanvasRenderingContext2D, options: DrawWidgetOptions): void {
-    const { width } = options
-    const { y, height } = this
-
-    const { fillStyle, strokeStyle, textAlign, textBaseline, font } = ctx
-
-    ctx.fillStyle = this.background_color
-    ctx.fillRect(15, y, width - 30, height)
-
-    ctx.strokeStyle = this.outline_color
-    ctx.strokeRect(15, y, width - 30, height)
-
-    ctx.fillStyle = this.text_color
-    ctx.font = '11px monospace'
-    ctx.textAlign = 'center'
-    ctx.textBaseline = 'middle'
-
-    const text = 'Fileupload: Vue-only'
-    ctx.fillText(text, width / 2, y + height / 2)
-
-    Object.assign(ctx, {
-      fillStyle,
-      strokeStyle,
-      textAlign,
-      textBaseline,
-      font
-    })
-  }
-
-  onClick(_options: WidgetEventOptions): void {
-    // This is a widget that only has a Vue widgets implementation
-  }
-}

src/lib/litegraph/src/widgets/GalleriaWidget.ts

@@ -1,50 +0,0 @@
-import type { IGalleriaWidget } from '../types/widgets'
-import {
-  BaseWidget,
-  type DrawWidgetOptions,
-  type WidgetEventOptions
-} from './BaseWidget'
-
-/**
- * Widget for displaying image galleries
- * This is a widget that only has a Vue widgets implementation
- */
-export class GalleriaWidget
-  extends BaseWidget<IGalleriaWidget>
-  implements IGalleriaWidget
-{
-  override type = 'galleria' as const
-
-  drawWidget(ctx: CanvasRenderingContext2D, options: DrawWidgetOptions): void {
-    const { width } = options
-    const { y, height } = this
-
-    const { fillStyle, strokeStyle, textAlign, textBaseline, font } = ctx
-
-    ctx.fillStyle = this.background_color
-    ctx.fillRect(15, y, width - 30, height)
-
-    ctx.strokeStyle = this.outline_color
-    ctx.strokeRect(15, y, width - 30, height)
-
-    ctx.fillStyle = this.text_color
-    ctx.font = '11px monospace'
-    ctx.textAlign = 'center'
-    ctx.textBaseline = 'middle'
-
-    const text = 'Galleria: Vue-only'
-    ctx.fillText(text, width / 2, y + height / 2)
-
-    Object.assign(ctx, {
-      fillStyle,
-      strokeStyle,
-      textAlign,
-      textBaseline,
-      font
-    })
-  }
-
-  onClick(_options: WidgetEventOptions): void {
-    // This is a widget that only has a Vue widgets implementation
-  }
-}