fix: properly merge LCOV shard coverage instead of concatenating

When the same source file appears in multiple shards, naive concatenation
double-counts LF:/LH: counters. Add scripts/merge-lcov.ts that unions
DA: records per source file (max hit count per line) and recomputes
summary counters from merged data.

Also fix coverage-report.ts and coverage-slack-notify.ts to deduplicate
per-file stats using Math.max instead of summing, making them robust
against unmerged LCOV input.

.github/actions/find-workflow-run/action.yaml

@@ -0,0 +1,65 @@
+name: Find Workflow Run
+description: Finds a workflow run for a given commit SHA and outputs its status and run ID.
+
+inputs:
+  workflow-id:
+    description: The workflow filename (e.g., 'ci-size-data.yaml')
+    required: true
+  head-sha:
+    description: The commit SHA to find runs for
+    required: true
+  not-found-status:
+    description: Status to output when no run exists
+    required: false
+    default: pending
+  token:
+    description: GitHub token for API access
+    required: true
+
+outputs:
+  status:
+    description: One of 'ready', 'pending', 'failed', or the not-found-status value
+    value: ${{ steps.find.outputs.status }}
+  run-id:
+    description: The workflow run ID (only set when status is 'ready')
+    value: ${{ steps.find.outputs.run-id }}
+
+runs:
+  using: composite
+  steps:
+    - name: Find workflow run
+      id: find
+      uses: actions/github-script@v8
+      env:
+        WORKFLOW_ID: ${{ inputs.workflow-id }}
+        HEAD_SHA: ${{ inputs.head-sha }}
+        NOT_FOUND_STATUS: ${{ inputs.not-found-status }}
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const { data: runs } = await github.rest.actions.listWorkflowRuns({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            workflow_id: process.env.WORKFLOW_ID,
+            head_sha: process.env.HEAD_SHA,
+            per_page: 1,
+          });
+
+          const run = runs.workflow_runs[0];
+          if (!run) {
+            core.setOutput('status', process.env.NOT_FOUND_STATUS);
+            return;
+          }
+
+          if (run.status !== 'completed') {
+            core.setOutput('status', 'pending');
+            return;
+          }
+
+          if (run.conclusion !== 'success') {
+            core.setOutput('status', 'failed');
+            return;
+          }
+
+          core.setOutput('status', 'ready');
+          core.setOutput('run-id', String(run.id));

.github/workflows/ci-tests-e2e-coverage.yaml

@@ -0,0 +1,62 @@
+name: 'CI: E2E Coverage'
+
+on:
+  workflow_run:
+    workflows: ['CI: Tests E2E']
+    types:
+      - completed
+
+concurrency:
+  group: e2e-coverage-${{ github.event.workflow_run.head_sha }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  merge:
+    if: >
+      github.repository == 'Comfy-Org/ComfyUI_frontend' &&
+      github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup frontend
+        uses: ./.github/actions/setup-frontend
+
+      - name: Download all shard coverage data
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          run_id: ${{ github.event.workflow_run.id }}
+          name: e2e-coverage-shard-.*
+          name_is_regexp: true
+          path: temp/coverage-shards
+          if_no_artifact_found: warn
+
+      - name: Merge shard coverage into single LCOV
+        run: |
+          mkdir -p coverage/playwright
+          pnpm exec tsx scripts/merge-lcov.ts temp/coverage-shards coverage/playwright/coverage.lcov
+          wc -l coverage/playwright/coverage.lcov
+
+      - name: Upload merged coverage data
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: e2e-coverage
+          path: coverage/playwright/
+          retention-days: 30
+          if-no-files-found: warn
+
+      - name: Upload E2E coverage to Codecov
+        if: always()
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
+        with:
+          files: coverage/playwright/coverage.lcov
+          flags: e2e
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: false

.github/workflows/ci-tests-e2e.yaml

@@ -86,6 +86,7 @@ jobs:
         run: pnpm exec playwright test --project=chromium --shard=${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --reporter=blob
         env:
           PLAYWRIGHT_BLOB_OUTPUT_DIR: ./blob-report
+          COLLECT_COVERAGE: 'true'
 
       - name: Upload blob report
         uses: actions/upload-artifact@v6
@@ -95,6 +96,15 @@ jobs:
           path: blob-report/
           retention-days: 1
 
+      - name: Upload shard coverage data
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: e2e-coverage-shard-${{ matrix.shardIndex }}
+          path: coverage/playwright/
+          retention-days: 1
+          if-no-files-found: warn
+
   playwright-tests:
     # Ideally, each shard runs test in 6 minutes, but allow up to 15 minutes
     timeout-minutes: 15

.github/workflows/ci-tests-unit.yaml

@@ -26,10 +26,20 @@ jobs:
       - name: Run Vitest tests with coverage
         run: pnpm test:coverage
 
+      - name: Upload unit coverage artifact
+        if: always() && github.event_name == 'push'
+        uses: actions/upload-artifact@v6
+        with:
+          name: unit-coverage
+          path: coverage/lcov.info
+          retention-days: 30
+          if-no-files-found: warn
+
       - name: Upload coverage to Codecov
         if: always()
         uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           files: coverage/lcov.info
+          flags: unit
           token: ${{ secrets.CODECOV_TOKEN }}
           fail_ci_if_error: false

.github/workflows/coverage-slack-notify.yaml

@@ -0,0 +1,149 @@
+name: 'Coverage: Slack Notification'
+
+on:
+  workflow_run:
+    workflows: ['CI: Tests Unit']
+    branches: [main]
+    types:
+      - completed
+
+permissions:
+  contents: read
+  actions: read
+  pull-requests: read
+
+jobs:
+  notify:
+    if: >
+      github.repository == 'Comfy-Org/ComfyUI_frontend' &&
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup frontend
+        uses: ./.github/actions/setup-frontend
+
+      - name: Download current unit coverage
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          run_id: ${{ github.event.workflow_run.id }}
+          name: unit-coverage
+          path: coverage
+
+      - name: Download previous unit coverage baseline
+        continue-on-error: true
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          branch: main
+          workflow: coverage-slack-notify.yaml
+          name: unit-coverage-baseline
+          path: temp/coverage-baseline
+          if_no_artifact_found: warn
+
+      - name: Download latest E2E coverage
+        continue-on-error: true
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          branch: main
+          workflow: ci-tests-e2e-coverage.yaml
+          name: e2e-coverage
+          path: temp/e2e-coverage
+          if_no_artifact_found: warn
+
+      - name: Download previous E2E coverage baseline
+        continue-on-error: true
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          branch: main
+          workflow: coverage-slack-notify.yaml
+          name: e2e-coverage-baseline
+          path: temp/e2e-coverage-baseline
+          if_no_artifact_found: warn
+
+      - name: Resolve merged PR metadata
+        id: pr-meta
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const sha = context.payload.workflow_run.head_sha;
+            const { data: commit } = await github.rest.repos.getCommit({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              ref: sha,
+            });
+            const message = commit.commit.message ?? '';
+            const firstLine = message.split('\n')[0];
+            const match = firstLine.match(/\(#(\d+)\)\s*$/);
+            if (!match) {
+              core.setOutput('skip', 'true');
+              core.info('No PR number found in commit message — skipping.');
+              return;
+            }
+            const prNumber = match[1];
+            const { data: pr } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: Number(prNumber),
+            });
+            core.setOutput('skip', 'false');
+            core.setOutput('number', prNumber);
+            core.setOutput('url', pr.html_url);
+            core.setOutput('author', pr.user.login);
+
+      - name: Generate Slack notification
+        if: steps.pr-meta.outputs.skip != 'true'
+        id: slack-payload
+        env:
+          PR_URL: ${{ steps.pr-meta.outputs.url }}
+          PR_NUMBER: ${{ steps.pr-meta.outputs.number }}
+          PR_AUTHOR: ${{ steps.pr-meta.outputs.author }}
+        run: |
+          PAYLOAD=$(pnpm exec tsx scripts/coverage-slack-notify.ts \
+            --pr-url="$PR_URL" \
+            --pr-number="$PR_NUMBER" \
+            --author="$PR_AUTHOR")
+          if [ -n "$PAYLOAD" ]; then
+            echo "has_payload=true" >> "$GITHUB_OUTPUT"
+            DELIM="SLACK_PAYLOAD_$(date +%s)"
+            echo "payload<<$DELIM" >> "$GITHUB_OUTPUT"
+            printf '%s\n' "$PAYLOAD" >> "$GITHUB_OUTPUT"
+            echo "$DELIM" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_payload=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Post to Slack
+        if: steps.slack-payload.outputs.has_payload == 'true'
+        continue-on-error: true
+        env:
+          SLACK_PAYLOAD: ${{ steps.slack-payload.outputs.payload }}
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+        run: |
+          # Channel: #p-frontend-automated-testing
+          BODY=$(echo "$SLACK_PAYLOAD" | jq --arg ch "C0AP09LKRDZ" '. + {channel: $ch}')
+          curl -sf -X POST \
+            -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "$BODY" \
+            -o /dev/null \
+            https://slack.com/api/chat.postMessage
+
+      - name: Save unit coverage baseline
+        if: always() && hashFiles('coverage/lcov.info') != ''
+        uses: actions/upload-artifact@v6
+        with:
+          name: unit-coverage-baseline
+          path: coverage/lcov.info
+          retention-days: 90
+          if-no-files-found: warn
+
+      - name: Save E2E coverage baseline
+        if: always() && hashFiles('temp/e2e-coverage/coverage.lcov') != ''
+        uses: actions/upload-artifact@v6
+        with:
+          name: e2e-coverage-baseline
+          path: temp/e2e-coverage/coverage.lcov
+          retention-days: 90
+          if-no-files-found: warn

.github/workflows/pr-report.yaml

@@ -2,7 +2,7 @@ name: 'PR: Unified Report'
 
 on:
   workflow_run:
-    workflows: ['CI: Size Data', 'CI: Performance Report']
+    workflows: ['CI: Size Data', 'CI: Performance Report', 'CI: E2E Coverage']
     types:
       - completed
 
@@ -67,73 +67,23 @@ jobs:
             core.setOutput('base', livePr.base.ref);
             core.setOutput('head-sha', livePr.head.sha);
 
-      - name: Find size workflow run for this commit
+      - name: Find size workflow run
         if: steps.pr-meta.outputs.skip != 'true'
         id: find-size
-        uses: actions/github-script@v8
+        uses: ./.github/actions/find-workflow-run
         with:
-          script: |
-            const headSha = '${{ steps.pr-meta.outputs.head-sha }}';
-            const { data: runs } = await github.rest.actions.listWorkflowRuns({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              workflow_id: 'ci-size-data.yaml',
-              head_sha: headSha,
-              per_page: 1,
-            });
+          workflow-id: ci-size-data.yaml
+          head-sha: ${{ steps.pr-meta.outputs.head-sha }}
+          token: ${{ secrets.GITHUB_TOKEN }}
 
-            const run = runs.workflow_runs[0];
-            if (!run) {
-              core.setOutput('status', 'pending');
-              return;
-            }
-
-            if (run.status !== 'completed') {
-              core.setOutput('status', 'pending');
-              return;
-            }
-
-            if (run.conclusion !== 'success') {
-              core.setOutput('status', 'failed');
-              return;
-            }
-
-            core.setOutput('status', 'ready');
-            core.setOutput('run-id', String(run.id));
-
-      - name: Find perf workflow run for this commit
+      - name: Find perf workflow run
         if: steps.pr-meta.outputs.skip != 'true'
         id: find-perf
-        uses: actions/github-script@v8
+        uses: ./.github/actions/find-workflow-run
         with:
-          script: |
-            const headSha = '${{ steps.pr-meta.outputs.head-sha }}';
-            const { data: runs } = await github.rest.actions.listWorkflowRuns({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              workflow_id: 'ci-perf-report.yaml',
-              head_sha: headSha,
-              per_page: 1,
-            });
-
-            const run = runs.workflow_runs[0];
-            if (!run) {
-              core.setOutput('status', 'pending');
-              return;
-            }
-
-            if (run.status !== 'completed') {
-              core.setOutput('status', 'pending');
-              return;
-            }
-
-            if (run.conclusion !== 'success') {
-              core.setOutput('status', 'failed');
-              return;
-            }
-
-            core.setOutput('status', 'ready');
-            core.setOutput('run-id', String(run.id));
+          workflow-id: ci-perf-report.yaml
+          head-sha: ${{ steps.pr-meta.outputs.head-sha }}
+          token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Download size data (current)
         if: steps.pr-meta.outputs.skip != 'true' && steps.find-size.outputs.status == 'ready'
@@ -154,6 +104,25 @@ jobs:
           path: temp/size-prev
           if_no_artifact_found: warn
 
+      - name: Find coverage workflow run
+        if: steps.pr-meta.outputs.skip != 'true'
+        id: find-coverage
+        uses: ./.github/actions/find-workflow-run
+        with:
+          workflow-id: ci-tests-e2e-coverage.yaml
+          head-sha: ${{ steps.pr-meta.outputs.head-sha }}
+          not-found-status: skip
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download coverage data
+        if: steps.pr-meta.outputs.skip != 'true' && steps.find-coverage.outputs.status == 'ready'
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        with:
+          name: e2e-coverage
+          run_id: ${{ steps.find-coverage.outputs.run-id }}
+          path: temp/coverage
+          if_no_artifact_found: warn
+
       - name: Download perf metrics (current)
         if: steps.pr-meta.outputs.skip != 'true' && steps.find-perf.outputs.status == 'ready'
         uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
@@ -189,9 +158,10 @@ jobs:
       - name: Generate unified report
         if: steps.pr-meta.outputs.skip != 'true'
         run: >
-          node scripts/unified-report.js
+          pnpm exec tsx scripts/unified-report.ts
           --size-status=${{ steps.find-size.outputs.status }}
           --perf-status=${{ steps.find-perf.outputs.status }}
+          --coverage-status=${{ steps.find-coverage.outputs.status }}
           > pr-report.md
 
       - name: Remove legacy separate comments

browser_tests/assets/subgraphs/subgraph-multi-instance-promoted-text-values.json

@@ -1,284 +0,0 @@
-{
-  "id": "2f54e2f0-6db4-4bdf-84a8-9c3ea3ec0123",
-  "revision": 0,
-  "last_node_id": 13,
-  "last_link_id": 9,
-  "nodes": [
-    {
-      "id": 11,
-      "type": "422723e8-4bf6-438c-823f-881ca81acead",
-      "pos": [120, 180],
-      "size": [210, 168],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        { "name": "clip", "type": "CLIP", "link": null },
-        { "name": "model", "type": "MODEL", "link": null },
-        { "name": "positive", "type": "CONDITIONING", "link": null },
-        { "name": "negative", "type": "CONDITIONING", "link": null },
-        { "name": "latent_image", "type": "LATENT", "link": null }
-      ],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": ["Alpha\n"]
-    },
-    {
-      "id": 12,
-      "type": "422723e8-4bf6-438c-823f-881ca81acead",
-      "pos": [420, 180],
-      "size": [210, 168],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [
-        { "name": "clip", "type": "CLIP", "link": null },
-        { "name": "model", "type": "MODEL", "link": null },
-        { "name": "positive", "type": "CONDITIONING", "link": null },
-        { "name": "negative", "type": "CONDITIONING", "link": null },
-        { "name": "latent_image", "type": "LATENT", "link": null }
-      ],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": ["Beta\n"]
-    },
-    {
-      "id": 13,
-      "type": "422723e8-4bf6-438c-823f-881ca81acead",
-      "pos": [720, 180],
-      "size": [210, 168],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [
-        { "name": "clip", "type": "CLIP", "link": null },
-        { "name": "model", "type": "MODEL", "link": null },
-        { "name": "positive", "type": "CONDITIONING", "link": null },
-        { "name": "negative", "type": "CONDITIONING", "link": null },
-        { "name": "latent_image", "type": "LATENT", "link": null }
-      ],
-      "outputs": [],
-      "properties": {},
-      "widgets_values": ["Gamma\n"]
-    }
-  ],
-  "links": [],
-  "groups": [],
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "422723e8-4bf6-438c-823f-881ca81acead",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 11,
-          "lastLinkId": 15,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "New Subgraph",
-        "inputNode": {
-          "id": -10,
-          "bounding": [481.59912109375, 379.13336181640625, 120, 160]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [1121.59912109375, 379.13336181640625, 120, 40]
-        },
-        "inputs": [
-          {
-            "id": "0f07c10e-5705-4764-9b24-b69606c6dbcc",
-            "name": "text",
-            "type": "STRING",
-            "linkIds": [10],
-            "pos": { "0": 581.59912109375, "1": 399.13336181640625 }
-          },
-          {
-            "id": "214a5060-24dd-4299-ab78-8027dc5b9c59",
-            "name": "clip",
-            "type": "CLIP",
-            "linkIds": [11],
-            "pos": { "0": 581.59912109375, "1": 419.13336181640625 }
-          },
-          {
-            "id": "8ab94c5d-e7df-433c-9177-482a32340552",
-            "name": "model",
-            "type": "MODEL",
-            "linkIds": [12],
-            "pos": { "0": 581.59912109375, "1": 439.13336181640625 }
-          },
-          {
-            "id": "8a4cd719-8c67-473b-9b44-ac0582d02641",
-            "name": "positive",
-            "type": "CONDITIONING",
-            "linkIds": [13],
-            "pos": { "0": 581.59912109375, "1": 459.13336181640625 }
-          },
-          {
-            "id": "a78d6b3a-ad40-4300-b0a5-2cdbdb8dc135",
-            "name": "negative",
-            "type": "CONDITIONING",
-            "linkIds": [14],
-            "pos": { "0": 581.59912109375, "1": 479.13336181640625 }
-          },
-          {
-            "id": "4c7abe0c-902d-49ef-a5b0-cbf02b50b693",
-            "name": "latent_image",
-            "type": "LATENT",
-            "linkIds": [15],
-            "pos": { "0": 581.59912109375, "1": 499.13336181640625 }
-          }
-        ],
-        "outputs": [],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 10,
-            "type": "CLIPTextEncode",
-            "pos": [661.59912109375, 314.13336181640625],
-            "size": [400, 200],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "clip",
-                "name": "clip",
-                "type": "CLIP",
-                "link": 11
-              },
-              {
-                "localized_name": "text",
-                "name": "text",
-                "type": "STRING",
-                "widget": { "name": "text" },
-                "link": 10
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "CONDITIONING",
-                "name": "CONDITIONING",
-                "type": "CONDITIONING",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "CLIPTextEncode"
-            },
-            "widgets_values": [""]
-          },
-          {
-            "id": 11,
-            "type": "KSampler",
-            "pos": [674.1234741210938, 570.5839233398438],
-            "size": [270, 262],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model",
-                "name": "model",
-                "type": "MODEL",
-                "link": 12
-              },
-              {
-                "localized_name": "positive",
-                "name": "positive",
-                "type": "CONDITIONING",
-                "link": 13
-              },
-              {
-                "localized_name": "negative",
-                "name": "negative",
-                "type": "CONDITIONING",
-                "link": 14
-              },
-              {
-                "localized_name": "latent_image",
-                "name": "latent_image",
-                "type": "LATENT",
-                "link": 15
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "LATENT",
-                "name": "LATENT",
-                "type": "LATENT",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "KSampler"
-            },
-            "widgets_values": [0, "randomize", 20, 8, "euler", "simple", 1]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 10,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 10,
-            "target_slot": 1,
-            "type": "STRING"
-          },
-          {
-            "id": 11,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 10,
-            "target_slot": 0,
-            "type": "CLIP"
-          },
-          {
-            "id": 12,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 11,
-            "target_slot": 0,
-            "type": "MODEL"
-          },
-          {
-            "id": 13,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 11,
-            "target_slot": 1,
-            "type": "CONDITIONING"
-          },
-          {
-            "id": 14,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 11,
-            "target_slot": 2,
-            "type": "CONDITIONING"
-          },
-          {
-            "id": 15,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 11,
-            "target_slot": 3,
-            "type": "LATENT"
-          }
-        ],
-        "extra": {}
-      }
-    ]
-  },
-  "config": {},
-  "extra": {
-    "ds": {
-      "scale": 1,
-      "offset": [0, 0]
-    },
-    "frontendVersion": "1.24.1"
-  },
-  "version": 0.4
-}

browser_tests/fixtures/ComfyPage.ts

@@ -1,6 +1,7 @@
 import type { APIRequestContext, Locator, Page } from '@playwright/test'
 import { test as base } from '@playwright/test'
 import { config as dotenvConfig } from 'dotenv'
+import MCR from 'monocart-coverage-reports'
 
 import { NodeBadgeMode } from '@/types/nodeSource'
 import { ComfyActionbar } from '@e2e/helpers/actionbar'
@@ -407,10 +408,28 @@ export class ComfyPage {
 
 export const testComfySnapToGridGridSize = 50
 
+const COLLECT_COVERAGE = process.env.COLLECT_COVERAGE === 'true'
+
 export const comfyPageFixture = base.extend<{
   comfyPage: ComfyPage
   comfyMouse: ComfyMouse
 }>({
+  page: async ({ page, browserName }, use) => {
+    if (browserName !== 'chromium' || !COLLECT_COVERAGE) {
+      return use(page)
+    }
+
+    await page.coverage.startJSCoverage({ resetOnNavigation: false })
+    await use(page)
+    const coverage = await page.coverage.stopJSCoverage()
+
+    const mcr = MCR({
+      outputDir: './coverage/playwright',
+      reports: []
+    })
+    await mcr.add(coverage)
+  },
+
   comfyPage: async ({ page, request }, use, testInfo) => {
     const comfyPage = new ComfyPage(page, request)
 

browser_tests/globalTeardown.ts

@@ -1,15 +1,29 @@
 import { config as dotenvConfig } from 'dotenv'
+import MCR from 'monocart-coverage-reports'
 
 import { writePerfReport } from '@e2e/helpers/perfReporter'
 import { restorePath } from '@e2e/utils/backupUtils'
 
 dotenvConfig()
 
-export default function globalTeardown() {
+export default async function globalTeardown() {
   writePerfReport()
 
   if (!process.env.CI && process.env.TEST_COMFYUI_DIR) {
     restorePath([process.env.TEST_COMFYUI_DIR, 'user'])
     restorePath([process.env.TEST_COMFYUI_DIR, 'models'])
   }
+
+  if (process.env.COLLECT_COVERAGE === 'true') {
+    const mcr = MCR({
+      outputDir: './coverage/playwright',
+      reports: [['lcovonly', { file: 'coverage.lcov' }], ['text-summary']],
+      sourceFilter: {
+        '**/node_modules/**': false,
+        '**/browser_tests/**': false,
+        '**/*': true
+      }
+    })
+    await mcr.generate()
+  }
 }

browser_tests/tests/cloud-asset-default.spec.ts

@@ -0,0 +1,82 @@
+import { expect } from '@playwright/test'
+
+import type { Asset, ListAssetsResponse } from '@comfyorg/ingest-types'
+import { comfyPageFixture } from '@e2e/fixtures/ComfyPage'
+import {
+  STABLE_CHECKPOINT,
+  STABLE_CHECKPOINT_2
+} from '@e2e/fixtures/data/assetFixtures'
+
+function makeAssetsResponse(assets: Asset[]): ListAssetsResponse {
+  return { assets, total: assets.length, has_more: false }
+}
+
+const CLOUD_ASSETS: Asset[] = [STABLE_CHECKPOINT, STABLE_CHECKPOINT_2]
+
+// Stub /api/assets before the app loads. The local ComfyUI backend has no
+// /api/assets endpoint (returns 503), which poisons the assets store on
+// first load. Narrow pattern avoids intercepting static /assets/*.js bundles.
+//
+// TODO: Consider moving this stub into ComfyPage fixture for all @cloud tests.
+const test = comfyPageFixture.extend<{ stubCloudAssets: void }>({
+  stubCloudAssets: [
+    async ({ page }, use) => {
+      const pattern = '**/api/assets?*'
+      await page.route(pattern, (route) =>
+        route.fulfill({
+          status: 200,
+          contentType: 'application/json',
+          body: JSON.stringify(makeAssetsResponse(CLOUD_ASSETS))
+        })
+      )
+      await use()
+      await page.unroute(pattern)
+    },
+    { auto: true }
+  ]
+})
+
+test.describe('Asset-supported node default value', { tag: '@cloud' }, () => {
+  test.afterEach(async ({ comfyPage }) => {
+    await comfyPage.nodeOps.clearGraph()
+  })
+
+  test('should use first cloud asset when server default is not in assets', async ({
+    comfyPage
+  }) => {
+    // The default workflow contains a CheckpointLoaderSimple node whose
+    // server default (from object_info) is a local file not in cloud assets.
+    // Wait for the existing node's asset widget to mount, confirming the
+    // assets store has been populated from the stub before adding a new node.
+    await expect
+      .poll(
+        () =>
+          comfyPage.page.evaluate(() => {
+            const node = window.app!.graph.nodes.find(
+              (n: { type: string }) => n.type === 'CheckpointLoaderSimple'
+            )
+            return node?.widgets?.find(
+              (w: { name: string }) => w.name === 'ckpt_name'
+            )?.type
+          }),
+        { timeout: 10_000 }
+      )
+      .toBe('asset')
+
+    // Add a new CheckpointLoaderSimple — should use first cloud asset,
+    // not the server's object_info default.
+    const widgetValue = await comfyPage.page.evaluate(() => {
+      const node = window.LiteGraph!.createNode('CheckpointLoaderSimple')
+      window.app!.graph.add(node!)
+      const widget = node!.widgets?.find(
+        (w: { name: string }) => w.name === 'ckpt_name'
+      )
+      return String(widget?.value ?? '')
+    })
+
+    // Production resolves via getAssetFilename (user_metadata.filename →
+    // metadata.filename → asset.name). Test fixtures have no metadata
+    // filename, so asset.name is the resolved value.
+    expect(widgetValue).toBe(CLOUD_ASSETS[0].name)
+  })
+})

browser_tests/tests/subgraph/subgraphSerialization.spec.ts

@@ -1,6 +1,5 @@
 import { expect } from '@playwright/test'
 
-import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
 import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
 import { getPromotedWidgets } from '@e2e/helpers/promotedWidgets'
 
@@ -9,31 +8,6 @@ const LEGACY_PREFIXED_WORKFLOW =
   'subgraphs/nested-subgraph-legacy-prefixed-proxy-widgets'
 
 test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
-  const getPromotedHostWidgetValues = async (
-    comfyPage: ComfyPage,
-    nodeIds: string[]
-  ) => {
-    return comfyPage.page.evaluate((ids) => {
-      const graph = window.app!.canvas.graph!
-
-      return ids.map((id) => {
-        const node = graph.getNodeById(id)
-        if (
-          !node ||
-          typeof node.isSubgraphNode !== 'function' ||
-          !node.isSubgraphNode()
-        ) {
-          return { id, values: [] as unknown[] }
-        }
-
-        return {
-          id,
-          values: (node.widgets ?? []).map((widget) => widget.value)
-        }
-      })
-    }, nodeIds)
-  }
-
   test('Promoted widget remains usable after serialize and reload', async ({
     comfyPage
   }) => {
@@ -109,35 +83,5 @@ test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
       await expect(textarea).toBeVisible()
       await expect(textarea).toBeDisabled()
     })
-
-    test('Multiple instances of the same subgraph keep distinct promoted widget values after load and reload', async ({
-      comfyPage
-    }) => {
-      const workflowName =
-        'subgraphs/subgraph-multi-instance-promoted-text-values'
-      const hostNodeIds = ['11', '12', '13']
-      const expectedValues = ['Alpha\n', 'Beta\n', 'Gamma\n']
-
-      await comfyPage.workflow.loadWorkflow(workflowName)
-      await comfyPage.nextFrame()
-
-      const initialValues = await getPromotedHostWidgetValues(
-        comfyPage,
-        hostNodeIds
-      )
-      expect(initialValues.map(({ values }) => values[0])).toEqual(
-        expectedValues
-      )
-
-      await comfyPage.subgraph.serializeAndReload()
-
-      const reloadedValues = await getPromotedHostWidgetValues(
-        comfyPage,
-        hostNodeIds
-      )
-      expect(reloadedValues.map(({ values }) => values[0])).toEqual(
-        expectedValues
-      )
-    })
   })
 })

package.json

@@ -44,6 +44,7 @@
     "stylelint:fix": "stylelint --cache --fix '{apps,packages,src}/**/*.{css,vue}'",
     "stylelint": "stylelint --cache '{apps,packages,src}/**/*.{css,vue}'",
     "test:browser": "pnpm exec nx e2e",
+    "test:browser:coverage": "cross-env COLLECT_COVERAGE=true pnpm test:browser",
     "test:browser:local": "cross-env PLAYWRIGHT_LOCAL=1 PLAYWRIGHT_TEST_URL=http://localhost:5173 pnpm test:browser",
     "test:coverage": "vitest run --coverage",
     "test:unit": "nx run test",
@@ -174,6 +175,7 @@
     "lint-staged": "catalog:",
     "markdown-table": "catalog:",
     "mixpanel-browser": "catalog:",
+    "monocart-coverage-reports": "catalog:",
     "nx": "catalog:",
     "oxfmt": "catalog:",
     "oxlint": "catalog:",

playwright.config.ts

@@ -3,15 +3,12 @@ import { defineConfig, devices } from '@playwright/test'
 
 const maybeLocalOptions: PlaywrightTestConfig = process.env.PLAYWRIGHT_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: 1, // Single worker for easier debugging. Increase to match CPU cores if you want to run a lot of tests in parallel.
-
+      timeout: 30_000,
+      retries: 0,
+      workers: 1,
       use: {
-        trace: 'on', // Always capture traces (CI uses 'on-first-retry')
-        video: 'on' // Always record video (CI uses 'retain-on-failure')
+        trace: 'on',
+        video: 'on'
       }
     }
   : {
@@ -36,7 +33,7 @@ export default defineConfig({
       name: 'chromium',
       use: { ...devices['Desktop Chrome'] },
       timeout: 15000,
-      grepInvert: /@mobile|@perf|@audit|@cloud/ // Run all tests except those tagged with @mobile, @perf, @audit, or @cloud
+      grepInvert: /@mobile|@perf|@audit|@cloud/
     },
 
     {
@@ -65,60 +62,28 @@ export default defineConfig({
       name: 'chromium-2x',
       use: { ...devices['Desktop Chrome'], deviceScaleFactor: 2 },
       timeout: 15000,
-      grep: /@2x/ // Run all tests tagged with @2x
+      grep: /@2x/
     },
 
     {
       name: 'chromium-0.5x',
       use: { ...devices['Desktop Chrome'], deviceScaleFactor: 0.5 },
       timeout: 15000,
-      grep: /@0.5x/ // Run all tests tagged with @0.5x
+      grep: /@0.5x/
     },
 
-    // {
-    //   name: 'firefox',
-    //   use: { ...devices['Desktop Firefox'] },
-    // },
-
-    // {
-    //   name: 'webkit',
-    //   use: { ...devices['Desktop Safari'] },
-    // },
-
     {
       name: 'cloud',
       use: { ...devices['Desktop Chrome'] },
       timeout: 15000,
-      grep: /@cloud/, // Run only tests tagged with @cloud
-      grepInvert: /@oss/ // Exclude tests tagged with @oss
+      grep: /@cloud/,
+      grepInvert: /@oss/
     },
 
-    /* Test against mobile viewports. */
     {
       name: 'mobile-chrome',
       use: { ...devices['Pixel 5'], hasTouch: true },
-      grep: /@mobile/ // Run only tests tagged with @mobile
+      grep: /@mobile/
     }
-    // {
-    //   name: 'Mobile Safari',
-    //   use: { ...devices['iPhone 12'] },
-    // },
-
-    /* Test against branded browsers. */
-    // {
-    //   name: 'Microsoft Edge',
-    //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
-    // },
-    // {
-    //   name: 'Google Chrome',
-    //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
-    // },
   ]
-
-  /* Run your local dev server before starting the tests */
-  // webServer: {
-  //   command: 'pnpm dev',
-  //   url: 'http://127.0.0.1:5173',
-  //   reuseExistingServer: !process.env.CI,
-  // },
 })

pnpm-lock.yaml

@@ -276,6 +276,9 @@ catalogs:
     mixpanel-browser:
       specifier: ^2.71.0
       version: 2.71.0
+    monocart-coverage-reports:
+      specifier: ^2.12.9
+      version: 2.12.9
     nx:
       specifier: 22.6.1
       version: 22.6.1
@@ -762,6 +765,9 @@ importers:
       mixpanel-browser:
         specifier: 'catalog:'
         version: 2.71.0
+      monocart-coverage-reports:
+        specifier: 'catalog:'
+        version: 2.12.9
       nx:
         specifier: 'catalog:'
         version: 22.6.1
@@ -4997,6 +5003,14 @@ packages:
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
 
+  acorn-loose@8.5.2:
+    resolution: {integrity: sha512-PPvV6g8UGMGgjrMu+n/f9E/tCSkNQ2Y97eFvuVdJfG11+xdIeDcLyNdC8SHcrHbRqkfwLASdplyR6B6sKM1U4A==}
+    engines: {node: '>=0.4.0'}
+
+  acorn-walk@8.3.5:
+    resolution: {integrity: sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==}
+    engines: {node: '>=0.4.0'}
+
   acorn@7.4.1:
     resolution: {integrity: sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==}
     engines: {node: '>=0.4.0'}
@@ -5581,6 +5595,9 @@ packages:
     resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
     engines: {node: ^14.18.0 || >=16.10.0}
 
+  console-grid@2.2.3:
+    resolution: {integrity: sha512-+mecFacaFxGl+1G31IsCx41taUXuW2FxX+4xIE0TIPhgML+Jb9JFcBWGhhWerd1/vhScubdmHqTwOhB0KCUUAg==}
+
   constantinople@4.0.1:
     resolution: {integrity: sha512-vCrqcSIq4//Gx74TXXCGnHpulY1dskqLTFGDmhrGxzeXL8lF8kvXv6mpNWlJj1uD4DW23D4ljAqbY4RRaaUZIw==}
 
@@ -5910,6 +5927,9 @@ packages:
     engines: {node: '>=14'}
     hasBin: true
 
+  eight-colors@1.3.3:
+    resolution: {integrity: sha512-4B54S2Qi4pJjeHmCbDIsveQZWQ/TSSQng4ixYJ9/SYHHpeS5nYK0pzcHvWzWUfRsvJQjwoIENhAwqg59thQceg==}
+
   ejs@3.1.10:
     resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==}
     engines: {node: '>=0.10.0'}
@@ -7458,6 +7478,9 @@ packages:
     resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
     hasBin: true
 
+  lz-utils@2.1.0:
+    resolution: {integrity: sha512-CMkfimAypidTtWjNDxY8a1bc1mJdyEh04V2FfEQ5Zh8Nx4v7k850EYa+dOWGn9hKG5xOyHP5MkuduAZCTHRvJw==}
+
   magic-string-ast@1.0.3:
     resolution: {integrity: sha512-CvkkH1i81zl7mmb94DsRiFeG9V2fR2JeuK8yDgS8oiZSFa++wWLEgZ5ufEOyLHbvSbD1gTRKv9NdX69Rnvr9JA==}
     engines: {node: '>=20.19.0'}
@@ -7734,6 +7757,13 @@ packages:
     resolution: {integrity: sha512-4W79zekKGyYU4JXVmB78DOscMFaJth2gGhgfTl2alWE4rNe3nf4N2pqenQ0rEtIewrnD79M687Ouba3YGTLOvg==}
     engines: {node: '>=18.0.0'}
 
+  monocart-coverage-reports@2.12.9:
+    resolution: {integrity: sha512-vtFqbC3Egl4nVa1FSIrQvMPO6HZtb9lo+3IW7/crdvrLNW2IH8lUsxaK0TsKNmMO2mhFWwqQywLV2CZelqPgwA==}
+    hasBin: true
+
+  monocart-locator@1.0.2:
+    resolution: {integrity: sha512-v8W5hJLcWMIxLCcSi/MHh+VeefI+ycFmGz23Froer9QzWjrbg4J3gFJBuI/T1VLNoYxF47bVPPxq8ZlNX4gVCw==}
+
   mrmime@2.0.1:
     resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
     engines: {node: '>=10'}
@@ -14174,6 +14204,14 @@ snapshots:
     dependencies:
       acorn: 8.16.0
 
+  acorn-loose@8.5.2:
+    dependencies:
+      acorn: 8.16.0
+
+  acorn-walk@8.3.5:
+    dependencies:
+      acorn: 8.16.0
+
   acorn@7.4.1: {}
 
   acorn@8.16.0: {}
@@ -14899,6 +14937,8 @@ snapshots:
 
   consola@3.4.2: {}
 
+  console-grid@2.2.3: {}
+
   constantinople@4.0.1:
     dependencies:
       '@babel/parser': 7.29.0
@@ -15241,6 +15281,8 @@ snapshots:
       minimatch: 9.0.1
       semver: 7.7.4
 
+  eight-colors@1.3.3: {}
+
   ejs@3.1.10:
     dependencies:
       jake: 10.9.2
@@ -17017,6 +17059,8 @@ snapshots:
 
   lz-string@1.5.0: {}
 
+  lz-utils@2.1.0: {}
+
   magic-string-ast@1.0.3:
     dependencies:
       magic-string: 0.30.21
@@ -17489,6 +17533,23 @@ snapshots:
 
   modern-tar@0.7.3: {}
 
+  monocart-coverage-reports@2.12.9:
+    dependencies:
+      acorn: 8.16.0
+      acorn-loose: 8.5.2
+      acorn-walk: 8.3.5
+      commander: 14.0.3
+      console-grid: 2.2.3
+      eight-colors: 1.3.3
+      foreground-child: 3.3.1
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-report: 3.0.1
+      istanbul-reports: 3.2.0
+      lz-utils: 2.1.0
+      monocart-locator: 1.0.2
+
+  monocart-locator@1.0.2: {}
+
   mrmime@2.0.1: {}
 
   ms@2.1.3: {}

pnpm-workspace.yaml

@@ -93,6 +93,7 @@ catalog:
   lint-staged: ^16.2.7
   markdown-table: ^3.0.4
   mixpanel-browser: ^2.71.0
+  monocart-coverage-reports: ^2.12.9
   nx: 22.6.1
   oxfmt: ^0.44.0
   oxlint: ^1.59.0

scripts/coverage-report.ts

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from 'node:fs'
+
+interface FileStats {
+  lines: number
+  covered: number
+}
+
+interface UncoveredFile {
+  file: string
+  pct: number
+  missed: number
+}
+
+const lcovPath = process.argv[2] || 'coverage/playwright/coverage.lcov'
+
+if (!existsSync(lcovPath)) {
+  process.stdout.write(
+    '## 🔬 E2E Coverage\n\n> ⚠️ No coverage data found. Check the CI workflow logs.\n'
+  )
+  process.exit(0)
+}
+
+const lcov = readFileSync(lcovPath, 'utf-8')
+
+interface RecordAccum {
+  lf: number
+  lh: number
+  fnf: number
+  fnh: number
+  brf: number
+  brh: number
+}
+
+const fileRecords = new Map<string, RecordAccum>()
+let currentFile = ''
+
+for (const line of lcov.split('\n')) {
+  if (line.startsWith('SF:')) {
+    currentFile = line.slice(3)
+  } else if (line.startsWith('LF:')) {
+    const n = parseInt(line.slice(3), 10) || 0
+    const rec = fileRecords.get(currentFile) ?? {
+      lf: 0,
+      lh: 0,
+      fnf: 0,
+      fnh: 0,
+      brf: 0,
+      brh: 0
+    }
+    rec.lf = Math.max(rec.lf, n)
+    fileRecords.set(currentFile, rec)
+  } else if (line.startsWith('LH:')) {
+    const n = parseInt(line.slice(3), 10) || 0
+    const rec = fileRecords.get(currentFile) ?? {
+      lf: 0,
+      lh: 0,
+      fnf: 0,
+      fnh: 0,
+      brf: 0,
+      brh: 0
+    }
+    rec.lh = Math.max(rec.lh, n)
+    fileRecords.set(currentFile, rec)
+  } else if (line.startsWith('FNF:')) {
+    const n = parseInt(line.slice(4), 10) || 0
+    const rec = fileRecords.get(currentFile)
+    if (rec) rec.fnf = Math.max(rec.fnf, n)
+  } else if (line.startsWith('FNH:')) {
+    const n = parseInt(line.slice(4), 10) || 0
+    const rec = fileRecords.get(currentFile)
+    if (rec) rec.fnh = Math.max(rec.fnh, n)
+  } else if (line.startsWith('BRF:')) {
+    const n = parseInt(line.slice(4), 10) || 0
+    const rec = fileRecords.get(currentFile)
+    if (rec) rec.brf = Math.max(rec.brf, n)
+  } else if (line.startsWith('BRH:')) {
+    const n = parseInt(line.slice(4), 10) || 0
+    const rec = fileRecords.get(currentFile)
+    if (rec) rec.brh = Math.max(rec.brh, n)
+  }
+}
+
+let totalLines = 0
+let coveredLines = 0
+let totalFunctions = 0
+let coveredFunctions = 0
+let totalBranches = 0
+let coveredBranches = 0
+const fileStats = new Map<string, FileStats>()
+
+for (const [file, rec] of fileRecords) {
+  totalLines += rec.lf
+  coveredLines += rec.lh
+  totalFunctions += rec.fnf
+  coveredFunctions += rec.fnh
+  totalBranches += rec.brf
+  coveredBranches += rec.brh
+  fileStats.set(file, { lines: rec.lf, covered: rec.lh })
+}
+
+function pct(covered: number, total: number): string {
+  if (total === 0) return '—'
+  return ((covered / total) * 100).toFixed(1) + '%'
+}
+
+function bar(covered: number, total: number): string {
+  if (total === 0) return '—'
+  const p = (covered / total) * 100
+  if (p >= 80) return '🟢'
+  if (p >= 50) return '🟡'
+  return '🔴'
+}
+
+const lines: string[] = []
+lines.push('## 🔬 E2E Coverage')
+lines.push('')
+lines.push('| Metric | Covered | Total | Pct | |')
+lines.push('|---|--:|--:|--:|---|')
+lines.push(
+  `| Lines | ${coveredLines} | ${totalLines} | ${pct(coveredLines, totalLines)} | ${bar(coveredLines, totalLines)} |`
+)
+lines.push(
+  `| Functions | ${coveredFunctions} | ${totalFunctions} | ${pct(coveredFunctions, totalFunctions)} | ${bar(coveredFunctions, totalFunctions)} |`
+)
+lines.push(
+  `| Branches | ${coveredBranches} | ${totalBranches} | ${pct(coveredBranches, totalBranches)} | ${bar(coveredBranches, totalBranches)} |`
+)
+
+const uncovered: UncoveredFile[] = [...fileStats.entries()]
+  .filter(([, s]) => s.lines > 0)
+  .map(([file, s]) => ({
+    file: file.replace(/^.*\/src\//, 'src/'),
+    pct: s.lines > 0 ? (s.covered / s.lines) * 100 : 100,
+    missed: s.lines - s.covered
+  }))
+  .filter((f) => f.missed > 0)
+  .sort((a, b) => b.missed - a.missed)
+  .slice(0, 10)
+
+if (uncovered.length > 0) {
+  lines.push('')
+  lines.push('<details>')
+  lines.push('<summary>Top 10 files by uncovered lines</summary>')
+  lines.push('')
+  lines.push('| File | Coverage | Missed |')
+  lines.push('|---|--:|--:|')
+  for (const f of uncovered) {
+    lines.push(`| \`${f.file}\` | ${f.pct.toFixed(1)}% | ${f.missed} |`)
+  }
+  lines.push('')
+  lines.push('</details>')
+}
+
+process.stdout.write(lines.join('\n') + '\n')

scripts/coverage-slack-notify.ts

@@ -0,0 +1,228 @@
+import { existsSync, readFileSync } from 'node:fs'
+
+const TARGET = 80
+const MILESTONE_STEP = 5
+const BAR_WIDTH = 20
+
+interface CoverageData {
+  percentage: number
+  totalLines: number
+  coveredLines: number
+}
+
+interface SlackBlock {
+  type: 'section'
+  text: {
+    type: 'mrkdwn'
+    text: string
+  }
+}
+
+function parseLcovContent(content: string): CoverageData | null {
+  const perFile = new Map<string, { lf: number; lh: number }>()
+  let currentFile = ''
+
+  for (const line of content.split('\n')) {
+    if (line.startsWith('SF:')) {
+      currentFile = line.slice(3)
+    } else if (line.startsWith('LF:')) {
+      const n = parseInt(line.slice(3), 10) || 0
+      const entry = perFile.get(currentFile) ?? { lf: 0, lh: 0 }
+      entry.lf = Math.max(entry.lf, n)
+      perFile.set(currentFile, entry)
+    } else if (line.startsWith('LH:')) {
+      const n = parseInt(line.slice(3), 10) || 0
+      const entry = perFile.get(currentFile) ?? { lf: 0, lh: 0 }
+      entry.lh = Math.max(entry.lh, n)
+      perFile.set(currentFile, entry)
+    }
+  }
+
+  let totalLines = 0
+  let coveredLines = 0
+  for (const { lf, lh } of perFile.values()) {
+    totalLines += lf
+    coveredLines += lh
+  }
+
+  if (totalLines === 0) return null
+
+  return {
+    percentage: (coveredLines / totalLines) * 100,
+    totalLines,
+    coveredLines
+  }
+}
+
+function parseLcov(filePath: string): CoverageData | null {
+  if (!existsSync(filePath)) return null
+  return parseLcovContent(readFileSync(filePath, 'utf-8'))
+}
+
+function progressBar(percentage: number): string {
+  const clamped = Math.max(0, Math.min(100, percentage))
+  const filled = Math.round((clamped / 100) * BAR_WIDTH)
+  const empty = BAR_WIDTH - filled
+  return '█'.repeat(filled) + '░'.repeat(empty)
+}
+
+function formatPct(value: number): string {
+  return value.toFixed(1) + '%'
+}
+
+function formatDelta(delta: number): string {
+  const sign = delta >= 0 ? '+' : ''
+  return sign + delta.toFixed(1) + '%'
+}
+
+function crossedMilestone(prev: number, curr: number): number | null {
+  const prevBucket = Math.floor(prev / MILESTONE_STEP)
+  const currBucket = Math.floor(curr / MILESTONE_STEP)
+
+  if (currBucket > prevBucket) {
+    return currBucket * MILESTONE_STEP
+  }
+  return null
+}
+
+function buildMilestoneBlock(label: string, milestone: number): SlackBlock {
+  if (milestone >= TARGET) {
+    return {
+      type: 'section',
+      text: {
+        type: 'mrkdwn',
+        text: [
+          `🏆 *GOAL REACHED: ${label} coverage hit ${milestone}%!* 🏆`,
+          `\`${progressBar(milestone)}\` ${milestone}% ✅`,
+          'The team did it! 🎊🥳🎉'
+        ].join('\n')
+      }
+    }
+  }
+
+  const remaining = TARGET - milestone
+  return {
+    type: 'section',
+    text: {
+      type: 'mrkdwn',
+      text: [
+        `🎉🎉🎉 *MILESTONE: ${label} coverage hit ${milestone}%!*`,
+        `\`${progressBar(milestone)}\` ${milestone}% → ${TARGET}% target`,
+        `${remaining} percentage point${remaining !== 1 ? 's' : ''} to go!`
+      ].join('\n')
+    }
+  }
+}
+
+function parseArgs(argv: string[]): {
+  prUrl: string
+  prNumber: string
+  author: string
+} {
+  let prUrl = ''
+  let prNumber = ''
+  let author = ''
+
+  for (const arg of argv) {
+    if (arg.startsWith('--pr-url=')) prUrl = arg.slice('--pr-url='.length)
+    else if (arg.startsWith('--pr-number='))
+      prNumber = arg.slice('--pr-number='.length)
+    else if (arg.startsWith('--author=')) author = arg.slice('--author='.length)
+  }
+
+  return { prUrl, prNumber, author }
+}
+
+function formatCoverageRow(
+  label: string,
+  current: CoverageData,
+  baseline: CoverageData
+): string {
+  const delta = current.percentage - baseline.percentage
+  return `*${label}:*  ${formatPct(baseline.percentage)} → ${formatPct(current.percentage)}  (${formatDelta(delta)})`
+}
+
+function main() {
+  const { prUrl, prNumber, author } = parseArgs(process.argv.slice(2))
+
+  const unitCurrent = parseLcov('coverage/lcov.info')
+  const unitBaseline = parseLcov('temp/coverage-baseline/lcov.info')
+  const e2eCurrent = parseLcov('temp/e2e-coverage/coverage.lcov')
+  const e2eBaseline = parseLcov('temp/e2e-coverage-baseline/coverage.lcov')
+
+  const unitImproved =
+    unitCurrent !== null &&
+    unitBaseline !== null &&
+    unitCurrent.percentage > unitBaseline.percentage
+
+  const e2eImproved =
+    e2eCurrent !== null &&
+    e2eBaseline !== null &&
+    e2eCurrent.percentage > e2eBaseline.percentage
+
+  if (!unitImproved && !e2eImproved) {
+    process.exit(0)
+  }
+
+  const blocks: SlackBlock[] = []
+
+  const summaryLines: string[] = []
+  summaryLines.push(
+    `✅ *Coverage improved!* — <${prUrl}|PR #${prNumber}> by <https://github.com/${author}|${author}>`
+  )
+  summaryLines.push('')
+
+  if (unitCurrent && unitBaseline) {
+    summaryLines.push(formatCoverageRow('Unit', unitCurrent, unitBaseline))
+  }
+
+  if (e2eCurrent && e2eBaseline) {
+    summaryLines.push(formatCoverageRow('E2E', e2eCurrent, e2eBaseline))
+  }
+
+  summaryLines.push('')
+
+  if (unitCurrent) {
+    summaryLines.push(
+      `\`${progressBar(unitCurrent.percentage)}\` ${formatPct(unitCurrent.percentage)} unit → ${TARGET}% target`
+    )
+  }
+  if (e2eCurrent) {
+    summaryLines.push(
+      `\`${progressBar(e2eCurrent.percentage)}\` ${formatPct(e2eCurrent.percentage)} e2e → ${TARGET}% target`
+    )
+  }
+
+  blocks.push({
+    type: 'section',
+    text: {
+      type: 'mrkdwn',
+      text: summaryLines.join('\n')
+    }
+  })
+
+  if (unitCurrent && unitBaseline) {
+    const milestone = crossedMilestone(
+      unitBaseline.percentage,
+      unitCurrent.percentage
+    )
+    if (milestone !== null) {
+      blocks.push(buildMilestoneBlock('Unit test', milestone))
+    }
+  }
+
+  if (e2eCurrent && e2eBaseline) {
+    const milestone = crossedMilestone(
+      e2eBaseline.percentage,
+      e2eCurrent.percentage
+    )
+    if (milestone !== null) {
+      blocks.push(buildMilestoneBlock('E2E test', milestone))
+    }
+  }
+
+  const payload = { text: 'Coverage improved!', blocks }
+  process.stdout.write(JSON.stringify(payload))
+}
+
+main()

scripts/merge-lcov.ts

@@ -0,0 +1,198 @@
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+interface FileRecord {
+  lines: Map<number, number>
+  functions: Map<string, { name: string; line: number; hits: number }>
+  branches: Map<
+    string,
+    { line: number; block: number; branch: number; hits: number }
+  >
+}
+
+function getOrCreateRecord(
+  files: Map<string, FileRecord>,
+  sf: string
+): FileRecord {
+  let rec = files.get(sf)
+  if (!rec) {
+    rec = {
+      lines: new Map(),
+      functions: new Map(),
+      branches: new Map()
+    }
+    files.set(sf, rec)
+  }
+  return rec
+}
+
+function parseLcovFiles(paths: string[]): Map<string, FileRecord> {
+  const files = new Map<string, FileRecord>()
+  let current: FileRecord | null = null
+
+  for (const filePath of paths) {
+    if (!existsSync(filePath)) continue
+    const content = readFileSync(filePath, 'utf-8')
+
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+
+      if (trimmed.startsWith('SF:')) {
+        current = getOrCreateRecord(files, trimmed.slice(3))
+      } else if (trimmed === 'end_of_record') {
+        current = null
+      } else if (current) {
+        if (trimmed.startsWith('DA:')) {
+          const parts = trimmed.slice(3).split(',')
+          const lineNum = parseInt(parts[0], 10)
+          const hits = parseInt(parts[1], 10) || 0
+          const prev = current.lines.get(lineNum) ?? 0
+          current.lines.set(lineNum, Math.max(prev, hits))
+        } else if (trimmed.startsWith('FN:')) {
+          const parts = trimmed.slice(3).split(',')
+          const fnLine = parseInt(parts[0], 10)
+          const fnName = parts.slice(1).join(',')
+          if (!current.functions.has(fnName)) {
+            current.functions.set(fnName, {
+              name: fnName,
+              line: fnLine,
+              hits: 0
+            })
+          }
+        } else if (trimmed.startsWith('FNDA:')) {
+          const parts = trimmed.slice(5).split(',')
+          const hits = parseInt(parts[0], 10) || 0
+          const fnName = parts.slice(1).join(',')
+          const fn = current.functions.get(fnName)
+          if (fn) {
+            fn.hits = Math.max(fn.hits, hits)
+          } else {
+            current.functions.set(fnName, { name: fnName, line: 0, hits })
+          }
+        } else if (trimmed.startsWith('BRDA:')) {
+          const parts = trimmed.slice(5).split(',')
+          const brLine = parseInt(parts[0], 10)
+          const block = parseInt(parts[1], 10)
+          const branch = parseInt(parts[2], 10)
+          const hits = parts[3] === '-' ? 0 : parseInt(parts[3], 10) || 0
+          const key = `${brLine},${block},${branch}`
+          const prev = current.branches.get(key)
+          if (prev) {
+            prev.hits = Math.max(prev.hits, hits)
+          } else {
+            current.branches.set(key, {
+              line: brLine,
+              block,
+              branch,
+              hits
+            })
+          }
+        }
+      }
+    }
+  }
+
+  return files
+}
+
+function writeLcov(files: Map<string, FileRecord>): string {
+  const out: string[] = []
+
+  for (const [sf, rec] of [...files.entries()].sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )) {
+    out.push(`SF:${sf}`)
+
+    for (const fn of rec.functions.values()) {
+      out.push(`FN:${fn.line},${fn.name}`)
+    }
+    const fnTotal = rec.functions.size
+    let fnHit = 0
+    for (const fn of rec.functions.values()) {
+      out.push(`FNDA:${fn.hits},${fn.name}`)
+      if (fn.hits > 0) fnHit++
+    }
+    out.push(`FNF:${fnTotal}`)
+    out.push(`FNH:${fnHit}`)
+
+    for (const br of rec.branches.values()) {
+      out.push(
+        `BRDA:${br.line},${br.block},${br.branch},${br.hits === 0 ? '-' : br.hits}`
+      )
+    }
+    const brTotal = rec.branches.size
+    let brHit = 0
+    for (const br of rec.branches.values()) {
+      if (br.hits > 0) brHit++
+    }
+    out.push(`BRF:${brTotal}`)
+    out.push(`BRH:${brHit}`)
+
+    for (const [lineNum, hits] of [...rec.lines.entries()].sort(
+      (a, b) => a[0] - b[0]
+    )) {
+      out.push(`DA:${lineNum},${hits}`)
+    }
+    const lf = rec.lines.size
+    let lh = 0
+    for (const hits of rec.lines.values()) {
+      if (hits > 0) lh++
+    }
+    out.push(`LF:${lf}`)
+    out.push(`LH:${lh}`)
+
+    out.push('end_of_record')
+  }
+
+  return out.join('\n') + '\n'
+}
+
+function main() {
+  const inputDir = process.argv[2]
+  const outputFile = process.argv[3]
+
+  if (!inputDir || !outputFile) {
+    console.error('Usage: merge-lcov.ts <input-dir> <output-file>')
+    console.error(
+      '  Finds all coverage.lcov files under <input-dir> and merges them.'
+    )
+    process.exit(1)
+  }
+
+  const findResult = execSync(
+    `find ${JSON.stringify(resolve(inputDir))} -name 'coverage.lcov' -type f`,
+    { encoding: 'utf-8' }
+  ).trim()
+
+  if (!findResult) {
+    console.error('No coverage.lcov files found under', inputDir)
+    writeFileSync(outputFile, '')
+    process.exit(0)
+  }
+
+  const lcovFiles = findResult.split('\n').filter(Boolean)
+  console.error(`Merging ${lcovFiles.length} shard LCOV files...`)
+
+  const merged = parseLcovFiles(lcovFiles)
+  const output = writeLcov(merged)
+
+  writeFileSync(outputFile, output)
+
+  let totalFiles = 0
+  let totalLines = 0
+  let coveredLines = 0
+  for (const rec of merged.values()) {
+    totalFiles++
+    totalLines += rec.lines.size
+    for (const hits of rec.lines.values()) {
+      if (hits > 0) coveredLines++
+    }
+  }
+  console.error(
+    `Merged: ${totalFiles} source files, ${coveredLines}/${totalLines} lines covered`
+  )
+}
+
+main()

scripts/unified-report.ts

@@ -1,11 +1,9 @@
-// @ts-check
 import { execFileSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
 
-const args = process.argv.slice(2)
+const args: string[] = process.argv.slice(2)
 
-/** @param {string} name */
-function getArg(name) {
+function getArg(name: string): string | undefined {
   const prefix = `--${name}=`
   const arg = args.find((a) => a.startsWith(prefix))
   return arg ? arg.slice(prefix.length) : undefined
@@ -13,11 +11,10 @@ function getArg(name) {
 
 const sizeStatus = getArg('size-status') ?? 'pending'
 const perfStatus = getArg('perf-status') ?? 'pending'
+const coverageStatus = getArg('coverage-status') ?? 'skip'
 
-/** @type {string[]} */
-const lines = []
+const lines: string[] = []
 
-// --- Size section ---
 if (sizeStatus === 'ready') {
   try {
     const sizeReport = execFileSync('node', ['scripts/size-report.js'], {
@@ -43,7 +40,6 @@ if (sizeStatus === 'ready') {
 
 lines.push('')
 
-// --- Perf section ---
 if (perfStatus === 'ready' && existsSync('test-results/perf-metrics.json')) {
   try {
     const perfReport = execFileSync(
@@ -72,4 +68,33 @@ if (perfStatus === 'ready' && existsSync('test-results/perf-metrics.json')) {
   lines.push('> ⏳ Performance tests in progress…')
 }
 
+if (coverageStatus === 'ready' && existsSync('temp/coverage/coverage.lcov')) {
+  try {
+    const coverageReport = execFileSync(
+      'pnpm',
+      [
+        'exec',
+        'tsx',
+        'scripts/coverage-report.ts',
+        'temp/coverage/coverage.lcov'
+      ],
+      { encoding: 'utf-8' }
+    ).trimEnd()
+    lines.push('')
+    lines.push(coverageReport)
+  } catch {
+    lines.push('')
+    lines.push('## 🔬 E2E Coverage')
+    lines.push('')
+    lines.push(
+      '> ⚠️ Failed to render coverage report. Check the CI workflow logs.'
+    )
+  }
+} else if (coverageStatus === 'failed') {
+  lines.push('')
+  lines.push('## 🔬 E2E Coverage')
+  lines.push('')
+  lines.push('> ⚠️ Coverage collection failed. Check the CI workflow logs.')
+}
+
 process.stdout.write(lines.join('\n') + '\n')

src/core/graph/subgraph/promotedWidgetTypes.ts

@@ -24,8 +24,6 @@ export interface PromotedWidgetView extends IBaseWidget {
    * origin.
    */
   readonly disambiguatingSourceNodeId?: string
-  /** Whether the resolved source widget is workflow-persistent. */
-  readonly sourceSerialize: boolean
 }
 
 export function isPromotedWidgetView(

src/core/graph/subgraph/promotedWidgetView.ts

@@ -77,15 +77,6 @@ class PromotedWidgetView implements IPromotedWidgetView {
 
   readonly serialize = false
 
-  /**
-   * Whether the resolved source widget is workflow-persistent.
-   * Used by SubgraphNode.serialize to skip preview/audio/video widgets
-   * whose source sets serialize = false.
-   */
-  get sourceSerialize(): boolean {
-    return this.resolveDeepest()?.widget.serialize !== false
-  }
-
   last_y?: number
   computedHeight?: number
 
@@ -158,43 +149,13 @@ class PromotedWidgetView implements IPromotedWidgetView {
     return this.resolveDeepest()?.widget.linkedWidgets
   }
 
-  private get _instanceKey(): string {
-    return this.disambiguatingSourceNodeId
-      ? `${this.sourceNodeId}:${this.sourceWidgetName}:${this.disambiguatingSourceNodeId}`
-      : `${this.sourceNodeId}:${this.sourceWidgetName}`
-  }
-
   get value(): IBaseWidget['value'] {
-    const instanceValue = this.subgraphNode._instanceWidgetValues.get(
-      this._instanceKey
-    )
-    if (instanceValue !== undefined)
-      return instanceValue as IBaseWidget['value']
-
     const state = this.getWidgetState()
     if (state && isWidgetValue(state.value)) return state.value
     return this.resolveAtHost()?.widget.value
   }
 
-  /**
-   * Execution-time serialization — returns the per-instance value stored
-   * during configure, falling back to the regular value getter.
-   *
-   * The widget state store is shared across instances (keyed by inner node
-   * ID), so the regular getter returns the last-configured value for all
-   * instances.  graphToPrompt already prefers serializeValue over .value,
-   * so this is the hook that makes multi-instance execution correct.
-   */
-  serializeValue(): IBaseWidget['value'] {
-    const v = this.subgraphNode._instanceWidgetValues.get(this._instanceKey)
-    if (v !== undefined) return v as IBaseWidget['value']
-    return this.value
-  }
-
   set value(value: IBaseWidget['value']) {
-    // Keep per-instance map in sync for execution (graphToPrompt)
-    this.subgraphNode._instanceWidgetValues.set(this._instanceKey, value)
-
     const linkedWidgets = this.getLinkedInputWidgets()
     if (linkedWidgets.length > 0) {
       const widgetStore = useWidgetValueStore()

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

@@ -253,7 +253,7 @@ describe('Subgraph proxyWidgets', () => {
     expect(subgraphNode.widgets).toHaveLength(0)
   })
 
-  test('serialize stores widgets_values for promoted views', () => {
+  test('serialize does not produce widgets_values for promoted views', () => {
     const [subgraphNode, innerNodes, innerIds] = setupSubgraph(1)
     innerNodes[0].addWidget('text', 'stringWidget', 'value', () => {})
     usePromotionStore().setPromotions(
@@ -265,7 +265,9 @@ describe('Subgraph proxyWidgets', () => {
 
     const serialized = subgraphNode.serialize()
 
-    expect(serialized.widgets_values).toEqual(['value'])
+    // SubgraphNode doesn't set serialize_widgets, so widgets_values is absent.
+    // Even if it were set, views have serialize: false and would be skipped.
+    expect(serialized.widgets_values).toBeUndefined()
   })
 
   test('serialize preserves proxyWidgets in properties', () => {

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

@@ -186,16 +186,11 @@ export class ExecutableNodeDTO implements ExecutableLGraphNode {
         if (!widget) return
 
         // Special case: SubgraphNode widget.
-        // Prefer serializeValue (per-instance) over the shared .value getter
-        // so multiple SubgraphNode instances return their own configured values.
-        const widgetValue = widget.serializeValue
-          ? widget.serializeValue(subgraphNode, -1)
-          : widget.value
         return {
           node: this,
           origin_id: this.id,
           origin_slot: -1,
-          widgetInfo: { value: widgetValue }
+          widgetInfo: { value: widget.value }
         }
       }
 

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

@@ -1,166 +0,0 @@
-import { createTestingPinia } from '@pinia/testing'
-import { setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it } from 'vitest'
-
-import type { ISlotType } from '@/lib/litegraph/src/litegraph'
-import { BaseWidget, LGraphNode } from '@/lib/litegraph/src/litegraph'
-
-import {
-  createTestSubgraph,
-  createTestSubgraphNode,
-  resetSubgraphFixtureState
-} from './__fixtures__/subgraphHelpers'
-
-function createNodeWithWidget(
-  title: string,
-  widgetValue: unknown = 42,
-  slotType: ISlotType = 'number'
-) {
-  const node = new LGraphNode(title)
-  const input = node.addInput('value', slotType)
-  node.addOutput('out', slotType)
-
-  // @ts-expect-error Abstract class instantiation
-  const widget = new BaseWidget({
-    name: 'widget',
-    type: 'number',
-    value: widgetValue,
-    y: 0,
-    options: { min: 0, max: 100, step: 1 },
-    node
-  })
-  node.widgets = [widget]
-  input.widget = { name: widget.name }
-
-  return { node, widget, input }
-}
-
-beforeEach(() => {
-  setActivePinia(createTestingPinia({ stubActions: false }))
-  resetSubgraphFixtureState()
-})
-
-describe('SubgraphNode multi-instance widget isolation', () => {
-  it('preserves per-instance widget values after configure', () => {
-    const subgraph = createTestSubgraph({
-      inputs: [{ name: 'value', type: 'number' }]
-    })
-
-    const { node } = createNodeWithWidget('TestNode', 0)
-    subgraph.add(node)
-    subgraph.inputNode.slots[0].connect(node.inputs[0], node)
-
-    const instance1 = createTestSubgraphNode(subgraph, { id: 201 })
-    const instance2 = createTestSubgraphNode(subgraph, { id: 202 })
-
-    // Simulate what LGraph.configure does: call configure with different widgets_values
-    instance1.configure({
-      id: 201,
-      type: subgraph.id,
-      pos: [100, 100],
-      size: [200, 100],
-      inputs: [],
-      outputs: [],
-      mode: 0,
-      order: 0,
-      flags: {},
-      properties: { proxyWidgets: [['-1', 'widget']] },
-      widgets_values: [10]
-    })
-
-    instance2.configure({
-      id: 202,
-      type: subgraph.id,
-      pos: [400, 100],
-      size: [200, 100],
-      inputs: [],
-      outputs: [],
-      mode: 0,
-      order: 1,
-      flags: {},
-      properties: { proxyWidgets: [['-1', 'widget']] },
-      widgets_values: [20]
-    })
-
-    const widgets1 = instance1.widgets!
-    const widgets2 = instance2.widgets!
-
-    expect(widgets1.length).toBeGreaterThan(0)
-    expect(widgets2.length).toBeGreaterThan(0)
-    expect(widgets1[0].value).toBe(10)
-    expect(widgets2[0].value).toBe(20)
-    expect(widgets1[0].serializeValue!(instance1, 0)).toBe(10)
-    expect(widgets2[0].serializeValue!(instance2, 0)).toBe(20)
-    expect(instance1.serialize().widgets_values).toEqual([10])
-    expect(instance2.serialize().widgets_values).toEqual([20])
-  })
-
-  it('round-trips per-instance widget values through serialize and configure', () => {
-    const subgraph = createTestSubgraph({
-      inputs: [{ name: 'value', type: 'number' }]
-    })
-
-    const { node } = createNodeWithWidget('TestNode', 0)
-    subgraph.add(node)
-    subgraph.inputNode.slots[0].connect(node.inputs[0], node)
-
-    const originalInstance = createTestSubgraphNode(subgraph, { id: 301 })
-    originalInstance.configure({
-      id: 301,
-      type: subgraph.id,
-      pos: [100, 100],
-      size: [200, 100],
-      inputs: [],
-      outputs: [],
-      mode: 0,
-      order: 0,
-      flags: {},
-      properties: { proxyWidgets: [['-1', 'widget']] },
-      widgets_values: [33]
-    })
-
-    const serialized = originalInstance.serialize()
-
-    const restoredInstance = createTestSubgraphNode(subgraph, { id: 302 })
-    restoredInstance.configure({
-      ...serialized,
-      id: 302,
-      type: subgraph.id
-    })
-
-    const restoredWidget = restoredInstance.widgets?.[0]
-    expect(restoredWidget?.value).toBe(33)
-    expect(restoredWidget?.serializeValue?.(restoredInstance, 0)).toBe(33)
-  })
-
-  it('skips non-serializable source widgets during serialize', () => {
-    const subgraph = createTestSubgraph({
-      inputs: [{ name: 'value', type: 'number' }]
-    })
-
-    const { node, widget } = createNodeWithWidget('TestNode', 10)
-    subgraph.add(node)
-    subgraph.inputNode.slots[0].connect(node.inputs[0], node)
-
-    // Mark the source widget as non-persistent (e.g. preview widget)
-    widget.serialize = false
-
-    const instance = createTestSubgraphNode(subgraph, { id: 501 })
-    instance.configure({
-      id: 501,
-      type: subgraph.id,
-      pos: [100, 100],
-      size: [200, 100],
-      inputs: [],
-      outputs: [],
-      mode: 0,
-      order: 0,
-      flags: {},
-      properties: { proxyWidgets: [['-1', 'widget']] },
-      widgets_values: []
-    })
-
-    const serialized = instance.serialize()
-    expect(serialized.widgets_values).toBeUndefined()
-  })
-})

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

@@ -993,20 +993,7 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
     }
   }
 
-  /** Temporarily stored during configure for use by _internalConfigureAfterSlots */
-  private _pendingWidgetsValues?: unknown[]
-
-  /**
-   * Per-instance promoted widget values.
-   * Multiple SubgraphNode instances share the same inner nodes, so
-   * promoted widget values must be stored per-instance to avoid collisions.
-   * Key: `${sourceNodeId}:${sourceWidgetName}`
-   */
-  readonly _instanceWidgetValues = new Map<string, unknown>()
-
   override configure(info: ExportedSubgraphInstance): void {
-    this._pendingWidgetsValues = info.widgets_values
-
     for (const input of this.inputs) {
       if (
         input._listenerController &&
@@ -1137,21 +1124,6 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
       if (store.isPromoted(this.rootGraph.id, this.id, source)) continue
       store.promote(this.rootGraph.id, this.id, source)
     }
-
-    // Hydrate per-instance promoted widget values from serialized data.
-    // LGraphNode.configure skips promoted widgets (serialize === false on
-    // the view), so they must be applied here after promoted views exist.
-    // Only iterate serializable views to match what serialize() wrote.
-    if (this._pendingWidgetsValues) {
-      const views = this._getPromotedViews()
-      let i = 0
-      for (const view of views) {
-        if (!view.sourceSerialize) continue
-        if (i >= this._pendingWidgetsValues.length) break
-        view.value = this._pendingWidgetsValues[i++] as typeof view.value
-      }
-      this._pendingWidgetsValues = undefined
-    }
   }
 
   /**
@@ -1601,7 +1573,28 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
     ctx.restore()
   }
 
+  /**
+   * Synchronizes widget values from this SubgraphNode instance to the
+   * corresponding widgets in the subgraph definition before serialization.
+   * This ensures nested subgraph widget values are preserved when saving.
+   */
   override serialize(): ISerialisedNode {
+    // Sync widget values to subgraph definition before serialization.
+    // Only sync for inputs that are linked to a promoted widget via _widget.
+    for (const input of this.inputs) {
+      if (!input._widget) continue
+
+      const subgraphInput =
+        input._subgraphSlot ??
+        this.subgraph.inputNode.slots.find((slot) => slot.name === input.name)
+      if (!subgraphInput) continue
+
+      const connectedWidgets = subgraphInput.getConnectedWidgets()
+      for (const connectedWidget of connectedWidgets) {
+        connectedWidget.value = input._widget.value
+      }
+    }
+
     // Write promotion store state back to properties for serialization
     const entries = usePromotionStore().getPromotions(
       this.rootGraph.id,
@@ -1609,22 +1602,7 @@ export class SubgraphNode extends LGraphNode implements BaseLGraph {
     )
     this.properties.proxyWidgets = this._serializeEntries(entries)
 
-    const serialized = super.serialize()
-    const views = this._getPromotedViews()
-
-    const serializableViews = views.filter((view) => view.sourceSerialize)
-    if (serializableViews.length > 0) {
-      serialized.widgets_values = serializableViews.map((view) => {
-        const value = view.serializeValue
-          ? view.serializeValue(this, -1)
-          : view.value
-        return value != null && typeof value === 'object'
-          ? JSON.parse(JSON.stringify(value))
-          : (value ?? null)
-      })
-    }
-
-    return serialized
+    return super.serialize()
   }
   override clone() {
     const clone = super.clone()

src/renderer/extensions/vueNodes/widgets/composables/useComboWidget.test.ts

@@ -28,6 +28,7 @@ function createMockAssetItem(overrides: Partial<AssetItem> = {}): AssetItem {
 const mockDistributionState = vi.hoisted(() => ({ isCloud: false }))
 const mockUpdateInputs = vi.hoisted(() => vi.fn(() => Promise.resolve()))
 const mockGetInputName = vi.hoisted(() => vi.fn((hash: string) => hash))
+const mockGetAssets = vi.hoisted(() => vi.fn(() => [] as AssetItem[]))
 const mockAssetsStoreState = vi.hoisted(() => {
   const inputAssets: AssetItem[] = []
   return {
@@ -55,7 +56,8 @@ vi.mock('@/stores/assetsStore', () => ({
       return mockAssetsStoreState.inputLoading
     },
     updateInputs: mockUpdateInputs,
-    getInputName: mockGetInputName
+    getInputName: mockGetInputName,
+    getAssets: mockGetAssets
   }))
 }))
 
@@ -199,67 +201,117 @@ describe('useComboWidget', () => {
     expect(widget).toBe(mockWidget)
   })
 
-  it('should create asset browser widget when API enabled', () => {
-    mockDistributionState.isCloud = true
-    vi.mocked(assetService.shouldUseAssetBrowser).mockReturnValue(true)
+  describe('cloud asset browser widget', () => {
+    // "Select model" is the fallback from t('widgets.selectModel')
+    // in createAssetWidget when defaultValue is undefined.
+    const PLACEHOLDER = 'Select model'
 
-    const constructor = useComboWidget()
-    const mockWidget = createMockWidget({
-      type: 'asset',
-      name: 'ckpt_name',
-      value: 'model1.safetensors'
-    })
-    const mockNode = createMockNode('CheckpointLoaderSimple')
-    vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
-    const inputSpec = createMockInputSpec({
-      name: 'ckpt_name',
-      options: ['model1.safetensors', 'model2.safetensors']
+    function setupCloudAssetWidget(
+      inputSpecOverrides: Partial<InputSpec> = {}
+    ) {
+      mockDistributionState.isCloud = true
+      vi.mocked(assetService.shouldUseAssetBrowser).mockReturnValue(true)
+
+      const constructor = useComboWidget()
+      const mockWidget = createMockWidget({
+        type: 'asset',
+        name: 'ckpt_name',
+        value: ''
+      })
+      const mockNode = createMockNode('CheckpointLoaderSimple')
+      vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
+      const inputSpec = createMockInputSpec({
+        name: 'ckpt_name',
+        ...inputSpecOverrides
+      })
+
+      constructor(mockNode, inputSpec)
+      return { mockNode }
+    }
+
+    function getWidgetDefault(mockNode: ReturnType<typeof createMockNode>) {
+      return vi.mocked(mockNode.addWidget).mock.calls[0]?.[2]
+    }
+
+    it('should create asset browser widget when API enabled', () => {
+      mockGetAssets.mockReturnValue([
+        createMockAssetItem({ name: 'cloud_model.safetensors' })
+      ])
+
+      const { mockNode } = setupCloudAssetWidget({
+        options: ['model1.safetensors', 'model2.safetensors']
+      })
+
+      expect(
+        vi.mocked(assetService.shouldUseAssetBrowser)
+      ).toHaveBeenCalledWith('CheckpointLoaderSimple', 'ckpt_name')
+      expect(mockNode.addWidget).toHaveBeenCalledWith(
+        'asset',
+        'ckpt_name',
+        expect.anything(),
+        expect.any(Function),
+        expect.any(Object)
+      )
     })
 
-    const widget = constructor(mockNode, inputSpec)
+    it('should use first cloud asset as default instead of server combo options', () => {
+      mockGetAssets.mockReturnValue([
+        createMockAssetItem({ name: 'cloud_model.safetensors' })
+      ])
 
-    expect(mockNode.addWidget).toHaveBeenCalledWith(
-      'asset',
-      'ckpt_name',
-      'model1.safetensors',
-      expect.any(Function),
-      expect.any(Object)
-    )
-    expect(vi.mocked(assetService.shouldUseAssetBrowser)).toHaveBeenCalledWith(
-      'CheckpointLoaderSimple',
-      'ckpt_name'
-    )
-    expect(widget).toBe(mockWidget)
-  })
+      const { mockNode } = setupCloudAssetWidget({
+        options: ['local_only_model.safetensors']
+      })
 
-  it('should create asset browser widget when default value provided without options', () => {
-    mockDistributionState.isCloud = true
-    vi.mocked(assetService.shouldUseAssetBrowser).mockReturnValue(true)
-
-    const constructor = useComboWidget()
-    const mockWidget = createMockWidget({
-      type: 'asset',
-      name: 'ckpt_name',
-      value: 'fallback.safetensors'
-    })
-    const mockNode = createMockNode('CheckpointLoaderSimple')
-    vi.mocked(mockNode.addWidget).mockReturnValue(mockWidget)
-    const inputSpec = createMockInputSpec({
-      name: 'ckpt_name',
-      default: 'fallback.safetensors'
-      // Note: no options array provided
+      expect(getWidgetDefault(mockNode)).toBe('cloud_model.safetensors')
     })
 
-    const widget = constructor(mockNode, inputSpec)
+    it('should fallback to assets[0] when inputSpec.default not in cloud assets', () => {
+      mockGetAssets.mockReturnValue([
+        createMockAssetItem({ name: 'cloud_model.safetensors' })
+      ])
 
-    expect(mockNode.addWidget).toHaveBeenCalledWith(
-      'asset',
-      'ckpt_name',
-      'fallback.safetensors',
-      expect.any(Function),
-      expect.any(Object)
-    )
-    expect(widget).toBe(mockWidget)
+      const { mockNode } = setupCloudAssetWidget({
+        default: 'not_in_cloud.safetensors'
+      })
+
+      expect(getWidgetDefault(mockNode)).toBe('cloud_model.safetensors')
+    })
+
+    it('should prefer inputSpec.default when it exists in cloud assets', () => {
+      mockGetAssets.mockReturnValue([
+        createMockAssetItem({ name: 'other_model.safetensors' }),
+        createMockAssetItem({ name: 'fallback.safetensors' })
+      ])
+
+      const { mockNode } = setupCloudAssetWidget({
+        // Note: no options array provided
+        default: 'fallback.safetensors'
+      })
+
+      expect(getWidgetDefault(mockNode)).toBe('fallback.safetensors')
+    })
+
+    it('should create asset browser widget when default value provided without options', () => {
+      mockGetAssets.mockReturnValue([])
+
+      const { mockNode } = setupCloudAssetWidget({
+        // Note: no options array provided
+        default: 'fallback.safetensors'
+      })
+
+      expect(getWidgetDefault(mockNode)).toBe(PLACEHOLDER)
+    })
+
+    it('should fallback to placeholder when cloud assets not loaded', () => {
+      mockGetAssets.mockReturnValue([])
+
+      const { mockNode } = setupCloudAssetWidget({
+        options: ['local_model.safetensors']
+      })
+
+      expect(getWidgetDefault(mockNode)).toBe(PLACEHOLDER)
+    })
   })
 
   it('should show Select model when asset widget has undefined current value', () => {

src/renderer/extensions/vueNodes/widgets/composables/useComboWidget.ts

@@ -6,6 +6,7 @@ import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
 import { isComboWidget } from '@/lib/litegraph/src/litegraph'
 import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
 import { assetService } from '@/platform/assets/services/assetService'
+import { getAssetFilename } from '@/platform/assets/utils/assetMetadataUtils'
 import { createAssetWidget } from '@/platform/assets/utils/createAssetWidget'
 import { isCloud } from '@/platform/distribution/types'
 import type {
@@ -104,6 +105,25 @@ const addMultiSelectWidget = (
   return widget
 }
 
+/**
+ * Resolve the default value for a cloud asset widget.
+ * Priority: inputSpec.default (if present in cloud assets) → first cloud
+ * asset → undefined (shows placeholder).
+ */
+function resolveCloudDefault(
+  nodeType: string,
+  specDefault: string | undefined
+): string | undefined {
+  const assets = useAssetsStore().getAssets(nodeType)
+  if (specDefault != null) {
+    const inAssets = assets.some((a) => getAssetFilename(a) === specDefault)
+    if (inAssets) return specDefault
+  }
+  // empty filename → undefined (shows placeholder)
+  const filename = assets.length ? getAssetFilename(assets[0]) : undefined
+  return filename || undefined
+}
+
 function createAssetBrowserWidget(
   node: LGraphNode,
   inputSpec: ComboInputSpec,
@@ -195,7 +215,14 @@ const addComboWidget = (
 
   if (isCloud) {
     if (assetService.shouldUseAssetBrowser(node.comfyClass, inputSpec.name)) {
-      return createAssetBrowserWidget(node, inputSpec, defaultValue)
+      // Default from cloud assets, not from server combo options.
+      // Server options list local files that may not exist in the user's
+      // cloud asset library, leading to missing-model errors on undo/reload.
+      const cloudDefault = resolveCloudDefault(
+        node.comfyClass ?? '',
+        inputSpec.default
+      )
+      return createAssetBrowserWidget(node, inputSpec, cloudDefault)
     }
 
     if (NODE_MEDIA_TYPE_MAP[node.comfyClass ?? '']) {